flow-api-translator 0.26.0 → 0.28.0

package/dist/flowDefToTSDef.js.flow

@@ -928,12 +928,44 @@ const getTransforms = (
               cloneJSDocCommentsToNewNode(member, newNode);
               classMembers.push(newNode);
             } else {
+              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: TSESTree.MethodDefinitionAmbiguous = {
                 type: 'MethodDefinition',
                 loc: DUMMY_LOC,
                 accessibility: member.accessibility,
-                computed: member.computed ?? false,
-                key: member.key,
+                computed: computed ?? false,
+                key,
                 kind: member.kind,
                 optional: member.optional,
                 override: false,
@@ -1030,8 +1062,9 @@ const getTransforms = (
         superClass:
           superClass == null
             ? null
-            : // Bug: superclass.id can be qualified
-              transform.Identifier((superClass.id: $FlowFixMe), false),
+            : superClass.id.type === 'QualifiedTypeIdentifier'
+            ? transform.QualifiedTypeIdentifier(superClass.id)
+            : transform.Identifier((superClass.id: $FlowFixMe), false),
         superTypeParameters:
           superClass?.typeParameters == null
             ? undefined
@@ -1057,6 +1090,16 @@ const getTransforms = (
             | TSESTree.TSTypeAliasDeclaration
           ),
           TSESTree.ExportDefaultDeclaration,
+        ]
+      | [
+          (
+            | TSESTree.VariableDeclaration
+            | TSESTree.ClassDeclaration
+            | TSESTree.TSDeclareFunction
+            | TSESTree.TSTypeAliasDeclaration
+          ),
+          TSESTree.TSTypeAliasDeclaration,
+          TSESTree.ExportDefaultDeclaration,
         ] {
       if (node.default === true) {
         const declaration = node.declaration;
@@ -1204,6 +1247,38 @@ const getTransforms = (
             // intentional fallthrough to the "default" handling
           }
 
+          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: {
             /*
             flow allows syntax like
@@ -1243,6 +1318,29 @@ const getTransforms = (
                 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,
@@ -1343,9 +1441,66 @@ const getTransforms = (
             }
           })();
 
-          return declarations.map(
-            ({declaration, exportKind}) =>
-              ({
+          const mappedDeclarations: Array<
+            | TSESTree.ExportNamedDeclaration
+            | Array<TSESTree.ExportNamedDeclaration>,
+          > = declarations.map(({declaration, exportKind}) => {
+            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: TSESTree.ExportNamedDeclarationWithoutSourceWithSingle =
+              {
                 type: 'ExportNamedDeclaration',
                 loc: DUMMY_LOC,
                 // flow does not currently support assertions
@@ -1354,8 +1509,11 @@ const getTransforms = (
                 exportKind,
                 source: null,
                 specifiers: [],
-              }: TSESTree.ExportNamedDeclarationWithoutSourceWithSingle),
-          );
+              };
+            return exportNamedDeclaration;
+          });
+
+          return mappedDeclarations.flat();
         } else {
           return ({
             type: 'ExportNamedDeclaration',
@@ -1611,6 +1769,50 @@ const getTransforms = (
       // 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,
@@ -1971,6 +2173,37 @@ const getTransforms = (
           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': {
           // `$Diff<A, B>` => `Pick<A, Exclude<keyof A, keyof B>>`
@@ -2545,8 +2778,8 @@ const getTransforms = (
               },
             };
           }
-          // 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':
             return {
@@ -2559,7 +2792,7 @@ const getTransforms = (
                 right: {
                   type: 'Identifier',
                   loc: DUMMY_LOC,
-                  name: `ElementRef`,
+                  name: `ComponentRef`,
                 },
               },
               typeParameters: {
@@ -2587,7 +2820,7 @@ const getTransforms = (
                 },
               },
             };
-          // React.MixedElement -> JSX.Element
+          // React.MixedElement -> React.JSX.Element
           case 'React$MixedElement':
           case 'React.MixedElement': {
             assertHasExactlyNTypeParameters(0);
@@ -2598,9 +2831,18 @@ const getTransforms = (
                 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',
@@ -2742,8 +2984,8 @@ const getTransforms = (
               },
             };
           }
-          // 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': {
             const [param] = assertHasExactlyNTypeParameters(1);
@@ -2754,9 +2996,18 @@ const getTransforms = (
                 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',
@@ -2963,8 +3214,10 @@ const getTransforms = (
       return {
         type: 'TSInterfaceHeritage',
         loc: DUMMY_LOC,
-        // Bug: node.id can be qualified
-        expression: transform.Identifier((node.id: $FlowFixMe), false),
+        expression:
+          node.id.type === 'QualifiedTypeIdentifier'
+            ? transform.QualifiedTypeIdentifier(node.id)
+            : transform.Identifier(node.id, false),
         typeParameters:
           node.typeParameters == null
             ? undefined
@@ -3255,8 +3508,8 @@ const getTransforms = (
         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 };
         ```
@@ -3285,7 +3538,10 @@ const getTransforms = (
             }
 
             const spreadType = transformTypeAnnotationType(property.argument);
-            if (spreadType.type !== 'TSTypeReference') {
+            if (
+              spreadType.type !== 'TSTypeReference' &&
+              spreadType.type !== 'TSTypeQuery'
+            ) {
               return unsupportedAnnotation(
                 property,
                 'object types with complex spreads',
@@ -3334,14 +3590,22 @@ const getTransforms = (
               params: [
                 currentType,
                 {
-                  type: 'TSTypeOperator',
+                  type: 'TSUnionType',
                   loc: DUMMY_LOC,
-                  operator: 'keyof',
-                  typeAnnotation: {
-                    type: 'TSUnionType',
-                    loc: DUMMY_LOC,
-                    types: [...remainingTypes, objectType],
-                  },
+                  types: [
+                    ...remainingTypes.map(t => ({
+                      type: 'TSTypeOperator',
+                      loc: DUMMY_LOC,
+                      operator: 'keyof',
+                      typeAnnotation: t,
+                    })),
+                    {
+                      type: 'TSTypeOperator',
+                      loc: DUMMY_LOC,
+                      operator: 'keyof',
+                      typeAnnotation: objectType,
+                    },
+                  ],
                 },
               ],
             },
@@ -3371,7 +3635,38 @@ const getTransforms = (
     },
     ObjectTypeIndexer(
       node: FlowESTree.ObjectTypeIndexer,
-    ): TSESTree.TSIndexSignature {
+    ): TSESTree.TSIndexSignature | TSESTree.TSPropertySignatureComputedName {
+      if (node.key.type === 'GenericTypeAnnotation') {
+        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?.kind === 'plus',
+          static: node.static,
+          typeAnnotation: {
+            type: 'TSTypeAnnotation',
+            loc: DUMMY_LOC,
+            typeAnnotation: transformTypeAnnotationType(node.value),
+          },
+        };
+      }
       return {
         type: 'TSIndexSignature',
         loc: DUMMY_LOC,