flow-api-translator 0.26.0 → 0.27.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,25 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             return unsupportedAnnotation(node, fullTypeName);
           }
 
+        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':
           {
@@ -2393,7 +2587,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }
               }
             };
-          // React.MixedElement -> JSX.Element
+          // React.MixedElement -> React.JSX.Element
 
           case 'React$MixedElement':
           case 'React.MixedElement':
@@ -2406,9 +2600,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 +2750,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 +2764,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 +2950,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)
       };
     },
@@ -3024,7 +3235,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');
             }
 
@@ -3100,7 +3311,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 +3359,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 +3370,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 +3418,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',

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,24 @@ const getTransforms = (
           return unsupportedAnnotation(node, fullTypeName);
         }
 
+        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>>`
@@ -2587,7 +2807,7 @@ const getTransforms = (
                 },
               },
             };
-          // React.MixedElement -> JSX.Element
+          // React.MixedElement -> React.JSX.Element
           case 'React$MixedElement':
           case 'React.MixedElement': {
             assertHasExactlyNTypeParameters(0);
@@ -2598,9 +2818,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 +2971,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 +2983,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 +3201,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
@@ -3285,7 +3525,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',
@@ -3371,7 +3614,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,

package/dist/flowToFlowDef.js

@@ -69,9 +69,9 @@ function transferProgramStatementProperties(stmt, orgStmt) {
   stmt.loc = orgStmt.loc;
 }
 /**
- * Consume an abribray Flow AST and convert it into a Type defintion file.
+ * Consume an arbitrary Flow AST and convert it into a type definition file.
  *
- * To do this all runtime logic will be stripped and only Type that describe the module boundary will remain.
+ * To do this all runtime logic will be stripped and only types that describe the module boundary will remain.
  */
 
 
@@ -355,8 +355,8 @@ function convertExpressionToTypeAnnotation(expr, context) {
 
     case 'Identifier':
       {
-        return [_hermesTransform.t.GenericTypeAnnotation({
-          id: _hermesTransform.t.Identifier({
+        return [_hermesTransform.t.TypeofTypeAnnotation({
+          argument: _hermesTransform.t.Identifier({
             name: expr.name
           })
         }), (0, _FlowAnalyze.analyzeTypeDependencies)(expr, context)];
@@ -381,6 +381,13 @@ function convertExpressionToTypeAnnotation(expr, context) {
         return [resultExpr, deps];
       }
 
+    case 'MemberExpression':
+      {
+        return [_hermesTransform.t.TypeofTypeAnnotation({
+          argument: convertExpressionToTypeofIdentifier(expr, context)
+        }), (0, _FlowAnalyze.analyzeTypeDependencies)(expr, context)];
+      }
+
     default:
       {
         return [(0, _ErrorUtils.flowFixMeOrError)(expr, `convertExpressionToTypeAnnotation: Unsupported expression of type "${expr.type}", a type annotation is required.`, context), []];
@@ -388,6 +395,12 @@ function convertExpressionToTypeAnnotation(expr, context) {
   }
 }
 
+function inheritComments(fromNode, toNode) {
+  // $FlowFixMe[unclear-type]
+  toNode.comments = fromNode.comments;
+  return toNode;
+}
+
 function convertObjectExpression(expr, context) {
   const [resultProperties, deps] = convertArray(expr.properties, prop => {
     switch (prop.type) {
@@ -411,11 +424,11 @@ function convertObjectExpression(expr, context) {
             }
 
             const [resultExpr, deps] = convertAFunction(prop.value, context);
-            return [_hermesTransform.t.ObjectTypeMethodSignature({
+            return [inheritComments(prop, _hermesTransform.t.ObjectTypeMethodSignature({
               // $FlowFixMe[incompatible-call]
               key: (0, _hermesTransform.asDetachedNode)(prop.key),
               value: resultExpr
-            }), deps];
+            })), deps];
           }
 
           if (prop.kind === 'get' || prop.kind === 'set') {
@@ -425,22 +438,22 @@ function convertObjectExpression(expr, context) {
 
             const kind = prop.kind;
             const [resultExpr, deps] = convertAFunction(prop.value, context);
-            return [_hermesTransform.t.ObjectTypeAccessorSignature({
+            return [inheritComments(prop, _hermesTransform.t.ObjectTypeAccessorSignature({
               // $FlowFixMe[incompatible-call]
               key: (0, _hermesTransform.asDetachedNode)(prop.key),
               kind,
               value: resultExpr
-            }), deps];
+            })), deps];
           }
 
           const [resultExpr, deps] = convertExpressionToTypeAnnotation(prop.value, context);
-          return [_hermesTransform.t.ObjectTypePropertySignature({
+          return [inheritComments(prop, _hermesTransform.t.ObjectTypePropertySignature({
             // $FlowFixMe[incompatible-call]
             key: (0, _hermesTransform.asDetachedNode)(prop.key),
             value: resultExpr,
             optional: false,
             variance: null
-          }), deps];
+          })), deps];
         }
     }
   });
@@ -777,6 +790,32 @@ function convertExpressionToIdentifier(node, context) {
   throw (0, _ErrorUtils.translationError)(node, `Expected ${node.type} to be an Identifier or Member with Identifier property, non-Super object.`, context);
 }
 
+function convertExpressionToTypeofIdentifier(node, context) {
+  if (node.type === 'Identifier') {
+    return _hermesTransform.t.Identifier({
+      name: node.name
+    });
+  }
+
+  if (node.type === 'MemberExpression') {
+    const {
+      property,
+      object
+    } = node;
+
+    if (property.type === 'Identifier' && object.type !== 'Super') {
+      return _hermesTransform.t.QualifiedTypeofIdentifier({
+        qualification: convertExpressionToTypeofIdentifier(object, context),
+        id: _hermesTransform.t.Identifier({
+          name: property.name
+        })
+      });
+    }
+  }
+
+  throw (0, _ErrorUtils.translationError)(node, `Expected ${node.type} to be an Identifier or Member with Identifier property, non-Super object.`, context);
+}
+
 function convertSuperClassHelper(detachedId, nodeForDependencies, superTypeParameters, context) {
   const [resultTypeParams, typeParamsDeps] = convertTypeParameterInstantiationOrNull(superTypeParameters, context);
   const superDeps = (0, _FlowAnalyze.analyzeTypeDependencies)(nodeForDependencies, context);
@@ -845,6 +884,8 @@ function convertClassMember(member, context) {
   switch (member.type) {
     case 'PropertyDefinition':
       {
+        var _member$value;
+
         // PrivateIdentifier's are not exposed so can be stripped.
         if (member.key.type === 'PrivateIdentifier') {
           return EMPTY_TRANSLATION_RESULT;
@@ -854,6 +895,18 @@ function convertClassMember(member, context) {
           throw (0, _ErrorUtils.translationError)(member.key, `ClassMember PropertyDefinition: Unsupported key type of "${member.key.type}"`, context);
         }
 
+        if (((_member$value = member.value) == null ? void 0 : _member$value.type) === 'ArrowFunctionExpression' && member.typeAnnotation == null) {
+          const [resultTypeAnnotation, deps] = convertAFunction(member.value, context);
+          return [_hermesTransform.t.ObjectTypePropertySignature({
+            // $FlowFixMe[incompatible-call]
+            key: (0, _hermesTransform.asDetachedNode)(member.key),
+            value: resultTypeAnnotation,
+            optional: member.optional,
+            static: member.static,
+            variance: member.variance
+          }), deps];
+        }
+
         const [resultTypeAnnotation, deps] = convertTypeAnnotation(member.typeAnnotation, member, context);
         return [_hermesTransform.t.ObjectTypePropertySignature({
           // $FlowFixMe[incompatible-call]
@@ -872,18 +925,21 @@ function convertClassMember(member, context) {
           return EMPTY_TRANSLATION_RESULT;
         }
 
-        if (!(0, _hermesEstree.isIdentifier)(member.key) && !(0, _hermesEstree.isStringLiteral)(member.key) && !(0, _hermesEstree.isNumericLiteral)(member.key)) {
+        if (!(0, _hermesEstree.isIdentifier)(member.key) && !(0, _hermesEstree.isStringLiteral)(member.key) && !(0, _hermesEstree.isNumericLiteral)(member.key) && !((0, _hermesEstree.isMemberExpressionWithNonComputedProperty)(member.key) && member.key.object.type === 'Identifier' && member.key.object.name === 'Symbol' && ['iterator', 'asyncIterator'].includes(member.key.property.name))) {
           throw (0, _ErrorUtils.translationError)(member.key, `ClassMember PropertyDefinition: Unsupported key type of "${member.key.type}"`, context);
         }
 
         const [resultValue, deps] = convertAFunction(member.value, context);
+        const newKey = (0, _hermesEstree.isMemberExpressionWithNonComputedProperty)(member.key) && member.key.object.type === 'Identifier' && member.key.object.name === 'Symbol' ? _hermesTransform.t.Identifier({
+          name: `@@${member.key.property.name}`
+        }) : member.key;
 
         if (member.kind === 'get' || member.kind === 'set') {
           // accessors are methods - but flow accessor signatures are properties
           const kind = member.kind;
           return [_hermesTransform.t.ObjectTypeAccessorSignature({
             // $FlowFixMe[incompatible-call]
-            key: (0, _hermesTransform.asDetachedNode)(member.key),
+            key: (0, _hermesTransform.asDetachedNode)(newKey),
             value: resultValue,
             static: member.static,
             kind
@@ -892,7 +948,7 @@ function convertClassMember(member, context) {
 
         return [_hermesTransform.t.ObjectTypeMethodSignature({
           // $FlowFixMe[incompatible-call]
-          key: (0, _hermesTransform.asDetachedNode)(member.key),
+          key: (0, _hermesTransform.asDetachedNode)(newKey),
           value: resultValue,
           static: member.static
         }), deps];

package/dist/flowToFlowDef.js.flow

@@ -50,6 +50,7 @@ import type {
   ObjectTypeProperty,
   OpaqueType,
   QualifiedTypeIdentifier,
+  QualifiedTypeofIdentifier,
   Program,
   RestElement,
   Statement,
@@ -84,6 +85,7 @@ import {
   isStringLiteral,
   isNumericLiteral,
   isIdentifier,
+  isMemberExpressionWithNonComputedProperty,
 } from 'hermes-estree';
 
 const EMPTY_TRANSLATION_RESULT = [null, []];
@@ -149,9 +151,9 @@ function transferProgramStatementProperties(
 }
 
 /**
- * Consume an abribray Flow AST and convert it into a Type defintion file.
+ * Consume an arbitrary Flow AST and convert it into a type definition file.
  *
- * To do this all runtime logic will be stripped and only Type that describe the module boundary will remain.
+ * To do this all runtime logic will be stripped and only types that describe the module boundary will remain.
  */
 export default function flowToFlowDef(
   ast: Program,
@@ -443,7 +445,7 @@ function convertExpressionToTypeAnnotation(
     }
     case 'Identifier': {
       return [
-        t.GenericTypeAnnotation({id: t.Identifier({name: expr.name})}),
+        t.TypeofTypeAnnotation({argument: t.Identifier({name: expr.name})}),
         analyzeTypeDependencies(expr, context),
       ];
     }
@@ -460,6 +462,14 @@ function convertExpressionToTypeAnnotation(
       const [resultExpr, deps] = convertAFunction(expr, context);
       return [resultExpr, deps];
     }
+    case 'MemberExpression': {
+      return [
+        t.TypeofTypeAnnotation({
+          argument: convertExpressionToTypeofIdentifier(expr, context),
+        }),
+        analyzeTypeDependencies(expr, context),
+      ];
+    }
     default: {
       return [
         flowFixMeOrError(
@@ -473,6 +483,15 @@ function convertExpressionToTypeAnnotation(
   }
 }
 
+function inheritComments<T: DetachedNode<ESNode>>(
+  fromNode: ESNode,
+  toNode: T,
+): T {
+  // $FlowFixMe[unclear-type]
+  (toNode: any).comments = (fromNode: any).comments;
+  return toNode;
+}
+
 function convertObjectExpression(
   expr: ObjectExpression,
   context: TranslationContext,
@@ -513,13 +532,16 @@ function convertObjectExpression(
 
           const [resultExpr, deps] = convertAFunction(prop.value, context);
           return [
-            t.ObjectTypeMethodSignature({
-              // $FlowFixMe[incompatible-call]
-              key: asDetachedNode<
-                Identifier | NumericLiteral | StringLiteral | Expression,
-              >(prop.key),
-              value: resultExpr,
-            }),
+            inheritComments(
+              prop,
+              t.ObjectTypeMethodSignature({
+                // $FlowFixMe[incompatible-call]
+                key: asDetachedNode<
+                  Identifier | NumericLiteral | StringLiteral | Expression,
+                >(prop.key),
+                value: resultExpr,
+              }),
+            ),
             deps,
           ];
         }
@@ -539,14 +561,17 @@ function convertObjectExpression(
           const kind = prop.kind;
           const [resultExpr, deps] = convertAFunction(prop.value, context);
           return [
-            t.ObjectTypeAccessorSignature({
-              // $FlowFixMe[incompatible-call]
-              key: asDetachedNode<
-                Identifier | NumericLiteral | StringLiteral | Expression,
-              >(prop.key),
-              kind,
-              value: resultExpr,
-            }),
+            inheritComments(
+              prop,
+              t.ObjectTypeAccessorSignature({
+                // $FlowFixMe[incompatible-call]
+                key: asDetachedNode<
+                  Identifier | NumericLiteral | StringLiteral | Expression,
+                >(prop.key),
+                kind,
+                value: resultExpr,
+              }),
+            ),
             deps,
           ];
         }
@@ -557,15 +582,18 @@ function convertObjectExpression(
         );
 
         return [
-          t.ObjectTypePropertySignature({
-            // $FlowFixMe[incompatible-call]
-            key: asDetachedNode<
-              Identifier | NumericLiteral | StringLiteral | Expression,
-            >(prop.key),
-            value: resultExpr,
-            optional: false,
-            variance: null,
-          }),
+          inheritComments(
+            prop,
+            t.ObjectTypePropertySignature({
+              // $FlowFixMe[incompatible-call]
+              key: asDetachedNode<
+                Identifier | NumericLiteral | StringLiteral | Expression,
+              >(prop.key),
+              value: resultExpr,
+              optional: false,
+              variance: null,
+            }),
+          ),
           deps,
         ];
       }
@@ -1003,6 +1031,31 @@ function convertExpressionToIdentifier(
   );
 }
 
+function convertExpressionToTypeofIdentifier(
+  node: Expression,
+  context: TranslationContext,
+): DetachedNode<Identifier> | DetachedNode<QualifiedTypeofIdentifier> {
+  if (node.type === 'Identifier') {
+    return t.Identifier({name: node.name});
+  }
+
+  if (node.type === 'MemberExpression') {
+    const {property, object} = node;
+    if (property.type === 'Identifier' && object.type !== 'Super') {
+      return t.QualifiedTypeofIdentifier({
+        qualification: convertExpressionToTypeofIdentifier(object, context),
+        id: t.Identifier({name: property.name}),
+      });
+    }
+  }
+
+  throw translationError(
+    node,
+    `Expected ${node.type} to be an Identifier or Member with Identifier property, non-Super object.`,
+    context,
+  );
+}
+
 function convertSuperClassHelper(
   detachedId: DetachedNode<Identifier | QualifiedTypeIdentifier>,
   nodeForDependencies: ESNode,
@@ -1135,6 +1188,30 @@ function convertClassMember(
         );
       }
 
+      if (
+        member.value?.type === 'ArrowFunctionExpression' &&
+        member.typeAnnotation == null
+      ) {
+        const [resultTypeAnnotation, deps] = convertAFunction(
+          member.value,
+          context,
+        );
+
+        return [
+          t.ObjectTypePropertySignature({
+            // $FlowFixMe[incompatible-call]
+            key: asDetachedNode<
+              ClassPropertyNameComputed | ClassPropertyNameNonComputed,
+            >(member.key),
+            value: resultTypeAnnotation,
+            optional: member.optional,
+            static: member.static,
+            variance: member.variance,
+          }),
+          deps,
+        ];
+      }
+
       const [resultTypeAnnotation, deps] = convertTypeAnnotation(
         member.typeAnnotation,
         member,
@@ -1163,7 +1240,13 @@ function convertClassMember(
       if (
         !isIdentifier(member.key) &&
         !isStringLiteral(member.key) &&
-        !isNumericLiteral(member.key)
+        !isNumericLiteral(member.key) &&
+        !(
+          isMemberExpressionWithNonComputedProperty(member.key) &&
+          member.key.object.type === 'Identifier' &&
+          member.key.object.name === 'Symbol' &&
+          ['iterator', 'asyncIterator'].includes(member.key.property.name)
+        )
       ) {
         throw translationError(
           member.key,
@@ -1174,15 +1257,23 @@ function convertClassMember(
 
       const [resultValue, deps] = convertAFunction(member.value, context);
 
+      const newKey =
+        isMemberExpressionWithNonComputedProperty(member.key) &&
+        member.key.object.type === 'Identifier' &&
+        member.key.object.name === 'Symbol'
+          ? t.Identifier({name: `@@${member.key.property.name}`})
+          : member.key;
+
       if (member.kind === 'get' || member.kind === 'set') {
         // accessors are methods - but flow accessor signatures are properties
         const kind = member.kind;
+
         return [
           t.ObjectTypeAccessorSignature({
             // $FlowFixMe[incompatible-call]
             key: asDetachedNode<
               ClassPropertyNameComputed | ClassPropertyNameNonComputed,
-            >(member.key),
+            >(newKey),
             value: resultValue,
             static: member.static,
             kind,
@@ -1196,7 +1287,7 @@ function convertClassMember(
           // $FlowFixMe[incompatible-call]
           key: asDetachedNode<
             ClassPropertyNameComputed | ClassPropertyNameNonComputed,
-          >(member.key),
+          >(newKey),
           value: resultValue,
           static: member.static,
         }),

package/dist/utils/ts-estree-ast-types.js.flow

@@ -455,6 +455,7 @@ export type Expression =
   | TSAsExpression
   | TSInstantiationExpression
   | TSNonNullExpression
+  | TSQualifiedName
   | TSTypeAssertion
   | UnaryExpression
   | UpdateExpression
@@ -772,6 +773,7 @@ export type LeftHandSideExpression =
   | ThisExpression
   | TSAsExpression
   | TSNonNullExpression
+  | TSQualifiedName
   | TSTypeAssertion;
 export interface LineComment extends BaseToken {
   +type: 'Line';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flow-api-translator",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "description": "Toolkit for creating Flow and TypeScript compatible libraries from Flow source code.",
   "main": "dist/index.js",
   "license": "MIT",
@@ -13,10 +13,10 @@
     "@typescript-eslint/parser": "7.2.0",
     "@typescript-eslint/visitor-keys": "7.2.0",
     "flow-enums-runtime": "^0.0.6",
-    "hermes-eslint": "0.26.0",
-    "hermes-estree": "0.26.0",
-    "hermes-parser": "0.26.0",
-    "hermes-transform": "0.26.0",
+    "hermes-eslint": "0.27.0",
+    "hermes-estree": "0.27.0",
+    "hermes-parser": "0.27.0",
+    "hermes-transform": "0.27.0",
     "typescript": "5.3.2"
   },
   "peerDependencies": {