flow-api-translator 0.330.0 → 0.332.0

package/dist/flowDefToTSDef.js

@@ -503,6 +503,50 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     let typeof_import_count = 0;
     return () => `$$IMPORT_TYPEOF_${++typeof_import_count}$$`;
   })();
+  function transformImportTypeReference(node, typeArguments = null) {
+    const names = [];
+    let current = node;
+    while (current.type === 'QualifiedTypeIdentifier' || current.type === 'QualifiedTypeofIdentifier') {
+      names.unshift(current.id);
+      current = current.qualification;
+    }
+    if (current.type !== 'ImportType') {
+      return null;
+    }
+    let qualifier = null;
+    for (const name of names) {
+      const identifier = {
+        type: 'Identifier',
+        loc: DUMMY_LOC,
+        name: name.name
+      };
+      qualifier = qualifier == null ? identifier : {
+        type: 'TSQualifiedName',
+        loc: DUMMY_LOC,
+        left: qualifier,
+        right: identifier
+      };
+    }
+    const source = {
+      type: 'Literal',
+      loc: DUMMY_LOC,
+      raw: current.argument.raw,
+      value: current.argument.value
+    };
+    return {
+      type: 'TSImportType',
+      loc: DUMMY_LOC,
+      argument: {
+        type: 'TSLiteralType',
+        loc: DUMMY_LOC,
+        literal: source
+      },
+      options: null,
+      qualifier,
+      source,
+      typeArguments
+    };
+  }
   const transformTypeAnnotationType = node => {
     switch (node.type) {
       case 'AnyTypeAnnotation':
@@ -555,8 +599,12 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         return transform.SymbolTypeAnnotation(node);
       case 'ThisTypeAnnotation':
         return transform.ThisTypeAnnotation(node);
+      case 'TemplateLiteralTypeAnnotation':
+        return transform.TemplateLiteralTypeAnnotation(node);
       case 'TupleTypeAnnotation':
         return transform.TupleTypeAnnotation(node);
+      case 'TupleTypeElement':
+        return transform.TupleTypeElement(node);
       case 'TypeofTypeAnnotation':
         return transform.TypeofTypeAnnotation(node);
       case 'UnionTypeAnnotation':
@@ -567,6 +615,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         return transform.TypePredicateAnnotation(node);
       case 'ConditionalTypeAnnotation':
         return transform.ConditionalTypeAnnotation(node);
+      case 'ConstructorTypeAnnotation':
+        return transform.ConstructorTypeAnnotation(node);
       case 'InferTypeAnnotation':
         return transform.InferTypeAnnotation(node);
       case 'KeyofTypeAnnotation':
@@ -585,6 +635,53 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         throw unexpectedTranslationError(node, `Unhandled type ${node.type}`);
     }
   };
+  const declareTypeAsVariable = (specifier, type) => [{
+    type: 'VariableDeclaration',
+    loc: DUMMY_LOC,
+    declarations: [{
+      type: 'VariableDeclarator',
+      loc: DUMMY_LOC,
+      id: {
+        type: 'Identifier',
+        loc: DUMMY_LOC,
+        name: specifier,
+        typeAnnotation: {
+          type: 'TSTypeAnnotation',
+          loc: DUMMY_LOC,
+          typeAnnotation: transformTypeAnnotationType(type)
+        }
+      },
+      init: null
+    }],
+    declare: true,
+    kind: 'const'
+  }, {
+    type: 'TSTypeAliasDeclaration',
+    declare: true,
+    id: {
+      type: 'Identifier',
+      decorators: [],
+      name: specifier,
+      optional: false,
+      loc: DUMMY_LOC
+    },
+    typeAnnotation: {
+      type: 'TSTypeQuery',
+      exprName: {
+        type: 'Identifier',
+        decorators: [],
+        name: specifier,
+        optional: false,
+        loc: DUMMY_LOC
+      },
+      loc: DUMMY_LOC
+    },
+    loc: DUMMY_LOC
+  }];
+  const isDeclaredClass = name => {
+    const exportedVar = topScope.set.get(name);
+    return exportedVar != null && exportedVar.defs.length === 1 && exportedVar.defs[0].type === 'ClassName';
+  };
   const wellKnownSymbols = new Set(['iterator', 'asyncIterator', 'dispose', 'asyncDispose']);
   const transform = {
     AnyTypeAnnotation(_node) {
@@ -804,6 +901,18 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         }
       }
       const superClass = node.extends.length > 0 ? node.extends[0] : undefined;
+      let superClassExpression = null;
+      let superTypeArguments;
+      if (superClass != null) {
+        switch (superClass.type) {
+          case 'DeclareClassExtendsCall':
+            return unsupportedDeclaration(superClass, 'mixin class extends clauses', node.id, true, node.typeParameters);
+          case 'InterfaceExtends':
+            superClassExpression = superClass.id.type === 'QualifiedTypeIdentifier' ? transform.QualifiedTypeIdentifier(superClass.id) : transform.Identifier(superClass.id, false);
+            superTypeArguments = transform.TypeParameterInstantiation(superClass.typeParameters);
+            break;
+        }
+      }
       return {
         type: 'ClassDeclaration',
         loc: DUMMY_LOC,
@@ -815,8 +924,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         declare: true,
         id: transform.Identifier(node.id, false),
         implements: node.implements == null ? undefined : node.implements.map(transform.ClassImplements),
-        superClass: superClass == null ? null : superClass.id.type === 'QualifiedTypeIdentifier' ? transform.QualifiedTypeIdentifier(superClass.id) : transform.Identifier(superClass.id, false),
-        superTypeArguments: transform.TypeParameterInstantiation(superClass == null ? void 0 : superClass.typeParameters),
+        superClass: superClassExpression,
+        superTypeArguments,
         typeParameters: node.typeParameters == null ? undefined : transform.TypeParameterDeclaration(node.typeParameters)
       };
     },
@@ -842,6 +951,14 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           case 'DeclareFunction':
             {
               const functionDecl = transform.DeclareFunction(declaration);
+              if (declaration.id == null) {
+                return {
+                  type: 'ExportDefaultDeclaration',
+                  loc: DUMMY_LOC,
+                  declaration: functionDecl,
+                  exportKind: 'value'
+                };
+              }
               const name = declaration.id.name;
               return [functionDecl, {
                 type: 'ExportDefaultDeclaration',
@@ -926,77 +1043,25 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             }
           case 'TypeofTypeAnnotation':
             {
-              if (declaration.type === 'TypeofTypeAnnotation' && declaration.argument.type === 'Identifier') {
-                const name = declaration.argument.name;
-                const exportedVar = topScope.set.get(name);
-                if (exportedVar != null && exportedVar.defs.length === 1) {
-                  const def = exportedVar.defs[0];
-                  switch (def.type) {
-                    case 'ClassName':
-                      {
-                        return {
-                          type: 'ExportDefaultDeclaration',
-                          declaration: {
-                            type: 'Identifier',
-                            decorators: [],
-                            name,
-                            optional: false,
-                            loc: DUMMY_LOC
-                          },
-                          exportKind: 'value',
-                          loc: DUMMY_LOC
-                        };
-                      }
-                  }
-                }
-              }
-            }
-          default:
-            {
-              const SPECIFIER = '$$EXPORT_DEFAULT_DECLARATION$$';
-              return [{
-                type: 'VariableDeclaration',
-                loc: DUMMY_LOC,
-                declarations: [{
-                  type: 'VariableDeclarator',
-                  loc: DUMMY_LOC,
-                  id: {
-                    type: 'Identifier',
-                    loc: DUMMY_LOC,
-                    name: SPECIFIER,
-                    typeAnnotation: {
-                      type: 'TSTypeAnnotation',
-                      loc: DUMMY_LOC,
-                      typeAnnotation: transformTypeAnnotationType(declaration)
-                    }
-                  },
-                  init: null
-                }],
-                declare: true,
-                kind: 'const'
-              }, {
-                type: 'TSTypeAliasDeclaration',
-                declare: true,
-                id: {
-                  type: 'Identifier',
-                  decorators: [],
-                  name: SPECIFIER,
-                  optional: false,
-                  loc: DUMMY_LOC
-                },
-                typeAnnotation: {
-                  type: 'TSTypeQuery',
-                  exprName: {
+              if (declaration.type === 'TypeofTypeAnnotation' && declaration.argument.type === 'Identifier' && isDeclaredClass(declaration.argument.name)) {
+                return {
+                  type: 'ExportDefaultDeclaration',
+                  declaration: {
                     type: 'Identifier',
                     decorators: [],
-                    name: SPECIFIER,
+                    name: declaration.argument.name,
                     optional: false,
                     loc: DUMMY_LOC
                   },
+                  exportKind: 'value',
                   loc: DUMMY_LOC
-                },
-                loc: DUMMY_LOC
-              }, {
+                };
+              }
+            }
+          default:
+            {
+              const SPECIFIER = (0, _TSNodeUtils.getDefaultExportBindingName)(declaration, opts.useSemanticDefaultExportNames === true);
+              return [...declareTypeAsVariable(SPECIFIER, declaration), {
                 type: 'ExportDefaultDeclaration',
                 loc: DUMMY_LOC,
                 declaration: {
@@ -1048,6 +1113,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                   declaration: transform.DeclareInterface(node.declaration),
                   exportKind: 'type'
                 }];
+              case 'DeclareNamespace':
+                return [{
+                  declaration: unsupportedDeclaration(node.declaration, 'namespaces', node.declaration.id),
+                  exportKind: 'value'
+                }];
               case 'DeclareOpaqueType':
                 return [{
                   declaration: transform.DeclareOpaqueType(node.declaration),
@@ -1279,8 +1349,13 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       };
     },
     DeclareFunction(node) {
-      const id = transform.Identifier(node.id, false);
-      const functionInfo = transform.FunctionTypeAnnotation(node.id.typeAnnotation.typeAnnotation);
+      var _node$id$typeAnnotati, _node$id;
+      const annotation = (_node$id$typeAnnotati = (_node$id = node.id) == null ? void 0 : _node$id.typeAnnotation) != null ? _node$id$typeAnnotati : node.typeAnnotation;
+      if (annotation == null) {
+        throw translationError(node, 'Declare function is missing its type');
+      }
+      const functionType = annotation.typeAnnotation;
+      const functionInfo = transform.FunctionTypeAnnotation(functionType);
       return {
         type: 'TSDeclareFunction',
         loc: DUMMY_LOC,
@@ -1289,10 +1364,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         declare: true,
         expression: false,
         generator: false,
-        id: {
+        id: node.id == null ? null : {
           type: 'Identifier',
           loc: DUMMY_LOC,
-          name: id.name
+          name: node.id.name
         },
         params: functionInfo.params,
         returnType: functionInfo.returnType,
@@ -1409,7 +1484,31 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       return EnumImpl(node);
     },
     DeclareModuleExports(node) {
-      throw translationError(node, 'CommonJS exports are not supported.');
+      if (node.parent.type === 'Program' && node.parent.body.some(statement => statement.type === 'DeclareExportAllDeclaration' || statement.type === 'DeclareExportDeclaration' || statement.type === 'ExportAllDeclaration' || statement.type === 'ExportDefaultDeclaration' || statement.type === 'ExportNamedDeclaration')) {
+        throw translationError(node, 'CommonJS exports cannot be combined with ES module exports.');
+      }
+      const type = node.typeAnnotation.typeAnnotation;
+      if (type.type === 'TypeofTypeAnnotation' && type.argument.type === 'Identifier' && isDeclaredClass(type.argument.name)) {
+        return {
+          type: 'TSExportAssignment',
+          loc: DUMMY_LOC,
+          expression: {
+            type: 'Identifier',
+            loc: DUMMY_LOC,
+            name: type.argument.name
+          }
+        };
+      }
+      const SPECIFIER = '$$MODULE_EXPORTS$$';
+      return [...declareTypeAsVariable(SPECIFIER, type), {
+        type: 'TSExportAssignment',
+        loc: DUMMY_LOC,
+        expression: {
+          type: 'Identifier',
+          loc: DUMMY_LOC,
+          name: SPECIFIER
+        }
+      }];
     },
     ExistsTypeAnnotation(node) {
       return unsupportedAnnotation(node, 'existential type');
@@ -1489,7 +1588,39 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         loc: DUMMY_LOC,
         exported: transform.Identifier(node.exported, false),
         local: transform.Identifier(node.local, false),
-        exportKind: 'value'
+        exportKind: node.exportKind
+      };
+    },
+    ConstructorTypeAnnotation(node) {
+      const params = node.params.map(transform.FunctionTypeParam);
+      if (node.rest != null) {
+        const rest = node.rest;
+        params.push({
+          type: 'RestElement',
+          loc: DUMMY_LOC,
+          argument: rest.name == null ? {
+            type: 'Identifier',
+            loc: DUMMY_LOC,
+            name: '$$REST$$'
+          } : transform.Identifier(rest.name, false),
+          typeAnnotation: {
+            type: 'TSTypeAnnotation',
+            loc: DUMMY_LOC,
+            typeAnnotation: transformTypeAnnotationType(rest.typeAnnotation)
+          }
+        });
+      }
+      return {
+        type: 'TSConstructorType',
+        loc: DUMMY_LOC,
+        abstract: node.abstract,
+        params,
+        returnType: {
+          type: 'TSTypeAnnotation',
+          loc: DUMMY_LOC,
+          typeAnnotation: transformTypeAnnotationType(node.returnType)
+        },
+        typeParameters: node.typeParameters == null ? undefined : transform.TypeParameterDeclaration(node.typeParameters)
       };
     },
     FunctionTypeAnnotation(node) {
@@ -1530,7 +1661,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         returnType: {
           type: 'TSTypeAnnotation',
           loc: DUMMY_LOC,
-          typeAnnotation: transformTypeAnnotationType(node.returnType)
+          typeAnnotation: node.returnType == null ? {
+            type: 'TSAnyKeyword',
+            loc: DUMMY_LOC
+          } : transformTypeAnnotationType(node.returnType)
         },
         typeParameters: node.typeParameters == null ? undefined : transform.TypeParameterDeclaration(node.typeParameters)
       };
@@ -1549,6 +1683,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       };
     },
     GenericTypeAnnotation(node) {
+      var _transform$TypeParame;
+      const importType = transformImportTypeReference(node.id, (_transform$TypeParame = transform.TypeParameterInstantiation(node.typeParameters)) != null ? _transform$TypeParame : null);
+      if (importType != null) {
+        return importType;
+      }
       const [fullTypeName, baseId] = (() => {
         let names = [];
         let currentNode = node.id;
@@ -2410,10 +2549,14 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             return unsupportedAnnotation(node, fullTypeName);
         }
       }
+      const typeName = node.id.type === 'Identifier' ? transform.Identifier(node.id, false) : node.id.type === 'QualifiedTypeIdentifier' ? transform.QualifiedTypeIdentifier(node.id) : null;
+      if (typeName == null) {
+        throw unexpectedTranslationError(node, 'Unreachable import type');
+      }
       return {
         type: 'TSTypeReference',
         loc: DUMMY_LOC,
-        typeName: node.id.type === 'Identifier' ? transform.Identifier(node.id, false) : transform.QualifiedTypeIdentifier(node.id),
+        typeName,
         typeArguments: transform.TypeParameterInstantiation(node.typeParameters)
       };
     },
@@ -2615,7 +2758,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     },
     ObjectTypeAnnotation(node) {
       if (node.properties.length === 1 && node.properties[0].type === 'ObjectTypeMappedTypeProperty') {
-        var _prop$variance, _prop$variance2;
+        var _prop$varianceOp, _prop$variance, _prop$variance2;
         const prop = node.properties[0];
         const tsProp = {
           type: 'TSMappedType',
@@ -2638,10 +2781,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             name: prop.keyTparam.name
           },
           constraint: transformTypeAnnotationType(prop.sourceType),
-          readonly: ((_prop$variance = prop.variance) == null ? void 0 : _prop$variance.kind) === 'plus' || ((_prop$variance2 = prop.variance) == null ? void 0 : _prop$variance2.kind) === 'readonly',
+          readonly: (_prop$varianceOp = prop.varianceOp) != null ? _prop$varianceOp : ((_prop$variance = prop.variance) == null ? void 0 : _prop$variance.kind) === 'plus' || ((_prop$variance2 = prop.variance) == null ? void 0 : _prop$variance2.kind) === 'readonly',
           optional: prop.optional === 'Optional',
           typeAnnotation: transformTypeAnnotationType(prop.propType),
-          nameType: null
+          nameType: prop.nameType == null ? null : transformTypeAnnotationType(prop.nameType)
         };
         return tsProp;
       }
@@ -2669,6 +2812,9 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           if (property.type === 'ObjectTypeMappedTypeProperty') {
             return unsupportedAnnotation(property, 'object type with mapped type property along with other properties');
           }
+          if (property.type === 'ObjectTypePrivateField') {
+            return unsupportedAnnotation(property, 'private type fields');
+          }
           members.push({
             start: property.range[0],
             node: transform.ObjectTypeProperty(property)
@@ -2700,6 +2846,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             typesToIntersect.push(spreadType);
           } else if (property.type === 'ObjectTypeMappedTypeProperty') {
             return unsupportedAnnotation(property, 'object type with mapped type property');
+          } else if (property.type === 'ObjectTypePrivateField') {
+            return unsupportedAnnotation(property, 'private type fields');
           } else {
             members.push({
               start: property.range[0],
@@ -2772,6 +2920,9 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       var _node$variance3, _node$variance4;
       if (node.key.type === 'GenericTypeAnnotation') {
         var _node$variance, _node$variance2;
+        if (node.key.id.type === 'ImportType') {
+          throw translationError(node, 'Unsupported import type indexer key');
+        }
         const ident = node.key.id.type === 'Identifier' ? node.key.id : node.key.id.id;
         return {
           type: 'TSPropertySignature',
@@ -2929,19 +3080,27 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     },
     QualifiedTypeIdentifier(node) {
       const qual = node.qualification;
+      if (qual.type === 'ImportType') {
+        throw unexpectedTranslationError(qual, 'Unreachable import type');
+      }
+      const left = qual.type === 'Identifier' ? transform.Identifier(qual, false) : transform.QualifiedTypeIdentifier(qual);
       return {
         type: 'TSQualifiedName',
         loc: DUMMY_LOC,
-        left: qual.type === 'Identifier' ? transform.Identifier(qual, false) : transform.QualifiedTypeIdentifier(qual),
+        left,
         right: transform.Identifier(node.id, false)
       };
     },
     QualifiedTypeofIdentifier(node) {
       const qual = node.qualification;
+      if (qual.type === 'ImportType') {
+        throw unexpectedTranslationError(qual, 'Unreachable import type');
+      }
+      const left = qual.type === 'Identifier' ? transform.Identifier(qual, false) : transform.QualifiedTypeofIdentifier(qual);
       return {
         type: 'TSQualifiedName',
         loc: DUMMY_LOC,
-        left: qual.type === 'Identifier' ? transform.Identifier(qual, false) : transform.QualifiedTypeofIdentifier(qual),
+        left,
         right: transform.Identifier(node.id, false)
       };
     },
@@ -2995,6 +3154,22 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         loc: DUMMY_LOC
       };
     },
+    TemplateLiteralTypeAnnotation(node) {
+      return {
+        type: 'TSTemplateLiteralType',
+        loc: DUMMY_LOC,
+        quasis: node.quasis.map(quasi => ({
+          type: 'TemplateElement',
+          loc: DUMMY_LOC,
+          tail: quasi.tail,
+          value: {
+            cooked: quasi.value.cooked,
+            raw: quasi.value.raw
+          }
+        })),
+        types: node.types.map(transformTypeAnnotationType)
+      };
+    },
     TupleTypeAnnotation(node) {
       const allReadOnly = node.elementTypes.length > 0 && node.elementTypes.every(element => element.type === 'TupleTypeLabeledElement' && element.variance != null && (element.variance.kind === 'plus' || element.variance.kind === 'readonly'));
       const elems = node.elementTypes.map(element => {
@@ -3053,6 +3228,14 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeAnnotation: tupleAnnot
       } : tupleAnnot;
     },
+    TupleTypeElement(node) {
+      const elementType = transformTypeAnnotationType(node.elementType);
+      return node.optional ? {
+        type: 'TSOptionalType',
+        loc: DUMMY_LOC,
+        typeAnnotation: elementType
+      } : elementType;
+    },
     TypeAlias(node) {
       return transform.DeclareTypeAlias(node);
     },
@@ -3064,6 +3247,27 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       };
     },
     TypeofTypeAnnotation(node) {
+      if (node.argument.type === 'ImportType') {
+        const importType = transformImportTypeReference(node.argument);
+        if (importType == null) {
+          throw unexpectedTranslationError(node, 'Invalid import type');
+        }
+        return {
+          type: 'TSTypeQuery',
+          loc: DUMMY_LOC,
+          exprName: importType,
+          typeArguments: undefined
+        };
+      }
+      const importType = node.argument.type === 'QualifiedTypeofIdentifier' ? transformImportTypeReference(node.argument) : null;
+      if (importType != null) {
+        return {
+          type: 'TSTypeQuery',
+          loc: DUMMY_LOC,
+          exprName: importType,
+          typeArguments: undefined
+        };
+      }
       switch (node.argument.type) {
         case 'Identifier':
           return {
@@ -3079,6 +3283,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             exprName: transform.QualifiedTypeofIdentifier(node.argument),
             typeArguments: undefined
           };
+        default:
+          throw unexpectedTranslationError(node.argument, 'Unexpected typeof annotation argument');
       }
     },
     TypeParameter(node) {
@@ -3184,6 +3390,13 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     },
     TypeOperator(node) {
       switch (node.operator) {
+        case 'unique':
+          return {
+            type: 'TSTypeOperator',
+            loc: DUMMY_LOC,
+            operator: 'unique',
+            typeAnnotation: transformTypeAnnotationType(node.typeAnnotation)
+          };
         case 'renders':
         case 'renders?':
         case 'renders*':