| 1 | {"version":3,"sources":["../../src/react/utils.js"],"names":["isReactElement","val","ObjectValue","realm","$Realm","react","enabled","reactElements","has","properties","$$typeof","getProperty","globalObject","$GlobalObject","globalSymbolValue","intrinsics","undefined","NumberValue","value","SymbolValue","symbolFromRegistry","globalSymbolRegistry","find","e","$Symbol","_isReactElement","$Key","set","createdDuringReconcilation","firstRenderOnly","isReactPropsObject","reactProps","getReactSymbol","symbolKey","reactSymbol","symbols","get","SymbolFor","Symbol","SymbolForDescriptor","descriptor","SymbolForValue","$Call","StringValue","isTagName","ast","type","test","name","isReactComponent","length","toUpperCase","valueIsClassComponent","FunctionValue","prototype","To","ToBooleanPartial","valueIsKnownReactAbstraction","AbstractObjectValue","abstractHints","valueIsReactLibraryObject","logger","fbLibraries","reactVersion","tryQuery","reactCreateElement","reactCloneElement","reactIsValidElement","reactComponent","reactChildren","valueIsLegacyCreateClassComponent","valueIsFactoryClassComponent","ArrayValue","isIntrinsicAndHasWidenedNumericProperty","addKeyToReactElement","reactElement","typeValue","refValue","propsValue","currentKeyValue","null","uniqueKey","getUniqueReactElementKey","usedReactElementKeys","newKeyValue","createInternalReactElement","index","key","Math","random","toString","replace","substring","add","forEachArrayValue","array","mapFunc","lengthValue","i","elementProperty","elementPropertyDescriptor","elementValue","Value","mapArrayValue","newArray","Create","ArrayCreate","returnTheNewArray","newElement","CreateDataPropertyOrThrow","GetDescriptorForProperty","propertyName","object","convertSimpleClassComponentToFunctionalComponent","complexComponentType","additionalFunctionEffects","configurable","Properties","DeletePropertyOrThrow","$FunctionKind","$Prototype","FunctionPrototype","$FormalParameters","t","identifier","transforms","push","body","funcNode","functionExpression","blockStatement","file","program","expressionStatement","path","node","isIdentifier","isThisExpression","parentPath","parentNode","isMemberExpression","replaceWith","property","FatalError","traverse","cache","clear","createBinding","cloneProperties","newProperties","Map","cloneSymbols","newSymbols","symbol","cloneValue","originalValue","_prototype","copyToObject","cloneFunction","newValue","ECMAScriptSourceFunctionValue","intrinsicName","Object","assign","originalPrototype","$HomeObject","clonePrototype","Set","newPrototype","ObjectPrototype","skipFunctionProperties","convertFunctionalComponentToComplexClassComponent","functionalComponentType","userCodePropertiesToAdd","userCodeSymbolsToAdd","binding","unshift","variableDeclaration","variableDeclarator","memberExpression","thisExpression","normalizeFunctionalComponentParamaters","func","lengthProperty","writable","enumerable","map","param","createReactHintObject","args","firstRenderValue","getComponentTypeFromRootValue","_valueIsKnownReactAbstraction","AbstractValue","reactHint","reactRelay","Array","isArray","componentType","flagPropsWithNoPartialKeyOrRef","props","propsWithNoPartialKeyOrRef","hasNoPartialKeyOrRef","isPartialObject","values","isTop","elements","getElements","element","wasSafe","recursivelyFlattenArray","targetArray","item","flattenChildren","flattenedChildren","makeFinal","evaluateWithNestedParentEffects","nestedEffects","f","nextEffects","slice","modifiedBindings","modifiedProperties","createdObjects","effects","shift","result","Completion","shallowCloneWithoutEffects","applyEffects","Effects","Generator","generator","pathConditions","undoBindings","restoreProperties","size","reportIntrospectionError","createReactEvaluatedNode","status","children","message","getComponentName","BoundFunctionValue","boundText","__originalName","convertConfigObjectToReactComponentTreeConfig","config","isRoot","modelString","UndefinedValue","propValue","BooleanValue","JSON","parse","componentModelError","CompilerDiagnostic","currentLocation","handleError","diagnostic","getValueFromFunctionCall","funcThis","isConstructor","funcCall","newCall","$Construct","completion","error","AbruptCompletion","PossiblyNormalCompletion","composeWithSavedCompletion","SimpleNormalCompletion","isEventProp","toLowerCase","getLocationFromValue","expressionLocation","start","line","column","end","createNoopFunction","noopFunction","noOpFunc","uniqueOrderedTag","functionBodyUniqueTagSeed","$ECMAScriptCode","doNotOptimizeComponent","doNotOptimize","createDefaultPropsHelper","defaultPropsHelper","escapeHelperAst","plugins","helper","params","ref","obj","ObjectCreate","kind","activeReconciler","componentTreeConfig","mightBeFinalObject","applyClonedTemporalAlias","clonedProps","temporalAlias","temporalOperationEntry","getTemporalOperationEntryFromDerivedValue","TemporalObjectAssignEntry","temporalArgs","to","sources","arg","createTemporalObjectAssign","cloneProps","newChildren","propName","makePartial","isSimpleObject","makeSimple","applyObjectAssignConfigsForReactElement","globalObj","objAssign","ECMAScriptFunctionValue","objectAssignCall","canExcludeReactElementObjectProperty","reactElementData","isHostComponent","cloneReactElement","shouldCloneProps","keyValue","hardModifyReactObjectPropertyBinding","mightNotBeFinalObject","newDescriptor","newBinding"],"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, Effects } from \"../realm.js\";\nimport { AbruptCompletion, Completion, PossiblyNormalCompletion, SimpleNormalCompletion } from \"../completions.js\";\nimport type { BabelNode, BabelNodeJSXIdentifier } from \"@babel/types\";\nimport { parseExpression } from \"@babel/parser\";\nimport {\n AbstractObjectValue,\n AbstractValue,\n ArrayValue,\n BooleanValue,\n BoundFunctionValue,\n ECMAScriptFunctionValue,\n ECMAScriptSourceFunctionValue,\n FunctionValue,\n NumberValue,\n ObjectValue,\n StringValue,\n SymbolValue,\n UndefinedValue,\n Value,\n} from \"../values/index.js\";\nimport { Generator, TemporalObjectAssignEntry } from \"../utils/generator.js\";\nimport type {\n Descriptor,\n FunctionBodyAstNode,\n ReactComponentTreeConfig,\n ReactHint,\n PropertyBinding,\n} from \"../types.js\";\nimport { Get, cloneDescriptor } from \"../methods/index.js\";\nimport { computeBinary } from \"../evaluators/BinaryExpression.js\";\nimport type { AdditionalFunctionEffects, ReactEvaluatedNode } from \"../serializer/types.js\";\nimport invariant from \"../invariant.js\";\nimport { Create, Properties, To } from \"../singletons.js\";\nimport traverse from \"@babel/traverse\";\nimport * as t from \"@babel/types\";\nimport type { BabelNodeStatement } from \"@babel/types\";\nimport { CompilerDiagnostic, FatalError } from \"../errors.js\";\n\nexport type ReactSymbolTypes =\n | \"react.element\"\n | \"react.context\"\n | \"react.provider\"\n | \"react.fragment\"\n | \"react.portal\"\n | \"react.return\"\n | \"react.call\";\n\nexport function isReactElement(val: Value): boolean {\n if (!(val instanceof ObjectValue)) {\n return false;\n }\n let realm = val.$Realm;\n if (!realm.react.enabled) {\n return false;\n }\n if (realm.react.reactElements.has(val)) {\n return true;\n }\n if (!val.properties.has(\"type\") || !val.properties.has(\"props\") || !val.properties.has(\"$$typeof\")) {\n return false;\n }\n let $$typeof = getProperty(realm, val, \"$$typeof\");\n let globalObject = realm.$GlobalObject;\n let globalSymbolValue = getProperty(realm, globalObject, \"Symbol\");\n\n if (globalSymbolValue === realm.intrinsics.undefined) {\n if ($$typeof instanceof NumberValue) {\n return $$typeof.value === 0xeac7;\n }\n } else if ($$typeof instanceof SymbolValue) {\n let symbolFromRegistry = realm.globalSymbolRegistry.find(e => e.$Symbol === $$typeof);\n let _isReactElement = symbolFromRegistry !== undefined && symbolFromRegistry.$Key === \"react.element\";\n if (_isReactElement) {\n // If we get there, it means the ReactElement was created in manual user-space\n realm.react.reactElements.set(val, { createdDuringReconcilation: false, firstRenderOnly: false });\n return true;\n }\n }\n return false;\n}\n\nexport function isReactPropsObject(val: Value): boolean {\n if (!(val instanceof ObjectValue)) {\n return false;\n }\n let realm = val.$Realm;\n if (!realm.react.enabled) {\n return false;\n }\n if (realm.react.reactProps.has(val)) {\n return true;\n }\n return false;\n}\n\nexport function getReactSymbol(symbolKey: ReactSymbolTypes, realm: Realm): SymbolValue {\n let reactSymbol = realm.react.symbols.get(symbolKey);\n if (reactSymbol !== undefined) {\n return reactSymbol;\n }\n let SymbolFor = realm.intrinsics.Symbol.properties.get(\"for\");\n if (SymbolFor !== undefined) {\n let SymbolForDescriptor = SymbolFor.descriptor;\n\n if (SymbolForDescriptor !== undefined) {\n let SymbolForValue = SymbolForDescriptor.value;\n if (SymbolForValue instanceof ObjectValue && typeof SymbolForValue.$Call === \"function\") {\n reactSymbol = SymbolForValue.$Call(realm.intrinsics.Symbol, [new StringValue(realm, symbolKey)]);\n invariant(reactSymbol instanceof SymbolValue);\n realm.react.symbols.set(symbolKey, reactSymbol);\n }\n }\n }\n invariant(reactSymbol instanceof SymbolValue, `Symbol(\"${symbolKey}\") could not be found in realm`);\n return reactSymbol;\n}\n\nexport function isTagName(ast: BabelNode): boolean {\n return ast.type === \"JSXIdentifier\" && /^[a-z]|\\-/.test(((ast: any): BabelNodeJSXIdentifier).name);\n}\n\nexport function isReactComponent(name: string): boolean {\n return name.length > 0 && name[0] === name[0].toUpperCase();\n}\n\nexport function valueIsClassComponent(realm: Realm, value: Value): boolean {\n if (!(value instanceof FunctionValue)) {\n return false;\n }\n let prototype = Get(realm, value, \"prototype\");\n\n if (prototype instanceof ObjectValue) {\n return To.ToBooleanPartial(realm, Get(realm, prototype, \"isReactComponent\"));\n }\n return false;\n}\n\nexport function valueIsKnownReactAbstraction(realm: Realm, value: Value): boolean {\n return value instanceof AbstractObjectValue && realm.react.abstractHints.has(value);\n}\n\n// logger isn't typed otherwise it will increase flow cycle length :()\nexport function valueIsReactLibraryObject(realm: Realm, value: ObjectValue, logger: any): boolean {\n if (realm.fbLibraries.react === value) {\n return true;\n }\n // we check that the object is the React or React-like library by checking for\n // core properties that should exist on it\n let reactVersion = logger.tryQuery(() => Get(realm, value, \"version\"), undefined);\n if (!(reactVersion instanceof StringValue)) {\n return false;\n }\n let reactCreateElement = logger.tryQuery(() => Get(realm, value, \"createElement\"), undefined);\n if (!(reactCreateElement instanceof FunctionValue)) {\n return false;\n }\n let reactCloneElement = logger.tryQuery(() => Get(realm, value, \"cloneElement\"), undefined);\n if (!(reactCloneElement instanceof FunctionValue)) {\n return false;\n }\n let reactIsValidElement = logger.tryQuery(() => Get(realm, value, \"isValidElement\"), undefined);\n if (!(reactIsValidElement instanceof FunctionValue)) {\n return false;\n }\n let reactComponent = logger.tryQuery(() => Get(realm, value, \"Component\"), undefined);\n if (!(reactComponent instanceof FunctionValue)) {\n return false;\n }\n let reactChildren = logger.tryQuery(() => Get(realm, value, \"Children\"), undefined);\n if (!(reactChildren instanceof ObjectValue)) {\n return false;\n }\n return false;\n}\n\nexport function valueIsLegacyCreateClassComponent(realm: Realm, value: Value): boolean {\n if (!(value instanceof FunctionValue)) {\n return false;\n }\n let prototype = Get(realm, value, \"prototype\");\n\n if (prototype instanceof ObjectValue) {\n return prototype.properties.has(\"__reactAutoBindPairs\");\n }\n return false;\n}\n\nexport function valueIsFactoryClassComponent(realm: Realm, value: Value): boolean {\n if (value instanceof ObjectValue && !ArrayValue.isIntrinsicAndHasWidenedNumericProperty(value)) {\n return To.ToBooleanPartial(realm, Get(realm, value, \"render\"));\n }\n return false;\n}\n\nexport function addKeyToReactElement(realm: Realm, reactElement: ObjectValue): ObjectValue {\n let typeValue = getProperty(realm, reactElement, \"type\");\n let refValue = getProperty(realm, reactElement, \"ref\");\n let propsValue = getProperty(realm, reactElement, \"props\");\n // we need to apply a key when we're branched\n let currentKeyValue = getProperty(realm, reactElement, \"key\") || realm.intrinsics.null;\n let uniqueKey = getUniqueReactElementKey(\"\", realm.react.usedReactElementKeys);\n let newKeyValue = new StringValue(realm, uniqueKey);\n if (currentKeyValue !== realm.intrinsics.null) {\n newKeyValue = computeBinary(realm, \"+\", currentKeyValue, newKeyValue);\n }\n invariant(propsValue instanceof ObjectValue);\n return createInternalReactElement(realm, typeValue, newKeyValue, refValue, propsValue);\n}\n// we create a unique key for each JSXElement to prevent collisions\n// otherwise React will detect a missing/conflicting key at runtime and\n// this can break the reconcilation of JSXElements in arrays\nexport function getUniqueReactElementKey(index?: string, usedReactElementKeys: Set<string>): string {\n let key;\n do {\n key = Math.random()\n .toString(36)\n .replace(/[^a-z]+/g, \"\")\n .substring(0, 2);\n } while (usedReactElementKeys.has(key));\n usedReactElementKeys.add(key);\n if (index !== undefined) {\n return `${key}${index}`;\n }\n return key;\n}\n\n// a helper function to loop over ArrayValues\nexport function forEachArrayValue(\n realm: Realm,\n array: ArrayValue,\n mapFunc: (element: Value, index: number) => void\n): void {\n let lengthValue = Get(realm, array, \"length\");\n invariant(lengthValue instanceof NumberValue, \"TODO: support non-numeric length on forEachArrayValue\");\n let length = lengthValue.value;\n for (let i = 0; i < length; i++) {\n let elementProperty = array.properties.get(\"\" + i);\n let elementPropertyDescriptor = elementProperty && elementProperty.descriptor;\n if (elementPropertyDescriptor) {\n let elementValue = elementPropertyDescriptor.value;\n if (elementValue instanceof Value) {\n mapFunc(elementValue, i);\n }\n }\n }\n}\n\nexport function mapArrayValue(\n realm: Realm,\n array: ArrayValue,\n mapFunc: (element: Value, descriptor: Descriptor) => Value\n): ArrayValue {\n let lengthValue = Get(realm, array, \"length\");\n invariant(lengthValue instanceof NumberValue, \"TODO: support non-numeric length on mapArrayValue\");\n let length = lengthValue.value;\n let newArray = Create.ArrayCreate(realm, length);\n let returnTheNewArray = false;\n\n for (let i = 0; i < length; i++) {\n let elementProperty = array.properties.get(\"\" + i);\n let elementPropertyDescriptor = elementProperty && elementProperty.descriptor;\n if (elementPropertyDescriptor) {\n let elementValue = elementPropertyDescriptor.value;\n if (elementValue instanceof Value) {\n let newElement = mapFunc(elementValue, elementPropertyDescriptor);\n if (newElement !== elementValue) {\n returnTheNewArray = true;\n }\n Create.CreateDataPropertyOrThrow(realm, newArray, \"\" + i, newElement);\n continue;\n }\n }\n Create.CreateDataPropertyOrThrow(realm, newArray, \"\" + i, realm.intrinsics.undefined);\n }\n return returnTheNewArray ? newArray : array;\n}\n\nfunction GetDescriptorForProperty(value: ObjectValue, propertyName: string): ?Descriptor {\n let object = value.properties.get(propertyName);\n invariant(object);\n return object.descriptor;\n}\n\nexport function convertSimpleClassComponentToFunctionalComponent(\n realm: Realm,\n complexComponentType: ECMAScriptSourceFunctionValue,\n additionalFunctionEffects: AdditionalFunctionEffects\n): void {\n let prototype = complexComponentType.properties.get(\"prototype\");\n invariant(prototype);\n invariant(prototype.descriptor);\n prototype.descriptor.configurable = true;\n Properties.DeletePropertyOrThrow(realm, complexComponentType, \"prototype\");\n\n // change the function kind\n complexComponentType.$FunctionKind = \"normal\";\n // set the prototype back to an object\n complexComponentType.$Prototype = realm.intrinsics.FunctionPrototype;\n // give the function the functional components params\n complexComponentType.$FormalParameters = [t.identifier(\"props\"), t.identifier(\"context\")];\n // add a transform to occur after the additional function has serialized the body of the class\n additionalFunctionEffects.transforms.push((body: Array<BabelNodeStatement>) => {\n // as this was a class before and is now a functional component, we need to replace\n // this.props and this.context to props and context, via the function arugments\n let funcNode = t.functionExpression(null, [], t.blockStatement(body));\n\n traverse(\n t.file(t.program([t.expressionStatement(funcNode)])),\n {\n \"Identifier|ThisExpression\"(path) {\n let node = path.node;\n if ((t.isIdentifier(node) && node.name === \"this\") || t.isThisExpression(node)) {\n let parentPath = path.parentPath;\n let parentNode = parentPath.node;\n\n if (t.isMemberExpression(parentNode)) {\n // remove the \"this\" from the member\n parentPath.replaceWith(parentNode.property);\n } else {\n throw new FatalError(\n `conversion of a simple class component to functional component failed due to \"this\" not being replaced`\n );\n }\n }\n },\n },\n undefined,\n {},\n undefined\n );\n traverse.cache.clear();\n });\n}\n\nfunction createBinding(descriptor: void | Descriptor, key: string | SymbolValue, object: ObjectValue) {\n return {\n descriptor,\n key,\n object,\n };\n}\n\nfunction cloneProperties(realm: Realm, properties: Map<string, any>, object: ObjectValue): Map<string, any> {\n let newProperties = new Map();\n for (let [propertyName, { descriptor }] of properties) {\n newProperties.set(propertyName, createBinding(cloneDescriptor(descriptor), propertyName, object));\n }\n return newProperties;\n}\n\nfunction cloneSymbols(realm: Realm, symbols: Map<SymbolValue, any>, object: ObjectValue): Map<SymbolValue, any> {\n let newSymbols = new Map();\n for (let [symbol, { descriptor }] of symbols) {\n newSymbols.set(symbol, createBinding(cloneDescriptor(descriptor), symbol, object));\n }\n return newSymbols;\n}\n\nfunction cloneValue(\n realm: Realm,\n originalValue: Value,\n _prototype: null | ObjectValue,\n copyToObject?: ObjectValue\n): Value {\n if (originalValue instanceof FunctionValue) {\n return cloneFunction(realm, originalValue, _prototype, copyToObject);\n }\n invariant(false, \"TODO: add support to cloneValue() for more value types\");\n}\n\nfunction cloneFunction(\n realm: Realm,\n originalValue: Value,\n _prototype: null | ObjectValue,\n copyToObject?: ObjectValue\n): FunctionValue {\n let newValue;\n if (originalValue instanceof ECMAScriptSourceFunctionValue) {\n newValue = copyToObject || new ECMAScriptSourceFunctionValue(realm, originalValue.intrinsicName);\n invariant(newValue instanceof ECMAScriptSourceFunctionValue);\n // $FlowFixMe: complains about Object.assign\n Object.assign(newValue, originalValue);\n let properties = cloneProperties(realm, originalValue.properties, newValue);\n newValue.properties = properties;\n let symbols = cloneSymbols(realm, originalValue.symbols, newValue);\n newValue.symbols = symbols;\n\n // handle home object + prototype\n let originalPrototype = originalValue.$HomeObject;\n invariant(originalPrototype instanceof ObjectValue);\n let prototype = _prototype || clonePrototype(realm, originalPrototype);\n newValue.$HomeObject = prototype;\n if (originalPrototype.properties.has(\"constructor\")) {\n Properties.Set(realm, prototype, \"constructor\", newValue, false);\n }\n if (originalValue.properties.has(\"prototype\")) {\n Properties.Set(realm, newValue, \"prototype\", prototype, false);\n }\n }\n invariant(newValue instanceof FunctionValue, \"TODO: add support to cloneValue() for more function types\");\n return newValue;\n}\n\nfunction clonePrototype(realm: Realm, prototype: Value): ObjectValue {\n invariant(prototype instanceof ObjectValue);\n let newPrototype = new ObjectValue(realm, realm.intrinsics.ObjectPrototype, prototype.intrinsicName);\n\n Object.assign(newPrototype, prototype);\n for (let [propertyName] of prototype.properties) {\n if (propertyName !== \"constructor\") {\n let originalValue = Get(realm, prototype, propertyName);\n let newValue = cloneValue(realm, originalValue, prototype);\n Properties.Set(realm, newPrototype, propertyName, newValue, false);\n }\n }\n for (let [symbol] of prototype.symbols) {\n let originalValue = Get(realm, prototype, symbol);\n let newValue = cloneValue(realm, originalValue, prototype);\n Properties.Set(realm, newPrototype, symbol, newValue, false);\n }\n return newPrototype;\n}\n\nconst skipFunctionProperties = new Set([\"length\", \"prototype\", \"arguments\", \"name\", \"caller\"]);\n\nexport function convertFunctionalComponentToComplexClassComponent(\n realm: Realm,\n functionalComponentType: ECMAScriptSourceFunctionValue,\n complexComponentType: void | ECMAScriptSourceFunctionValue,\n additionalFunctionEffects: AdditionalFunctionEffects\n): void {\n invariant(complexComponentType instanceof ECMAScriptSourceFunctionValue);\n // get all properties on the functional component that were added in user-code\n // we add defaultProps as undefined, as merging a class component's defaultProps on to\n // a differnet component isn't right, we can discard defaultProps instead via folding\n // we also don't want propTypes from the class component, so we remove that too\n let userCodePropertiesToAdd: Map<string, PropertyBinding> = new Map([\n [\"defaultProps\", createBinding(undefined, \"defaultProps\", functionalComponentType)],\n [\"propTypes\", createBinding(undefined, \"propTypes\", functionalComponentType)],\n ]);\n let userCodeSymbolsToAdd: Map<SymbolValue, PropertyBinding> = new Map();\n\n for (let [propertyName, binding] of functionalComponentType.properties) {\n if (!skipFunctionProperties.has(propertyName)) {\n userCodePropertiesToAdd.set(propertyName, binding);\n }\n }\n for (let [symbol, binding] of functionalComponentType.symbols) {\n userCodeSymbolsToAdd.set(symbol, binding);\n }\n\n cloneValue(realm, complexComponentType, null, functionalComponentType);\n // then copy back and properties that were on the original functional component\n // ensuring we overwrite any existing ones\n for (let [propertyName, binding] of userCodePropertiesToAdd) {\n functionalComponentType.properties.set(propertyName, binding);\n }\n for (let [symbol, binding] of userCodeSymbolsToAdd) {\n functionalComponentType.symbols.set(symbol, binding);\n }\n // add a transform to occur after the additional function has serialized the body of the class\n additionalFunctionEffects.transforms.push((body: Array<BabelNodeStatement>) => {\n // as we've converted a functional component to a complex one, we are going to have issues with\n // \"props\" and \"context\" references, as they're now going to be \"this.props\" and \"this.context\".\n // we simply need a to add to vars to beginning of the body to get around this\n // if they're not used, any DCE tool post-Prepack (GCC or Uglify) will remove them\n body.unshift(\n t.variableDeclaration(\"var\", [\n t.variableDeclarator(t.identifier(\"props\"), t.memberExpression(t.thisExpression(), t.identifier(\"props\"))),\n t.variableDeclarator(t.identifier(\"context\"), t.memberExpression(t.thisExpression(), t.identifier(\"context\"))),\n ])\n );\n });\n}\n\nexport function normalizeFunctionalComponentParamaters(func: ECMAScriptSourceFunctionValue): void {\n // fix the length as we may change the arguments\n let lengthProperty = GetDescriptorForProperty(func, \"length\");\n invariant(lengthProperty);\n lengthProperty.writable = false;\n lengthProperty.enumerable = false;\n lengthProperty.configurable = true;\n func.$FormalParameters = func.$FormalParameters.map((param, i) => {\n if (i === 0) {\n return t.isIdentifier(param) ? param : t.identifier(\"props\");\n } else {\n return t.isIdentifier(param) ? param : t.identifier(\"context\");\n }\n });\n if (func.$FormalParameters.length === 1) {\n func.$FormalParameters.push(t.identifier(\"context\"));\n }\n // ensure the length value is set to the correct value after\n // we've made mutations to the arguments of this function\n let lengthValue = lengthProperty.value;\n invariant(lengthValue instanceof NumberValue);\n lengthValue.value = func.$FormalParameters.length;\n}\n\nexport function createReactHintObject(\n object: ObjectValue,\n propertyName: string,\n args: Array<Value>,\n firstRenderValue: Value\n): ReactHint {\n return {\n firstRenderValue,\n object,\n propertyName,\n args,\n };\n}\n\nexport function getComponentTypeFromRootValue(realm: Realm, value: Value): ECMAScriptSourceFunctionValue | null {\n let _valueIsKnownReactAbstraction = valueIsKnownReactAbstraction(realm, value);\n if (!(value instanceof ECMAScriptSourceFunctionValue || _valueIsKnownReactAbstraction)) {\n return null;\n }\n if (_valueIsKnownReactAbstraction) {\n invariant(value instanceof AbstractValue);\n let reactHint = realm.react.abstractHints.get(value);\n\n invariant(reactHint);\n if (typeof reactHint !== \"string\" && reactHint.object === realm.fbLibraries.reactRelay) {\n switch (reactHint.propertyName) {\n case \"createFragmentContainer\":\n case \"createPaginationContainer\":\n case \"createRefetchContainer\":\n invariant(Array.isArray(reactHint.args));\n // componentType is the 1st argument of a ReactRelay container\n let componentType = reactHint.args[0];\n invariant(componentType instanceof ECMAScriptSourceFunctionValue);\n return componentType;\n default:\n invariant(\n false,\n `unsupported known React abstraction - ReactRelay property \"${reactHint.propertyName}\" not supported`\n );\n }\n }\n if (reactHint.object === realm.fbLibraries.react && reactHint.propertyName === \"forwardRef\") {\n return null;\n }\n invariant(false, \"unsupported known React abstraction\");\n } else {\n invariant(value instanceof ECMAScriptSourceFunctionValue);\n return value;\n }\n}\n\nexport function flagPropsWithNoPartialKeyOrRef(realm: Realm, props: ObjectValue | AbstractObjectValue): void {\n realm.react.propsWithNoPartialKeyOrRef.add(props);\n}\n\nexport function hasNoPartialKeyOrRef(realm: Realm, props: ObjectValue | AbstractObjectValue): boolean {\n if (realm.react.propsWithNoPartialKeyOrRef.has(props)) {\n return true;\n }\n if (props instanceof ObjectValue && !props.isPartialObject()) {\n return true;\n }\n if (props instanceof AbstractObjectValue) {\n if (props.values.isTop()) {\n return false;\n }\n let elements = props.values.getElements();\n for (let element of elements) {\n invariant(element instanceof ObjectValue);\n let wasSafe = hasNoPartialKeyOrRef(realm, element);\n if (!wasSafe) {\n return false;\n }\n }\n return true;\n }\n if (props instanceof ObjectValue && props.properties.has(\"key\") && props.properties.has(\"ref\")) {\n return true;\n }\n return false;\n}\n\nfunction recursivelyFlattenArray(realm: Realm, array, targetArray): void {\n forEachArrayValue(realm, array, item => {\n if (item instanceof ArrayValue && !item.intrinsicName) {\n recursivelyFlattenArray(realm, item, targetArray);\n } else {\n let lengthValue = Get(realm, targetArray, \"length\");\n invariant(lengthValue instanceof NumberValue);\n Properties.Set(realm, targetArray, \"\" + lengthValue.value, item, true);\n }\n });\n}\n\nexport function flattenChildren(realm: Realm, array: ArrayValue): ArrayValue {\n let flattenedChildren = Create.ArrayCreate(realm, 0);\n recursivelyFlattenArray(realm, array, flattenedChildren);\n flattenedChildren.makeFinal();\n return flattenedChildren;\n}\n\nexport function evaluateWithNestedParentEffects(\n realm: Realm,\n nestedEffects: Array<Effects>,\n f: () => Effects\n): Effects {\n let nextEffects = nestedEffects.slice();\n let modifiedBindings;\n let modifiedProperties;\n let createdObjects;\n let value;\n\n if (nextEffects.length !== 0) {\n let effects = nextEffects.shift();\n value = effects.result;\n if (value instanceof Completion) value = value.shallowCloneWithoutEffects();\n createdObjects = effects.createdObjects;\n modifiedBindings = effects.modifiedBindings;\n modifiedProperties = effects.modifiedProperties;\n realm.applyEffects(\n new Effects(\n value,\n new Generator(realm, \"evaluateWithNestedEffects\", effects.generator.pathConditions),\n modifiedBindings,\n modifiedProperties,\n createdObjects\n )\n );\n }\n try {\n if (nextEffects.length === 0) {\n return f();\n } else {\n return evaluateWithNestedParentEffects(realm, nextEffects, f);\n }\n } finally {\n if (modifiedBindings && modifiedProperties) {\n realm.undoBindings(modifiedBindings);\n realm.restoreProperties(modifiedProperties);\n }\n }\n}\n\n// This function is mainly use to get internal properties\n// on objects that we know are safe to access internally\n// such as ReactElements. Getting properties here does\n// not emit change to modified bindings and is intended\n// for only internal usage – not for user-land code\nexport function getProperty(\n realm: Realm,\n object: ObjectValue | AbstractObjectValue,\n property: string | SymbolValue\n): Value {\n if (object instanceof AbstractObjectValue) {\n if (object.values.isTop()) {\n return realm.intrinsics.undefined;\n }\n let elements = object.values.getElements();\n invariant(elements.size === 1, \"TODO: deal with multiple elements\");\n for (let element of elements) {\n invariant(element instanceof ObjectValue, \"TODO: deal with object set templates\");\n object = element;\n }\n invariant(object instanceof ObjectValue);\n }\n let binding;\n if (typeof property === \"string\") {\n binding = object.properties.get(property);\n } else {\n binding = object.symbols.get(property);\n }\n if (!binding) {\n return realm.intrinsics.undefined;\n }\n let descriptor = binding.descriptor;\n\n if (!descriptor) {\n return realm.intrinsics.undefined;\n }\n let value = descriptor.value;\n if (value === undefined) {\n AbstractValue.reportIntrospectionError(object, `react/utils/getProperty unsupported getter/setter property`);\n throw new FatalError();\n }\n invariant(value instanceof Value, `react/utils/getProperty should not be called on internal properties`);\n return value;\n}\n\nexport function createReactEvaluatedNode(\n status:\n | \"ROOT\"\n | \"NEW_TREE\"\n | \"INLINED\"\n | \"BAIL-OUT\"\n | \"FATAL\"\n | \"UNKNOWN_TYPE\"\n | \"RENDER_PROPS\"\n | \"FORWARD_REF\"\n | \"NORMAL\",\n name: string\n): ReactEvaluatedNode {\n return {\n children: [],\n message: \"\",\n name,\n status,\n };\n}\n\nexport function getComponentName(realm: Realm, componentType: Value): string {\n if (componentType instanceof SymbolValue && componentType === getReactSymbol(\"react.fragment\", realm)) {\n return \"React.Fragment\";\n } else if (componentType instanceof SymbolValue) {\n return \"unknown symbol\";\n }\n // $FlowFixMe: this code is fine, Flow thinks that coponentType is bound to string...\n if (isReactComponent(componentType)) {\n return \"ReactElement\";\n }\n if (componentType === realm.intrinsics.undefined || componentType === realm.intrinsics.null) {\n return \"no name\";\n }\n invariant(\n componentType instanceof ECMAScriptSourceFunctionValue ||\n componentType instanceof BoundFunctionValue ||\n componentType instanceof AbstractObjectValue ||\n componentType instanceof AbstractValue ||\n componentType instanceof ObjectValue\n );\n let boundText = componentType instanceof BoundFunctionValue ? \"bound \" : \"\";\n\n if (componentType.__originalName) {\n return boundText + componentType.__originalName;\n }\n if (realm.fbLibraries.reactRelay !== undefined) {\n if (componentType === Get(realm, realm.fbLibraries.reactRelay, \"QueryRenderer\")) {\n return boundText + \"QueryRenderer\";\n }\n }\n if (componentType instanceof ECMAScriptSourceFunctionValue && componentType.$Prototype !== undefined) {\n let name = Get(realm, componentType, \"name\");\n\n if (name instanceof StringValue) {\n return boundText + name.value;\n }\n }\n if (realm.react.abstractHints.has(componentType)) {\n let reactHint = realm.react.abstractHints.get(componentType);\n\n invariant(reactHint !== undefined);\n if (reactHint.object === realm.fbLibraries.react && reactHint.propertyName === \"forwardRef\") {\n return \"forwarded ref\";\n }\n }\n if (componentType instanceof FunctionValue) {\n return boundText + \"anonymous\";\n }\n return \"unknown\";\n}\n\nexport function convertConfigObjectToReactComponentTreeConfig(\n realm: Realm,\n config: ObjectValue | UndefinedValue\n): ReactComponentTreeConfig {\n // defaults\n let firstRenderOnly = false;\n let isRoot = false;\n let modelString;\n\n if (!(config instanceof UndefinedValue)) {\n for (let [key] of config.properties) {\n let propValue = getProperty(realm, config, key);\n if (propValue instanceof StringValue || propValue instanceof NumberValue || propValue instanceof BooleanValue) {\n let value = propValue.value;\n\n if (typeof value === \"boolean\") {\n // boolean options\n if (key === \"firstRenderOnly\") {\n firstRenderOnly = value;\n } else if (key === \"isRoot\") {\n isRoot = value;\n }\n } else if (typeof value === \"string\") {\n try {\n // result here is ignored as the main point here is to\n // check and produce error\n JSON.parse(value);\n } catch (e) {\n let componentModelError = new CompilerDiagnostic(\n \"Failed to parse model for component\",\n realm.currentLocation,\n \"PP1008\",\n \"FatalError\"\n );\n if (realm.handleError(componentModelError) !== \"Recover\") {\n throw new FatalError();\n }\n }\n // string options\n if (key === \"model\") {\n modelString = value;\n }\n }\n } else {\n let diagnostic = new CompilerDiagnostic(\n \"__optimizeReactComponentTree(rootComponent, config) has been called with invalid arguments\",\n realm.currentLocation,\n \"PP0024\",\n \"FatalError\"\n );\n realm.handleError(diagnostic);\n if (realm.handleError(diagnostic) === \"Fail\") throw new FatalError();\n }\n }\n }\n return {\n firstRenderOnly,\n isRoot,\n modelString,\n };\n}\n\nexport function getValueFromFunctionCall(\n realm: Realm,\n func: ECMAScriptSourceFunctionValue | BoundFunctionValue,\n funcThis: ObjectValue | AbstractObjectValue | UndefinedValue,\n args: Array<Value>,\n isConstructor?: boolean = false\n): Value {\n invariant(func.$Call, \"Expected function to be a FunctionValue with $Call method\");\n let funcCall = func.$Call;\n let newCall = func.$Construct;\n let completion;\n try {\n if (isConstructor) {\n invariant(newCall);\n completion = newCall(args, func);\n } else {\n completion = funcCall(funcThis, args);\n }\n } catch (error) {\n if (error instanceof AbruptCompletion) {\n completion = error;\n } else {\n throw error;\n }\n }\n if (completion instanceof PossiblyNormalCompletion) {\n // in this case one of the branches may complete abruptly, which means that\n // not all control flow branches join into one flow at this point.\n // Consequently we have to continue tracking changes until the point where\n // all the branches come together into one.\n completion = realm.composeWithSavedCompletion(completion);\n }\n // return or throw completion\n if (completion instanceof AbruptCompletion) throw completion;\n if (completion instanceof SimpleNormalCompletion) completion = completion.value;\n invariant(completion instanceof Value);\n return completion;\n}\n\nfunction isEventProp(name: string): boolean {\n return name.length > 2 && name[0].toLowerCase() === \"o\" && name[1].toLowerCase() === \"n\";\n}\n\nexport function getLocationFromValue(expressionLocation: any): string {\n // if we can't get a value, then it's likely that the source file was not given\n // (this happens in React tests) so instead don't print any location\n return expressionLocation\n ? ` at location: ${expressionLocation.start.line}:${expressionLocation.start.column} ` +\n `- ${expressionLocation.end.line}:${expressionLocation.end.line}`\n : \"\";\n}\n\nexport function createNoopFunction(realm: Realm): ECMAScriptSourceFunctionValue {\n if (realm.react.noopFunction !== undefined) {\n return realm.react.noopFunction;\n }\n let noOpFunc = new ECMAScriptSourceFunctionValue(realm);\n let body = t.blockStatement([]);\n ((body: any): FunctionBodyAstNode).uniqueOrderedTag = realm.functionBodyUniqueTagSeed++;\n noOpFunc.$FormalParameters = [];\n noOpFunc.$ECMAScriptCode = body;\n realm.react.noopFunction = noOpFunc;\n return noOpFunc;\n}\n\nexport function doNotOptimizeComponent(realm: Realm, componentType: Value): boolean {\n if (componentType instanceof ObjectValue) {\n let doNotOptimize = Get(realm, componentType, \"__reactCompilerDoNotOptimize\");\n\n if (doNotOptimize instanceof BooleanValue) {\n return doNotOptimize.value;\n }\n }\n return false;\n}\n\nexport function createDefaultPropsHelper(realm: Realm): ECMAScriptSourceFunctionValue {\n let defaultPropsHelper = `\n function defaultPropsHelper(props, defaultProps) {\n for (var propName in defaultProps) {\n if (props[propName] === undefined) {\n props[propName] = defaultProps[propName];\n }\n }\n return props;\n }\n `;\n\n let escapeHelperAst = parseExpression(defaultPropsHelper, { plugins: [\"flow\"] });\n let helper = new ECMAScriptSourceFunctionValue(realm);\n let body = escapeHelperAst.body;\n ((body: any): FunctionBodyAstNode).uniqueOrderedTag = realm.functionBodyUniqueTagSeed++;\n helper.$ECMAScriptCode = body;\n helper.$FormalParameters = escapeHelperAst.params;\n return helper;\n}\n\nexport function createInternalReactElement(\n realm: Realm,\n type: Value,\n key: Value,\n ref: Value,\n props: ObjectValue\n): ObjectValue {\n let obj = Create.ObjectCreate(realm, realm.intrinsics.ObjectPrototype);\n\n // Sanity check the type is not conditional\n if (type instanceof AbstractValue && type.kind === \"conditional\") {\n invariant(false, \"createInternalReactElement should never encounter a conditional type\");\n }\n\n Create.CreateDataPropertyOrThrow(realm, obj, \"$$typeof\", getReactSymbol(\"react.element\", realm));\n Create.CreateDataPropertyOrThrow(realm, obj, \"type\", type);\n Create.CreateDataPropertyOrThrow(realm, obj, \"key\", key);\n Create.CreateDataPropertyOrThrow(realm, obj, \"ref\", ref);\n Create.CreateDataPropertyOrThrow(realm, obj, \"props\", props);\n Create.CreateDataPropertyOrThrow(realm, obj, \"_owner\", realm.intrinsics.null);\n obj.makeFinal();\n // If we're in \"rendering\" a React component tree, we should have an active reconciler\n let activeReconciler = realm.react.activeReconciler;\n let createdDuringReconcilation = activeReconciler !== undefined;\n let firstRenderOnly = createdDuringReconcilation ? activeReconciler.componentTreeConfig.firstRenderOnly : false;\n\n realm.react.reactElements.set(obj, { createdDuringReconcilation, firstRenderOnly });\n // Sanity check to ensure no bugs have crept in\n invariant(\n realm.react.reactProps.has(props) && props.mightBeFinalObject(),\n \"React props object is not correctly setup\"\n );\n return obj;\n}\n\nfunction applyClonedTemporalAlias(realm: Realm, props: ObjectValue, clonedProps: ObjectValue): void {\n let temporalAlias = props.temporalAlias;\n invariant(temporalAlias !== undefined);\n if (temporalAlias.kind === \"conditional\") {\n // Leave in for now, we should deal with this later, but there might\n // be a better option.\n invariant(false, \"TODO applyClonedTemporalAlias conditional\");\n }\n let temporalOperationEntry = realm.getTemporalOperationEntryFromDerivedValue(temporalAlias);\n if (!(temporalOperationEntry instanceof TemporalObjectAssignEntry)) {\n invariant(false, \"TODO nont TemporalObjectAssignEntry\");\n }\n invariant(temporalOperationEntry !== undefined);\n let temporalArgs = temporalOperationEntry.args;\n // replace the original props with the cloned one\n let [to, ...sources] = temporalArgs.map(arg => (arg === props ? clonedProps : arg));\n\n invariant(to instanceof ObjectValue || to instanceof AbstractObjectValue);\n AbstractValue.createTemporalObjectAssign(realm, to, sources);\n}\n\nexport function cloneProps(realm: Realm, props: ObjectValue, newChildren?: Value): ObjectValue {\n let clonedProps = new ObjectValue(realm, realm.intrinsics.ObjectPrototype);\n\n for (let [propName, binding] of props.properties) {\n if (binding && binding.descriptor && binding.descriptor.enumerable) {\n if (newChildren !== undefined && propName === \"children\") {\n Properties.Set(realm, clonedProps, propName, newChildren, true);\n } else {\n Properties.Set(realm, clonedProps, propName, getProperty(realm, props, propName), true);\n }\n }\n }\n\n if (props.isPartialObject()) {\n clonedProps.makePartial();\n }\n if (props.isSimpleObject()) {\n clonedProps.makeSimple();\n }\n if (realm.react.propsWithNoPartialKeyOrRef.has(props)) {\n flagPropsWithNoPartialKeyOrRef(realm, clonedProps);\n }\n if (props.temporalAlias !== undefined) {\n applyClonedTemporalAlias(realm, props, clonedProps);\n }\n clonedProps.makeFinal();\n realm.react.reactProps.add(clonedProps);\n return clonedProps;\n}\n\nexport function applyObjectAssignConfigsForReactElement(realm: Realm, to: ObjectValue, sources: Array<Value>): void {\n // Get the global Object.assign\n let globalObj = Get(realm, realm.$GlobalObject, \"Object\");\n invariant(globalObj instanceof ObjectValue);\n let objAssign = Get(realm, globalObj, \"assign\");\n invariant(objAssign instanceof ECMAScriptFunctionValue);\n let objectAssignCall = objAssign.$Call;\n invariant(objectAssignCall !== undefined);\n\n // Use the existing internal Prepack Object.assign model\n objectAssignCall(realm.intrinsics.undefined, [to, ...sources]);\n}\n\n// In firstRenderOnly mode, we strip off onEventHanlders and any props\n// that are functions as they are not required for init render.\nexport function canExcludeReactElementObjectProperty(\n realm: Realm,\n reactElement: ObjectValue,\n name: string,\n value: Value\n): boolean {\n let reactElementData = realm.react.reactElements.get(reactElement);\n invariant(reactElementData !== undefined);\n let { firstRenderOnly } = reactElementData;\n let isHostComponent = getProperty(realm, reactElement, \"type\") instanceof StringValue;\n return firstRenderOnly && isHostComponent && (isEventProp(name) || value instanceof FunctionValue);\n}\n\nexport function cloneReactElement(realm: Realm, reactElement: ObjectValue, shouldCloneProps: boolean): ObjectValue {\n let typeValue = getProperty(realm, reactElement, \"type\");\n let keyValue = getProperty(realm, reactElement, \"key\");\n let refValue = getProperty(realm, reactElement, \"ref\");\n let propsValue = getProperty(realm, reactElement, \"props\");\n\n invariant(propsValue instanceof ObjectValue);\n if (shouldCloneProps) {\n propsValue = cloneProps(realm, propsValue);\n }\n return createInternalReactElement(realm, typeValue, keyValue, refValue, propsValue);\n}\n\n// This function changes an object's property value by changing it's binding\n// and descriptor, thus bypassing the binding detection system. This is a\n// dangerous function and should only be used on objects created by React.\n// It's primary use is to update ReactElement / React props properties\n// during the visitor equivalence stage as an optimization feature.\n// It will invariant if used on objects that are not final.\nexport function hardModifyReactObjectPropertyBinding(\n realm: Realm,\n object: ObjectValue,\n propName: string,\n value: Value\n): void {\n invariant(\n object.mightBeFinalObject() && !object.mightNotBeFinalObject(),\n \"hardModifyReactObjectPropertyBinding can only be used on final objects!\"\n );\n let binding = object.properties.get(propName);\n if (binding === undefined) {\n binding = {\n object,\n descriptor: {\n configurable: true,\n enumerable: true,\n value: undefined,\n writable: true,\n },\n key: propName,\n };\n }\n let descriptor = binding.descriptor;\n invariant(descriptor !== undefined);\n let newDescriptor = Object.assign({}, descriptor, {\n value,\n });\n let newBinding = Object.assign({}, binding, {\n descriptor: newDescriptor,\n });\n object.properties.set(propName, newBinding);\n}\n"],"file":"utils.js"} |