flow-api-translator 0.26.0 → 0.28.0

package/dist/flowDefToTSDef.js

@@ -879,14 +879,45 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 cloneJSDocCommentsToNewNode(member, newNode);
                 classMembers.push(newNode);
               } else {
-                var _member$computed, _member$static;
+                var _member$static;
+
+                const [key, computed] = (() => {
+                  const _key = member.key;
+
+                  if (_key.type === 'Identifier' && _key.name.startsWith('@@')) {
+                    const name = _key.name.slice(2);
+
+                    if (['iterator', 'asyncIterator'].includes(name)) {
+                      return [{
+                        type: 'MemberExpression',
+                        computed: false,
+                        object: {
+                          type: 'Identifier',
+                          name: 'Symbol',
+                          optional: false,
+                          loc: DUMMY_LOC
+                        },
+                        optional: false,
+                        property: {
+                          type: 'Identifier',
+                          name,
+                          optional: false,
+                          loc: DUMMY_LOC
+                        },
+                        loc: DUMMY_LOC
+                      }, true];
+                    }
+                  }
+
+                  return [member.key, member.computed];
+                })();
 
                 const newNode = {
                   type: 'MethodDefinition',
                   loc: DUMMY_LOC,
                   accessibility: member.accessibility,
-                  computed: (_member$computed = member.computed) != null ? _member$computed : false,
-                  key: member.key,
+                  computed: computed != null ? computed : false,
+                  key,
                   kind: member.kind,
                   optional: member.optional,
                   override: false,
@@ -914,13 +945,13 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
           case 'TSPropertySignature':
             {
-              var _member$computed2, _member$static2;
+              var _member$computed, _member$static2;
 
               const newNode = {
                 type: 'PropertyDefinition',
                 loc: DUMMY_LOC,
                 accessibility: member.accessibility,
-                computed: (_member$computed2 = member.computed) != null ? _member$computed2 : false,
+                computed: (_member$computed = member.computed) != null ? _member$computed : false,
                 declare: false,
                 key: member.key,
                 optional: member.optional,
@@ -974,8 +1005,7 @@ 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 : // Bug: superclass.id can be qualified
-        transform.Identifier(superClass.id, false),
+        superClass: superClass == null ? null : superClass.id.type === 'QualifiedTypeIdentifier' ? transform.QualifiedTypeIdentifier(superClass.id) : transform.Identifier(superClass.id, false),
         superTypeParameters: (superClass == null ? void 0 : superClass.typeParameters) == null ? undefined : transform.TypeParameterInstantiation(superClass.typeParameters),
         typeParameters: node.typeParameters == null ? undefined : transform.TypeParameterDeclaration(node.typeParameters) // TODO - mixins??
 
@@ -1117,6 +1147,37 @@ 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
+                        };
+                      }
+                  }
+                }
+              } // intentional fallthrough to the "default" handling
+
+            }
+
           default:
             {
               /*
@@ -1152,6 +1213,28 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }],
                 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
               }, {
                 type: 'ExportDefaultDeclaration',
                 loc: DUMMY_LOC,
@@ -1243,19 +1326,72 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             }
           })();
 
-          return declarations.map(({
+          const mappedDeclarations = declarations.map(({
             declaration,
             exportKind
-          }) => ({
-            type: 'ExportNamedDeclaration',
-            loc: DUMMY_LOC,
-            // flow does not currently support assertions
-            assertions: [],
-            declaration,
-            exportKind,
-            source: null,
-            specifiers: []
-          }));
+          }) => {
+            if (declaration.type === 'VariableDeclaration' && declaration.declarations.length === 1) {
+              const ident = declaration.declarations[0].id;
+
+              if (ident.type === 'Identifier') {
+                const name = ident.name;
+                return [{
+                  type: 'ExportNamedDeclaration',
+                  loc: DUMMY_LOC,
+                  // flow does not currently support assertions
+                  assertions: [],
+                  declaration,
+                  exportKind,
+                  source: null,
+                  specifiers: []
+                }, {
+                  type: 'ExportNamedDeclaration',
+                  declaration: {
+                    type: 'TSTypeAliasDeclaration',
+                    declare: true,
+                    id: {
+                      type: 'Identifier',
+                      decorators: [],
+                      name,
+                      optional: false,
+                      loc: DUMMY_LOC
+                    },
+                    typeAnnotation: {
+                      type: 'TSTypeQuery',
+                      exprName: {
+                        type: 'Identifier',
+                        decorators: [],
+                        name,
+                        optional: false,
+                        loc: DUMMY_LOC
+                      },
+                      loc: DUMMY_LOC
+                    },
+                    loc: DUMMY_LOC
+                  },
+                  source: null,
+                  loc: DUMMY_LOC,
+                  specifiers: [],
+                  exportKind: 'type',
+                  // flow does not currently support assertions
+                  assertions: []
+                }];
+              }
+            }
+
+            const exportNamedDeclaration = {
+              type: 'ExportNamedDeclaration',
+              loc: DUMMY_LOC,
+              // flow does not currently support assertions
+              assertions: [],
+              declaration,
+              exportKind,
+              source: null,
+              specifiers: []
+            };
+            return exportNamedDeclaration;
+          });
+          return mappedDeclarations.flat();
         } else {
           return {
             type: 'ExportNamedDeclaration',
@@ -1472,6 +1608,45 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       // TS doesn't currently have nominal types - https://github.com/Microsoft/Typescript/issues/202
       // TODO - we could simulate this in a variety of ways
       // Examples - https://basarat.gitbook.io/typescript/main-1/nominaltyping
+      if (node.supertype == null && node.typeParameters == null) {
+        const name = `__${node.id.name}__`;
+        return {
+          type: 'TSTypeAliasDeclaration',
+          loc: DUMMY_LOC,
+          declare: true,
+          id: transform.Identifier(node.id, false),
+          typeAnnotation: {
+            type: 'TSIntersectionType',
+            types: [{
+              type: 'TSSymbolKeyword',
+              loc: DUMMY_LOC
+            }, {
+              type: 'TSTypeLiteral',
+              loc: DUMMY_LOC,
+              members: [{
+                type: 'TSPropertySignature',
+                computed: false,
+                loc: DUMMY_LOC,
+                key: {
+                  type: 'Identifier',
+                  name: name,
+                  loc: DUMMY_LOC
+                },
+                typeAnnotation: {
+                  type: 'TSTypeAnnotation',
+                  loc: DUMMY_LOC,
+                  typeAnnotation: {
+                    type: 'TSStringKeyword',
+                    loc: DUMMY_LOC
+                  }
+                }
+              }]
+            }],
+            loc: DUMMY_LOC
+          }
+        };
+      }
+
       return {
         type: 'TSTypeAliasDeclaration',
         loc: DUMMY_LOC,
@@ -1782,6 +1957,39 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             return unsupportedAnnotation(node, fullTypeName);
           }
 
+        case '$ArrayBufferView':
+          {
+            // `$ArrayBufferView` => `ArrayBufferView`
+            return {
+              type: 'TSTypeReference',
+              loc: DUMMY_LOC,
+              typeName: {
+                type: 'Identifier',
+                loc: DUMMY_LOC,
+                name: 'ArrayBufferView'
+              }
+            };
+          }
+
+        case '$ArrayLike':
+          {
+            // `$ArrayLike<T>` => `ArrayLike<T>`
+            return {
+              type: 'TSTypeReference',
+              loc: DUMMY_LOC,
+              typeName: {
+                type: 'Identifier',
+                loc: DUMMY_LOC,
+                name: 'ArrayLike'
+              },
+              typeParameters: {
+                type: 'TSTypeParameterInstantiation',
+                loc: DUMMY_LOC,
+                params: assertHasExactlyNTypeParameters(1)
+              }
+            };
+          }
+
         case '$Diff':
         case '$Rest':
           {
@@ -2349,8 +2557,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }
               };
             }
-          // React.ElementRef<typeof Component> -> React.ElementRef<typeof Component>
-          // React$ElementRef<typeof Component> -> React.ElementRef<typeof Component>
+          // React.ElementRef<typeof Component> -> React.ComponentRef<typeof Component>
+          // React$ElementRef<typeof Component> -> React.ComponentRef<typeof Component>
 
           case 'React$ElementRef':
           case 'React.ElementRef':
@@ -2364,7 +2572,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 right: {
                   type: 'Identifier',
                   loc: DUMMY_LOC,
-                  name: `ElementRef`
+                  name: `ComponentRef`
                 }
               },
               typeParameters: {
@@ -2393,7 +2601,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }
               }
             };
-          // React.MixedElement -> JSX.Element
+          // React.MixedElement -> React.JSX.Element
 
           case 'React$MixedElement':
           case 'React.MixedElement':
@@ -2406,9 +2614,18 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                   type: 'TSQualifiedName',
                   loc: DUMMY_LOC,
                   left: {
-                    type: 'Identifier',
+                    type: 'TSQualifiedName',
                     loc: DUMMY_LOC,
-                    name: 'JSX'
+                    left: {
+                      type: 'Identifier',
+                      loc: DUMMY_LOC,
+                      name: 'React'
+                    },
+                    right: {
+                      type: 'Identifier',
+                      loc: DUMMY_LOC,
+                      name: 'JSX'
+                    }
                   },
                   right: {
                     type: 'Identifier',
@@ -2547,8 +2764,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }
               };
             }
-          // React.ElementConfig<A> ->  JSX.LibraryManagedAttributes<A, React.ComponentProps<A>>
-          // React$ElementConfig<A> ->  JSX.LibraryManagedAttributes<A, React.ComponentProps<A>>
+          // React.ElementConfig<A> ->  React.JSX.LibraryManagedAttributes<A, React.ComponentProps<A>>
+          // React$ElementConfig<A> ->  React.JSX.LibraryManagedAttributes<A, React.ComponentProps<A>>
 
           case 'React.ElementConfig':
           case 'React$ElementConfig':
@@ -2561,9 +2778,18 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                   type: 'TSQualifiedName',
                   loc: DUMMY_LOC,
                   left: {
-                    type: 'Identifier',
+                    type: 'TSQualifiedName',
                     loc: DUMMY_LOC,
-                    name: 'JSX'
+                    left: {
+                      type: 'Identifier',
+                      loc: DUMMY_LOC,
+                      name: 'React'
+                    },
+                    right: {
+                      type: 'Identifier',
+                      loc: DUMMY_LOC,
+                      name: 'JSX'
+                    }
                   },
                   right: {
                     type: 'Identifier',
@@ -2738,8 +2964,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       return {
         type: 'TSInterfaceHeritage',
         loc: DUMMY_LOC,
-        // Bug: node.id can be qualified
-        expression: transform.Identifier(node.id, false),
+        expression: node.id.type === 'QualifiedTypeIdentifier' ? transform.QualifiedTypeIdentifier(node.id) : transform.Identifier(node.id, false),
         typeParameters: node.typeParameters == null ? undefined : transform.TypeParameterInstantiation(node.typeParameters)
       };
     },
@@ -3000,8 +3225,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         type T = { ...T1, ...T2, ...T3, b: string  };
         // becomes
         type T =
-          & Omit<T1, keyof (T2 | T3 | { b: string })>
-          & Omit<T2, keyof (T3 | { b: string })>
+          & Omit<T1, keyof T2 | keyof T3 | keyof { b: string }>
+          & Omit<T2, keyof T3 | keyof { b: string }>
           & Omit<T3, keyof { b: string }>
           & { b: string };
         ```
@@ -3024,7 +3249,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
             const spreadType = transformTypeAnnotationType(property.argument);
 
-            if (spreadType.type !== 'TSTypeReference') {
+            if (spreadType.type !== 'TSTypeReference' && spreadType.type !== 'TSTypeQuery') {
               return unsupportedAnnotation(property, 'object types with complex spreads');
             }
 
@@ -3065,14 +3290,19 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               type: 'TSTypeParameterInstantiation',
               loc: DUMMY_LOC,
               params: [currentType, {
-                type: 'TSTypeOperator',
+                type: 'TSUnionType',
                 loc: DUMMY_LOC,
-                operator: 'keyof',
-                typeAnnotation: {
-                  type: 'TSUnionType',
+                types: [...remainingTypes.map(t => ({
+                  type: 'TSTypeOperator',
                   loc: DUMMY_LOC,
-                  types: [...remainingTypes, objectType]
-                }
+                  operator: 'keyof',
+                  typeAnnotation: t
+                })), {
+                  type: 'TSTypeOperator',
+                  loc: DUMMY_LOC,
+                  operator: 'keyof',
+                  typeAnnotation: objectType
+                }]
               }]
             }
           });
@@ -3100,7 +3330,40 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     },
 
     ObjectTypeIndexer(node) {
-      var _node$variance;
+      var _node$variance2;
+
+      if (node.key.type === 'GenericTypeAnnotation') {
+        var _node$variance;
+
+        const ident = node.key.id.type === 'Identifier' ? node.key.id : node.key.id.id;
+        return {
+          type: 'TSPropertySignature',
+          computed: true,
+          loc: DUMMY_LOC,
+          key: {
+            type: 'BinaryExpression',
+            operator: 'in',
+            loc: DUMMY_LOC,
+            left: {
+              type: 'Identifier',
+              name: node.id == null ? '$$Key$$' : node.id.name,
+              loc: DUMMY_LOC
+            },
+            right: {
+              type: 'Identifier',
+              name: ident.name,
+              loc: DUMMY_LOC
+            }
+          },
+          readonly: ((_node$variance = node.variance) == null ? void 0 : _node$variance.kind) === 'plus',
+          static: node.static,
+          typeAnnotation: {
+            type: 'TSTypeAnnotation',
+            loc: DUMMY_LOC,
+            typeAnnotation: transformTypeAnnotationType(node.value)
+          }
+        };
+      }
 
       return {
         type: 'TSIndexSignature',
@@ -3115,7 +3378,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             typeAnnotation: transformTypeAnnotationType(node.key)
           }
         }],
-        readonly: ((_node$variance = node.variance) == null ? void 0 : _node$variance.kind) === 'plus',
+        readonly: ((_node$variance2 = node.variance) == null ? void 0 : _node$variance2.kind) === 'plus',
         static: node.static,
         typeAnnotation: {
           type: 'TSTypeAnnotation',
@@ -3126,7 +3389,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     },
 
     ObjectTypeProperty(node) {
-      var _node$variance2;
+      var _node$variance3;
 
       const key = node.key.type === 'Identifier' ? transform.Identifier(node.key) : transform.StringLiteral(node.key);
 
@@ -3174,7 +3437,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         computed: false,
         key,
         optional: node.optional,
-        readonly: ((_node$variance2 = node.variance) == null ? void 0 : _node$variance2.kind) === 'plus',
+        readonly: ((_node$variance3 = node.variance) == null ? void 0 : _node$variance3.kind) === 'plus',
         static: node.static,
         typeAnnotation: {
           type: 'TSTypeAnnotation',