flow-api-translator 0.37.0 → 0.328.0

package/dist/flowDefToTSDef.js.flow

@@ -10,23 +10,26 @@
 
 'use strict';
 
-import type {ObjectWithLoc} from 'hermes-estree';
+import type {ObjectWithLoc} from 'flow-estree';
 import type {TranslationOptions} from './utils/TranslationUtils';
-import type {ScopeManager} from 'hermes-eslint';
+import type {ScopeManager} from 'flow-eslint';
 
-import * as FlowESTree from 'hermes-estree';
+import * as FlowESTree from 'flow-estree';
 import * as TSESTree from './utils/ts-estree-ast-types';
 import {
   cloneJSDocCommentsToNewNode as cloneJSDocCommentsToNewNodeOriginal,
   makeCommentOwnLine as makeCommentOwnLineOriginal,
-} from 'hermes-transform';
+} from 'flow-transform';
 import {
   buildCodeFrame,
   translationError as translationErrorBase,
   unexpectedTranslationError as unexpectedTranslationErrorBase,
 } from './utils/ErrorUtils';
 import {removeAtFlowFromDocblock} from './utils/DocblockUtils';
-import {extractPropertyKeyLiterals} from './utils/TSNodeUtils';
+import {
+  ensureTypeIncludesUndefined,
+  extractPropertyKeyLiterals,
+} from './utils/TSNodeUtils';
 import {EOL} from 'os';
 
 type DeclarationOrUnsupported<T> = T | TSESTree.TSTypeAliasDeclaration;
@@ -54,6 +57,65 @@ const makeCommentOwnLine =
   // $FlowExpectedError[incompatible-type] - trust me this re-type is 100% safe
   makeCommentOwnLineOriginal as (string, unknown) => string;
 
+/**
+ * `DeclareComponent` reaches us in one of two shapes: parsed nodes carry
+ * `ComponentParameter`/`RestElement` in `params` with a null `rest` (the
+ * `ComponentDeclaration` shape the Flow parser reuses here), while detached
+ * nodes built with `flow-transform` use `ComponentTypeParameter` + `rest`.
+ * Normalize both onto the latter so the shared `ComponentTypeParameters`
+ * translation — which `ComponentTypeAnnotation` also uses — sees one shape.
+ */
+function normalizeDeclareComponentParams(
+  params: FlowESTree.DeclareComponent['params'],
+  rest: FlowESTree.DeclareComponent['rest'],
+  onUnexpected: (node: ObjectWithLoc, message: string) => Error,
+): [
+  ReadonlyArray<FlowESTree.ComponentTypeParameter>,
+  FlowESTree.ComponentTypeParameter | null,
+] {
+  const normalizedParams: Array<FlowESTree.ComponentTypeParameter> = [];
+  let normalizedRest: FlowESTree.ComponentTypeParameter | null = rest;
+
+  const toComponentTypeParameter = (
+    name: FlowESTree.ComponentTypeParameter['name'],
+    local: FlowESTree.ESNode,
+    source: FlowESTree.BaseToken,
+  ): FlowESTree.ComponentTypeParameter => {
+    if (local.type !== 'Identifier' || local.typeAnnotation == null) {
+      throw onUnexpected(
+        source,
+        `DeclareComponent: expected an annotated identifier parameter, got "${local.type}"`,
+      );
+    }
+    return constructFlowNode<FlowESTree.ComponentTypeParameter>({
+      type: 'ComponentTypeParameter',
+      name,
+      typeAnnotation: local.typeAnnotation.typeAnnotation,
+      optional: local.optional,
+      loc: source.loc,
+      range: source.range,
+    });
+  };
+
+  for (const param of params) {
+    switch (param.type) {
+      case 'ComponentTypeParameter':
+        normalizedParams.push(param);
+        break;
+      case 'ComponentParameter':
+        normalizedParams.push(
+          toComponentTypeParameter(param.name, param.local, param),
+        );
+        break;
+      case 'RestElement':
+        normalizedRest = toComponentTypeParameter(null, param.argument, param);
+        break;
+    }
+  }
+
+  return [normalizedParams, normalizedRest];
+}
+
 const VALID_REACT_IMPORTS = new Set<string>(['React', 'react']);
 
 function isValidReactImportOrGlobal(id: FlowESTree.Identifier): boolean {
@@ -1562,7 +1624,15 @@ const getTransforms = (
           ? undefined
           : transform.TypeParameterDeclaration(node.typeParameters);
 
-      const params = transform.ComponentTypeParameters(node.params, node.rest);
+      const [declaredParams, declaredRest] = normalizeDeclareComponentParams(
+        node.params,
+        node.rest,
+        unexpectedTranslationError,
+      );
+      const params = transform.ComponentTypeParameters(
+        declaredParams,
+        declaredRest,
+      );
 
       // TS cannot support `renderType` so we always use ReactNode as the return type.
       const hasReactImport = isReactImport(node, 'React');
@@ -1861,15 +1931,21 @@ const getTransforms = (
         type: 'VariableDeclaration',
         loc: DUMMY_LOC,
         declare: true,
-        declarations: [
-          {
+        declarations: node.declarations.map(declaration => {
+          if (declaration.id.type !== 'Identifier') {
+            throw translationError(
+              declaration.id,
+              `DeclareVariable: unsupported declarator of type "${declaration.id.type}"`,
+            );
+          }
+          return {
             type: 'VariableDeclarator',
             loc: DUMMY_LOC,
             declare: true,
-            id: transform.Identifier(node.id, true),
+            id: transform.Identifier(declaration.id, true),
             init: null,
-          },
-        ],
+          };
+        }),
         kind: node.kind,
       };
     },
@@ -3851,7 +3927,12 @@ const getTransforms = (
         typeAnnotation: {
           type: 'TSTypeAnnotation',
           loc: DUMMY_LOC,
-          typeAnnotation: transformTypeAnnotationType(node.value),
+          typeAnnotation:
+            node.optional === true
+              ? ensureTypeIncludesUndefined(
+                  transformTypeAnnotationType(node.value),
+                )
+              : transformTypeAnnotationType(node.value),
         },
       };
     },

package/dist/flowImportTo.js

@@ -4,61 +4,50 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.flowImportTo = flowImportTo;
-
-var _hermesParser = require("hermes-parser");
-
+var _flowParser = require("flow-parser");
 function flowImportTo(ast, _code, _scopeManager, opts) {
   function mapSource(source) {
     const resultValue = opts.sourceMapper({
       module: source.value
     });
-
     if (resultValue === source.value) {
       return source;
     }
-
-    return _hermesParser.SimpleTransform.nodeWith(source, {
+    return _flowParser.SimpleTransform.nodeWith(source, {
       value: resultValue,
       raw: `"${resultValue}"`
     });
   }
-
-  const result = _hermesParser.SimpleTransform.transform(ast, {
+  const result = _flowParser.SimpleTransform.transform(ast, {
     transform(node) {
       switch (node.type) {
         case 'ImportDeclaration':
           {
-            return _hermesParser.SimpleTransform.nodeWith(node, {
+            return _flowParser.SimpleTransform.nodeWith(node, {
               source: mapSource(node.source)
             });
           }
-
         case 'DeclareExportAllDeclaration':
         case 'ExportAllDeclaration':
         case 'DeclareExportDeclaration':
         case 'ExportNamedDeclaration':
           {
             if (node.source != null) {
-              return _hermesParser.SimpleTransform.nodeWith(node, {
+              return _flowParser.SimpleTransform.nodeWith(node, {
                 source: mapSource(node.source)
               });
             }
-
             return node;
           }
-
         default:
           {
             return node;
           }
       }
     }
-
   });
-
   if (result == null || result.type !== 'Program') {
     throw new Error('flowImportTo: Unexpected transform result.');
   }
-
   return result;
 }

package/dist/flowImportTo.js.flow

@@ -10,10 +10,10 @@
 
 'use strict';
 
-import type {ScopeManager} from 'hermes-eslint';
-import type {Program, ESNode, StringLiteral} from 'hermes-estree';
+import type {ScopeManager} from 'flow-eslint';
+import type {Program, ESNode, StringLiteral} from 'flow-estree';
 
-import {SimpleTransform} from 'hermes-parser';
+import {SimpleTransform} from 'flow-parser';
 
 export type SourceMapperParams = {
   module: string,