flow-api-translator 0.15.1 → 0.17.0

package/dist/flowToFlowDef.js

@@ -265,9 +265,15 @@ function stripUnusedDefs(detachedStmt, usedDeps, context) {
 
 function convertStatement(stmt, context) {
   switch (stmt.type) {
+    case 'ComponentDeclaration':
+      {
+        const [result, deps] = convertComponentDeclaration(stmt, context);
+        return [result, deps];
+      }
+
     case 'FunctionDeclaration':
       {
-        const [result, deps] = convertFunctionDeclation(stmt, context);
+        const [result, deps] = convertFunctionDeclaration(stmt, context);
         return [result, deps];
       }
 
@@ -491,9 +497,19 @@ function convertLiteral(expr, context) {
 
 function convertExportDeclaration(decl, opts, context) {
   switch (decl.type) {
+    case 'ComponentDeclaration':
+      {
+        const [declDecl, deps] = convertComponentDeclaration(decl, context);
+        return [opts.default ? _hermesTransform.t.DeclareExportDefaultDeclaration({
+          declaration: declDecl
+        }) : _hermesTransform.t.DeclareExportDeclarationNamedWithDeclaration({
+          declaration: declDecl
+        }), deps];
+      }
+
     case 'FunctionDeclaration':
       {
-        const [declDecl, deps] = convertFunctionDeclation(decl, context);
+        const [declDecl, deps] = convertFunctionDeclaration(decl, context);
         return [opts.default ? _hermesTransform.t.DeclareExportDefaultDeclaration({
           declaration: declDecl
         }) : _hermesTransform.t.DeclareExportDeclarationNamedWithDeclaration({
@@ -588,6 +604,20 @@ function convertExportDeclaration(decl, opts, context) {
 }
 
 function convertExportDefaultDeclaration(stmt, context) {
+  const expr = stmt.declaration;
+
+  if ((0, _hermesEstree.isExpression)(expr) && expr.type === 'Identifier') {
+    const name = expr.name;
+    const [declDecl, deps] = [_hermesTransform.t.TypeofTypeAnnotation({
+      argument: _hermesTransform.t.Identifier({
+        name
+      })
+    }), (0, _FlowAnalyze.analyzeTypeDependencies)(expr, context)];
+    return [_hermesTransform.t.DeclareExportDefaultDeclaration({
+      declaration: declDecl
+    }), deps];
+  }
+
   return convertExportDeclaration(stmt.declaration, {
     default: true
   }, context);
@@ -637,6 +667,14 @@ function convertVariableDeclaration(stmt, context) {
       return [(0, _ErrorUtils.flowFixMeOrError)(first, `VariableDeclaration: Type annotation missing`, context), []];
     }
 
+    if (init.type === 'Identifier') {
+      return [_hermesTransform.t.TypeofTypeAnnotation({
+        argument: _hermesTransform.t.Identifier({
+          name: init.name
+        })
+      }), (0, _FlowAnalyze.analyzeTypeDependencies)(init, context)];
+    }
+
     return convertExpressionToTypeAnnotation(init, context);
   })();
 
@@ -783,7 +821,86 @@ function convertClassMember(member, context) {
   }
 }
 
-function convertFunctionDeclation(func, context) {
+function convertComponentDeclaration(comp, context) {
+  const [resultTypeParams, typeParamsDeps] = convertTypeParameterDeclarationOrNull(comp.typeParameters, context);
+  const [resultParams, resultRestParam, paramsAndRestDeps] = convertComponentParameters(comp.params, context);
+
+  const [resultRendersType, rendersTypeDeps] = (() => {
+    const rendersType = comp.rendersType;
+
+    if (rendersType == null) {
+      return EMPTY_TRANSLATION_RESULT;
+    }
+
+    return [(0, _hermesTransform.asDetachedNode)(rendersType), (0, _FlowAnalyze.analyzeTypeDependencies)(rendersType, context)];
+  })();
+
+  return [_hermesTransform.t.DeclareComponent({
+    id: comp.id,
+    params: resultParams,
+    rest: resultRestParam,
+    typeParameters: resultTypeParams,
+    rendersType: resultRendersType
+  }), [...typeParamsDeps, ...paramsAndRestDeps, ...rendersTypeDeps]];
+}
+
+function convertComponentParameters(params, context) {
+  return params.reduce(([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, param, context);
+
+          const resultParam = _hermesTransform.t.ComponentTypeParameter({
+            name: (0, _hermesTransform.asDetachedNode)(param.name),
+            typeAnnotation: typeAnnotationType,
+            optional
+          });
+
+          return [[...resultParams, resultParam], restParam, [...paramsDeps, ...typeDeps]];
+        }
+
+      case 'RestElement':
+        {
+          if (restParam != null) {
+            throw (0, _ErrorUtils.translationError)(param, `ComponentParameter: Multiple rest elements found`, context);
+          }
+
+          const argument = param.argument;
+
+          if (argument.type === 'AssignmentPattern' || argument.type === 'ArrayPattern' || argument.type === 'RestElement') {
+            throw (0, _ErrorUtils.translationError)(param, `ComponentParameter: Invalid RestElement usage`, context);
+          }
+
+          const [typeAnnotationType, typeDeps] = convertTypeAnnotation(argument.typeAnnotation, argument, context);
+
+          const resultRestParam = _hermesTransform.t.ComponentTypeParameter({
+            name: _hermesTransform.t.Identifier({
+              name: argument.type === 'Identifier' ? argument.name : 'rest'
+            }),
+            typeAnnotation: typeAnnotationType,
+            optional: argument.type === 'Identifier' ? argument.optional : false
+          });
+
+          return [resultParams, resultRestParam, [...paramsDeps, ...typeDeps]];
+        }
+    }
+  }, [[], null, []]);
+}
+
+function convertFunctionDeclaration(func, context) {
   const id = func.id;
 
   if (id == null) {

package/dist/flowToFlowDef.js.flow

@@ -18,7 +18,11 @@ import type {
   ClassMember,
   ClassPropertyNameComputed,
   ClassPropertyNameNonComputed,
+  ComponentDeclaration,
+  ComponentParameter,
+  ComponentTypeParameter,
   DeclareClass,
+  DeclareComponent,
   DeclareFunction,
   DeclareOpaqueType,
   DeclareVariable,
@@ -43,12 +47,14 @@ import type {
   ObjectTypeProperty,
   OpaqueType,
   Program,
+  RestElement,
   Statement,
   StringLiteral,
   TypeAlias,
   TypeAnnotation,
   TypeAnnotationType,
   TypeCastExpression,
+  TypeOperator,
   TypeParameterDeclaration,
   TypeParameterInstantiation,
   VariableDeclaration,
@@ -356,8 +362,12 @@ function convertStatement(
   context: TranslationContext,
 ): TranslatedResult<ProgramStatement> {
   switch (stmt.type) {
+    case 'ComponentDeclaration': {
+      const [result, deps] = convertComponentDeclaration(stmt, context);
+      return [result, deps];
+    }
     case 'FunctionDeclaration': {
-      const [result, deps] = convertFunctionDeclation(stmt, context);
+      const [result, deps] = convertFunctionDeclaration(stmt, context);
       return [result, deps];
     }
     case 'ClassDeclaration': {
@@ -608,8 +618,21 @@ function convertExportDeclaration(
   context: TranslationContext,
 ): TranslatedResult<ProgramStatement> {
   switch (decl.type) {
+    case 'ComponentDeclaration': {
+      const [declDecl, deps] = convertComponentDeclaration(decl, context);
+      return [
+        opts.default
+          ? t.DeclareExportDefaultDeclaration({
+              declaration: declDecl,
+            })
+          : t.DeclareExportDeclarationNamedWithDeclaration({
+              declaration: declDecl,
+            }),
+        deps,
+      ];
+    }
     case 'FunctionDeclaration': {
-      const [declDecl, deps] = convertFunctionDeclation(decl, context);
+      const [declDecl, deps] = convertFunctionDeclaration(decl, context);
       return [
         opts.default
           ? t.DeclareExportDefaultDeclaration({
@@ -744,6 +767,20 @@ function convertExportDefaultDeclaration(
   stmt: ExportDefaultDeclaration,
   context: TranslationContext,
 ): TranslatedResult<ProgramStatement> {
+  const expr = stmt.declaration;
+  if (isExpression(expr) && (expr: Expression).type === 'Identifier') {
+    const name = ((expr: $FlowFixMe): Identifier).name;
+    const [declDecl, deps] = [
+      t.TypeofTypeAnnotation({argument: t.Identifier({name})}),
+      analyzeTypeDependencies(expr, context),
+    ];
+    return [
+      t.DeclareExportDefaultDeclaration({
+        declaration: declDecl,
+      }),
+      deps,
+    ];
+  }
   return convertExportDeclaration(stmt.declaration, {default: true}, context);
 }
 
@@ -814,6 +851,13 @@ function convertVariableDeclaration(
       ];
     }
 
+    if (init.type === 'Identifier') {
+      return [
+        t.TypeofTypeAnnotation({argument: t.Identifier({name: init.name})}),
+        analyzeTypeDependencies(init, context),
+      ];
+    }
+
     return convertExpressionToTypeAnnotation(init, context);
   })();
 
@@ -1048,8 +1092,126 @@ function convertClassMember(
     }
   }
 }
+function convertComponentDeclaration(
+  comp: ComponentDeclaration,
+  context: TranslationContext,
+): TranslatedResult<DeclareComponent> {
+  const [resultTypeParams, typeParamsDeps] =
+    convertTypeParameterDeclarationOrNull(comp.typeParameters, context);
+
+  const [resultParams, resultRestParam, paramsAndRestDeps] =
+    convertComponentParameters(comp.params, context);
+
+  const [resultRendersType, rendersTypeDeps] = (() => {
+    const rendersType = comp.rendersType;
+    if (rendersType == null) {
+      return EMPTY_TRANSLATION_RESULT;
+    }
+
+    return [
+      asDetachedNode<TypeOperator>(rendersType),
+      analyzeTypeDependencies(rendersType, context),
+    ];
+  })();
+
+  return [
+    t.DeclareComponent({
+      id: comp.id,
+      params: resultParams,
+      rest: resultRestParam,
+      typeParameters: resultTypeParams,
+      rendersType: resultRendersType,
+    }),
+    [...typeParamsDeps, ...paramsAndRestDeps, ...rendersTypeDeps],
+  ];
+}
+
+type TranslatedComponentParametersResults = [
+  $ReadOnlyArray<DetachedNode<ComponentTypeParameter>>,
+  ?DetachedNode<ComponentTypeParameter>,
+  TranslatedDeps,
+];
+
+function convertComponentParameters(
+  params: $ReadOnlyArray<ComponentParameter | RestElement>,
+  context: TranslationContext,
+): TranslatedComponentParametersResults {
+  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,
+            param,
+            context,
+          );
+
+          const resultParam = t.ComponentTypeParameter({
+            name: asDetachedNode(param.name),
+            typeAnnotation: typeAnnotationType,
+            optional,
+          });
+
+          return [
+            [...resultParams, resultParam],
+            restParam,
+            [...paramsDeps, ...typeDeps],
+          ];
+        }
+        case 'RestElement': {
+          if (restParam != null) {
+            throw translationError(
+              param,
+              `ComponentParameter: Multiple rest elements found`,
+              context,
+            );
+          }
+          const argument = param.argument;
+          if (
+            argument.type === 'AssignmentPattern' ||
+            argument.type === 'ArrayPattern' ||
+            argument.type === 'RestElement'
+          ) {
+            throw translationError(
+              param,
+              `ComponentParameter: Invalid RestElement usage`,
+              context,
+            );
+          }
+          const [typeAnnotationType, typeDeps] = convertTypeAnnotation(
+            argument.typeAnnotation,
+            argument,
+            context,
+          );
+
+          const resultRestParam = t.ComponentTypeParameter({
+            name: t.Identifier({
+              name: argument.type === 'Identifier' ? argument.name : 'rest',
+            }),
+            typeAnnotation: typeAnnotationType,
+            optional:
+              argument.type === 'Identifier' ? argument.optional : false,
+          });
+
+          return [resultParams, resultRestParam, [...paramsDeps, ...typeDeps]];
+        }
+      }
+    },
+    [[], null, []],
+  );
+}
 
-function convertFunctionDeclation(
+function convertFunctionDeclaration(
   func: FunctionDeclaration,
   context: TranslationContext,
 ): TranslatedResult<DeclareFunction> {

package/dist/flowToJS.js

@@ -14,175 +14,26 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.flowToJS = flowToJS;
 
-var _DocblockUtils = require("./utils/DocblockUtils");
-
 var _hermesParser = require("hermes-parser");
 
+var _DocblockUtils = require("./utils/DocblockUtils");
+
 const {
   nodeWith
 } = _hermesParser.astNodeMutationHelpers;
 
-function transform(node) {
-  switch (node.type) {
-    case 'Program':
-      {
-        const docblock = node.docblock;
-
-        if (docblock == null) {
-          return node;
-        }
-
-        return nodeWith(node, {
-          docblock: (0, _DocblockUtils.removeAtFlowFromDocblock)(docblock)
-        });
-      }
-
-    case 'TypeCastExpression':
-      {
-        return node.expression;
-      }
-
-    case 'CallExpression':
-    case 'NewExpression':
-      {
-        if (node.typeArguments != null) {
-          return nodeWith(node, {
-            typeArguments: null
-          });
-        }
-
-        return node;
-      }
-
-    case 'ObjectPattern':
-    case 'ArrayPattern':
-    case 'Identifier':
-      {
-        if (node.typeAnnotation != null) {
-          return nodeWith(node, {
-            typeAnnotation: null
-          });
-        }
-
-        return node;
-      }
-
-    case 'DeclareClass':
-    case 'DeclareFunction':
-    case 'DeclareInterface':
-    case 'DeclareModule':
-    case 'DeclareModuleExports':
-    case 'DeclareOpaqueType':
-    case 'DeclareTypeAlias':
-    case 'DeclareVariable':
-    case 'InterfaceDeclaration':
-    case 'OpaqueType':
-    case 'TypeAlias':
-      {
-        return null;
-      }
-
-    case 'FunctionDeclaration':
-    case 'ArrowFunctionExpression':
-    case 'FunctionExpression':
-      {
-        const newParams = [];
-
-        for (let i = 0; i < node.params.length; i++) {
-          if (i === 0 && node.params[0].type === 'Identifier' && node.params[0].name === 'this') {
-            continue;
-          }
-
-          let param = node.params[i];
-
-          if (param.type === 'AssignmentPattern') {
-            param = param.left;
-          }
-
-          if (param.optional === true) {
-            param = nodeWith(param, {
-              optional: false
-            });
-          }
+function stripAtFlow(ast, _options) {
+  const docblock = ast.docblock;
 
-          newParams.push(param);
-        }
-
-        return nodeWith(node, {
-          params: newParams,
-          returnType: null,
-          typeParameters: null,
-          predicate: null
-        });
-      }
-
-    case 'ClassDeclaration':
-    case 'ClassExpression':
-      {
-        return nodeWith(node, {
-          typeParameters: null,
-          superTypeParameters: null,
-          implements: [],
-          decorators: []
-        });
-      }
-
-    case 'PropertyDefinition':
-      {
-        return nodeWith(node, {
-          typeAnnotation: null,
-          variance: null,
-          declare: false,
-          optional: false
-        });
-      }
-
-    case 'ImportDeclaration':
-      {
-        if (node.importKind === 'type' || node.importKind === 'typeof') {
-          return null;
-        }
-
-        const nonTypeSpecifiers = node.specifiers.filter(s => s.type !== 'ImportSpecifier' || s.importKind !== 'type' && s.importKind !== 'typeof');
-
-        if (nonTypeSpecifiers.length === 0) {
-          return null;
-        }
-
-        if (nonTypeSpecifiers.length === node.specifiers.length) {
-          return node;
-        }
-
-        return nodeWith(node, {
-          specifiers: nonTypeSpecifiers
-        });
-      }
-
-    case 'ExportAllDeclaration':
-    case 'ExportNamedDeclaration':
-      {
-        if (node.exportKind === 'type') {
-          return null;
-        }
-
-        return node;
-      }
-
-    default:
-      {
-        return node;
-      }
+  if (docblock == null) {
+    return ast;
   }
-}
 
-function flowToJS(sourceAST, _code, _scopeManager) {
-  const result = _hermesParser.SimpleTransform.transform(sourceAST, {
-    transform
+  return nodeWith(ast, {
+    docblock: (0, _DocblockUtils.removeAtFlowFromDocblock)(docblock)
   });
+}
 
-  if (result == null || result.type !== 'Program') {
-    throw new Error('flowToJS: Unexpected transform result.');
-  }
-
-  return result;
+function flowToJS(sourceAST, _code, _scopeManager) {
+  return [_hermesParser.Transforms.stripComponentSyntax, _hermesParser.Transforms.stripFlowTypes, stripAtFlow].reduce((ast, transform) => transform(ast, {}), sourceAST);
 }