npm - @tinacms/app - Versions diffs - 1.0.3 → 1.0.5 - Mend

@tinacms/app 1.0.3 → 1.0.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (144) hide show

package/appFiles/node_modules/@babel/traverse/lib/path/inference/index.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"names":["anyTypeAnnotation","isAnyTypeAnnotation","isArrayTypeAnnotation","isBooleanTypeAnnotation","isEmptyTypeAnnotation","isFlowBaseAnnotation","isGenericTypeAnnotation","isIdentifier","isMixedTypeAnnotation","isNumberTypeAnnotation","isStringTypeAnnotation","isTSArrayType","isTSTypeAnnotation","isTSTypeReference","isTupleTypeAnnotation","isTypeAnnotation","isUnionTypeAnnotation","isVoidTypeAnnotation","stringTypeAnnotation","voidTypeAnnotation","getTypeAnnotation","type","getData","_getTypeAnnotation","typeAnnotation","setData","typeAnnotationInferringNodes","WeakSet","node","key","parentPath","isVariableDeclarator","declar","declarParent","isForInStatement","isForOfStatement","has","add","inferer","inferers","call","validParent","delete","isBaseType","baseName","soft","_isBaseType","Error","couldBeBaseType","name","type2","types","baseTypeStrictlyMatches","rightArg","left","right","isGenericType","genericName","id","typeName"],"sources":["../../../src/path/inference/index.ts"],"sourcesContent":["import type NodePath from \"../index\";\nimport * as inferers from \"./inferers\";\nimport {\n anyTypeAnnotation,\n isAnyTypeAnnotation,\n isArrayTypeAnnotation,\n isBooleanTypeAnnotation,\n isEmptyTypeAnnotation,\n isFlowBaseAnnotation,\n isGenericTypeAnnotation,\n isIdentifier,\n isMixedTypeAnnotation,\n isNumberTypeAnnotation,\n isStringTypeAnnotation,\n isTSArrayType,\n isTSTypeAnnotation,\n isTSTypeReference,\n isTupleTypeAnnotation,\n isTypeAnnotation,\n isUnionTypeAnnotation,\n isVoidTypeAnnotation,\n stringTypeAnnotation,\n voidTypeAnnotation,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\n\n/*\n Infer the type of the current `NodePath`.\n /\n\nexport function getTypeAnnotation(this: NodePath): t.FlowType \| t.TSType {\n let type = this.getData(\"typeAnnotation\");\n if (type != null) {\n return type;\n }\n type = this._getTypeAnnotation() \|\| anyTypeAnnotation();\n if (isTypeAnnotation(type) \|\| isTSTypeAnnotation(type)) {\n type = type.typeAnnotation;\n }\n this.setData(\"typeAnnotation\", type);\n return type;\n}\n\n// Used to avoid infinite recursion in cases like\n// var b, c; if (0) { c = 1; b = c; } c = b;\n// It also works with indirect recursion.\nconst typeAnnotationInferringNodes = new WeakSet();\n\n/\n todo: split up this method\n */\n\nexport function _getTypeAnnotation(this: NodePath): any {\n const node = this.node;\n\n if (!node) {\n // handle initializerless variables, add in checks for loop initializers too\n if (this.key === \"init\" && this.parentPath.isVariableDeclarator()) {\n const declar = this.parentPath.parentPath;\n const declarParent = declar.parentPath;\n\n // for (let NODE in bar) {}\n if (declar.key === \"left\" && declarParent.isForInStatement()) {\n return stringTypeAnnotation();\n }\n\n // for (let NODE of bar) {}\n if (declar.key === \"left\" && declarParent.isForOfStatement()) {\n return anyTypeAnnotation();\n }\n\n return voidTypeAnnotation();\n } else {\n return;\n }\n }\n\n // @ts-expect-error typeAnnotation may not index node\n if (node.typeAnnotation) {\n // @ts-expect-error typeAnnotation may not index node\n return node.typeAnnotation;\n }\n\n if (typeAnnotationInferringNodes.has(node)) {\n // Bail out from type inference to avoid infinite loops\n return;\n }\n typeAnnotationInferringNodes.add(node);\n\n try {\n let inferer =\n // @ts-expect-error inferers do not cover all AST types\n inferers[node.type];\n if (inferer) {\n return inferer.call(this, node);\n }\n\n // @ts-expect-error inferers do not cover all AST types\n inferer = inferers[this.parentPath.type];\n if (inferer?.validParent) {\n return this.parentPath.getTypeAnnotation();\n }\n } finally {\n typeAnnotationInferringNodes.delete(node);\n }\n}\n\nexport function isBaseType(\n this: NodePath,\n baseName: string,\n soft?: boolean,\n): boolean {\n return _isBaseType(baseName, this.getTypeAnnotation(), soft);\n}\n\nfunction _isBaseType(\n baseName: string,\n type?: t.FlowType \| t.TSType,\n soft?: boolean,\n): boolean {\n if (baseName === \"string\") {\n return isStringTypeAnnotation(type);\n } else if (baseName === \"number\") {\n return isNumberTypeAnnotation(type);\n } else if (baseName === \"boolean\") {\n return isBooleanTypeAnnotation(type);\n } else if (baseName === \"any\") {\n return isAnyTypeAnnotation(type);\n } else if (baseName === \"mixed\") {\n return isMixedTypeAnnotation(type);\n } else if (baseName === \"empty\") {\n return isEmptyTypeAnnotation(type);\n } else if (baseName === \"void\") {\n return isVoidTypeAnnotation(type);\n } else {\n if (soft) {\n return false;\n } else {\n throw new Error(`Unknown base type ${baseName}`);\n }\n }\n}\n\nexport function couldBeBaseType(this: NodePath, name: string): boolean {\n const type = this.getTypeAnnotation();\n if (isAnyTypeAnnotation(type)) return true;\n\n if (isUnionTypeAnnotation(type)) {\n for (const type2 of type.types) {\n if (isAnyTypeAnnotation(type2) \|\| _isBaseType(name, type2, true)) {\n return true;\n }\n }\n return false;\n } else {\n return _isBaseType(name, type, true);\n }\n}\n\nexport function baseTypeStrictlyMatches(\n this: NodePath,\n rightArg: NodePath,\n): boolean {\n const left = this.getTypeAnnotation();\n const right = rightArg.getTypeAnnotation();\n\n if (!isAnyTypeAnnotation(left) && isFlowBaseAnnotation(left)) {\n return right.type === left.type;\n }\n return false;\n}\n\nexport function isGenericType(this: NodePath, genericName: string): boolean {\n const type = this.getTypeAnnotation();\n if (genericName === \"Array\") {\n // T[]\n if (\n isTSArrayType(type) \|\|\n isArrayTypeAnnotation(type) \|\|\n isTupleTypeAnnotation(type)\n ) {\n return true;\n }\n }\n return (\n (isGenericTypeAnnotation(type) &&\n isIdentifier(type.id, {\n name: genericName,\n })) \|\|\n (isTSTypeReference(type) &&\n isIdentifier(type.typeName, {\n name: genericName,\n }))\n );\n}\n"],"mappings":"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"}
1	+ {"version":3,"names":["anyTypeAnnotation","isAnyTypeAnnotation","isArrayTypeAnnotation","isBooleanTypeAnnotation","isEmptyTypeAnnotation","isFlowBaseAnnotation","isGenericTypeAnnotation","isIdentifier","isMixedTypeAnnotation","isNumberTypeAnnotation","isStringTypeAnnotation","isTSArrayType","isTSTypeAnnotation","isTSTypeReference","isTupleTypeAnnotation","isTypeAnnotation","isUnionTypeAnnotation","isVoidTypeAnnotation","stringTypeAnnotation","voidTypeAnnotation","getTypeAnnotation","type","getData","_getTypeAnnotation","typeAnnotation","setData","typeAnnotationInferringNodes","WeakSet","node","key","parentPath","isVariableDeclarator","declar","declarParent","isForInStatement","isForOfStatement","has","add","inferer","inferers","call","validParent","delete","isBaseType","baseName","soft","_isBaseType","Error","couldBeBaseType","name","type2","types","baseTypeStrictlyMatches","rightArg","left","right","isGenericType","genericName","id","typeName"],"sources":["../../../src/path/inference/index.ts"],"sourcesContent":["import type NodePath from \"../index\";\nimport * as inferers from \"./inferers\";\nimport {\n anyTypeAnnotation,\n isAnyTypeAnnotation,\n isArrayTypeAnnotation,\n isBooleanTypeAnnotation,\n isEmptyTypeAnnotation,\n isFlowBaseAnnotation,\n isGenericTypeAnnotation,\n isIdentifier,\n isMixedTypeAnnotation,\n isNumberTypeAnnotation,\n isStringTypeAnnotation,\n isTSArrayType,\n isTSTypeAnnotation,\n isTSTypeReference,\n isTupleTypeAnnotation,\n isTypeAnnotation,\n isUnionTypeAnnotation,\n isVoidTypeAnnotation,\n stringTypeAnnotation,\n voidTypeAnnotation,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\n\n/*\n Infer the type of the current `NodePath`.\n /\n\nexport function getTypeAnnotation(this: NodePath): t.FlowType \| t.TSType {\n let type = this.getData(\"typeAnnotation\");\n if (type != null) {\n return type;\n }\n type = this._getTypeAnnotation() \|\| anyTypeAnnotation();\n if (isTypeAnnotation(type) \|\| isTSTypeAnnotation(type)) {\n type = type.typeAnnotation;\n }\n this.setData(\"typeAnnotation\", type);\n return type;\n}\n\n// Used to avoid infinite recursion in cases like\n// var b, c; if (0) { c = 1; b = c; } c = b;\n// It also works with indirect recursion.\nconst typeAnnotationInferringNodes = new WeakSet();\n\n/\n todo: split up this method\n */\n\nexport function _getTypeAnnotation(this: NodePath): any {\n const node = this.node;\n\n if (!node) {\n // handle initializerless variables, add in checks for loop initializers too\n if (this.key === \"init\" && this.parentPath.isVariableDeclarator()) {\n const declar = this.parentPath.parentPath;\n const declarParent = declar.parentPath;\n\n // for (let NODE in bar) {}\n if (declar.key === \"left\" && declarParent.isForInStatement()) {\n return stringTypeAnnotation();\n }\n\n // for (let NODE of bar) {}\n if (declar.key === \"left\" && declarParent.isForOfStatement()) {\n return anyTypeAnnotation();\n }\n\n return voidTypeAnnotation();\n } else {\n return;\n }\n }\n\n // @ts-expect-error typeAnnotation may not index node\n if (node.typeAnnotation) {\n // @ts-expect-error typeAnnotation may not index node\n return node.typeAnnotation;\n }\n\n if (typeAnnotationInferringNodes.has(node)) {\n // Bail out from type inference to avoid infinite loops\n return;\n }\n typeAnnotationInferringNodes.add(node);\n\n try {\n let inferer =\n // @ts-expect-error inferers do not cover all AST types\n inferers[node.type];\n if (inferer) {\n return inferer.call(this, node);\n }\n\n // @ts-expect-error inferers do not cover all AST types\n inferer = inferers[this.parentPath.type];\n if (inferer?.validParent) {\n return this.parentPath.getTypeAnnotation();\n }\n } finally {\n typeAnnotationInferringNodes.delete(node);\n }\n}\n\nexport function isBaseType(\n this: NodePath,\n baseName: string,\n soft?: boolean,\n): boolean {\n return _isBaseType(baseName, this.getTypeAnnotation(), soft);\n}\n\nfunction _isBaseType(\n baseName: string,\n type?: t.FlowType \| t.TSType,\n soft?: boolean,\n): boolean {\n if (baseName === \"string\") {\n return isStringTypeAnnotation(type);\n } else if (baseName === \"number\") {\n return isNumberTypeAnnotation(type);\n } else if (baseName === \"boolean\") {\n return isBooleanTypeAnnotation(type);\n } else if (baseName === \"any\") {\n return isAnyTypeAnnotation(type);\n } else if (baseName === \"mixed\") {\n return isMixedTypeAnnotation(type);\n } else if (baseName === \"empty\") {\n return isEmptyTypeAnnotation(type);\n } else if (baseName === \"void\") {\n return isVoidTypeAnnotation(type);\n } else {\n if (soft) {\n return false;\n } else {\n throw new Error(`Unknown base type ${baseName}`);\n }\n }\n}\n\nexport function couldBeBaseType(this: NodePath, name: string): boolean {\n const type = this.getTypeAnnotation();\n if (isAnyTypeAnnotation(type)) return true;\n\n if (isUnionTypeAnnotation(type)) {\n for (const type2 of type.types) {\n if (isAnyTypeAnnotation(type2) \|\| _isBaseType(name, type2, true)) {\n return true;\n }\n }\n return false;\n } else {\n return _isBaseType(name, type, true);\n }\n}\n\nexport function baseTypeStrictlyMatches(\n this: NodePath,\n rightArg: NodePath,\n): boolean {\n const left = this.getTypeAnnotation();\n const right = rightArg.getTypeAnnotation();\n\n if (!isAnyTypeAnnotation(left) && isFlowBaseAnnotation(left)) {\n return right.type === left.type;\n }\n return false;\n}\n\nexport function isGenericType(this: NodePath, genericName: string): boolean {\n const type = this.getTypeAnnotation();\n if (genericName === \"Array\") {\n // T[]\n if (\n isTSArrayType(type) \|\|\n isArrayTypeAnnotation(type) \|\|\n isTupleTypeAnnotation(type)\n ) {\n return true;\n }\n }\n return (\n (isGenericTypeAnnotation(type) &&\n isIdentifier(type.id, {\n name: genericName,\n })) \|\|\n (isTSTypeReference(type) &&\n isIdentifier(type.typeName, {\n name: genericName,\n }))\n );\n}\n"],"mappings":"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"}

package/appFiles/node_modules/@babel/traverse/lib/path/inference/inferer-reference.js CHANGED Viewed

@@ -14,7 +14,6 @@ const {
 } = _t;
 function _default(node) {
   if (!this.isReferenced()) return;
   const binding = this.scope.getBinding(node.name);
   if (binding) {
     if (binding.identifier.typeAnnotation) {
@@ -23,15 +22,12 @@ function _default(node) {
       return getTypeAnnotationBindingConstantViolations(binding, this, node.name);
     }
   }
   if (node.name === "undefined") {
     return voidTypeAnnotation();
   } else if (node.name === "NaN" || node.name === "Infinity") {
     return numberTypeAnnotation();
-  } else if (node.name === "arguments") {
-  }
+  } else if (node.name === "arguments") {}
 }
 function getTypeAnnotationBindingConstantViolations(binding, path, name) {
   const types = [];
   const functionConstantViolations = [];
@@ -39,15 +35,11 @@ function getTypeAnnotationBindingConstantViolations(binding, path, name) {
   const testType = getConditionalAnnotation(binding, path, name);
   if (testType) {
     const testConstantViolations = getConstantViolationsBefore(binding, testType.ifStatement);
     constantViolations = constantViolations.filter(path => testConstantViolations.indexOf(path) < 0);
     types.push(testType.typeAnnotation);
   }
   if (constantViolations.length) {
     constantViolations.push(...functionConstantViolations);
     for (const violation of constantViolations) {
       types.push(violation.getTypeAnnotation());
     }
@@ -91,7 +83,6 @@ function inferAnnotationFromBinaryExpression(name, path) {
     return;
   }
   if (operator !== "===" && operator !== "==") return;
   let typeofPath;
   let typePath;
   if (left.isUnaryExpression({
@@ -109,13 +100,10 @@ function inferAnnotationFromBinaryExpression(name, path) {
   if (!typeofPath.get("argument").isIdentifier({
     name
   })) return;
   typePath = typePath.resolve();
   if (!typePath.isLiteral()) return;
   const typeValue = typePath.node.value;
   if (typeof typeValue !== "string") return;
   return createTypeAnnotationBasedOnTypeof(typeValue);
 }
 function getParentConditionalPath(binding, path, name) {

package/appFiles/node_modules/@babel/traverse/lib/path/inference/inferer-reference.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"names":["BOOLEAN_NUMBER_BINARY_OPERATORS","createTypeAnnotationBasedOnTypeof","numberTypeAnnotation","voidTypeAnnotation","node","isReferenced","binding","scope","getBinding","name","identifier","typeAnnotation","getTypeAnnotationBindingConstantViolations","path","types","functionConstantViolations","constantViolations","getConstantViolationsBefore","testType","getConditionalAnnotation","testConstantViolations","ifStatement","filter","indexOf","push","length","violation","getTypeAnnotation","createUnionType","functions","violations","slice","unshift","resolve","status","_guessExecutionStatusRelativeTo","inferAnnotationFromBinaryExpression","operator","right","get","left","target","isIdentifier","typeofPath","typePath","isUnaryExpression","isLiteral","typeValue","value","getParentConditionalPath","parentPath","isIfStatement","isConditionalExpression","key","isFunction","test","paths","i","isLogicalExpression","isBinaryExpression","type"],"sources":["../../../src/path/inference/inferer-reference.ts"],"sourcesContent":["import type NodePath from \"../index\";\nimport {\n BOOLEAN_NUMBER_BINARY_OPERATORS,\n createTypeAnnotationBasedOnTypeof,\n numberTypeAnnotation,\n voidTypeAnnotation,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\nimport type Binding from \"../../scope/binding\";\n\nimport { createUnionType } from \"./util\";\n\nexport default function (this: NodePath<t.Identifier>, node: t.Identifier) {\n if (!this.isReferenced()) return;\n\n // check if a binding exists of this value and if so then return a union type of all\n // possible types that the binding could be\n const binding = this.scope.getBinding(node.name);\n if (binding) {\n if (binding.identifier.typeAnnotation) {\n return binding.identifier.typeAnnotation;\n } else {\n return getTypeAnnotationBindingConstantViolations(\n binding,\n this,\n node.name,\n );\n }\n }\n\n // built-in values\n if (node.name === \"undefined\") {\n return voidTypeAnnotation();\n } else if (node.name === \"NaN\" \|\| node.name === \"Infinity\") {\n return numberTypeAnnotation();\n } else if (node.name === \"arguments\") {\n // todo\n }\n}\n\nfunction getTypeAnnotationBindingConstantViolations(\n binding: Binding,\n path: NodePath<t.Identifier>,\n name: string,\n) {\n const types = [];\n\n const functionConstantViolations: NodePath[] = [];\n let constantViolations = getConstantViolationsBefore(\n binding,\n path,\n functionConstantViolations,\n );\n\n const testType = getConditionalAnnotation(binding, path, name);\n if (testType) {\n const testConstantViolations = getConstantViolationsBefore(\n binding,\n testType.ifStatement,\n );\n\n // remove constant violations observed before the IfStatement\n constantViolations = constantViolations.filter(\n path => testConstantViolations.indexOf(path) < 0,\n );\n\n // clear current types and add in observed test type\n types.push(testType.typeAnnotation);\n }\n\n if (constantViolations.length) {\n // pick one constant from each scope which will represent the last possible\n // control flow path that it could've taken/been\n /* This code is broken for the following problems:\n * It thinks that assignments can only happen in scopes.\n * What about conditionals, if statements without block,\n * or guarded assignments.\n * It also checks to see if one of the assignments is in the\n * same scope and uses that as the only \"violation\". However,\n * the binding is returned by `getConstantViolationsBefore` so we for\n * sure always going to return that as the only \"violation\".\n let rawConstantViolations = constantViolations.reverse();\n let visitedScopes = [];\n constantViolations = [];\n for (let violation of (rawConstantViolations: Array<NodePath>)) {\n let violationScope = violation.scope;\n if (visitedScopes.indexOf(violationScope) >= 0) continue;\n\n visitedScopes.push(violationScope);\n constantViolations.push(violation);\n\n if (violationScope === path.scope) {\n constantViolations = [violation];\n break;\n }\n }*/\n\n // add back on function constant violations since we can't track calls\n constantViolations.push(...functionConstantViolations);\n\n // push on inferred types of violated paths\n for (const violation of constantViolations) {\n types.push(violation.getTypeAnnotation());\n }\n }\n\n if (!types.length) {\n return;\n }\n\n return createUnionType(types);\n}\n\nfunction getConstantViolationsBefore(\n binding: Binding,\n path: NodePath,\n functions?: NodePath[],\n) {\n const violations = binding.constantViolations.slice();\n violations.unshift(binding.path);\n return violations.filter(violation => {\n violation = violation.resolve();\n const status = violation._guessExecutionStatusRelativeTo(path);\n if (functions && status === \"unknown\") functions.push(violation);\n return status === \"before\";\n });\n}\n\nfunction inferAnnotationFromBinaryExpression(\n name: string,\n path: NodePath<t.BinaryExpression>,\n) {\n const operator = path.node.operator;\n\n const right = path.get(\"right\").resolve();\n const left = path.get(\"left\").resolve();\n\n let target;\n if (left.isIdentifier({ name })) {\n target = right;\n } else if (right.isIdentifier({ name })) {\n target = left;\n }\n\n if (target) {\n if (operator === \"===\") {\n return target.getTypeAnnotation();\n }\n if (BOOLEAN_NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {\n return numberTypeAnnotation();\n }\n\n return;\n }\n\n if (operator !== \"===\" && operator !== \"==\") return;\n\n //\n let typeofPath: NodePath<t.UnaryExpression>;\n let typePath: NodePath<t.Expression>;\n if (left.isUnaryExpression({ operator: \"typeof\" })) {\n typeofPath = left;\n typePath = right as NodePath<t.Expression>;\n } else if (right.isUnaryExpression({ operator: \"typeof\" })) {\n typeofPath = right;\n typePath = left as NodePath<t.Expression>;\n }\n\n if (!typeofPath) return;\n // and that the argument of the typeof path references us!\n if (!typeofPath.get(\"argument\").isIdentifier({ name })) return;\n\n // ensure that the type path is a Literal\n typePath = typePath.resolve() as NodePath<t.Expression>;\n if (!typePath.isLiteral()) return;\n\n // and that it's a string so we can infer it\n // @ts-expect-error todo(flow->ts): value is not defined for NullLiteral and some other\n const typeValue = typePath.node.value;\n if (typeof typeValue !== \"string\") return;\n\n // turn type value into a type annotation\n // @ts-expect-error todo(flow->ts): move validation from helper or relax type constraint to just a string\n return createTypeAnnotationBasedOnTypeof(typeValue);\n}\n\nfunction getParentConditionalPath(\n binding: Binding,\n path: NodePath,\n name: string,\n) {\n let parentPath;\n while ((parentPath = path.parentPath)) {\n if (parentPath.isIfStatement() \|\| parentPath.isConditionalExpression()) {\n if (path.key === \"test\") {\n return;\n }\n\n return parentPath as NodePath<t.IfStatement \| t.ConditionalExpression>;\n }\n if (parentPath.isFunction()) {\n if (parentPath.parentPath.scope.getBinding(name) !== binding) return;\n }\n\n path = parentPath;\n }\n}\n\nfunction getConditionalAnnotation<T extends t.Node>(\n binding: Binding,\n path: NodePath<T>,\n name?: string,\n): {\n typeAnnotation: t.FlowType \| t.TSType;\n ifStatement: NodePath<t.IfStatement \| t.ConditionalExpression>;\n} {\n const ifStatement = getParentConditionalPath(binding, path, name);\n if (!ifStatement) return;\n\n const test = ifStatement.get(\"test\");\n const paths = [test];\n const types = [];\n\n for (let i = 0; i < paths.length; i++) {\n const path = paths[i];\n\n if (path.isLogicalExpression()) {\n if (path.node.operator === \"&&\") {\n paths.push(path.get(\"left\"));\n paths.push(path.get(\"right\"));\n }\n } else if (path.isBinaryExpression()) {\n const type = inferAnnotationFromBinaryExpression(name, path);\n if (type) types.push(type);\n }\n }\n\n if (types.length) {\n return {\n typeAnnotation: createUnionType(types),\n ifStatement,\n };\n }\n\n return getConditionalAnnotation(binding, ifStatement, name);\n}\n"],"mappings":"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"}
1	+ {"version":3,"names":["BOOLEAN_NUMBER_BINARY_OPERATORS","createTypeAnnotationBasedOnTypeof","numberTypeAnnotation","voidTypeAnnotation","node","isReferenced","binding","scope","getBinding","name","identifier","typeAnnotation","getTypeAnnotationBindingConstantViolations","path","types","functionConstantViolations","constantViolations","getConstantViolationsBefore","testType","getConditionalAnnotation","testConstantViolations","ifStatement","filter","indexOf","push","length","violation","getTypeAnnotation","createUnionType","functions","violations","slice","unshift","resolve","status","_guessExecutionStatusRelativeTo","inferAnnotationFromBinaryExpression","operator","right","get","left","target","isIdentifier","typeofPath","typePath","isUnaryExpression","isLiteral","typeValue","value","getParentConditionalPath","parentPath","isIfStatement","isConditionalExpression","key","isFunction","test","paths","i","isLogicalExpression","isBinaryExpression","type"],"sources":["../../../src/path/inference/inferer-reference.ts"],"sourcesContent":["import type NodePath from \"../index\";\nimport {\n BOOLEAN_NUMBER_BINARY_OPERATORS,\n createTypeAnnotationBasedOnTypeof,\n numberTypeAnnotation,\n voidTypeAnnotation,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\nimport type Binding from \"../../scope/binding\";\n\nimport { createUnionType } from \"./util\";\n\nexport default function (this: NodePath<t.Identifier>, node: t.Identifier) {\n if (!this.isReferenced()) return;\n\n // check if a binding exists of this value and if so then return a union type of all\n // possible types that the binding could be\n const binding = this.scope.getBinding(node.name);\n if (binding) {\n if (binding.identifier.typeAnnotation) {\n return binding.identifier.typeAnnotation;\n } else {\n return getTypeAnnotationBindingConstantViolations(\n binding,\n this,\n node.name,\n );\n }\n }\n\n // built-in values\n if (node.name === \"undefined\") {\n return voidTypeAnnotation();\n } else if (node.name === \"NaN\" \|\| node.name === \"Infinity\") {\n return numberTypeAnnotation();\n } else if (node.name === \"arguments\") {\n // todo\n }\n}\n\nfunction getTypeAnnotationBindingConstantViolations(\n binding: Binding,\n path: NodePath<t.Identifier>,\n name: string,\n) {\n const types = [];\n\n const functionConstantViolations: NodePath[] = [];\n let constantViolations = getConstantViolationsBefore(\n binding,\n path,\n functionConstantViolations,\n );\n\n const testType = getConditionalAnnotation(binding, path, name);\n if (testType) {\n const testConstantViolations = getConstantViolationsBefore(\n binding,\n testType.ifStatement,\n );\n\n // remove constant violations observed before the IfStatement\n constantViolations = constantViolations.filter(\n path => testConstantViolations.indexOf(path) < 0,\n );\n\n // clear current types and add in observed test type\n types.push(testType.typeAnnotation);\n }\n\n if (constantViolations.length) {\n // pick one constant from each scope which will represent the last possible\n // control flow path that it could've taken/been\n /* This code is broken for the following problems:\n * It thinks that assignments can only happen in scopes.\n * What about conditionals, if statements without block,\n * or guarded assignments.\n * It also checks to see if one of the assignments is in the\n * same scope and uses that as the only \"violation\". However,\n * the binding is returned by `getConstantViolationsBefore` so we for\n * sure always going to return that as the only \"violation\".\n let rawConstantViolations = constantViolations.reverse();\n let visitedScopes = [];\n constantViolations = [];\n for (let violation of (rawConstantViolations: Array<NodePath>)) {\n let violationScope = violation.scope;\n if (visitedScopes.indexOf(violationScope) >= 0) continue;\n\n visitedScopes.push(violationScope);\n constantViolations.push(violation);\n\n if (violationScope === path.scope) {\n constantViolations = [violation];\n break;\n }\n }*/\n\n // add back on function constant violations since we can't track calls\n constantViolations.push(...functionConstantViolations);\n\n // push on inferred types of violated paths\n for (const violation of constantViolations) {\n types.push(violation.getTypeAnnotation());\n }\n }\n\n if (!types.length) {\n return;\n }\n\n return createUnionType(types);\n}\n\nfunction getConstantViolationsBefore(\n binding: Binding,\n path: NodePath,\n functions?: NodePath[],\n) {\n const violations = binding.constantViolations.slice();\n violations.unshift(binding.path);\n return violations.filter(violation => {\n violation = violation.resolve();\n const status = violation._guessExecutionStatusRelativeTo(path);\n if (functions && status === \"unknown\") functions.push(violation);\n return status === \"before\";\n });\n}\n\nfunction inferAnnotationFromBinaryExpression(\n name: string,\n path: NodePath<t.BinaryExpression>,\n) {\n const operator = path.node.operator;\n\n const right = path.get(\"right\").resolve();\n const left = path.get(\"left\").resolve();\n\n let target;\n if (left.isIdentifier({ name })) {\n target = right;\n } else if (right.isIdentifier({ name })) {\n target = left;\n }\n\n if (target) {\n if (operator === \"===\") {\n return target.getTypeAnnotation();\n }\n if (BOOLEAN_NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {\n return numberTypeAnnotation();\n }\n\n return;\n }\n\n if (operator !== \"===\" && operator !== \"==\") return;\n\n //\n let typeofPath: NodePath<t.UnaryExpression>;\n let typePath: NodePath<t.Expression>;\n if (left.isUnaryExpression({ operator: \"typeof\" })) {\n typeofPath = left;\n typePath = right as NodePath<t.Expression>;\n } else if (right.isUnaryExpression({ operator: \"typeof\" })) {\n typeofPath = right;\n typePath = left as NodePath<t.Expression>;\n }\n\n if (!typeofPath) return;\n // and that the argument of the typeof path references us!\n if (!typeofPath.get(\"argument\").isIdentifier({ name })) return;\n\n // ensure that the type path is a Literal\n typePath = typePath.resolve() as NodePath<t.Expression>;\n if (!typePath.isLiteral()) return;\n\n // and that it's a string so we can infer it\n // @ts-expect-error todo(flow->ts): value is not defined for NullLiteral and some other\n const typeValue = typePath.node.value;\n if (typeof typeValue !== \"string\") return;\n\n // turn type value into a type annotation\n // @ts-expect-error todo(flow->ts): move validation from helper or relax type constraint to just a string\n return createTypeAnnotationBasedOnTypeof(typeValue);\n}\n\nfunction getParentConditionalPath(\n binding: Binding,\n path: NodePath,\n name: string,\n) {\n let parentPath;\n while ((parentPath = path.parentPath)) {\n if (parentPath.isIfStatement() \|\| parentPath.isConditionalExpression()) {\n if (path.key === \"test\") {\n return;\n }\n\n return parentPath as NodePath<t.IfStatement \| t.ConditionalExpression>;\n }\n if (parentPath.isFunction()) {\n if (parentPath.parentPath.scope.getBinding(name) !== binding) return;\n }\n\n path = parentPath;\n }\n}\n\nfunction getConditionalAnnotation<T extends t.Node>(\n binding: Binding,\n path: NodePath<T>,\n name?: string,\n): {\n typeAnnotation: t.FlowType \| t.TSType;\n ifStatement: NodePath<t.IfStatement \| t.ConditionalExpression>;\n} {\n const ifStatement = getParentConditionalPath(binding, path, name);\n if (!ifStatement) return;\n\n const test = ifStatement.get(\"test\");\n const paths = [test];\n const types = [];\n\n for (let i = 0; i < paths.length; i++) {\n const path = paths[i];\n\n if (path.isLogicalExpression()) {\n if (path.node.operator === \"&&\") {\n paths.push(path.get(\"left\"));\n paths.push(path.get(\"right\"));\n }\n } else if (path.isBinaryExpression()) {\n const type = inferAnnotationFromBinaryExpression(name, path);\n if (type) types.push(type);\n }\n }\n\n if (types.length) {\n return {\n typeAnnotation: createUnionType(types),\n ifStatement,\n };\n }\n\n return getConditionalAnnotation(binding, ifStatement, name);\n}\n"],"mappings":"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"}

package/appFiles/node_modules/@babel/traverse/lib/path/inference/inferers.js CHANGED Viewed

@@ -106,7 +106,6 @@ function BinaryExpression(node) {
     } else if (left.isBaseType("string") || right.isBaseType("string")) {
       return stringTypeAnnotation();
     }
     return unionTypeAnnotation([stringTypeAnnotation(), numberTypeAnnotation()]);
   }
 }
@@ -171,8 +170,7 @@ function CallExpression() {
   } = this.node;
   if (isObjectKeys(callee)) {
     return arrayTypeAnnotation(stringTypeAnnotation());
-  } else if (isArrayFrom(callee) || isObjectValues(callee) ||
-  isIdentifier(callee, {
+  } else if (isArrayFrom(callee) || isObjectValues(callee) || isIdentifier(callee, {
     name: "Array"
   })) {
     return arrayTypeAnnotation(anyTypeAnnotation());
@@ -201,8 +199,7 @@ function resolveCall(callee) {
         return genericTypeAnnotation(identifier("Iterator"));
       } else if (callee.node.returnType) {
         return callee.node.returnType;
-      } else {
-      }
+      } else {}
     }
   }
 }

package/appFiles/node_modules/@babel/traverse/lib/path/inference/inferers.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"names":["BOOLEAN_BINARY_OPERATORS","BOOLEAN_UNARY_OPERATORS","NUMBER_BINARY_OPERATORS","NUMBER_UNARY_OPERATORS","STRING_UNARY_OPERATORS","anyTypeAnnotation","arrayTypeAnnotation","booleanTypeAnnotation","buildMatchMemberExpression","genericTypeAnnotation","identifier","nullLiteralTypeAnnotation","numberTypeAnnotation","stringTypeAnnotation","tupleTypeAnnotation","unionTypeAnnotation","voidTypeAnnotation","isIdentifier","VariableDeclarator","get","getTypeAnnotation","TypeCastExpression","node","typeAnnotation","validParent","TSAsExpression","TSNonNullExpression","NewExpression","callee","type","TemplateLiteral","UnaryExpression","operator","indexOf","BinaryExpression","right","left","isBaseType","LogicalExpression","argumentTypes","createUnionType","ConditionalExpression","SequenceExpression","pop","ParenthesizedExpression","AssignmentExpression","UpdateExpression","StringLiteral","NumericLiteral","BooleanLiteral","NullLiteral","RegExpLiteral","ObjectExpression","ArrayExpression","RestElement","Func","isArrayFrom","isObjectKeys","isObjectValues","isObjectEntries","CallExpression","name","resolveCall","TaggedTemplateExpression","resolve","isFunction","async","generator","returnType"],"sources":["../../../src/path/inference/inferers.ts"],"sourcesContent":["import {\n BOOLEAN_BINARY_OPERATORS,\n BOOLEAN_UNARY_OPERATORS,\n NUMBER_BINARY_OPERATORS,\n NUMBER_UNARY_OPERATORS,\n STRING_UNARY_OPERATORS,\n anyTypeAnnotation,\n arrayTypeAnnotation,\n booleanTypeAnnotation,\n buildMatchMemberExpression,\n genericTypeAnnotation,\n identifier,\n nullLiteralTypeAnnotation,\n numberTypeAnnotation,\n stringTypeAnnotation,\n tupleTypeAnnotation,\n unionTypeAnnotation,\n voidTypeAnnotation,\n isIdentifier,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\n\nexport { default as Identifier } from \"./inferer-reference\";\n\nimport { createUnionType } from \"./util\";\nimport type NodePath from \"..\";\n\nexport function VariableDeclarator(this: NodePath<t.VariableDeclarator>) {\n if (!this.get(\"id\").isIdentifier()) return;\n return this.get(\"init\").getTypeAnnotation();\n}\n\nexport function TypeCastExpression(node: t.TypeCastExpression) {\n return node.typeAnnotation;\n}\n\nTypeCastExpression.validParent = true;\n\nexport function TSAsExpression(node: t.TSAsExpression) {\n return node.typeAnnotation;\n}\n\nTSAsExpression.validParent = true;\n\nexport function TSNonNullExpression(this: NodePath<t.TSNonNullExpression>) {\n return this.get(\"expression\").getTypeAnnotation();\n}\n\nexport function NewExpression(\n this: NodePath<t.NewExpression>,\n node: t.NewExpression,\n) {\n if (node.callee.type === \"Identifier\") {\n // only resolve identifier callee\n return genericTypeAnnotation(node.callee);\n }\n}\n\nexport function TemplateLiteral() {\n return stringTypeAnnotation();\n}\n\nexport function UnaryExpression(node: t.UnaryExpression) {\n const operator = node.operator;\n\n if (operator === \"void\") {\n return voidTypeAnnotation();\n } else if (NUMBER_UNARY_OPERATORS.indexOf(operator) >= 0) {\n return numberTypeAnnotation();\n } else if (STRING_UNARY_OPERATORS.indexOf(operator) >= 0) {\n return stringTypeAnnotation();\n } else if (BOOLEAN_UNARY_OPERATORS.indexOf(operator) >= 0) {\n return booleanTypeAnnotation();\n }\n}\n\nexport function BinaryExpression(\n this: NodePath<t.BinaryExpression>,\n node: t.BinaryExpression,\n) {\n const operator = node.operator;\n\n if (NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {\n return numberTypeAnnotation();\n } else if (BOOLEAN_BINARY_OPERATORS.indexOf(operator) >= 0) {\n return booleanTypeAnnotation();\n } else if (operator === \"+\") {\n const right = this.get(\"right\");\n const left = this.get(\"left\");\n\n if (left.isBaseType(\"number\") && right.isBaseType(\"number\")) {\n // both numbers so this will be a number\n return numberTypeAnnotation();\n } else if (left.isBaseType(\"string\") \|\| right.isBaseType(\"string\")) {\n // one is a string so the result will be a string\n return stringTypeAnnotation();\n }\n\n // unsure if left and right are strings or numbers so stay on the safe side\n return unionTypeAnnotation([\n stringTypeAnnotation(),\n numberTypeAnnotation(),\n ]);\n }\n}\n\nexport function LogicalExpression(this: NodePath<t.LogicalExpression>) {\n const argumentTypes = [\n this.get(\"left\").getTypeAnnotation(),\n this.get(\"right\").getTypeAnnotation(),\n ];\n\n return createUnionType(argumentTypes);\n}\n\nexport function ConditionalExpression(this: NodePath<t.ConditionalExpression>) {\n const argumentTypes = [\n this.get(\"consequent\").getTypeAnnotation(),\n this.get(\"alternate\").getTypeAnnotation(),\n ];\n\n return createUnionType(argumentTypes);\n}\n\nexport function SequenceExpression(this: NodePath<t.SequenceExpression>) {\n return this.get(\"expressions\").pop().getTypeAnnotation();\n}\n\nexport function ParenthesizedExpression(\n this: NodePath<t.ParenthesizedExpression>,\n) {\n return this.get(\"expression\").getTypeAnnotation();\n}\n\nexport function AssignmentExpression(this: NodePath<t.AssignmentExpression>) {\n return this.get(\"right\").getTypeAnnotation();\n}\n\nexport function UpdateExpression(\n this: NodePath<t.UpdateExpression>,\n node: t.UpdateExpression,\n) {\n const operator = node.operator;\n if (operator === \"++\" \|\| operator === \"--\") {\n return numberTypeAnnotation();\n }\n}\n\nexport function StringLiteral() {\n return stringTypeAnnotation();\n}\n\nexport function NumericLiteral() {\n return numberTypeAnnotation();\n}\n\nexport function BooleanLiteral() {\n return booleanTypeAnnotation();\n}\n\nexport function NullLiteral() {\n return nullLiteralTypeAnnotation();\n}\n\nexport function RegExpLiteral() {\n return genericTypeAnnotation(identifier(\"RegExp\"));\n}\n\nexport function ObjectExpression() {\n return genericTypeAnnotation(identifier(\"Object\"));\n}\n\nexport function ArrayExpression() {\n return genericTypeAnnotation(identifier(\"Array\"));\n}\n\nexport function RestElement() {\n return ArrayExpression();\n}\n\nRestElement.validParent = true;\n\nfunction Func() {\n return genericTypeAnnotation(identifier(\"Function\"));\n}\n\nexport {\n Func as FunctionExpression,\n Func as ArrowFunctionExpression,\n Func as FunctionDeclaration,\n Func as ClassExpression,\n Func as ClassDeclaration,\n};\n\nconst isArrayFrom = buildMatchMemberExpression(\"Array.from\");\nconst isObjectKeys = buildMatchMemberExpression(\"Object.keys\");\nconst isObjectValues = buildMatchMemberExpression(\"Object.values\");\nconst isObjectEntries = buildMatchMemberExpression(\"Object.entries\");\nexport function CallExpression(this: NodePath<t.CallExpression>) {\n const { callee } = this.node;\n if (isObjectKeys(callee)) {\n return arrayTypeAnnotation(stringTypeAnnotation());\n } else if (\n isArrayFrom(callee) \|\|\n isObjectValues(callee) \|\|\n // Detect \"var foo = Array()\" calls so we can optimize for arrays vs iterables.\n isIdentifier(callee, { name: \"Array\" })\n ) {\n return arrayTypeAnnotation(anyTypeAnnotation());\n } else if (isObjectEntries(callee)) {\n return arrayTypeAnnotation(\n tupleTypeAnnotation([stringTypeAnnotation(), anyTypeAnnotation()]),\n );\n }\n\n return resolveCall(this.get(\"callee\"));\n}\n\nexport function TaggedTemplateExpression(\n this: NodePath<t.TaggedTemplateExpression>,\n) {\n return resolveCall(this.get(\"tag\"));\n}\n\nfunction resolveCall(callee: NodePath) {\n callee = callee.resolve();\n\n if (callee.isFunction()) {\n const { node } = callee;\n if (node.async) {\n if (node.generator) {\n return genericTypeAnnotation(identifier(\"AsyncIterator\"));\n } else {\n return genericTypeAnnotation(identifier(\"Promise\"));\n }\n } else {\n if (node.generator) {\n return genericTypeAnnotation(identifier(\"Iterator\"));\n } else if (callee.node.returnType) {\n return callee.node.returnType;\n } else {\n // todo: get union type of all return arguments\n }\n }\n }\n}\n"],"mappings":"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"}
1	+ {"version":3,"names":["BOOLEAN_BINARY_OPERATORS","BOOLEAN_UNARY_OPERATORS","NUMBER_BINARY_OPERATORS","NUMBER_UNARY_OPERATORS","STRING_UNARY_OPERATORS","anyTypeAnnotation","arrayTypeAnnotation","booleanTypeAnnotation","buildMatchMemberExpression","genericTypeAnnotation","identifier","nullLiteralTypeAnnotation","numberTypeAnnotation","stringTypeAnnotation","tupleTypeAnnotation","unionTypeAnnotation","voidTypeAnnotation","isIdentifier","VariableDeclarator","get","getTypeAnnotation","TypeCastExpression","node","typeAnnotation","validParent","TSAsExpression","TSNonNullExpression","NewExpression","callee","type","TemplateLiteral","UnaryExpression","operator","indexOf","BinaryExpression","right","left","isBaseType","LogicalExpression","argumentTypes","createUnionType","ConditionalExpression","SequenceExpression","pop","ParenthesizedExpression","AssignmentExpression","UpdateExpression","StringLiteral","NumericLiteral","BooleanLiteral","NullLiteral","RegExpLiteral","ObjectExpression","ArrayExpression","RestElement","Func","isArrayFrom","isObjectKeys","isObjectValues","isObjectEntries","CallExpression","name","resolveCall","TaggedTemplateExpression","resolve","isFunction","async","generator","returnType"],"sources":["../../../src/path/inference/inferers.ts"],"sourcesContent":["import {\n BOOLEAN_BINARY_OPERATORS,\n BOOLEAN_UNARY_OPERATORS,\n NUMBER_BINARY_OPERATORS,\n NUMBER_UNARY_OPERATORS,\n STRING_UNARY_OPERATORS,\n anyTypeAnnotation,\n arrayTypeAnnotation,\n booleanTypeAnnotation,\n buildMatchMemberExpression,\n genericTypeAnnotation,\n identifier,\n nullLiteralTypeAnnotation,\n numberTypeAnnotation,\n stringTypeAnnotation,\n tupleTypeAnnotation,\n unionTypeAnnotation,\n voidTypeAnnotation,\n isIdentifier,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\n\nexport { default as Identifier } from \"./inferer-reference\";\n\nimport { createUnionType } from \"./util\";\nimport type NodePath from \"..\";\n\nexport function VariableDeclarator(this: NodePath<t.VariableDeclarator>) {\n if (!this.get(\"id\").isIdentifier()) return;\n return this.get(\"init\").getTypeAnnotation();\n}\n\nexport function TypeCastExpression(node: t.TypeCastExpression) {\n return node.typeAnnotation;\n}\n\nTypeCastExpression.validParent = true;\n\nexport function TSAsExpression(node: t.TSAsExpression) {\n return node.typeAnnotation;\n}\n\nTSAsExpression.validParent = true;\n\nexport function TSNonNullExpression(this: NodePath<t.TSNonNullExpression>) {\n return this.get(\"expression\").getTypeAnnotation();\n}\n\nexport function NewExpression(\n this: NodePath<t.NewExpression>,\n node: t.NewExpression,\n) {\n if (node.callee.type === \"Identifier\") {\n // only resolve identifier callee\n return genericTypeAnnotation(node.callee);\n }\n}\n\nexport function TemplateLiteral() {\n return stringTypeAnnotation();\n}\n\nexport function UnaryExpression(node: t.UnaryExpression) {\n const operator = node.operator;\n\n if (operator === \"void\") {\n return voidTypeAnnotation();\n } else if (NUMBER_UNARY_OPERATORS.indexOf(operator) >= 0) {\n return numberTypeAnnotation();\n } else if (STRING_UNARY_OPERATORS.indexOf(operator) >= 0) {\n return stringTypeAnnotation();\n } else if (BOOLEAN_UNARY_OPERATORS.indexOf(operator) >= 0) {\n return booleanTypeAnnotation();\n }\n}\n\nexport function BinaryExpression(\n this: NodePath<t.BinaryExpression>,\n node: t.BinaryExpression,\n) {\n const operator = node.operator;\n\n if (NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {\n return numberTypeAnnotation();\n } else if (BOOLEAN_BINARY_OPERATORS.indexOf(operator) >= 0) {\n return booleanTypeAnnotation();\n } else if (operator === \"+\") {\n const right = this.get(\"right\");\n const left = this.get(\"left\");\n\n if (left.isBaseType(\"number\") && right.isBaseType(\"number\")) {\n // both numbers so this will be a number\n return numberTypeAnnotation();\n } else if (left.isBaseType(\"string\") \|\| right.isBaseType(\"string\")) {\n // one is a string so the result will be a string\n return stringTypeAnnotation();\n }\n\n // unsure if left and right are strings or numbers so stay on the safe side\n return unionTypeAnnotation([\n stringTypeAnnotation(),\n numberTypeAnnotation(),\n ]);\n }\n}\n\nexport function LogicalExpression(this: NodePath<t.LogicalExpression>) {\n const argumentTypes = [\n this.get(\"left\").getTypeAnnotation(),\n this.get(\"right\").getTypeAnnotation(),\n ];\n\n return createUnionType(argumentTypes);\n}\n\nexport function ConditionalExpression(this: NodePath<t.ConditionalExpression>) {\n const argumentTypes = [\n this.get(\"consequent\").getTypeAnnotation(),\n this.get(\"alternate\").getTypeAnnotation(),\n ];\n\n return createUnionType(argumentTypes);\n}\n\nexport function SequenceExpression(this: NodePath<t.SequenceExpression>) {\n return this.get(\"expressions\").pop().getTypeAnnotation();\n}\n\nexport function ParenthesizedExpression(\n this: NodePath<t.ParenthesizedExpression>,\n) {\n return this.get(\"expression\").getTypeAnnotation();\n}\n\nexport function AssignmentExpression(this: NodePath<t.AssignmentExpression>) {\n return this.get(\"right\").getTypeAnnotation();\n}\n\nexport function UpdateExpression(\n this: NodePath<t.UpdateExpression>,\n node: t.UpdateExpression,\n) {\n const operator = node.operator;\n if (operator === \"++\" \|\| operator === \"--\") {\n return numberTypeAnnotation();\n }\n}\n\nexport function StringLiteral() {\n return stringTypeAnnotation();\n}\n\nexport function NumericLiteral() {\n return numberTypeAnnotation();\n}\n\nexport function BooleanLiteral() {\n return booleanTypeAnnotation();\n}\n\nexport function NullLiteral() {\n return nullLiteralTypeAnnotation();\n}\n\nexport function RegExpLiteral() {\n return genericTypeAnnotation(identifier(\"RegExp\"));\n}\n\nexport function ObjectExpression() {\n return genericTypeAnnotation(identifier(\"Object\"));\n}\n\nexport function ArrayExpression() {\n return genericTypeAnnotation(identifier(\"Array\"));\n}\n\nexport function RestElement() {\n return ArrayExpression();\n}\n\nRestElement.validParent = true;\n\nfunction Func() {\n return genericTypeAnnotation(identifier(\"Function\"));\n}\n\nexport {\n Func as FunctionExpression,\n Func as ArrowFunctionExpression,\n Func as FunctionDeclaration,\n Func as ClassExpression,\n Func as ClassDeclaration,\n};\n\nconst isArrayFrom = buildMatchMemberExpression(\"Array.from\");\nconst isObjectKeys = buildMatchMemberExpression(\"Object.keys\");\nconst isObjectValues = buildMatchMemberExpression(\"Object.values\");\nconst isObjectEntries = buildMatchMemberExpression(\"Object.entries\");\nexport function CallExpression(this: NodePath<t.CallExpression>) {\n const { callee } = this.node;\n if (isObjectKeys(callee)) {\n return arrayTypeAnnotation(stringTypeAnnotation());\n } else if (\n isArrayFrom(callee) \|\|\n isObjectValues(callee) \|\|\n // Detect \"var foo = Array()\" calls so we can optimize for arrays vs iterables.\n isIdentifier(callee, { name: \"Array\" })\n ) {\n return arrayTypeAnnotation(anyTypeAnnotation());\n } else if (isObjectEntries(callee)) {\n return arrayTypeAnnotation(\n tupleTypeAnnotation([stringTypeAnnotation(), anyTypeAnnotation()]),\n );\n }\n\n return resolveCall(this.get(\"callee\"));\n}\n\nexport function TaggedTemplateExpression(\n this: NodePath<t.TaggedTemplateExpression>,\n) {\n return resolveCall(this.get(\"tag\"));\n}\n\nfunction resolveCall(callee: NodePath) {\n callee = callee.resolve();\n\n if (callee.isFunction()) {\n const { node } = callee;\n if (node.async) {\n if (node.generator) {\n return genericTypeAnnotation(identifier(\"AsyncIterator\"));\n } else {\n return genericTypeAnnotation(identifier(\"Promise\"));\n }\n } else {\n if (node.generator) {\n return genericTypeAnnotation(identifier(\"Iterator\"));\n } else if (callee.node.returnType) {\n return callee.node.returnType;\n } else {\n // todo: get union type of all return arguments\n }\n }\n }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAsBA;AAEA;AAAyC;EAvBvCA,wBAAwB;EACxBC,uBAAuB;EACvBC,uBAAuB;EACvBC,sBAAsB;EACtBC,sBAAsB;EACtBC,iBAAiB;EACjBC,mBAAmB;EACnBC,qBAAqB;EACrBC,0BAA0B;EAC1BC,qBAAqB;EACrBC,UAAU;EACVC,yBAAyB;EACzBC,oBAAoB;EACpBC,oBAAoB;EACpBC,mBAAmB;EACnBC,mBAAmB;EACnBC,kBAAkB;EAClBC;AAAY;AASP,SAASC,kBAAkB,GAAuC;EACvE,IAAI,CAAC,IAAI,CAACC,GAAG,CAAC,IAAI,CAAC,CAACF,YAAY,EAAE,EAAE;EACpC,OAAO,IAAI,CAACE,GAAG,CAAC,MAAM,CAAC,CAACC,iBAAiB,EAAE;AAC7C;AAEO,SAASC,kBAAkB,CAACC,IAA0B,EAAE;EAC7D,OAAOA,IAAI,CAACC,cAAc;AAC5B;AAEAF,kBAAkB,CAACG,WAAW,GAAG,IAAI;AAE9B,SAASC,cAAc,CAACH,IAAsB,EAAE;EACrD,OAAOA,IAAI,CAACC,cAAc;AAC5B;AAEAE,cAAc,CAACD,WAAW,GAAG,IAAI;AAE1B,SAASE,mBAAmB,GAAwC;EACzE,OAAO,IAAI,CAACP,GAAG,CAAC,YAAY,CAAC,CAACC,iBAAiB,EAAE;AACnD;AAEO,SAASO,aAAa,CAE3BL,IAAqB,EACrB;EACA,IAAIA,IAAI,CAACM,MAAM,CAACC,IAAI,KAAK,YAAY,EAAE;IAErC,OAAOpB,qBAAqB,CAACa,IAAI,CAACM,MAAM,CAAC;EAC3C;AACF;AAEO,SAASE,eAAe,GAAG;EAChC,OAAOjB,oBAAoB,EAAE;AAC/B;AAEO,SAASkB,eAAe,CAACT,IAAuB,EAAE;EACvD,MAAMU,QAAQ,GAAGV,IAAI,CAACU,QAAQ;EAE9B,IAAIA,QAAQ,KAAK,MAAM,EAAE;IACvB,OAAOhB,kBAAkB,EAAE;EAC7B,CAAC,MAAM,IAAIb,sBAAsB,CAAC8B,OAAO,CAACD,QAAQ,CAAC,IAAI,CAAC,EAAE;IACxD,OAAOpB,oBAAoB,EAAE;EAC/B,CAAC,MAAM,IAAIR,sBAAsB,CAAC6B,OAAO,CAACD,QAAQ,CAAC,IAAI,CAAC,EAAE;IACxD,OAAOnB,oBAAoB,EAAE;EAC/B,CAAC,MAAM,IAAIZ,uBAAuB,CAACgC,OAAO,CAACD,QAAQ,CAAC,IAAI,CAAC,EAAE;IACzD,OAAOzB,qBAAqB,EAAE;EAChC;AACF;AAEO,SAAS2B,gBAAgB,CAE9BZ,IAAwB,EACxB;EACA,MAAMU,QAAQ,GAAGV,IAAI,CAACU,QAAQ;EAE9B,IAAI9B,uBAAuB,CAAC+B,OAAO,CAACD,QAAQ,CAAC,IAAI,CAAC,EAAE;IAClD,OAAOpB,oBAAoB,EAAE;EAC/B,CAAC,MAAM,IAAIZ,wBAAwB,CAACiC,OAAO,CAACD,QAAQ,CAAC,IAAI,CAAC,EAAE;IAC1D,OAAOzB,qBAAqB,EAAE;EAChC,CAAC,MAAM,IAAIyB,QAAQ,KAAK,GAAG,EAAE;IAC3B,MAAMG,KAAK,GAAG,IAAI,CAAChB,GAAG,CAAC,OAAO,CAAC;IAC/B,MAAMiB,IAAI,GAAG,IAAI,CAACjB,GAAG,CAAC,MAAM,CAAC;IAE7B,IAAIiB,IAAI,CAACC,UAAU,CAAC,QAAQ,CAAC,IAAIF,KAAK,CAACE,UAAU,CAAC,QAAQ,CAAC,EAAE;MAE3D,OAAOzB,oBAAoB,EAAE;IAC/B,CAAC,MAAM,IAAIwB,IAAI,CAACC,UAAU,CAAC,QAAQ,CAAC,IAAIF,KAAK,CAACE,UAAU,CAAC,QAAQ,CAAC,EAAE;MAElE,OAAOxB,oBAAoB,EAAE;IAC/B;IAGA,OAAOE,mBAAmB,CAAC,CACzBF,oBAAoB,EAAE,EACtBD,oBAAoB,EAAE,CACvB,CAAC;EACJ;AACF;AAEO,SAAS0B,iBAAiB,GAAsC;EACrE,MAAMC,aAAa,GAAG,CACpB,IAAI,CAACpB,GAAG,CAAC,MAAM,CAAC,CAACC,iBAAiB,EAAE,EACpC,IAAI,CAACD,GAAG,CAAC,OAAO,CAAC,CAACC,iBAAiB,EAAE,CACtC;EAED,OAAO,IAAAoB,qBAAe,EAACD,aAAa,CAAC;AACvC;AAEO,SAASE,qBAAqB,GAA0C;EAC7E,MAAMF,aAAa,GAAG,CACpB,IAAI,CAACpB,GAAG,CAAC,YAAY,CAAC,CAACC,iBAAiB,EAAE,EAC1C,IAAI,CAACD,GAAG,CAAC,WAAW,CAAC,CAACC,iBAAiB,EAAE,CAC1C;EAED,OAAO,IAAAoB,qBAAe,EAACD,aAAa,CAAC;AACvC;AAEO,SAASG,kBAAkB,GAAuC;EACvE,OAAO,IAAI,CAACvB,GAAG,CAAC,aAAa,CAAC,CAACwB,GAAG,EAAE,CAACvB,iBAAiB,EAAE;AAC1D;AAEO,SAASwB,uBAAuB,GAErC;EACA,OAAO,IAAI,CAACzB,GAAG,CAAC,YAAY,CAAC,CAACC,iBAAiB,EAAE;AACnD;AAEO,SAASyB,oBAAoB,GAAyC;EAC3E,OAAO,IAAI,CAAC1B,GAAG,CAAC,OAAO,CAAC,CAACC,iBAAiB,EAAE;AAC9C;AAEO,SAAS0B,gBAAgB,CAE9BxB,IAAwB,EACxB;EACA,MAAMU,QAAQ,GAAGV,IAAI,CAACU,QAAQ;EAC9B,IAAIA,QAAQ,KAAK,IAAI,IAAIA,QAAQ,KAAK,IAAI,EAAE;IAC1C,OAAOpB,oBAAoB,EAAE;EAC/B;AACF;AAEO,SAASmC,aAAa,GAAG;EAC9B,OAAOlC,oBAAoB,EAAE;AAC/B;AAEO,SAASmC,cAAc,GAAG;EAC/B,OAAOpC,oBAAoB,EAAE;AAC/B;AAEO,SAASqC,cAAc,GAAG;EAC/B,OAAO1C,qBAAqB,EAAE;AAChC;AAEO,SAAS2C,WAAW,GAAG;EAC5B,OAAOvC,yBAAyB,EAAE;AACpC;AAEO,SAASwC,aAAa,GAAG;EAC9B,OAAO1C,qBAAqB,CAACC,UAAU,CAAC,QAAQ,CAAC,CAAC;AACpD;AAEO,SAAS0C,gBAAgB,GAAG;EACjC,OAAO3C,qBAAqB,CAACC,UAAU,CAAC,QAAQ,CAAC,CAAC;AACpD;AAEO,SAAS2C,eAAe,GAAG;EAChC,OAAO5C,qBAAqB,CAACC,UAAU,CAAC,OAAO,CAAC,CAAC;AACnD;AAEO,SAAS4C,WAAW,GAAG;EAC5B,OAAOD,eAAe,EAAE;AAC1B;AAEAC,WAAW,CAAC9B,WAAW,GAAG,IAAI;AAE9B,SAAS+B,IAAI,GAAG;EACd,OAAO9C,qBAAqB,CAACC,UAAU,CAAC,UAAU,CAAC,CAAC;AACtD;AAUA,MAAM8C,WAAW,GAAGhD,0BAA0B,CAAC,YAAY,CAAC;AAC5D,MAAMiD,YAAY,GAAGjD,0BAA0B,CAAC,aAAa,CAAC;AAC9D,MAAMkD,cAAc,GAAGlD,0BAA0B,CAAC,eAAe,CAAC;AAClE,MAAMmD,eAAe,GAAGnD,0BAA0B,CAAC,gBAAgB,CAAC;AAC7D,SAASoD,cAAc,GAAmC;EAC/D,MAAM;IAAEhC;EAAO,CAAC,GAAG,IAAI,CAACN,IAAI;EAC5B,IAAImC,YAAY,CAAC7B,MAAM,CAAC,EAAE;IACxB,OAAOtB,mBAAmB,CAACO,oBAAoB,EAAE,CAAC;EACpD,CAAC,MAAM,IACL2C,WAAW,CAAC5B,MAAM,CAAC,IACnB8B,cAAc,CAAC9B,MAAM,CAAC,IAEtBX,YAAY,CAACW,MAAM,EAAE;IAAEiC,IAAI,EAAE;EAAQ,CAAC,CAAC,EACvC;IACA,OAAOvD,mBAAmB,CAACD,iBAAiB,EAAE,CAAC;EACjD,CAAC,MAAM,IAAIsD,eAAe,CAAC/B,MAAM,CAAC,EAAE;IAClC,OAAOtB,mBAAmB,CACxBQ,mBAAmB,CAAC,CAACD,oBAAoB,EAAE,EAAER,iBAAiB,EAAE,CAAC,CAAC,CACnE;EACH;EAEA,OAAOyD,WAAW,CAAC,IAAI,CAAC3C,GAAG,CAAC,QAAQ,CAAC,CAAC;AACxC;AAEO,SAAS4C,wBAAwB,GAEtC;EACA,OAAOD,WAAW,CAAC,IAAI,CAAC3C,GAAG,CAAC,KAAK,CAAC,CAAC;AACrC;AAEA,SAAS2C,WAAW,CAAClC,MAAgB,EAAE;EACrCA,MAAM,GAAGA,MAAM,CAACoC,OAAO,EAAE;EAEzB,IAAIpC,MAAM,CAACqC,UAAU,EAAE,EAAE;IACvB,MAAM;MAAE3C;IAAK,CAAC,GAAGM,MAAM;IACvB,IAAIN,IAAI,CAAC4C,KAAK,EAAE;MACd,IAAI5C,IAAI,CAAC6C,SAAS,EAAE;QAClB,OAAO1D,qBAAqB,CAACC,UAAU,CAAC,eAAe,CAAC,CAAC;MAC3D,CAAC,MAAM;QACL,OAAOD,qBAAqB,CAACC,UAAU,CAAC,SAAS,CAAC,CAAC;MACrD;IACF,CAAC,MAAM;MACL,IAAIY,IAAI,CAAC6C,SAAS,EAAE;QAClB,OAAO1D,qBAAqB,CAACC,UAAU,CAAC,UAAU,CAAC,CAAC;MACtD,CAAC,MAAM,IAAIkB,MAAM,CAACN,IAAI,CAAC8C,UAAU,EAAE;QACjC,OAAOxC,MAAM,CAACN,IAAI,CAAC8C,UAAU;MAC/B,CAAC,MAAM,CAEP;IACF;EACF;AACF"}

package/appFiles/node_modules/@babel/traverse/lib/path/introspection.js CHANGED Viewed

@@ -34,11 +34,9 @@ const {
   isType,
   matchesPattern: _matchesPattern
 } = _t;
 function matchesPattern(pattern, allowPartial) {
   return _matchesPattern(this.node, pattern, allowPartial);
 }
 function has(key) {
   const val = this.node && this.node[key];
   if (val && Array.isArray(val)) {
@@ -47,31 +45,23 @@ function has(key) {
     return !!val;
   }
 }
 function isStatic() {
   return this.scope.isStatic(this.node);
 }
 const is = has;
 exports.is = is;
 function isnt(key) {
   return !this.has(key);
 }
 function equals(key, value) {
   return this.node[key] === value;
 }
 function isNodeType(type) {
   return isType(this.type, type);
 }
 function canHaveVariableDeclarationOrExpression() {
   return (this.key === "init" || this.key === "left") && this.parentPath.isFor();
 }
 function canSwapBetweenExpressionAndStatement(replacement) {
   if (this.key !== "body" || !this.parentPath.isArrowFunctionExpression()) {
     return false;
@@ -83,7 +73,6 @@ function canSwapBetweenExpressionAndStatement(replacement) {
   }
   return false;
 }
 function isCompletionRecord(allowInsideFunction) {
   let path = this;
   let first = true;
@@ -92,19 +81,16 @@ function isCompletionRecord(allowInsideFunction) {
       type,
       container
     } = path;
     if (!first && (path.isFunction() || type === "StaticBlock")) {
       return !!allowInsideFunction;
     }
     first = false;
     if (Array.isArray(container) && path.key !== container.length - 1) {
       return false;
     }
   } while ((path = path.parentPath) && !path.isProgram() && !path.isDoExpression());
   return true;
 }
 function isStatementOrBlock() {
   if (this.parentPath.isLabeledStatement() || isBlockStatement(this.container)) {
     return false;
@@ -112,7 +98,6 @@ function isStatementOrBlock() {
     return STATEMENT_OR_BLOCK_KEYS.includes(this.key);
   }
 }
 function referencesImport(moduleSource, importName) {
   if (!this.isReferencedIdentifier()) {
     if (this.isJSXMemberExpression() && this.node.property.name === importName || (this.isMemberExpression() || this.isOptionalMemberExpression()) && (this.node.computed ? isStringLiteral(this.node.property, {
@@ -128,7 +113,6 @@ function referencesImport(moduleSource, importName) {
   const path = binding.path;
   const parent = path.parentPath;
   if (!parent.isImportDeclaration()) return false;
   if (parent.node.source.value === moduleSource) {
     if (!importName) return true;
   } else {
@@ -147,7 +131,6 @@ function referencesImport(moduleSource, importName) {
   }
   return false;
 }
 function getSource() {
   const node = this.node;
   if (node.end) {
@@ -160,38 +143,30 @@ function willIMaybeExecuteBefore(target) {
   return this._guessExecutionStatusRelativeTo(target) !== "after";
 }
 function getOuterFunction(path) {
-  return (path.scope.getFunctionParent() || path.scope.getProgramParent()).path;
+  return path.isProgram() ? path : (path.parentPath.scope.getFunctionParent() || path.parentPath.scope.getProgramParent()).path;
 }
 function isExecutionUncertain(type, key) {
   switch (type) {
     case "LogicalExpression":
       return key === "right";
     case "ConditionalExpression":
     case "IfStatement":
       return key === "consequent" || key === "alternate";
     case "WhileStatement":
     case "DoWhileStatement":
     case "ForInStatement":
     case "ForOfStatement":
       return key === "body";
     case "ForStatement":
       return key === "body" || key === "update";
     case "SwitchStatement":
       return key === "cases";
     case "TryStatement":
       return key === "handler";
     case "AssignmentPattern":
       return key === "right";
     case "OptionalMemberExpression":
       return key === "property";
     case "OptionalCallExpression":
       return key === "arguments";
     default:
@@ -207,7 +182,7 @@ function isExecutionUncertainInList(paths, maxIndex) {
   }
   return false;
 }
+const SYMBOL_CHECKING = Symbol();
 function _guessExecutionStatusRelativeTo(target) {
   return _guessExecutionStatusRelativeToCached(this, target, new Map());
 }
@@ -216,7 +191,6 @@ function _guessExecutionStatusRelativeToCached(base, target, cache) {
     this: getOuterFunction(base),
     target: getOuterFunction(target)
   };
   if (funcParent.target.node !== funcParent.this.node) {
     return _guessExecutionStatusRelativeToDifferentFunctionsCached(base, funcParent.target, cache);
   }
@@ -224,10 +198,8 @@ function _guessExecutionStatusRelativeToCached(base, target, cache) {
     target: target.getAncestry(),
     this: base.getAncestry()
   };
   if (paths.target.indexOf(base) >= 0) return "after";
   if (paths.this.indexOf(target) >= 0) return "before";
   let commonPath;
   const commonIndex = {
     target: 0,
@@ -252,11 +224,9 @@ function _guessExecutionStatusRelativeToCached(base, target, cache) {
     this: paths.this[commonIndex.this - 1],
     target: paths.target[commonIndex.target - 1]
   };
   if (divergence.target.listKey && divergence.this.listKey && divergence.target.container === divergence.this.container) {
     return divergence.target.key > divergence.this.key ? "before" : "after";
   }
   const keys = VISITOR_KEYS[commonPath.type];
   const keyPosition = {
     this: keys.indexOf(divergence.this.parentKey),
@@ -264,72 +234,65 @@ function _guessExecutionStatusRelativeToCached(base, target, cache) {
   };
   return keyPosition.target > keyPosition.this ? "before" : "after";
 }
-const executionOrderCheckedNodes = new Set();
 function _guessExecutionStatusRelativeToDifferentFunctionsInternal(base, target, cache) {
-  if (!target.isFunctionDeclaration() || target.parentPath.isExportDeclaration()) {
+  if (!target.isFunctionDeclaration()) {
+    if (_guessExecutionStatusRelativeToCached(base, target, cache) === "before") {
+      return "before";
+    }
+    return "unknown";
+  } else if (target.parentPath.isExportDeclaration()) {
     return "unknown";
   }
   const binding = target.scope.getBinding(target.node.id.name);
   if (!binding.references) return "before";
   const referencePaths = binding.referencePaths;
   let allStatus;
   for (const path of referencePaths) {
     const childOfFunction = !!path.find(path => path.node === target.node);
     if (childOfFunction) continue;
     if (path.key !== "callee" || !path.parentPath.isCallExpression()) {
       return "unknown";
     }
-    if (executionOrderCheckedNodes.has(path.node)) continue;
-    executionOrderCheckedNodes.add(path.node);
-    try {
-      const status = _guessExecutionStatusRelativeToCached(base, path, cache);
-      if (allStatus && allStatus !== status) {
-        return "unknown";
-      } else {
-        allStatus = status;
-      }
-    } finally {
-      executionOrderCheckedNodes.delete(path.node);
+    const status = _guessExecutionStatusRelativeToCached(base, path, cache);
+    if (allStatus && allStatus !== status) {
+      return "unknown";
+    } else {
+      allStatus = status;
     }
   }
   return allStatus;
 }
 function _guessExecutionStatusRelativeToDifferentFunctionsCached(base, target, cache) {
   let nodeMap = cache.get(base.node);
+  let cached;
   if (!nodeMap) {
     cache.set(base.node, nodeMap = new Map());
-  } else if (nodeMap.has(target.node)) {
-    return nodeMap.get(target.node);
+  } else if (cached = nodeMap.get(target.node)) {
+    if (cached === SYMBOL_CHECKING) {
+      return "unknown";
+    }
+    return cached;
   }
+  nodeMap.set(target.node, SYMBOL_CHECKING);
   const result = _guessExecutionStatusRelativeToDifferentFunctionsInternal(base, target, cache);
   nodeMap.set(target.node, result);
   return result;
 }
 function resolve(dangerous, resolved) {
   return this._resolve(dangerous, resolved) || this;
 }
 function _resolve(dangerous, resolved) {
   if (resolved && resolved.indexOf(this) >= 0) return;
   resolved = resolved || [];
   resolved.push(this);
   if (this.isVariableDeclarator()) {
     if (this.get("id").isIdentifier()) {
       return this.get("init").resolve(dangerous, resolved);
-    } else {
-    }
+    } else {}
   } else if (this.isReferencedIdentifier()) {
     const binding = this.scope.getBinding(this.node.name);
     if (!binding) return;
     if (!binding.constant) return;
     if (binding.kind === "module") return;
     if (binding.path !== this) {
       const ret = binding.path.resolve(dangerous, resolved);
@@ -339,10 +302,8 @@ function _resolve(dangerous, resolved) {
   } else if (this.isTypeCastExpression()) {
     return this.get("expression").resolve(dangerous, resolved);
   } else if (dangerous && this.isMemberExpression()) {
     const targetKey = this.toComputedKey();
     if (!isLiteral(targetKey)) return;
     const targetName = targetKey.value;
     const target = this.get("object").resolve(dangerous, resolved);
     if (target.isObjectExpression()) {
@@ -350,11 +311,9 @@ function _resolve(dangerous, resolved) {
       for (const prop of props) {
         if (!prop.isProperty()) continue;
         const key = prop.get("key");
         let match = prop.isnt("computed") && key.isIdentifier({
           name: targetName
         });
         match = match || key.isLiteral({
           value: targetName
         });