| 1 | {"version":3,"sources":["../../src/react/reconcilation.js"],"names":["setContextCurrentValue","contextObject","value","AbstractObjectValue","values","isTop","elements","getElements","size","element","ObjectValue","ExpectedBailOut","binding","properties","get","descriptor","Reconciler","constructor","realm","componentTreeConfig","statistics","logger","componentTreeState","_createComponentTreeState","alreadyEvaluatedRootNodes","Map","alreadyEvaluatedNestedClosures","Set","nestedOptimizedClosures","branchedComponentTrees","resolveReactComponentTree","componentType","props","context","evaluatedRootNode","resolveComponentTree","initialProps","initialContext","set","result","_resolveComponent","optimizedTrees","error","_handleComponentTreeRootFailure","react","activeReconciler","throwUnsupportedSideEffectError","msg","UnsupportedSideEffect","effects","wrapInGlobalEnv","evaluatePure","evaluateForEffects","sideEffectType","expressionLocation","_handleNestedOptimizedClosuresFromEffects","undefined","evaluatedNode","nestedEffects","length","push","resolveNestedOptimizedClosure","func","resolveOptimizedClosure","baseObject","$GlobalEnv","environmentRecord","WithBaseObject","BoundFunctionValue","$BoundThis","$BoundTargetFunction","ECMAScriptSourceFunctionValue","numArgs","getLength","args","targetFunc","add","params","$FormalParameters","parameterId","t","isIdentifier","AbstractValue","createAbstractArgument","name","handleError","CompilerDiagnostic","FatalError","UndefinedValue","Value","_resolveDeeply","optimizedNestedClosures","clearComponentTreeState","_queueOptimizedClosure","optimizeNestedFunctions","_queueNewComponentTree","rootValue","SymbolValue","deadEnds","hasEvaluatedRootNode","_resolveComplexClassComponent","classMetadata","branchStatus","evaluatedComplexNode","status","NewComponentTreeBranch","instance","renderMethod","_resolveSimpleClassComponent","_resolveFunctionalComponent","intrinsics","_getClassComponentMetadata","classComponentMetadata","has","_resolveContextProviderComponent","reactElement","typeValue","propsValue","evaluatedChildNode","children","componentsEvaluated","contextConsumer","lastValueProp","_incremementReferenceForContextNode","valueProp","firstRenderOnly","resolvedReactElement","_resolveReactElementHostChildren","resolvedPropsValue","_decremementReferenceForContextNode","childrenValue","inlinedComponents","contextNode","references","contextNodeReferences","_isContextValueKnown","isRoot","_resolveContextConsumerComponent","renderProp","_findReactComponentTrees","_resolveForwardRefComponent","refValue","reactHint","abstractHints","forwardedComponent","_resolveRelayQueryRendererComponent","_resolveClassComponent","instanceProperties","instanceSymbols","SimpleClassBailOut","_resolveClassComponentForFirstRenderOnly","getDerivedStateFromProps","getSnapshotBeforeUpdate","$Call","componentWillMount","unsafeComponentWillMount","_resolveRelayContainer","message","firstRenderValue","abstractRelayContext","createAbstractObject","abstractRelayEnvironment","abstractRelayInternal","Properties","contextTypes","DoNotOptimize","object","fbLibraries","reactRelay","childContext","_getComponentResolutionStrategy","QueryRenderer","propertyName","kind","$$typeof","_resolveReactDomPortal","createPortalNode","reactPortalValue","domNodeValue","resolvedReactPortalValue","reactDomValue","reactDom","reactDomPortalFunc","createTemporalFromBuildFunction","skipInvariant","isPure","_resolveAbstractConditionalValue","condValue","consequentVal","alternateVal","evaluateWithAbstractConditional","_resolveAbstractLogicalValue","leftValue","rightValue","operator","_resolveAbstractValue","generator","_resolveUnknownComponentType","bailOutMessage","_assignBailOutMessage","_resolveReactElementBadRef","_resolveReactElementUndefinedRender","resolvedChildren","ArrayValue","intrinsicName","newProps","_resolveFragmentComponent","_resolveReactElement","StringValue","componentResolutionStrategy","NullValue","render","verbose","logInformation","_resolveComponentResolutionFailure","ReconcilerFatalError","Completion","stack","NumberValue","BooleanValue","_isFinal","_resolveArray","location","$BailOutReason","arrayValue","isIntrinsicAndHasWidenedNumericProperty","arrayHint","arrayHints","thisVal","elementValue","makeFinal","evaluateNode","alreadyEvaluatedNode","hasEvaluatedNestedClosure","treatFunctionsAs","arg","ref","propName","enumerable"],"mappings":"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","sourcesContent":["/**\n * Copyright (c) 2017-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n */\n\n/* @flow */\n\nimport { Realm, type Effects } from \"../realm.js\";\nimport {\n AbstractObjectValue,\n AbstractValue,\n ArrayValue,\n BooleanValue,\n BoundFunctionValue,\n ECMAScriptSourceFunctionValue,\n FunctionValue,\n NullValue,\n NumberValue,\n ObjectValue,\n StringValue,\n SymbolValue,\n Value,\n UndefinedValue,\n} from \"../values/index.js\";\nimport { ReactStatistics, type ReactEvaluatedNode } from \"../serializer/types.js\";\nimport {\n cloneReactElement,\n cloneProps,\n createReactEvaluatedNode,\n doNotOptimizeComponent,\n evaluateWithNestedParentEffects,\n flattenChildren,\n hardModifyReactObjectPropertyBinding,\n getComponentName,\n getComponentTypeFromRootValue,\n getLocationFromValue,\n getProperty,\n getReactSymbol,\n getValueFromFunctionCall,\n isReactElement,\n mapArrayValue,\n valueIsClassComponent,\n valueIsFactoryClassComponent,\n valueIsKnownReactAbstraction,\n valueIsLegacyCreateClassComponent,\n} from \"./utils.js\";\nimport { Get } from \"../methods/index.js\";\nimport invariant from \"../invariant.js\";\nimport { Properties } from \"../singletons.js\";\nimport { FatalError, CompilerDiagnostic } from \"../errors.js\";\nimport {\n type BranchStatusEnum,\n getValueWithBranchingLogicApplied,\n wrapReactElementInBranchOrReturnValue,\n} from \"./branching.js\";\nimport { Completion } from \"../completions.js\";\nimport {\n getInitialProps,\n getInitialContext,\n createClassInstance,\n createSimpleClassInstance,\n evaluateClassConstructor,\n createClassInstanceForFirstRenderOnly,\n applyGetDerivedStateFromProps,\n} from \"./components.js\";\nimport {\n DoNotOptimize,\n ExpectedBailOut,\n NewComponentTreeBranch,\n ReconcilerFatalError,\n SimpleClassBailOut,\n UnsupportedSideEffect,\n} from \"./errors.js\";\nimport { Logger } from \"../utils/logger.js\";\nimport type { ClassComponentMetadata, ReactComponentTreeConfig, ReactHint } from \"../types.js\";\nimport { handleReportedSideEffect } from \"../serializer/utils.js\";\nimport { createOperationDescriptor } from \"../utils/generator.js\";\nimport * as t from \"@babel/types\";\n\ntype ComponentResolutionStrategy =\n | \"NORMAL\"\n | \"FRAGMENT\"\n | \"RELAY_QUERY_RENDERER\"\n | \"CONTEXT_PROVIDER\"\n | \"CONTEXT_CONSUMER\"\n | \"FORWARD_REF\";\n\nexport type OptimizedClosure = {\n evaluatedNode: ReactEvaluatedNode,\n func: ECMAScriptSourceFunctionValue | BoundFunctionValue,\n nestedEffects: Array<Effects>,\n componentType: Value | null,\n context: ObjectValue | AbstractObjectValue | null,\n};\n\nexport type BranchReactComponentTree = {\n context: ObjectValue | AbstractObjectValue | null,\n evaluatedNode: ReactEvaluatedNode,\n props: ObjectValue | AbstractObjectValue | null,\n rootValue: ECMAScriptSourceFunctionValue | AbstractValue,\n};\n\nexport type ComponentTreeState = {\n componentType: void | ECMAScriptSourceFunctionValue,\n contextTypes: Set<string>,\n deadEnds: number,\n status: \"SIMPLE\" | \"COMPLEX\",\n contextNodeReferences: Map<ObjectValue | AbstractObjectValue, number>,\n};\n\nfunction setContextCurrentValue(contextObject: ObjectValue | AbstractObjectValue, value: Value): void {\n if (contextObject instanceof AbstractObjectValue && !contextObject.values.isTop()) {\n let elements = contextObject.values.getElements();\n if (elements && elements.size === 1) {\n for (let element of elements) {\n invariant(element instanceof ObjectValue);\n contextObject = element;\n }\n } else {\n invariant(false, \"TODO: deal with multiple possible context objects\");\n }\n }\n if (!(contextObject instanceof ObjectValue)) {\n throw new ExpectedBailOut(\"cannot set currentValue on an abstract context consumer\");\n }\n let binding = contextObject.properties.get(\"currentValue\");\n\n if (binding && binding.descriptor) {\n binding.descriptor.value = value;\n } else {\n invariant(false, \"setContextCurrentValue failed to set the currentValue\");\n }\n}\n\nexport class Reconciler {\n constructor(\n realm: Realm,\n componentTreeConfig: ReactComponentTreeConfig,\n statistics: ReactStatistics,\n logger?: Logger\n ) {\n this.realm = realm;\n this.statistics = statistics;\n this.logger = logger;\n this.componentTreeConfig = componentTreeConfig;\n this.componentTreeState = this._createComponentTreeState();\n this.alreadyEvaluatedRootNodes = new Map();\n this.alreadyEvaluatedNestedClosures = new Set();\n this.nestedOptimizedClosures = [];\n this.branchedComponentTrees = [];\n }\n\n realm: Realm;\n statistics: ReactStatistics;\n logger: void | Logger;\n componentTreeState: ComponentTreeState;\n alreadyEvaluatedRootNodes: Map<ECMAScriptSourceFunctionValue, ReactEvaluatedNode>;\n alreadyEvaluatedNestedClosures: Set<FunctionValue>;\n componentTreeConfig: ReactComponentTreeConfig;\n currentEffectsStack: Array<Effects>;\n nestedOptimizedClosures: Array<OptimizedClosure>;\n branchedComponentTrees: Array<BranchReactComponentTree>;\n\n resolveReactComponentTree(\n componentType: ECMAScriptSourceFunctionValue,\n props: ObjectValue | AbstractObjectValue | null,\n context: ObjectValue | AbstractObjectValue | null,\n evaluatedRootNode: ReactEvaluatedNode\n ): Effects {\n const resolveComponentTree = () => {\n try {\n let initialProps = props || getInitialProps(this.realm, componentType, this.componentTreeConfig);\n let initialContext = context || getInitialContext(this.realm, componentType);\n this.alreadyEvaluatedRootNodes.set(componentType, evaluatedRootNode);\n let { result } = this._resolveComponent(componentType, initialProps, initialContext, \"ROOT\", evaluatedRootNode);\n this.statistics.optimizedTrees++;\n return result;\n } catch (error) {\n this._handleComponentTreeRootFailure(error, evaluatedRootNode);\n // flow belives we can get here, when it should never be possible\n invariant(false, \"resolveReactComponentTree error not handled correctly\");\n }\n };\n\n try {\n this.realm.react.activeReconciler = this;\n let throwUnsupportedSideEffectError = (msg: string) => {\n throw new UnsupportedSideEffect(msg);\n };\n let effects = this.realm.wrapInGlobalEnv(() =>\n this.realm.evaluatePure(\n () =>\n this.realm.evaluateForEffects(\n resolveComponentTree,\n /*state*/ null,\n `react component: ${getComponentName(this.realm, componentType)}`\n ),\n (sideEffectType, binding, expressionLocation) =>\n handleReportedSideEffect(throwUnsupportedSideEffectError, sideEffectType, binding, expressionLocation)\n )\n );\n this._handleNestedOptimizedClosuresFromEffects(effects, evaluatedRootNode);\n return effects;\n } finally {\n this.realm.react.activeReconciler = undefined;\n }\n }\n\n _handleNestedOptimizedClosuresFromEffects(effects: Effects, evaluatedNode: ReactEvaluatedNode) {\n for (let { nestedEffects } of this.nestedOptimizedClosures) {\n if (nestedEffects.length === 0) {\n nestedEffects.push(...nestedEffects, effects);\n }\n }\n }\n\n resolveNestedOptimizedClosure(\n func: ECMAScriptSourceFunctionValue | BoundFunctionValue,\n nestedEffects: Array<Effects>,\n componentType: Value | null,\n context: ObjectValue | AbstractObjectValue | null,\n evaluatedNode: ReactEvaluatedNode\n ): Effects {\n const resolveOptimizedClosure = () => {\n let baseObject = this.realm.$GlobalEnv.environmentRecord.WithBaseObject();\n // we want to optimize the function that is bound\n if (func instanceof BoundFunctionValue) {\n // we want to set the \"this\" to be the bound object\n // for firstRender this will optimize the function\n // for updates, \"this\" will be intrinsic, so either way\n // they should both work\n baseObject = func.$BoundThis;\n invariant(func.$BoundTargetFunction instanceof ECMAScriptSourceFunctionValue);\n func = func.$BoundTargetFunction;\n }\n let numArgs = func.getLength();\n let args = [];\n let targetFunc = func;\n\n this.alreadyEvaluatedNestedClosures.add(func);\n invariant(targetFunc instanceof ECMAScriptSourceFunctionValue);\n let params = targetFunc.$FormalParameters;\n if (numArgs && numArgs > 0 && params) {\n for (let parameterId of params) {\n if (t.isIdentifier(parameterId)) {\n // Create an AbstractValue similar to __abstract being called\n args.push(\n AbstractValue.createAbstractArgument(\n this.realm,\n ((parameterId: any): BabelNodeIdentifier).name,\n targetFunc.expressionLocation\n )\n );\n } else {\n this.realm.handleError(\n new CompilerDiagnostic(\n \"Non-identifier args to additional functions unsupported\",\n targetFunc.expressionLocation,\n \"PP1005\",\n \"FatalError\"\n )\n );\n throw new FatalError(\"Non-identifier args to additional functions unsupported\");\n }\n }\n }\n try {\n invariant(\n baseObject instanceof ObjectValue ||\n baseObject instanceof AbstractObjectValue ||\n baseObject instanceof UndefinedValue\n );\n let value = getValueFromFunctionCall(this.realm, func, baseObject, args);\n invariant(componentType instanceof Value);\n invariant(context instanceof ObjectValue || context instanceof AbstractObjectValue);\n let result = this._resolveDeeply(componentType, value, context, \"NEW_BRANCH\", evaluatedNode);\n this.statistics.optimizedNestedClosures++;\n return result;\n } catch (error) {\n this._handleComponentTreeRootFailure(error, evaluatedNode);\n // flow belives we can get here, when it should never be possible\n invariant(false, \"resolveNestedOptimizedClosure error not handled correctly\");\n }\n };\n\n try {\n this.realm.react.activeReconciler = this;\n let throwUnsupportedSideEffectError = (msg: string) => {\n throw new UnsupportedSideEffect(msg);\n };\n let effects = this.realm.wrapInGlobalEnv(() =>\n this.realm.evaluatePure(\n () =>\n evaluateWithNestedParentEffects(this.realm, nestedEffects, () =>\n this.realm.evaluateForEffects(resolveOptimizedClosure, /*state*/ null, `react nested optimized closure`)\n ),\n (sideEffectType, binding, expressionLocation) =>\n handleReportedSideEffect(throwUnsupportedSideEffectError, sideEffectType, binding, expressionLocation)\n )\n );\n this._handleNestedOptimizedClosuresFromEffects(effects, evaluatedNode);\n return effects;\n } finally {\n this.realm.react.activeReconciler = undefined;\n }\n }\n\n clearComponentTreeState(): void {\n this.componentTreeState = this._createComponentTreeState();\n }\n\n _queueOptimizedClosure(\n func: ECMAScriptSourceFunctionValue | BoundFunctionValue,\n evaluatedNode: ReactEvaluatedNode,\n componentType: Value | null,\n context: ObjectValue | AbstractObjectValue | null\n ): void {\n if (this.realm.react.optimizeNestedFunctions) {\n this.nestedOptimizedClosures.push({\n evaluatedNode,\n func,\n nestedEffects: [],\n componentType,\n context,\n });\n }\n }\n\n _queueNewComponentTree(\n rootValue: Value,\n evaluatedNode: ReactEvaluatedNode,\n props?: ObjectValue | AbstractObjectValue | null = null,\n context?: ObjectValue | AbstractObjectValue | null = null\n ): void {\n if (rootValue instanceof SymbolValue) {\n return;\n }\n invariant(rootValue instanceof ECMAScriptSourceFunctionValue || rootValue instanceof AbstractValue);\n this.componentTreeState.deadEnds++;\n let componentType = getComponentTypeFromRootValue(this.realm, rootValue);\n if (componentType !== null && !this.hasEvaluatedRootNode(componentType, evaluatedNode)) {\n this.branchedComponentTrees.push({\n context,\n evaluatedNode,\n props,\n rootValue,\n });\n }\n }\n\n _resolveComplexClassComponent(\n componentType: ECMAScriptSourceFunctionValue,\n props: ObjectValue | AbstractObjectValue,\n context: ObjectValue | AbstractObjectValue,\n classMetadata: ClassComponentMetadata,\n branchStatus: BranchStatusEnum,\n evaluatedNode: ReactEvaluatedNode\n ): Value {\n if (branchStatus !== \"ROOT\") {\n // if the tree is simple and we're not in a branch, we can make this tree complex\n // and make this complex component the root\n let evaluatedComplexNode = this.alreadyEvaluatedRootNodes.get(componentType);\n if (\n branchStatus === \"NO_BRANCH\" &&\n this.componentTreeState.status === \"SIMPLE\" &&\n evaluatedComplexNode &&\n evaluatedComplexNode.status !== \"RENDER_PROPS\"\n ) {\n this.componentTreeState.componentType = componentType;\n } else {\n this._queueNewComponentTree(componentType, evaluatedNode);\n evaluatedNode.status = \"NEW_TREE\";\n throw new NewComponentTreeBranch(evaluatedNode);\n }\n }\n this.componentTreeState.status = \"COMPLEX\";\n // create a new instance of this React class component\n let instance = createClassInstance(this.realm, componentType, props, context, classMetadata);\n // get the \"render\" method off the instance\n let renderMethod = Get(this.realm, instance, \"render\");\n invariant(renderMethod instanceof ECMAScriptSourceFunctionValue);\n // the render method doesn't have any arguments, so we just assign the context of \"this\" to be the instance\n return getValueFromFunctionCall(this.realm, renderMethod, instance, []);\n }\n\n _resolveSimpleClassComponent(\n componentType: ECMAScriptSourceFunctionValue,\n props: ObjectValue | AbstractObjectValue,\n context: ObjectValue | AbstractObjectValue,\n branchStatus: BranchStatusEnum,\n evaluatedNode: ReactEvaluatedNode\n ): Value {\n // create a new simple instance of this React class component\n let instance = createSimpleClassInstance(this.realm, componentType, props, context);\n // get the \"render\" method off the instance\n let renderMethod = Get(this.realm, instance, \"render\");\n invariant(renderMethod instanceof ECMAScriptSourceFunctionValue);\n // the render method doesn't have any arguments, so we just assign the context of \"this\" to be the instance\n return getValueFromFunctionCall(this.realm, renderMethod, instance, []);\n }\n\n _resolveFunctionalComponent(\n componentType: ECMAScriptSourceFunctionValue,\n props: ObjectValue | AbstractObjectValue,\n context: ObjectValue | AbstractObjectValue,\n evaluatedNode: ReactEvaluatedNode\n ) {\n return getValueFromFunctionCall(this.realm, componentType, this.realm.intrinsics.undefined, [props, context]);\n }\n\n _getClassComponentMetadata(\n componentType: ECMAScriptSourceFunctionValue,\n props: ObjectValue | AbstractObjectValue,\n context: ObjectValue | AbstractObjectValue\n ): ClassComponentMetadata {\n if (this.realm.react.classComponentMetadata.has(componentType)) {\n let classMetadata = this.realm.react.classComponentMetadata.get(componentType);\n invariant(classMetadata);\n return classMetadata;\n }\n // get all this assignments in the constructor\n let classMetadata = evaluateClassConstructor(this.realm, componentType, props, context);\n this.realm.react.classComponentMetadata.set(componentType, classMetadata);\n return classMetadata;\n }\n\n _resolveContextProviderComponent(\n componentType: Value,\n reactElement: ObjectValue,\n context: ObjectValue | AbstractObjectValue,\n branchStatus: BranchStatusEnum,\n evaluatedNode: ReactEvaluatedNode\n ): Value {\n let typeValue = getProperty(this.realm, reactElement, \"type\");\n let propsValue = getProperty(this.realm, reactElement, \"props\");\n\n let evaluatedChildNode = createReactEvaluatedNode(\"NORMAL\", \"Context.Provider\");\n evaluatedNode.children.push(evaluatedChildNode);\n this.statistics.componentsEvaluated++;\n invariant(typeValue instanceof ObjectValue || typeValue instanceof AbstractObjectValue);\n const contextConsumer = getProperty(this.realm, typeValue, \"context\");\n invariant(contextConsumer instanceof ObjectValue || contextConsumer instanceof AbstractObjectValue);\n let lastValueProp = getProperty(this.realm, contextConsumer, \"currentValue\");\n this._incremementReferenceForContextNode(contextConsumer);\n\n let valueProp;\n // if we have a value prop, set it\n if (propsValue instanceof ObjectValue || propsValue instanceof AbstractObjectValue) {\n valueProp = Get(this.realm, propsValue, \"value\");\n setContextCurrentValue(contextConsumer, valueProp);\n }\n if (propsValue instanceof ObjectValue) {\n // if the value is abstract, we need to keep the render prop as unless\n // we are in firstRenderOnly mode, where we can just inline the abstract value\n if (!(valueProp instanceof AbstractValue) || this.componentTreeConfig.firstRenderOnly) {\n let resolvedReactElement = this._resolveReactElementHostChildren(\n componentType,\n reactElement,\n context,\n branchStatus,\n evaluatedChildNode\n );\n let resolvedPropsValue = getProperty(this.realm, resolvedReactElement, \"props\");\n invariant(resolvedPropsValue instanceof ObjectValue || resolvedPropsValue instanceof AbstractObjectValue);\n invariant(lastValueProp instanceof Value);\n setContextCurrentValue(contextConsumer, lastValueProp);\n this._decremementReferenceForContextNode(contextConsumer);\n // if we no dead ends, we know the rest of the tree and can safely remove the provider\n if (this.componentTreeState.deadEnds === 0) {\n let childrenValue = Get(this.realm, resolvedPropsValue, \"children\");\n evaluatedChildNode.status = \"INLINED\";\n this.statistics.inlinedComponents++;\n return childrenValue;\n }\n return resolvedReactElement;\n }\n }\n let children = this._resolveReactElementHostChildren(\n componentType,\n reactElement,\n context,\n branchStatus,\n evaluatedChildNode\n );\n setContextCurrentValue(contextConsumer, lastValueProp);\n this._decremementReferenceForContextNode(contextConsumer);\n return children;\n }\n\n _decremementReferenceForContextNode(contextNode: ObjectValue | AbstractObjectValue): void {\n let references = this.componentTreeState.contextNodeReferences.get(contextNode);\n if (!references) {\n references = 0;\n } else {\n references--;\n }\n this.componentTreeState.contextNodeReferences.set(contextNode, references);\n }\n\n _incremementReferenceForContextNode(contextNode: ObjectValue | AbstractObjectValue): void {\n let references = this.componentTreeState.contextNodeReferences.get(contextNode);\n if (!references) {\n references = 1;\n } else {\n references++;\n }\n this.componentTreeState.contextNodeReferences.set(contextNode, references);\n }\n\n _isContextValueKnown(contextNode: ObjectValue | AbstractObjectValue): boolean {\n if (this.componentTreeConfig.isRoot) {\n return true;\n }\n if (this.componentTreeState.contextNodeReferences.has(contextNode)) {\n let references = this.componentTreeState.contextNodeReferences.get(contextNode);\n if (!references) {\n return false;\n }\n return references > 0;\n }\n return false;\n }\n\n _resolveContextConsumerComponent(\n componentType: Value,\n reactElement: ObjectValue,\n context: ObjectValue | AbstractObjectValue,\n branchStatus: BranchStatusEnum,\n evaluatedNode: ReactEvaluatedNode\n ): Value | void {\n let typeValue = getProperty(this.realm, reactElement, \"type\");\n let propsValue = getProperty(this.realm, reactElement, \"props\");\n let evaluatedChildNode = createReactEvaluatedNode(\"RENDER_PROPS\", \"Context.Consumer\");\n evaluatedNode.children.push(evaluatedChildNode);\n\n if (propsValue instanceof ObjectValue || propsValue instanceof AbstractObjectValue) {\n // get the \"render\" prop child off the instance\n if (propsValue instanceof ObjectValue && propsValue.properties.has(\"children\")) {\n let renderProp = getProperty(this.realm, propsValue, \"children\");\n\n this._findReactComponentTrees(propsValue, evaluatedChildNode, \"NORMAL_FUNCTIONS\");\n if (renderProp instanceof ECMAScriptSourceFunctionValue) {\n if (typeValue instanceof ObjectValue || typeValue instanceof AbstractObjectValue) {\n // make sure this context is in our tree\n if (this._isContextValueKnown(typeValue)) {\n let valueProp = Get(this.realm, typeValue, \"currentValue\");\n // if the value is abstract, we need to keep the render prop as unless\n // we are in firstRenderOnly mode, where we can just inline the abstract value\n if (!(valueProp instanceof AbstractValue) || this.componentTreeConfig.firstRenderOnly) {\n let result = getValueFromFunctionCall(this.realm, renderProp, this.realm.intrinsics.undefined, [\n valueProp,\n ]);\n this.statistics.inlinedComponents++;\n this.statistics.componentsEvaluated++;\n evaluatedChildNode.status = \"INLINED\";\n return this._resolveDeeply(componentType, result, context, branchStatus, evaluatedNode);\n }\n }\n }\n this._queueOptimizedClosure(renderProp, evaluatedChildNode, componentType, context);\n return;\n } else {\n this._findReactComponentTrees(renderProp, evaluatedChildNode, \"NESTED_CLOSURES\");\n }\n }\n }\n this.componentTreeState.deadEnds++;\n return;\n }\n\n _resolveForwardRefComponent(\n componentType: Value,\n reactElement: ObjectValue,\n context: ObjectValue | AbstractObjectValue,\n branchStatus: BranchStatusEnum,\n evaluatedNode: ReactEvaluatedNode\n ): Value | void {\n let typeValue = getProperty(this.realm, reactElement, \"type\");\n let propsValue = getProperty(this.realm, reactElement, \"props\");\n let refValue = getProperty(this.realm, reactElement, \"ref\");\n invariant(typeValue instanceof AbstractValue || typeValue instanceof ObjectValue);\n let reactHint = this.realm.react.abstractHints.get(typeValue);\n\n invariant(reactHint !== undefined);\n let [forwardedComponent] = reactHint.args;\n let evaluatedChildNode = createReactEvaluatedNode(\"FORWARD_REF\", getComponentName(this.realm, forwardedComponent));\n evaluatedNode.children.push(evaluatedChildNode);\n invariant(\n forwardedComponent instanceof ECMAScriptSourceFunctionValue,\n \"expect React.forwardRef() to be passed function value\"\n );\n let value = getValueFromFunctionCall(this.realm, forwardedComponent, this.realm.intrinsics.undefined, [\n propsValue,\n refValue,\n ]);\n return this._resolveDeeply(componentType, value, context, branchStatus, evaluatedChildNode);\n }\n\n _resolveRelayQueryRendererComponent(\n componentType: Value,\n reactElement: ObjectValue,\n context: ObjectValue | AbstractObjectValue,\n evaluatedNode: ReactEvaluatedNode\n ): Value | void {\n let typeValue = getProperty(this.realm, reactElement, \"type\");\n let propsValue = getProperty(this.realm, reactElement, \"props\");\n\n let evaluatedChildNode = createReactEvaluatedNode(\"RENDER_PROPS\", getComponentName(this.realm, typeValue));\n evaluatedNode.children.push(evaluatedChildNode);\n\n if (propsValue instanceof ObjectValue || propsValue instanceof AbstractObjectValue) {\n // get the \"render\" prop\n if (propsValue instanceof ObjectValue && propsValue.properties.has(\"render\")) {\n let renderProp = getProperty(this.realm, propsValue, \"render\");\n\n if (renderProp instanceof ECMAScriptSourceFunctionValue) {\n this._queueOptimizedClosure(renderProp, evaluatedChildNode, componentType, context);\n } else if (renderProp instanceof AbstractValue) {\n this._findReactComponentTrees(renderProp, evaluatedChildNode, \"NESTED_CLOSURES\", componentType, context);\n }\n }\n this._findReactComponentTrees(propsValue, evaluatedChildNode, \"NORMAL_FUNCTIONS\");\n return;\n }\n // this is the worst case, we were unable to find the render prop function\n // and won't be able to find any further components to evaluate as trees\n // because of that\n this.componentTreeState.deadEnds++;\n }\n\n _resolveClassComponent(\n componentType: ECMAScriptSourceFunctionValue,\n props: ObjectValue | AbstractObjectValue,\n context: ObjectValue | AbstractObjectValue,\n branchStatus: BranchStatusEnum,\n evaluatedNode: ReactEvaluatedNode\n ): Value {\n let value;\n\n let classMetadata = this._getClassComponentMetadata(componentType, props, context);\n let { instanceProperties, instanceSymbols } = classMetadata;\n\n // if there were no this assignments we can try and render it as a simple class component\n if (instanceProperties.size === 0 && instanceSymbols.size === 0) {\n // We first need to know what type of class component we're dealing with.\n // A \"simple\" class component is defined as:\n //\n // - having only a \"render\" method\n // - having no lifecycle events\n // - having no state\n // - having no instance variables\n //\n // the only things a class component should be able to access on \"this\" are:\n // - this.props\n // - this.context\n // - this._someRenderMethodX() etc\n //\n // Otherwise, the class component is a \"complex\" one.\n // To begin with, we don't know what type of component it is, so we try and render it as if it were\n // a simple component using the above heuristics. If an error occurs during this process, we assume\n // that the class wasn't simple, then try again with the \"complex\" heuristics.\n try {\n value = this._resolveSimpleClassComponent(componentType, props, context, branchStatus, evaluatedNode);\n } catch (error) {\n // if we get back a SimpleClassBailOut error, we know that this class component\n // wasn't a simple one and is likely to be a complex class component instead\n if (error instanceof SimpleClassBailOut) {\n // the component was not simple, so we continue with complex case\n } else {\n // else we rethrow the error\n throw error;\n }\n }\n }\n // handle the complex class component if there is not value\n if (value === undefined) {\n value = this._resolveComplexClassComponent(\n componentType,\n props,\n context,\n classMetadata,\n branchStatus,\n evaluatedNode\n );\n }\n return value;\n }\n\n _resolveClassComponentForFirstRenderOnly(\n componentType: ECMAScriptSourceFunctionValue,\n props: ObjectValue | AbstractObjectValue,\n context: ObjectValue | AbstractObjectValue,\n branchStatus: BranchStatusEnum,\n evaluatedNode: ReactEvaluatedNode\n ): Value {\n // create a new simple instance of this React class component\n let instance = createClassInstanceForFirstRenderOnly(this.realm, componentType, props, context, evaluatedNode);\n let getDerivedStateFromProps = Get(this.realm, componentType, \"getDerivedStateFromProps\");\n let getSnapshotBeforeUpdate = Get(this.realm, instance, \"getSnapshotBeforeUpdate\");\n\n // if either getDerivedStateFromProps or getSnapshotBeforeUpdate exist, then\n // we don't try and execute componentWillMount and UNSAFE_componentWillMount\n if (\n getDerivedStateFromProps !== this.realm.intrinsics.undefined ||\n getSnapshotBeforeUpdate !== this.realm.intrinsics.undefined\n ) {\n if (getDerivedStateFromProps instanceof ECMAScriptSourceFunctionValue && getDerivedStateFromProps.$Call) {\n applyGetDerivedStateFromProps(this.realm, getDerivedStateFromProps, instance, props);\n }\n } else {\n // get the \"componentWillMount\" and \"render\" methods off the instance\n let componentWillMount = Get(this.realm, instance, \"componentWillMount\");\n\n if (componentWillMount instanceof ECMAScriptSourceFunctionValue && componentWillMount.$Call) {\n componentWillMount.$Call(instance, []);\n }\n let unsafeComponentWillMount = Get(this.realm, instance, \"UNSAFE_componentWillMount\");\n\n if (unsafeComponentWillMount instanceof ECMAScriptSourceFunctionValue && unsafeComponentWillMount.$Call) {\n unsafeComponentWillMount.$Call(instance, []);\n }\n }\n let renderMethod = Get(this.realm, instance, \"render\");\n\n invariant(renderMethod instanceof ECMAScriptSourceFunctionValue);\n return getValueFromFunctionCall(this.realm, renderMethod, instance, []);\n }\n\n _resolveRelayContainer(\n reactHint: ReactHint,\n props: ObjectValue | AbstractObjectValue,\n context: ObjectValue | AbstractObjectValue,\n branchStatus: BranchStatusEnum,\n evaluatedNode: ReactEvaluatedNode\n ) {\n evaluatedNode.status = \"INLINED\";\n evaluatedNode.message = \"RelayContainer\";\n invariant(reactHint.firstRenderValue instanceof Value);\n // for better serialization, ensure context has the right abstract properties defined\n if (getProperty(this.realm, context, \"relay\") === this.realm.intrinsics.undefined) {\n let abstractRelayContext = AbstractValue.createAbstractObject(this.realm, \"context.relay\");\n let abstractRelayEnvironment = AbstractValue.createAbstractObject(this.realm, \"context.relay.environment\");\n let abstractRelayInternal = AbstractValue.createAbstractObject(\n this.realm,\n \"context.relay.environment.unstable_internal\"\n );\n Properties.Set(this.realm, context, \"relay\", abstractRelayContext, true);\n Properties.Set(this.realm, abstractRelayContext, \"environment\", abstractRelayEnvironment, true);\n Properties.Set(this.realm, abstractRelayEnvironment, \"unstable_internal\", abstractRelayInternal, true);\n }\n // add contextType to this component\n this.componentTreeState.contextTypes.add(\"relay\");\n return this._resolveComponent(reactHint.firstRenderValue, props, context, branchStatus, evaluatedNode);\n }\n\n _resolveComponent(\n componentType: Value,\n props: ObjectValue | AbstractObjectValue,\n context: ObjectValue | AbstractObjectValue,\n branchStatus: BranchStatusEnum,\n evaluatedNode: ReactEvaluatedNode\n ) {\n if (doNotOptimizeComponent(this.realm, componentType)) {\n throw new DoNotOptimize(\"__reactCompilerDoNotOptimize flag detected\");\n }\n this.statistics.componentsEvaluated++;\n if (valueIsKnownReactAbstraction(this.realm, componentType)) {\n invariant(componentType instanceof AbstractValue);\n let reactHint = this.realm.react.abstractHints.get(componentType);\n\n invariant(reactHint);\n if (\n typeof reactHint !== \"string\" &&\n reactHint.object === this.realm.fbLibraries.reactRelay &&\n this.componentTreeConfig.firstRenderOnly\n ) {\n return this._resolveRelayContainer(reactHint, props, context, branchStatus, evaluatedNode);\n }\n this._queueNewComponentTree(componentType, evaluatedNode);\n evaluatedNode.status = \"NEW_TREE\";\n evaluatedNode.message = \"RelayContainer\";\n throw new NewComponentTreeBranch(evaluatedNode);\n }\n invariant(componentType instanceof ECMAScriptSourceFunctionValue);\n let value;\n let childContext = context;\n\n // first we check if it's a legacy class component\n if (valueIsLegacyCreateClassComponent(this.realm, componentType)) {\n throw new ExpectedBailOut(\"components created with create-react-class are not supported\");\n } else if (valueIsClassComponent(this.realm, componentType)) {\n if (this.componentTreeConfig.firstRenderOnly) {\n value = this._resolveClassComponentForFirstRenderOnly(\n componentType,\n props,\n context,\n branchStatus,\n evaluatedNode\n );\n } else {\n value = this._resolveClassComponent(componentType, props, context, branchStatus, evaluatedNode);\n }\n } else {\n value = this._resolveFunctionalComponent(componentType, props, context, evaluatedNode);\n if (valueIsFactoryClassComponent(this.realm, value)) {\n invariant(value instanceof ObjectValue);\n if (branchStatus !== \"ROOT\") {\n throw new ExpectedBailOut(\"non-root factory class components are not suppoted\");\n } else {\n // TODO support factory components\n return {\n result: value,\n childContext,\n };\n }\n }\n }\n invariant(value !== undefined);\n return {\n result: this._resolveDeeply(\n componentType,\n value,\n context,\n branchStatus === \"ROOT\" ? \"NO_BRANCH\" : branchStatus,\n evaluatedNode\n ),\n childContext,\n };\n }\n\n _createComponentTreeState(): ComponentTreeState {\n return {\n componentType: undefined,\n contextTypes: new Set(),\n deadEnds: 0,\n status: \"SIMPLE\",\n contextNodeReferences: new Map(),\n };\n }\n\n _getComponentResolutionStrategy(value: Value): ComponentResolutionStrategy {\n // check if it's a ReactRelay.QueryRenderer\n if (this.realm.fbLibraries.reactRelay !== undefined) {\n let QueryRenderer = getProperty(this.realm, this.realm.fbLibraries.reactRelay, \"QueryRenderer\");\n if (value === QueryRenderer) {\n return \"RELAY_QUERY_RENDERER\";\n }\n }\n if (value === getReactSymbol(\"react.fragment\", this.realm)) {\n return \"FRAGMENT\";\n }\n if (value instanceof AbstractValue && this.realm.react.abstractHints.has(value)) {\n let reactHint = this.realm.react.abstractHints.get(value);\n\n invariant(reactHint !== undefined);\n if (reactHint.object === this.realm.fbLibraries.react && reactHint.propertyName === \"forwardRef\") {\n return \"FORWARD_REF\";\n }\n }\n if ((value instanceof ObjectValue || value instanceof AbstractObjectValue) && value.kind !== \"conditional\") {\n let $$typeof = getProperty(this.realm, value, \"$$typeof\");\n\n if ($$typeof === getReactSymbol(\"react.context\", this.realm)) {\n return \"CONTEXT_CONSUMER\";\n }\n if ($$typeof === getReactSymbol(\"react.provider\", this.realm)) {\n return \"CONTEXT_PROVIDER\";\n }\n }\n return \"NORMAL\";\n }\n\n _resolveReactDomPortal(\n createPortalNode: AbstractValue,\n args: Array<Value>,\n componentType: Value,\n context: ObjectValue | AbstractObjectValue,\n branchStatus: BranchStatusEnum,\n evaluatedNode: ReactEvaluatedNode\n ) {\n let [reactPortalValue, domNodeValue] = args;\n let evaluatedChildNode = createReactEvaluatedNode(\"INLINED\", \"ReactDOM.createPortal\");\n let resolvedReactPortalValue = this._resolveDeeply(\n componentType,\n reactPortalValue,\n context,\n branchStatus,\n evaluatedChildNode\n );\n evaluatedNode.children.push(evaluatedChildNode);\n if (resolvedReactPortalValue !== reactPortalValue) {\n this.statistics.inlinedComponents++;\n let reactDomValue = this.realm.fbLibraries.reactDom;\n invariant(reactDomValue instanceof ObjectValue);\n let reactDomPortalFunc = getProperty(this.realm, reactDomValue, \"createPortal\");\n return AbstractValue.createTemporalFromBuildFunction(\n this.realm,\n ObjectValue,\n [reactDomPortalFunc, resolvedReactPortalValue, domNodeValue],\n createOperationDescriptor(\"REACT_TEMPORAL_FUNC\"),\n { skipInvariant: true, isPure: true }\n );\n }\n return createPortalNode;\n }\n\n _resolveAbstractConditionalValue(\n componentType: Value,\n condValue: AbstractValue,\n consequentVal: Value,\n alternateVal: Value,\n context: ObjectValue | AbstractObjectValue,\n evaluatedNode: ReactEvaluatedNode\n ) {\n let value = this.realm.evaluateWithAbstractConditional(\n condValue,\n () => {\n return this.realm.evaluateForEffects(\n () =>\n wrapReactElementInBranchOrReturnValue(\n this.realm,\n this._resolveDeeply(componentType, consequentVal, context, \"NEW_BRANCH\", evaluatedNode)\n ),\n null,\n \"_resolveAbstractConditionalValue consequent\"\n );\n },\n () => {\n return this.realm.evaluateForEffects(\n () =>\n wrapReactElementInBranchOrReturnValue(\n this.realm,\n this._resolveDeeply(componentType, alternateVal, context, \"NEW_BRANCH\", evaluatedNode)\n ),\n null,\n \"_resolveAbstractConditionalValue alternate\"\n );\n }\n );\n if (value instanceof AbstractValue && value.kind === \"conditional\") {\n return getValueWithBranchingLogicApplied(this.realm, consequentVal, alternateVal, value);\n }\n return value;\n }\n\n _resolveAbstractLogicalValue(\n componentType: Value,\n value: AbstractValue,\n context: ObjectValue | AbstractObjectValue,\n evaluatedNode: ReactEvaluatedNode\n ) {\n let [leftValue, rightValue] = value.args;\n let operator = value.kind;\n\n invariant(leftValue instanceof AbstractValue);\n if (operator === \"||\") {\n return this._resolveAbstractConditionalValue(\n componentType,\n leftValue,\n leftValue,\n rightValue,\n context,\n evaluatedNode\n );\n } else {\n return this._resolveAbstractConditionalValue(\n componentType,\n leftValue,\n rightValue,\n leftValue,\n context,\n evaluatedNode\n );\n }\n }\n\n _resolveAbstractValue(\n componentType: Value,\n value: AbstractValue,\n context: ObjectValue | AbstractObjectValue,\n branchStatus: BranchStatusEnum,\n evaluatedNode: ReactEvaluatedNode\n ): Value {\n invariant(this.realm.generator);\n // TODO investigate what other kinds than \"conditional\" might be safe to deeply resolve\n if (value.kind === \"conditional\") {\n let [condValue, consequentVal, alternateVal] = value.args;\n invariant(condValue instanceof AbstractValue);\n return this._resolveAbstractConditionalValue(\n componentType,\n condValue,\n consequentVal,\n alternateVal,\n context,\n evaluatedNode\n );\n } else if (value.kind === \"||\" || value.kind === \"&&\") {\n return this._resolveAbstractLogicalValue(componentType, value, context, evaluatedNode);\n } else {\n if (value instanceof AbstractValue && this.realm.react.abstractHints.has(value)) {\n let reactHint = this.realm.react.abstractHints.get(value);\n\n invariant(reactHint !== undefined);\n if (reactHint.object === this.realm.fbLibraries.reactDom && reactHint.propertyName === \"createPortal\") {\n return this._resolveReactDomPortal(\n value,\n reactHint.args,\n componentType,\n context,\n branchStatus,\n evaluatedNode\n );\n }\n }\n this.componentTreeState.deadEnds++;\n }\n return value;\n }\n\n _resolveUnknownComponentType(reactElement: ObjectValue, evaluatedNode: ReactEvaluatedNode) {\n let typeValue = getProperty(this.realm, reactElement, \"type\");\n let propsValue = getProperty(this.realm, reactElement, \"props\");\n\n this._findReactComponentTrees(propsValue, evaluatedNode, \"NORMAL_FUNCTIONS\");\n if (typeValue instanceof AbstractValue) {\n this._findReactComponentTrees(typeValue, evaluatedNode, \"FUNCTIONAL_COMPONENTS\");\n return reactElement;\n } else {\n let evaluatedChildNode = createReactEvaluatedNode(\"BAIL-OUT\", getComponentName(this.realm, typeValue));\n evaluatedNode.children.push(evaluatedChildNode);\n let bailOutMessage = `type on <Component /> was not a ECMAScriptSourceFunctionValue`;\n evaluatedChildNode.message = bailOutMessage;\n this._assignBailOutMessage(reactElement, bailOutMessage);\n this.componentTreeState.deadEnds++;\n return reactElement;\n }\n }\n\n _resolveReactElementBadRef(reactElement: ObjectValue, evaluatedNode: ReactEvaluatedNode) {\n let typeValue = getProperty(this.realm, reactElement, \"type\");\n let propsValue = getProperty(this.realm, reactElement, \"props\");\n\n let evaluatedChildNode = createReactEvaluatedNode(\"BAIL-OUT\", getComponentName(this.realm, typeValue));\n evaluatedNode.children.push(evaluatedChildNode);\n let bailOutMessage = `refs are not supported on <Components />`;\n evaluatedChildNode.message = bailOutMessage;\n\n this._queueNewComponentTree(typeValue, evaluatedChildNode);\n this._findReactComponentTrees(propsValue, evaluatedNode, \"NORMAL_FUNCTIONS\");\n this._assignBailOutMessage(reactElement, bailOutMessage);\n return reactElement;\n }\n\n _resolveReactElementUndefinedRender(\n reactElement: ObjectValue,\n evaluatedNode: ReactEvaluatedNode,\n branchStatus: BranchStatusEnum\n ) {\n let typeValue = getProperty(this.realm, reactElement, \"type\");\n let propsValue = getProperty(this.realm, reactElement, \"props\");\n\n let evaluatedChildNode = createReactEvaluatedNode(\"BAIL-OUT\", getComponentName(this.realm, typeValue));\n evaluatedNode.children.push(evaluatedChildNode);\n let bailOutMessage = `undefined was returned from render`;\n evaluatedChildNode.message = bailOutMessage;\n\n this._assignBailOutMessage(reactElement, bailOutMessage);\n this._findReactComponentTrees(propsValue, evaluatedNode, \"NORMAL_FUNCTIONS\");\n return reactElement;\n }\n\n _resolveReactElementHostChildren(\n componentType: Value,\n reactElement: ObjectValue,\n context: ObjectValue | AbstractObjectValue,\n branchStatus: BranchStatusEnum,\n evaluatedNode: ReactEvaluatedNode\n ) {\n let propsValue = getProperty(this.realm, reactElement, \"props\");\n // terminal host component. Start evaluating its children.\n if (propsValue instanceof ObjectValue && propsValue.properties.has(\"children\")) {\n let childrenValue = Get(this.realm, propsValue, \"children\");\n\n if (childrenValue instanceof Value) {\n let resolvedChildren = this._resolveDeeply(componentType, childrenValue, context, branchStatus, evaluatedNode);\n // we can optimize further and flatten arrays on non-composite components\n if (resolvedChildren instanceof ArrayValue && !resolvedChildren.intrinsicName) {\n resolvedChildren = flattenChildren(this.realm, resolvedChildren);\n }\n if (resolvedChildren !== childrenValue) {\n let newProps = cloneProps(this.realm, propsValue, resolvedChildren);\n\n // This is safe to do as we clone a new ReactElement as part of reconcilation\n // so we will never be mutating an object used by something else. Furthermore,\n // the ReactElement is \"immutable\" so it can never change and only React controls\n // this object.\n hardModifyReactObjectPropertyBinding(this.realm, reactElement, \"props\", newProps);\n }\n }\n }\n return reactElement;\n }\n\n _resolveFragmentComponent(\n componentType: Value,\n reactElement: ObjectValue,\n context: ObjectValue | AbstractObjectValue,\n branchStatus: BranchStatusEnum,\n evaluatedNode: ReactEvaluatedNode\n ) {\n this.statistics.componentsEvaluated++;\n if (this.componentTreeConfig.firstRenderOnly) {\n let evaluatedChildNode = createReactEvaluatedNode(\"INLINED\", \"React.Fragment\");\n evaluatedNode.children.push(evaluatedChildNode);\n this.statistics.inlinedComponents++;\n let children = this._resolveReactElementHostChildren(\n componentType,\n reactElement,\n context,\n branchStatus,\n evaluatedChildNode\n );\n return children;\n } else {\n let evaluatedChildNode = createReactEvaluatedNode(\"NORMAL\", \"React.Fragment\");\n evaluatedNode.children.push(evaluatedChildNode);\n return this._resolveReactElementHostChildren(\n componentType,\n reactElement,\n context,\n branchStatus,\n evaluatedChildNode\n );\n }\n }\n\n _resolveReactElement(\n componentType: Value,\n reactElement: ObjectValue,\n context: ObjectValue | AbstractObjectValue,\n branchStatus: BranchStatusEnum,\n evaluatedNode: ReactEvaluatedNode\n ) {\n // We create a clone of the ReactElement to be safe. This is because the same\n // ReactElement might be a temporal referenced in other effects and also it allows us to\n // easily mutate and swap the props of the ReactElement with the optimized version with\n // resolved/inlined children.\n // Note: We used to sanitize out props for firstRender here, we now do this during serialization.\n reactElement = cloneReactElement(this.realm, reactElement, false);\n let typeValue = getProperty(this.realm, reactElement, \"type\");\n let propsValue = getProperty(this.realm, reactElement, \"props\");\n let refValue = getProperty(this.realm, reactElement, \"ref\");\n\n invariant(\n !(typeValue instanceof AbstractValue && typeValue.kind === \"conditional\"),\n `the reconciler should never encounter a ReactElement \"type\" that is conditional abstract value`\n );\n invariant(\n !(propsValue instanceof AbstractValue && propsValue.kind === \"conditional\"),\n `the reconciler should never encounter a ReactElement \"props\" that is conditional abstract value`\n );\n\n if (typeValue instanceof StringValue) {\n return this._resolveReactElementHostChildren(componentType, reactElement, context, branchStatus, evaluatedNode);\n }\n if (!(propsValue instanceof ObjectValue || propsValue instanceof AbstractObjectValue)) {\n this._assignBailOutMessage(\n reactElement,\n `props on <Component /> was not not an ObjectValue or an AbstractObjectValue`\n );\n return reactElement;\n }\n let componentResolutionStrategy = this._getComponentResolutionStrategy(typeValue);\n\n // We do not support \"ref\" on <Component /> ReactElements, unless it's a forwarded ref\n // or we are firstRenderOnly mode (in which case, we ignore the ref)\n if (\n !this.componentTreeConfig.firstRenderOnly &&\n !(refValue instanceof NullValue) &&\n componentResolutionStrategy !== \"FORWARD_REF\" &&\n // If we have an abstract value, it might mean a bad ref, but we will have\n // already thrown a FatalError in the createElement implementation by this\n // point, so if we're here, then the FatalError has been recovered explicitly\n !(refValue instanceof AbstractValue)\n ) {\n this._resolveReactElementBadRef(reactElement, evaluatedNode);\n }\n try {\n let result;\n\n switch (componentResolutionStrategy) {\n case \"NORMAL\": {\n if (\n !(typeValue instanceof ECMAScriptSourceFunctionValue || valueIsKnownReactAbstraction(this.realm, typeValue))\n ) {\n return this._resolveUnknownComponentType(reactElement, evaluatedNode);\n }\n let evaluatedChildNode = createReactEvaluatedNode(\"INLINED\", getComponentName(this.realm, typeValue));\n let render = this._resolveComponent(\n typeValue,\n propsValue,\n context,\n branchStatus === \"NEW_BRANCH\" ? \"BRANCH\" : branchStatus,\n evaluatedChildNode\n );\n if (this.logger !== undefined && this.realm.react.verbose && evaluatedChildNode.status === \"INLINED\") {\n this.logger.logInformation(` ✔ ${evaluatedChildNode.name} (inlined)`);\n }\n evaluatedNode.children.push(evaluatedChildNode);\n result = render.result;\n this.statistics.inlinedComponents++;\n break;\n }\n case \"FRAGMENT\": {\n return this._resolveFragmentComponent(componentType, reactElement, context, branchStatus, evaluatedNode);\n }\n case \"RELAY_QUERY_RENDERER\": {\n invariant(typeValue instanceof AbstractObjectValue);\n result = this._resolveRelayQueryRendererComponent(componentType, reactElement, context, evaluatedNode);\n break;\n }\n case \"CONTEXT_PROVIDER\": {\n return this._resolveContextProviderComponent(\n componentType,\n reactElement,\n context,\n branchStatus,\n evaluatedNode\n );\n }\n case \"CONTEXT_CONSUMER\": {\n result = this._resolveContextConsumerComponent(\n componentType,\n reactElement,\n context,\n branchStatus,\n evaluatedNode\n );\n break;\n }\n case \"FORWARD_REF\": {\n result = this._resolveForwardRefComponent(componentType, reactElement, context, branchStatus, evaluatedNode);\n break;\n }\n default:\n invariant(false, \"unsupported component resolution strategy\");\n }\n\n if (result === undefined) {\n result = reactElement;\n }\n if (result instanceof UndefinedValue) {\n return this._resolveReactElementUndefinedRender(reactElement, evaluatedNode, branchStatus);\n }\n return result;\n } catch (error) {\n return this._resolveComponentResolutionFailure(error, reactElement, evaluatedNode, branchStatus);\n }\n }\n\n _handleComponentTreeRootFailure(error: Error | Completion, evaluatedRootNode: ReactEvaluatedNode): void {\n if (error.name === \"Invariant Violation\") {\n throw error;\n } else if (error instanceof ReconcilerFatalError) {\n throw new ReconcilerFatalError(error.message, evaluatedRootNode);\n } else if (error instanceof UnsupportedSideEffect || error instanceof DoNotOptimize) {\n throw new ReconcilerFatalError(\n `Failed to render React component root \"${evaluatedRootNode.name}\" due to ${error.message}`,\n evaluatedRootNode\n );\n } else if (error instanceof Completion) {\n let value = error.value;\n invariant(value instanceof ObjectValue);\n let message = getProperty(this.realm, value, \"message\");\n let stack = getProperty(this.realm, value, \"stack\");\n invariant(message instanceof StringValue);\n invariant(stack instanceof StringValue);\n throw new ReconcilerFatalError(\n `Failed to render React component \"${evaluatedRootNode.name}\" due to a JS error: ${message.value}\\n${\n stack.value\n }`,\n evaluatedRootNode\n );\n }\n let message;\n if (error instanceof ExpectedBailOut) {\n message = `Failed to optimize React component tree for \"${evaluatedRootNode.name}\" due to an expected bail-out: ${\n error.message\n }`;\n } else if (error instanceof FatalError) {\n message = `Failed to optimize React component tree for \"${\n evaluatedRootNode.name\n }\" due to a fatal error during evaluation: ${error.message}`;\n } else {\n // if we don't know what the error is, then best to rethrow\n throw error;\n }\n throw new ReconcilerFatalError(message, evaluatedRootNode);\n }\n\n _resolveComponentResolutionFailure(\n error: Error | Completion,\n reactElement: ObjectValue,\n evaluatedNode: ReactEvaluatedNode,\n branchStatus: BranchStatusEnum\n ): Value {\n if (error.name === \"Invariant Violation\") {\n throw error;\n } else if (error instanceof ReconcilerFatalError) {\n throw error;\n } else if (error instanceof UnsupportedSideEffect) {\n throw new ReconcilerFatalError(\n `Failed to render React component \"${evaluatedNode.name}\" due to ${error.message}`,\n evaluatedNode\n );\n } else if (error instanceof DoNotOptimize) {\n return reactElement;\n } else if (error instanceof Completion) {\n let value = error.value;\n invariant(value instanceof ObjectValue);\n let message = getProperty(this.realm, value, \"message\");\n let stack = getProperty(this.realm, value, \"stack\");\n invariant(message instanceof StringValue);\n invariant(stack instanceof StringValue);\n throw new ReconcilerFatalError(\n `Failed to render React component \"${evaluatedNode.name}\" due to a JS error: ${message.value}\\n${stack.value}`,\n evaluatedNode\n );\n }\n let typeValue = getProperty(this.realm, reactElement, \"type\");\n let propsValue = getProperty(this.realm, reactElement, \"props\");\n // assign a bail out message\n if (error instanceof NewComponentTreeBranch) {\n this._findReactComponentTrees(propsValue, evaluatedNode, \"NORMAL_FUNCTIONS\");\n evaluatedNode.children.push(error.evaluatedNode);\n // NO-OP (we don't queue a newComponentTree as this was already done)\n } else {\n let evaluatedChildNode = createReactEvaluatedNode(\"BAIL-OUT\", getComponentName(this.realm, typeValue));\n if (this.logger !== undefined && this.realm.react.verbose) {\n this.logger.logInformation(` ✖ ${evaluatedChildNode.name} (bail-out)`);\n }\n evaluatedNode.children.push(evaluatedChildNode);\n this._queueNewComponentTree(typeValue, evaluatedChildNode);\n this._findReactComponentTrees(propsValue, evaluatedNode, \"NORMAL_FUNCTIONS\");\n if (error instanceof ExpectedBailOut) {\n evaluatedChildNode.message = error.message;\n this._assignBailOutMessage(reactElement, error.message);\n } else if (error instanceof FatalError) {\n let message = \"evaluation failed\";\n evaluatedChildNode.message = message;\n this._assignBailOutMessage(reactElement, message);\n } else {\n evaluatedChildNode.message = `unknown error`;\n throw error;\n }\n }\n // a child component bailed out during component folding, so return the function value and continue\n return reactElement;\n }\n\n _resolveDeeply(\n componentType: Value,\n value: Value,\n context: ObjectValue | AbstractObjectValue,\n branchStatus: BranchStatusEnum,\n evaluatedNode: ReactEvaluatedNode\n ): Value {\n if (\n value instanceof StringValue ||\n value instanceof NumberValue ||\n value instanceof BooleanValue ||\n value instanceof NullValue ||\n value instanceof UndefinedValue\n ) {\n // terminal values\n return value;\n }\n invariant(\n !(value instanceof ObjectValue) || value._isFinal !== undefined,\n `An object value was detected during React reconcilation without its bindings properly applied`\n );\n if (value instanceof AbstractValue) {\n return this._resolveAbstractValue(componentType, value, context, branchStatus, evaluatedNode);\n } else if (value instanceof ArrayValue) {\n // TODO investigate what about other iterables type objects\n return this._resolveArray(componentType, value, context, branchStatus, evaluatedNode);\n } else if (value instanceof ObjectValue && isReactElement(value)) {\n return this._resolveReactElement(componentType, value, context, branchStatus, evaluatedNode);\n } else {\n let location = getLocationFromValue(value.expressionLocation);\n throw new ExpectedBailOut(`invalid return value from render${location}`);\n }\n }\n\n _assignBailOutMessage(reactElement: ObjectValue, message: string): void {\n // $BailOutReason is a field on ObjectValue that allows us to specify a message\n // that gets serialized as a comment node during the ReactElement serialization stage\n message = `Bail-out: ${message}`;\n if (reactElement.$BailOutReason !== undefined) {\n // merge bail out messages if one already exists\n reactElement.$BailOutReason += `, ${message}`;\n } else {\n reactElement.$BailOutReason = message;\n }\n }\n\n _resolveArray(\n componentType: Value,\n arrayValue: ArrayValue,\n context: ObjectValue | AbstractObjectValue,\n branchStatus: BranchStatusEnum,\n evaluatedNode: ReactEvaluatedNode\n ): ArrayValue {\n if (ArrayValue.isIntrinsicAndHasWidenedNumericProperty(arrayValue)) {\n let arrayHint = this.realm.react.arrayHints.get(arrayValue);\n\n if (arrayHint !== undefined) {\n let { func, thisVal } = arrayHint;\n if (func instanceof ECMAScriptSourceFunctionValue || func instanceof BoundFunctionValue) {\n if (thisVal && thisVal !== this.realm.intrinsics.undefined) {\n throw new ExpectedBailOut(`abstract mapped arrays with \"this\" argument are not yet supported`);\n }\n this._queueOptimizedClosure(func, evaluatedNode, componentType, context);\n }\n }\n return arrayValue;\n }\n let children = mapArrayValue(this.realm, arrayValue, elementValue =>\n this._resolveDeeply(componentType, elementValue, context, \"NEW_BRANCH\", evaluatedNode)\n );\n children.makeFinal();\n return children;\n }\n\n hasEvaluatedRootNode(componentType: ECMAScriptSourceFunctionValue, evaluateNode: ReactEvaluatedNode): boolean {\n if (this.alreadyEvaluatedRootNodes.has(componentType)) {\n let alreadyEvaluatedNode = this.alreadyEvaluatedRootNodes.get(componentType);\n invariant(alreadyEvaluatedNode);\n evaluateNode.children = alreadyEvaluatedNode.children;\n evaluateNode.status = alreadyEvaluatedNode.status;\n evaluateNode.name = alreadyEvaluatedNode.name;\n return true;\n }\n return false;\n }\n\n hasEvaluatedNestedClosure(func: ECMAScriptSourceFunctionValue | BoundFunctionValue): boolean {\n return this.alreadyEvaluatedNestedClosures.has(func);\n }\n\n _findReactComponentTrees(\n value: Value,\n evaluatedNode: ReactEvaluatedNode,\n treatFunctionsAs: \"NORMAL_FUNCTIONS\" | \"NESTED_CLOSURES\" | \"FUNCTIONAL_COMPONENTS\",\n componentType?: Value,\n context?: ObjectValue | AbstractObjectValue\n ): void {\n if (value instanceof AbstractValue) {\n if (value.args.length > 0) {\n for (let arg of value.args) {\n this._findReactComponentTrees(arg, evaluatedNode, treatFunctionsAs, componentType, context);\n }\n } else {\n this.componentTreeState.deadEnds++;\n }\n } else if (valueIsKnownReactAbstraction(this.realm, value)) {\n let evaluatedChildNode = createReactEvaluatedNode(\"NEW_TREE\", getComponentName(this.realm, value));\n evaluatedNode.children.push(evaluatedChildNode);\n this._queueNewComponentTree(value, evaluatedChildNode);\n } else if (value instanceof ECMAScriptSourceFunctionValue || value instanceof BoundFunctionValue) {\n if (valueIsClassComponent(this.realm, value) || treatFunctionsAs === \"FUNCTIONAL_COMPONENTS\") {\n let evaluatedChildNode = createReactEvaluatedNode(\"NEW_TREE\", getComponentName(this.realm, value));\n evaluatedNode.children.push(evaluatedChildNode);\n this._queueNewComponentTree(value, evaluatedChildNode);\n } else if (treatFunctionsAs === \"NESTED_CLOSURES\") {\n invariant(componentType && context);\n this._queueOptimizedClosure(value, evaluatedNode, componentType, context);\n }\n } else if (value instanceof ObjectValue) {\n if (isReactElement(value)) {\n let typeValue = getProperty(this.realm, value, \"type\");\n let ref = getProperty(this.realm, value, \"ref\");\n let props = getProperty(this.realm, value, \"props\");\n\n if (valueIsKnownReactAbstraction(this.realm, typeValue) || typeValue instanceof ECMAScriptSourceFunctionValue) {\n let evaluatedChildNode = createReactEvaluatedNode(\"NEW_TREE\", getComponentName(this.realm, typeValue));\n evaluatedNode.children.push(evaluatedChildNode);\n this._queueNewComponentTree(typeValue, evaluatedChildNode);\n }\n this._findReactComponentTrees(ref, evaluatedNode, treatFunctionsAs, componentType, context);\n this._findReactComponentTrees(props, evaluatedNode, treatFunctionsAs, componentType, context);\n } else {\n for (let [propName, binding] of value.properties) {\n if (binding && binding.descriptor && binding.descriptor.enumerable) {\n this._findReactComponentTrees(\n getProperty(this.realm, value, propName),\n evaluatedNode,\n treatFunctionsAs,\n componentType,\n context\n );\n }\n }\n }\n }\n }\n}\n"],"file":"reconcilation.js"} |