flow-api-translator 0.36.0 → 0.37.0

package/dist/flowToFlowDef.js.flow

@@ -48,6 +48,7 @@ import type {
   ObjectExpression,
   ObjectTypeAnnotation,
   ObjectTypeProperty,
+  ObjectTypeSpreadProperty,
   OpaqueType,
   QualifiedTypeIdentifier,
   QualifiedTypeofIdentifier,
@@ -88,12 +89,14 @@ import {
   isMemberExpressionWithNonComputedProperty,
 } from 'hermes-estree';
 
-const EMPTY_TRANSLATION_RESULT = [null, []];
+const EMPTY_TRANSLATION_RESULT: TranslatedResultOrNull<empty> = [null, []];
 
-type TranslatedDeps = $ReadOnlyArray<Dep>;
-type TranslatedResultOrNull<T> = [DetachedNode<T> | null, TranslatedDeps];
+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];
@@ -101,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>> = [];
@@ -406,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];
     }
@@ -483,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;
 }
 
@@ -660,7 +667,7 @@ function convertLiteral(
 function convertExportDeclaration(
   decl:
     | ExportDefaultDeclaration['declaration']
-    | $NonMaybeType<ExportNamedDeclaration['declaration']>,
+    | NonNullable<ExportNamedDeclaration['declaration']>,
   opts: {default: boolean},
   context: TranslationContext,
 ): TranslatedResult<ProgramStatement> {
@@ -828,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),
@@ -936,6 +943,78 @@ function convertVariableDeclaration(
   ];
 }
 
+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,
@@ -1080,7 +1159,6 @@ function convertSuperClass(
   context: TranslationContext,
 ): TranslatedResultOrNull<InterfaceExtends> {
   if (superClass == null) {
-    // $FlowFixMe[incompatible-type]
     return EMPTY_TRANSLATION_RESULT;
   }
 
@@ -1175,7 +1253,15 @@ function convertClassMember(
     case 'PropertyDefinition': {
       // PrivateIdentifier's are not exposed so can be stripped.
       if (member.key.type === 'PrivateIdentifier') {
-        // $FlowFixMe[incompatible-type]
+        return EMPTY_TRANSLATION_RESULT;
+      }
+      if (
+        context.mungeUnderscores &&
+        member.key.type === 'Identifier' &&
+        member.key.name.length >= 2 &&
+        member.key.name[0] === '_' &&
+        member.key.name[1] !== '_'
+      ) {
         return EMPTY_TRANSLATION_RESULT;
       }
       if (
@@ -1243,7 +1329,15 @@ function convertClassMember(
     case 'MethodDefinition': {
       // PrivateIdentifier's are not exposed so can be stripped.
       if (member.key.type === 'PrivateIdentifier') {
-        // $FlowFixMe[incompatible-type]
+        return EMPTY_TRANSLATION_RESULT;
+      }
+      if (
+        context.mungeUnderscores &&
+        member.key.type === 'Identifier' &&
+        member.key.name.length >= 2 &&
+        member.key.name[0] === '_' &&
+        member.key.name[1] !== '_'
+      ) {
         return EMPTY_TRANSLATION_RESULT;
       }
       if (
@@ -1353,41 +1447,71 @@ function convertComponentDeclaration(
 }
 
 type TranslatedComponentParametersResults = [
-  $ReadOnlyArray<DetachedNode<ComponentTypeParameter>>,
+  ReadonlyArray<DetachedNode<ComponentTypeParameter>>,
   ?DetachedNode<ComponentTypeParameter>,
   TranslatedDeps,
 ];
 
+function hasNonIdentifierStringLiteralParam(
+  params: ReadonlyArray<ComponentParameter | RestElement>,
+): boolean {
+  return params.some(
+    param =>
+      param.type === 'ComponentParameter' &&
+      isStringLiteral(param.name) &&
+      !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(param.name.value),
+  );
+}
+
+function extractParamTypeInfo(
+  param: ComponentParameter,
+  context: TranslationContext,
+): [boolean, BindingName, TranslatedResult<TypeAnnotationType>] {
+  let optional = false;
+  let local = param.local;
+  if (local.type === 'AssignmentPattern') {
+    local = local.left;
+    optional = true;
+  }
+  if (!optional && local.type === 'Identifier') {
+    optional = local.optional;
+  }
+  return [
+    optional,
+    local,
+    convertTypeAnnotation(local.typeAnnotation, param, context),
+  ];
+}
+
 function convertComponentParameters(
-  params: $ReadOnlyArray<ComponentParameter | RestElement>,
+  params: ReadonlyArray<ComponentParameter | RestElement>,
   context: TranslationContext,
 ): TranslatedComponentParametersResults {
+  if (hasNonIdentifierStringLiteralParam(params)) {
+    return convertComponentParametersToPropsObject(params, context);
+  }
+
   return params.reduce<TranslatedComponentParametersResults>(
     ([resultParams, restParam, paramsDeps], param) => {
       switch (param.type) {
         case 'ComponentParameter': {
-          let optional = false;
-          let local = param.local;
-          if (local.type === 'AssignmentPattern') {
-            local = local.left;
-            optional = true;
-          }
-          if (!optional && local.type === 'Identifier') {
-            optional = local.optional;
-          }
-
-          const [typeAnnotationType, typeDeps] = convertTypeAnnotation(
-            local.typeAnnotation,
+          const [optional, _local, [typeAnnotationType, typeDeps]] =
+            extractParamTypeInfo(param, context);
+
+          const name =
+            isStringLiteral(param.name) &&
+            /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(param.name.value)
+              ? t.Identifier({name: param.name.value})
+              : asDetachedNode(param.name);
+          const resultParam = inheritComments(
             param,
-            context,
+            t.ComponentTypeParameter({
+              name,
+              typeAnnotation: typeAnnotationType,
+              optional,
+            }),
           );
 
-          const resultParam = t.ComponentTypeParameter({
-            name: asDetachedNode(param.name),
-            typeAnnotation: typeAnnotationType,
-            optional,
-          });
-
           return [
             [...resultParams, resultParam],
             restParam,
@@ -1420,14 +1544,18 @@ function convertComponentParameters(
             context,
           );
 
-          const resultRestParam = t.ComponentTypeParameter({
-            name: t.Identifier({
-              name: argument.type === 'Identifier' ? argument.name : 'rest',
+          const restName =
+            argument.type === 'Identifier' ? argument.name : 'rest';
+          const restOptional =
+            argument.type === 'Identifier' ? argument.optional : false;
+          const resultRestParam = inheritComments(
+            param,
+            t.ComponentTypeParameter({
+              name: t.Identifier({name: restName}),
+              typeAnnotation: typeAnnotationType,
+              optional: restOptional,
             }),
-            typeAnnotation: typeAnnotationType,
-            optional:
-              argument.type === 'Identifier' ? argument.optional : false,
-          });
+          );
 
           return [resultParams, resultRestParam, [...paramsDeps, ...typeDeps]];
         }
@@ -1437,6 +1565,72 @@ function convertComponentParameters(
   );
 }
 
+function convertComponentParametersToPropsObject(
+  params: ReadonlyArray<ComponentParameter | RestElement>,
+  context: TranslationContext,
+): TranslatedComponentParametersResults {
+  const properties: Array<
+    DetachedNode<ObjectTypeProperty | ObjectTypeSpreadProperty>,
+  > = [];
+  const allDeps: Array<Dep> = [];
+
+  for (const param of params) {
+    if (param.type === 'RestElement') {
+      const argument = param.argument;
+      if (
+        argument.type !== 'AssignmentPattern' &&
+        argument.type !== 'ArrayPattern' &&
+        argument.type !== 'RestElement'
+      ) {
+        const [typeAnnotationType, typeDeps] = convertTypeAnnotation(
+          argument.typeAnnotation,
+          argument,
+          context,
+        );
+        allDeps.push(...typeDeps);
+        properties.push(
+          t.ObjectTypeSpreadProperty({argument: typeAnnotationType}),
+        );
+      }
+      continue;
+    }
+
+    const [optional, _local, [typeAnnotationType, typeDeps]] =
+      extractParamTypeInfo(param, context);
+    allDeps.push(...typeDeps);
+
+    properties.push(
+      inheritComments(
+        param,
+        t.ObjectTypePropertySignature({
+          key: asDetachedNode(param.name),
+          value: typeAnnotationType,
+          optional,
+          static: false,
+          variance: null,
+        }),
+      ),
+    );
+  }
+
+  const propsType = t.ObjectTypeAnnotation({
+    inexact: false,
+    exact: false,
+    properties,
+    indexers: [],
+    callProperties: [],
+    internalSlots: [],
+  });
+
+  const restParam = t.ComponentTypeParameter({
+    name: t.Identifier({name: 'props'}),
+    typeAnnotation: propsType,
+    optional: false,
+  });
+
+  return [[], restParam, allDeps];
+}
+
 function convertHookDeclaration(
   hook: HookDeclaration,
   context: TranslationContext,
@@ -1461,7 +1655,7 @@ function convertHookDeclaration(
   const [resultTypeParams, typeParamsDeps] =
     convertTypeParameterDeclarationOrNull(hook.typeParameters, context);
 
-  const resultFunc = t.FunctionTypeAnnotation({
+  const resultFunc = t.HookTypeAnnotation({
     params: resultParams,
     returnType: resultReturnType,
     rest: restParam,
@@ -1555,12 +1749,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>(
@@ -1732,7 +1926,6 @@ function convertTypeAnnotationTypeOrNull(
   context: TranslationContext,
 ): TranslatedResultOrNull<TypeAnnotationType> {
   if (annot == null) {
-    // $FlowFixMe[incompatible-type]
     return EMPTY_TRANSLATION_RESULT;
   }
 
@@ -1743,7 +1936,6 @@ function convertTypeParameterDeclarationOrNull(
   context: TranslationContext,
 ): TranslatedResultOrNull<TypeParameterDeclaration> {
   if (decl == null) {
-    // $FlowFixMe[incompatible-type]
     return EMPTY_TRANSLATION_RESULT;
   }
   return [asDetachedNode(decl), analyzeTypeDependencies(decl, context)];
@@ -1753,7 +1945,6 @@ function convertTypeParameterInstantiationOrNull(
   context: TranslationContext,
 ): TranslatedResultOrNull<TypeParameterInstantiation> {
   if (inst == null) {
-    // $FlowFixMe[incompatible-type]
     return EMPTY_TRANSLATION_RESULT;
   }
   return [asDetachedNode(inst), analyzeTypeDependencies(inst, context)];

package/dist/flowToJS.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", {

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", {
@@ -37,13 +28,14 @@ var _TSDefToFlowDef = require("./TSDefToFlowDef");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-async function translateFlowToFlowDef(code, prettierOptions = {}) {
+async function translateFlowToFlowDef(code, prettierOptions = {}, opts) {
   const {
     ast,
     scopeManager
   } = await (0, _hermesTransform.parse)(code);
   const [flowDefAst, mutatedCode] = (0, _flowToFlowDef.default)(ast, code, scopeManager, {
-    recoverFromErrors: true
+    recoverFromErrors: true,
+    mungeUnderscores: opts == null ? void 0 : opts.mungeUnderscores
   });
   return (0, _hermesTransform.print)(flowDefAst, mutatedCode, prettierOptions);
 }
@@ -61,8 +53,7 @@ async function translateFlowDefToTSDef(code, prettierOptions = {}) {
   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, _hermesTransform.print)(tsAST, mutatedCode, { ...prettierOptions
   }, _visitorKeys.visitorKeys);
 }
 
@@ -74,18 +65,6 @@ async function translateFlowToJS(code, prettierOptions = {}) {
   const jsAST = (0, _flowToJS.flowToJS)(ast, code, scopeManager);
   return (0, _hermesTransform.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, {

package/dist/index.js.flow

@@ -24,11 +24,13 @@ import {TSDefToFlowDef} from './TSDefToFlowDef';
 export async function translateFlowToFlowDef(
   code: string,
   prettierOptions: {...} = {},
+  opts?: {mungeUnderscores?: boolean},
 ): Promise<string> {
   const {ast, scopeManager} = await parse(code);
 
   const [flowDefAst, mutatedCode] = flowToFlowDef(ast, code, scopeManager, {
     recoverFromErrors: true,
+    mungeUnderscores: opts?.mungeUnderscores,
   });
 
   return print(flowDefAst, mutatedCode, prettierOptions);