flow-api-translator 0.36.1 → 0.327.0

package/dist/utils/FlowAnalyze.js

@@ -1,12 +1,3 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * 
- * @format
- */
 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
@@ -14,42 +5,31 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.analyzeFunctionReturn = analyzeFunctionReturn;
 exports.analyzeTypeDependencies = analyzeTypeDependencies;
-
-var _hermesTransform = require("hermes-transform");
-
-var _hermesParser = require("hermes-parser");
-
+var _flowTransform = require("flow-transform");
+var _flowParser = require("flow-parser");
 function analyzeFunctionReturn(func) {
   const returnType = func.returnType;
-
   if (returnType != null) {
     return returnType;
-  } // We trust Flow has validated this function to only return void
-  // $FlowFixMe[incompatible-type]
-
-
-  return _hermesTransform.t.TypeAnnotation({
-    typeAnnotation: _hermesTransform.t.VoidTypeAnnotation()
+  }
+  return _flowTransform.t.TypeAnnotation({
+    typeAnnotation: _flowTransform.t.VoidTypeAnnotation()
   });
 }
-
 function analyzeTypeDependencies(rootNode, context) {
   const deps = [];
-
-  _hermesParser.SimpleTraverser.traverse(rootNode, {
+  _flowParser.SimpleTraverser.traverse(rootNode, {
     enter(node) {
       if (node.type === 'Identifier' || node.type === 'JSXIdentifier') {
         const variable = context.referenceMap.get(node);
-
         if (variable != null) {
           deps.push(variable.name);
+        } else if (context.variableMap.has(node.name)) {
+          deps.push(node.name);
         }
       }
     },
-
     leave() {}
-
   });
-
   return deps;
 }

package/dist/utils/FlowAnalyze.js.flow

@@ -10,11 +10,11 @@
 
 'use strict';
 
-import type {AFunction, TypeAnnotation, ESNode} from 'hermes-estree';
+import type {AFunction, TypeAnnotation, ESNode} from 'flow-estree';
 import type {TranslationContext, Dep} from './TranslationUtils';
 
-import {t} from 'hermes-transform';
-import {SimpleTraverser} from 'hermes-parser';
+import {t} from 'flow-transform';
+import {SimpleTraverser} from 'flow-parser';
 
 export function analyzeFunctionReturn(func: AFunction): TypeAnnotation {
   const returnType = func.returnType;
@@ -30,7 +30,7 @@ export function analyzeFunctionReturn(func: AFunction): TypeAnnotation {
 export function analyzeTypeDependencies(
   rootNode: ESNode,
   context: TranslationContext,
-): $ReadOnlyArray<Dep> {
+): ReadonlyArray<Dep> {
   const deps = [];
   SimpleTraverser.traverse(rootNode, {
     enter(node: ESNode) {
@@ -38,6 +38,11 @@ export function analyzeTypeDependencies(
         const variable = context.referenceMap.get(node);
         if (variable != null) {
           deps.push(variable.name);
+        } else if (context.variableMap.has(node.name)) {
+          // The scope manager may not track type references to value
+          // variables (e.g. `const Foo = require('foo')` used as `Foo`
+          // in a GenericTypeAnnotation). Fall back to variableMap.
+          deps.push(node.name);
         }
       }
     },

package/dist/utils/TSNodeUtils.js

@@ -0,0 +1,83 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ensureTypeIncludesUndefined = ensureTypeIncludesUndefined;
+exports.extractPropertyKeyLiterals = extractPropertyKeyLiterals;
+var TSESTree = _interopRequireWildcard(require("./ts-estree-ast-types"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+const DUMMY_LOC = {
+  start: {
+    line: 1,
+    column: 0
+  },
+  end: {
+    line: 1,
+    column: 0
+  }
+};
+function extractPropertyKeyLiterals(members) {
+  if (members.length === 0) {
+    return null;
+  }
+  const literals = [];
+  for (const member of members) {
+    if (member.type !== 'TSPropertySignature' && member.type !== 'TSMethodSignature') {
+      return null;
+    }
+    if (member.computed === true) {
+      return null;
+    }
+    const {
+      key
+    } = member;
+    if (key.type === 'Identifier') {
+      literals.push({
+        type: 'TSLiteralType',
+        loc: DUMMY_LOC,
+        literal: {
+          type: 'Literal',
+          loc: DUMMY_LOC,
+          value: key.name,
+          raw: `'${key.name}'`
+        }
+      });
+    } else if (key.type === 'Literal') {
+      literals.push({
+        type: 'TSLiteralType',
+        loc: DUMMY_LOC,
+        literal: key
+      });
+    } else {
+      return null;
+    }
+  }
+  return literals;
+}
+function ensureTypeIncludesUndefined(typeAnnotation) {
+  if (typeAnnotation.type === 'TSUndefinedKeyword') {
+    return typeAnnotation;
+  }
+  if (typeAnnotation.type === 'TSUnionType') {
+    if (typeAnnotation.types.some(type => type.type === 'TSUndefinedKeyword')) {
+      return typeAnnotation;
+    }
+    return {
+      type: 'TSUnionType',
+      loc: DUMMY_LOC,
+      types: [...typeAnnotation.types, {
+        type: 'TSUndefinedKeyword',
+        loc: DUMMY_LOC
+      }]
+    };
+  }
+  return {
+    type: 'TSUnionType',
+    loc: DUMMY_LOC,
+    types: [typeAnnotation, {
+      type: 'TSUndefinedKeyword',
+      loc: DUMMY_LOC
+    }]
+  };
+}

package/dist/utils/TSNodeUtils.js.flow

@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import type {SourceLocation} from 'flow-estree';
+
+import * as TSESTree from './ts-estree-ast-types';
+
+const DUMMY_LOC: SourceLocation = {
+  start: {line: 1, column: 0},
+  end: {line: 1, column: 0},
+};
+
+/**
+ * Extract statically known property key names from a list of TS type element
+ * nodes and return them as `TSLiteralType` (string literal) AST nodes.
+ *
+ * Returns `null` if any member has a computed or non-extractable key,
+ * or if the list is empty.
+ */
+export function extractPropertyKeyLiterals(
+  members: ReadonlyArray<TSESTree.TypeElement>,
+): Array<TSESTree.TSLiteralType> | null {
+  // An empty member list has no keys to extract. Returning `null` here lets
+  // the caller fall back to `keyof {}`, preserving the original output for
+  // spread-only objects (e.g. `{...T1}`) where a literal union would be
+  // invalid TS.
+  if (members.length === 0) {
+    return null;
+  }
+  const literals: Array<TSESTree.TSLiteralType> = [];
+  for (const member of members) {
+    if (
+      member.type !== 'TSPropertySignature' &&
+      member.type !== 'TSMethodSignature'
+    ) {
+      return null;
+    }
+    if (member.computed === true) {
+      return null;
+    }
+    const {key} = member;
+    if (key.type === 'Identifier') {
+      literals.push({
+        type: 'TSLiteralType',
+        loc: DUMMY_LOC,
+        literal: {
+          type: 'Literal',
+          loc: DUMMY_LOC,
+          value: key.name,
+          raw: `'${key.name}'`,
+        } as TSESTree.StringLiteral,
+      });
+    } else if (key.type === 'Literal') {
+      // A string or numeric literal key is already a valid literal type.
+      literals.push({
+        type: 'TSLiteralType',
+        loc: DUMMY_LOC,
+        literal: key,
+      });
+    } else {
+      return null;
+    }
+  }
+  return literals;
+}
+
+/**
+ * Returns a type that is guaranteed to include `undefined`, without duplicating
+ * it when already present.
+ *
+ * Flow's optional members permit `undefined`, so the faithful TypeScript
+ * translation of `foo?: T` is `foo?: T | undefined` (the two are distinct under
+ * `exactOptionalPropertyTypes`).
+ */
+export function ensureTypeIncludesUndefined(
+  typeAnnotation: TSESTree.TypeNode,
+): TSESTree.TypeNode {
+  if (typeAnnotation.type === 'TSUndefinedKeyword') {
+    return typeAnnotation;
+  }
+  if (typeAnnotation.type === 'TSUnionType') {
+    if (typeAnnotation.types.some(type => type.type === 'TSUndefinedKeyword')) {
+      return typeAnnotation;
+    }
+    return {
+      type: 'TSUnionType',
+      loc: DUMMY_LOC,
+      types: [
+        ...typeAnnotation.types,
+        {type: 'TSUndefinedKeyword', loc: DUMMY_LOC},
+      ],
+    };
+  }
+  return {
+    type: 'TSUnionType',
+    loc: DUMMY_LOC,
+    types: [typeAnnotation, {type: 'TSUndefinedKeyword', loc: DUMMY_LOC}],
+  };
+}

package/dist/utils/TranslationUtils.js

@@ -1,19 +1,9 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * 
- * @format
- */
 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createTranslationContext = createTranslationContext;
-
 function createTranslationContext(code, scopeManager, {
   recoverFromErrors,
   mungeUnderscores = true
@@ -21,18 +11,15 @@ function createTranslationContext(code, scopeManager, {
   const referenceMap = new Map();
   const variableMap = new Map();
   const moduleScope = scopeManager.globalScope.childScopes[0];
-
   if (moduleScope == null || moduleScope.type !== 'module') {
     throw new Error('createTranslationContext: Module scope not found');
   }
-
   for (const variable of moduleScope.variables) {
     for (const reference of variable.references) {
       referenceMap.set(reference.identifier, variable);
       variableMap.set(variable.name, variable);
     }
   }
-
   return {
     scopeManager,
     referenceMap,

package/dist/utils/TranslationUtils.js.flow

@@ -10,8 +10,8 @@
 
 'use strict';
 
-import type {Identifier, JSXIdentifier} from 'hermes-estree';
-import type {ScopeManager, Variable} from 'hermes-eslint';
+import type {Identifier, JSXIdentifier} from 'flow-estree';
+import type {ScopeManager, Variable} from 'flow-eslint';
 
 export type Dep = string;
 export type TranslationOptions = {

package/dist/utils/ts-estree-ast-types.js

@@ -1,30 +1 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * 
- * @format
- */
-
-/**
- * The following types have been adapted by hand from
- * https://unpkg.com/browse/@typescript-eslint/types@5.41.0/dist/generated/ast-spec.d.ts
- *
- * Changes:
- * - remove and inline `ValueOf` type
- * - `undefined` -> `void`
- * - remove all `declare` keywords
- * - comment out `bigint` type
- *     -> flow doesn't support it yet
- * - remove `range` and `loc` from `NodeOrTokenData`
- *     -> during conversion our locations will be all off, so we'll rely on prettier to print later
- * - make all properties readonly and all arrays $ReadOnlyArray
- *     -> unlike TS - flow enforces subtype constraints strictly!
- * - add `type` to interfaces that previously relied upon inheriting the `type`
- *     -> this is because flow sentinel refinement does not check inherited members
- * - create "Ambiguous" versions for some nodes that have unions (like PropertyDefinition, MemberDefinition)
- *     -> makes it easier to construct them from other nodes that have unions
- */
 'use strict';