flow-api-translator 0.36.1 → 0.327.0

package/dist/flowToFlowDef.js.flow

@@ -64,22 +64,22 @@ import type {
   TypeParameterDeclaration,
   TypeParameterInstantiation,
   VariableDeclaration,
-} from 'hermes-estree';
-import type {ScopeManager} from 'hermes-eslint';
-import type {DetachedNode} from 'hermes-transform';
+} from 'flow-estree';
+import type {ScopeManager} from 'flow-eslint';
+import type {DetachedNode} from 'flow-transform';
 import type {
   Dep,
   TranslationContext,
   TranslationOptions,
 } from './utils/TranslationUtils';
 
-import {t} from 'hermes-transform';
+import {t} from 'flow-transform';
 import {
   analyzeFunctionReturn,
   analyzeTypeDependencies,
 } from './utils/FlowAnalyze';
 import {createTranslationContext} from './utils/TranslationUtils';
-import {asDetachedNode} from 'hermes-transform';
+import {asDetachedNode} from 'flow-transform';
 import {translationError, flowFixMeOrError} from './utils/ErrorUtils';
 import {
   isExpression,
@@ -87,16 +87,16 @@ import {
   isNumericLiteral,
   isIdentifier,
   isMemberExpressionWithNonComputedProperty,
-} from 'hermes-estree';
+} from 'flow-estree';
 
 const EMPTY_TRANSLATION_RESULT: TranslatedResultOrNull<empty> = [null, []];
 
-type TranslatedDeps = $ReadOnlyArray<Dep>;
-type TranslatedResultOrNull<+T> = Readonly<
+type TranslatedDeps = ReadonlyArray<Dep>;
+type TranslatedResultOrNull<out T> = Readonly<
   [DetachedNode<T> | null, TranslatedDeps],
 >;
 type TranslatedResultArray<T> = [
-  $ReadOnlyArray<DetachedNode<T>>,
+  ReadonlyArray<DetachedNode<T>>,
   TranslatedDeps,
 ];
 type TranslatedResult<T> = [DetachedNode<T>, TranslatedDeps];
@@ -104,7 +104,7 @@ type TranslatedResult<T> = [DetachedNode<T>, TranslatedDeps];
 type ProgramStatement = Statement | ModuleDeclaration;
 
 function convertArray<TIn, TOut>(
-  items: $ReadOnlyArray<TIn>,
+  items: ReadonlyArray<TIn>,
   convert: TIn => TranslatedResultOrNull<TOut>,
 ): TranslatedResultArray<TOut> {
   const resultItems: Array<DetachedNode<TOut>> = [];
@@ -409,6 +409,10 @@ function convertStatement(
       return [result, deps];
     }
     case 'VariableDeclaration': {
+      const requireImport = convertRequireToImport(stmt);
+      if (requireImport != null) {
+        return requireImport;
+      }
       const [result, deps] = convertVariableDeclaration(stmt, context);
       return [result, deps];
     }
@@ -486,12 +490,12 @@ function convertExpressionToTypeAnnotation(
   }
 }
 
-function inheritComments<T: DetachedNode<ESNode>>(
+function inheritComments<T extends DetachedNode<ESNode>>(
   fromNode: ESNode,
   toNode: T,
 ): T {
   // $FlowFixMe[unclear-type]
-  (toNode: any).comments = (fromNode: any).comments;
+  (toNode as any).comments = (fromNode as any).comments;
   return toNode;
 }
 
@@ -663,7 +667,7 @@ function convertLiteral(
 function convertExportDeclaration(
   decl:
     | ExportDefaultDeclaration['declaration']
-    | $NonMaybeType<ExportNamedDeclaration['declaration']>,
+    | NonNullable<ExportNamedDeclaration['declaration']>,
   opts: {default: boolean},
   context: TranslationContext,
 ): TranslatedResult<ProgramStatement> {
@@ -831,8 +835,8 @@ function convertExportDefaultDeclaration(
   context: TranslationContext,
 ): TranslatedResult<ProgramStatement> {
   const expr = stmt.declaration;
-  if (isExpression(expr) && (expr: $FlowFixMe).type === 'Identifier') {
-    const name = ((expr: $FlowFixMe): Identifier).name;
+  if (isExpression(expr) && (expr as $FlowFixMe).type === 'Identifier') {
+    const name = (expr as $FlowFixMe as Identifier).name;
     const [declDecl, deps] = [
       t.TypeofTypeAnnotation({argument: t.Identifier({name})}),
       analyzeTypeDependencies(expr, context),
@@ -926,19 +930,97 @@ function convertVariableDeclaration(
 
   return [
     t.DeclareVariable({
-      id: t.Identifier({
-        name: id.name,
-        typeAnnotation: t.TypeAnnotation({
-          typeAnnotation: resultTypeAnnotation,
+      declarations: [
+        t.VariableDeclarator({
+          id: t.Identifier({
+            name: id.name,
+            typeAnnotation: t.TypeAnnotation({
+              typeAnnotation: resultTypeAnnotation,
+            }),
+            optional: false,
+          }),
+          init: null,
         }),
-        optional: false,
-      }),
+      ],
       kind: stmt.kind,
+      implicitDeclare: false,
     }),
     annotDeps,
   ];
 }
 
+function convertRequireToImport(
+  stmt: VariableDeclaration,
+): ?TranslatedResult<ProgramStatement> {
+  if (stmt.declarations.length !== 1) {
+    return null;
+  }
+  const decl = stmt.declarations[0];
+  const init = decl.init;
+  if (
+    init == null ||
+    init.type !== 'CallExpression' ||
+    init.callee.type !== 'Identifier' ||
+    init.callee.name !== 'require' ||
+    init.arguments.length !== 1
+  ) {
+    return null;
+  }
+  const sourceArg = init.arguments[0];
+  if (!isStringLiteral(sourceArg)) {
+    return null;
+  }
+  const id = decl.id;
+
+  if (id.type === 'Identifier') {
+    return [
+      t.ImportDeclaration({
+        importKind: 'value',
+        source: asDetachedNode(sourceArg),
+        specifiers: [
+          t.ImportDefaultSpecifier({
+            local: t.Identifier({name: id.name}),
+          }),
+        ],
+        attributes: [],
+      }),
+      [],
+    ];
+  }
+
+  if (id.type === 'ObjectPattern') {
+    const specifiers = [];
+    for (const prop of id.properties) {
+      if (prop.type === 'RestElement') {
+        return null;
+      }
+      const key = prop.key;
+      const value = prop.value;
+      if (key.type !== 'Identifier' || value.type !== 'Identifier') {
+        return null;
+      }
+      specifiers.push(
+        t.ImportSpecifier({
+          imported: t.Identifier({name: key.name}),
+          local: t.Identifier({name: value.name}),
+          importKind: null,
+        }),
+      );
+    }
+    return [
+      t.ImportDeclaration({
+        importKind: 'value',
+        source: asDetachedNode(sourceArg),
+        specifiers,
+        attributes: [],
+      }),
+      [],
+    ];
+  }
+
+  return null;
+}
+
 function convertImportDeclaration(
   stmt: ImportDeclaration,
   context: TranslationContext,
@@ -1371,13 +1453,13 @@ function convertComponentDeclaration(
 }
 
 type TranslatedComponentParametersResults = [
-  $ReadOnlyArray<DetachedNode<ComponentTypeParameter>>,
+  ReadonlyArray<DetachedNode<ComponentTypeParameter>>,
   ?DetachedNode<ComponentTypeParameter>,
   TranslatedDeps,
 ];
 
 function hasNonIdentifierStringLiteralParam(
-  params: $ReadOnlyArray<ComponentParameter | RestElement>,
+  params: ReadonlyArray<ComponentParameter | RestElement>,
 ): boolean {
   return params.some(
     param =>
@@ -1408,7 +1490,7 @@ function extractParamTypeInfo(
 }
 
 function convertComponentParameters(
-  params: $ReadOnlyArray<ComponentParameter | RestElement>,
+  params: ReadonlyArray<ComponentParameter | RestElement>,
   context: TranslationContext,
 ): TranslatedComponentParametersResults {
   if (hasNonIdentifierStringLiteralParam(params)) {
@@ -1490,7 +1572,7 @@ function convertComponentParameters(
 }
 
 function convertComponentParametersToPropsObject(
-  params: $ReadOnlyArray<ComponentParameter | RestElement>,
+  params: ReadonlyArray<ComponentParameter | RestElement>,
   context: TranslationContext,
 ): TranslatedComponentParametersResults {
   const properties: Array<
@@ -1673,12 +1755,12 @@ function convertAFunction(
 }
 
 type TranslatedFunctionParametersResults = [
-  $ReadOnlyArray<DetachedNode<FunctionTypeParam>>,
+  ReadonlyArray<DetachedNode<FunctionTypeParam>>,
   ?DetachedNode<FunctionTypeParam>,
   TranslatedDeps,
 ];
 function convertFunctionParameters(
-  params: $ReadOnlyArray<FunctionParameter>,
+  params: ReadonlyArray<FunctionParameter>,
   context: TranslationContext,
 ): TranslatedFunctionParametersResults {
   return params.reduce<TranslatedFunctionParametersResults>(

package/dist/flowToJS.js

@@ -1,39 +1,23 @@
-/**
- * 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.flowToJS = flowToJS;
-
-var _hermesParser = require("hermes-parser");
-
+var _flowParser = require("flow-parser");
 var _DocblockUtils = require("./utils/DocblockUtils");
-
 const {
   nodeWith
-} = _hermesParser.astNodeMutationHelpers;
-
+} = _flowParser.astNodeMutationHelpers;
 function stripAtFlow(ast, _options) {
   const docblock = ast.docblock;
-
   if (docblock == null) {
     return ast;
   }
-
   return nodeWith(ast, {
     docblock: (0, _DocblockUtils.removeAtFlowFromDocblock)(docblock)
   });
 }
-
 function flowToJS(sourceAST, _code, _scopeManager) {
-  return [_hermesParser.Transforms.transformComponentSyntax, _hermesParser.Transforms.stripFlowTypes, stripAtFlow].reduce((ast, transform) => transform(ast, {}), sourceAST);
+  return [_flowParser.Transforms.transformComponentSyntax, _flowParser.Transforms.stripFlowTypes, stripAtFlow].reduce((ast, transform) => transform(ast, {}), sourceAST);
 }

package/dist/flowToJS.js.flow

@@ -10,12 +10,12 @@
 
 'use strict';
 
-import type {ScopeManager} from 'hermes-eslint';
-import type {Program} from 'hermes-estree';
-import type {ParserOptions} from 'hermes-parser';
+import type {ScopeManager} from 'flow-eslint';
+import type {Program} from 'flow-estree';
+import type {ParserOptions} from 'flow-parser';
 
-import {Transforms} from 'hermes-parser';
-import {astNodeMutationHelpers} from 'hermes-parser';
+import {Transforms} from 'flow-parser';
+import {astNodeMutationHelpers} from 'flow-parser';
 import {removeAtFlowFromDocblock} from './utils/DocblockUtils';
 
 const {nodeWith} = astNodeMutationHelpers;

package/dist/index.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", {
@@ -18,98 +9,69 @@ exports.translateFlowToFlowDef = translateFlowToFlowDef;
 exports.translateFlowToJS = translateFlowToJS;
 exports.translateFlowToTSDef = translateFlowToTSDef;
 exports.unstable_translateTSDefToFlowDef = unstable_translateTSDefToFlowDef;
-
-var _hermesTransform = require("hermes-transform");
-
+var _flowTransform = require("flow-transform");
 var _parser = require("@typescript-eslint/parser");
-
 var _visitorKeys = require("@typescript-eslint/visitor-keys");
-
 var _flowToFlowDef = _interopRequireDefault(require("./flowToFlowDef"));
-
 var _flowDefToTSDef = require("./flowDefToTSDef");
-
 var _flowToJS = require("./flowToJS");
-
 var _flowImportTo = require("./flowImportTo");
-
 var _TSDefToFlowDef = require("./TSDefToFlowDef");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 async function translateFlowToFlowDef(code, prettierOptions = {}, opts) {
   const {
     ast,
     scopeManager
-  } = await (0, _hermesTransform.parse)(code);
+  } = await (0, _flowTransform.parse)(code);
   const [flowDefAst, mutatedCode] = (0, _flowToFlowDef.default)(ast, code, scopeManager, {
     recoverFromErrors: true,
     mungeUnderscores: opts == null ? void 0 : opts.mungeUnderscores
   });
-  return (0, _hermesTransform.print)(flowDefAst, mutatedCode, prettierOptions);
+  return (0, _flowTransform.print)(flowDefAst, mutatedCode, prettierOptions);
 }
-
 async function translateFlowToTSDef(code, prettierOptions = {}) {
   const flowDefCode = await translateFlowToFlowDef(code, prettierOptions);
   return translateFlowDefToTSDef(flowDefCode, prettierOptions);
 }
-
 async function translateFlowDefToTSDef(code, prettierOptions = {}) {
   const {
     ast,
     scopeManager
-  } = await (0, _hermesTransform.parse)(code);
+  } = await (0, _flowTransform.parse)(code);
   const [tsAST, mutatedCode] = (0, _flowDefToTSDef.flowDefToTSDef)(code, ast, scopeManager, {
     recoverFromErrors: true
   });
-  return (0, _hermesTransform.print)( // $FlowExpectedError[incompatible-type] - this is fine as we're providing the visitor keys
-  tsAST, mutatedCode, { ...prettierOptions
+  return (0, _flowTransform.print)(tsAST, mutatedCode, {
+    ...prettierOptions
   }, _visitorKeys.visitorKeys);
 }
-
 async function translateFlowToJS(code, prettierOptions = {}) {
   const {
     ast,
     scopeManager
-  } = await (0, _hermesTransform.parse)(code);
+  } = await (0, _flowTransform.parse)(code);
   const jsAST = (0, _flowToJS.flowToJS)(ast, code, scopeManager);
-  return (0, _hermesTransform.print)(jsAST, code, prettierOptions);
+  return (0, _flowTransform.print)(jsAST, code, prettierOptions);
 }
-/**
- * This translator is very experimental and unstable.
- *
- * It is not written with productionizing it in mind, but instead used to evaluate how close Flow
- * is to TypeScript.
- *
- * If you are going to use it anyways, you agree that you are calling a potentially broken function
- * without any guarantee.
- *
- * @deprecated
- */
-
-
 async function unstable_translateTSDefToFlowDef(code, prettierOptions = {}) {
   const ast = (0, _parser.parse)(code, {
     loc: true,
     range: true,
     sourceType: 'module'
   });
-
   if (ast == null) {
     throw `Failed to parse ${code} with @typescript-eslint/parser`;
   }
-
   const [flowAST, mutatedCode] = (0, _TSDefToFlowDef.TSDefToFlowDef)(code, ast, {
     recoverFromErrors: false
   });
-  return (0, _hermesTransform.print)(flowAST, mutatedCode, prettierOptions);
+  return (0, _flowTransform.print)(flowAST, mutatedCode, prettierOptions);
 }
-
 async function translateFlowImportsTo(code, prettierOptions = {}, opts) {
   const {
     ast,
     scopeManager
-  } = await (0, _hermesTransform.parse)(code);
+  } = await (0, _flowTransform.parse)(code);
   const jsAST = (0, _flowImportTo.flowImportTo)(ast, code, scopeManager, opts);
-  return (0, _hermesTransform.print)(jsAST, code, prettierOptions);
+  return (0, _flowTransform.print)(jsAST, code, prettierOptions);
 }

package/dist/index.js.flow

@@ -12,7 +12,7 @@
 
 import type {MapperOptions} from './flowImportTo';
 
-import {parse, print} from 'hermes-transform';
+import {parse, print} from 'flow-transform';
 import {parse as parseTS} from '@typescript-eslint/parser';
 import {visitorKeys as tsVisitorKeys} from '@typescript-eslint/visitor-keys';
 import flowToFlowDef from './flowToFlowDef';