flow-api-translator 0.10.0 → 0.10.1

package/dist/flowDefToTSDef.js

@@ -103,7 +103,7 @@ const getTransforms = (code, scopeManager) => {
 
 
     if (variableDef == null) {
-      return VALID_REACT_IMPORTS.has(id.name);
+      return VALID_REACT_IMPORTS.has(id.name) || id.name.startsWith('React$');
     }
 
     const def = variableDef.defs[0]; // Detect:
@@ -421,50 +421,48 @@ const getTransforms = (code, scopeManager) => {
               if (referencedId.type === 'Identifier') {
                 const exportedVar = topScope.set.get(referencedId.name);
 
-                if (exportedVar == null || exportedVar.defs.length !== 1) {
-                  throw unexpectedTranslationError(referencedId, `Unable to find exported variable ${referencedId.name}`);
-                }
-
-                const def = exportedVar.defs[0];
+                if (exportedVar != null && exportedVar.defs.length === 1) {
+                  const def = exportedVar.defs[0];
 
-                switch (def.type) {
-                  case 'ImportBinding':
-                    {
-                      // `import type { Wut } from 'mod'; declare export default Wut;`
-                      // `import { type Wut } from 'mod'; declare export default Wut;`
-                      // these cases should be wrapped in a variable because they're exporting a type, not a value
-                      const specifier = def.node;
+                  switch (def.type) {
+                    case 'ImportBinding':
+                      {
+                        // `import type { Wut } from 'mod'; declare export default Wut;`
+                        // `import { type Wut } from 'mod'; declare export default Wut;`
+                        // these cases should be wrapped in a variable because they're exporting a type, not a value
+                        const specifier = def.node;
 
-                      if (specifier.importKind === 'type' || specifier.parent.importKind === 'type') {
-                        // fallthrough to the "default" handling
-                        break;
-                      } // intentional fallthrough to the "value" handling
+                        if (specifier.importKind === 'type' || specifier.parent.importKind === 'type') {
+                          // fallthrough to the "default" handling
+                          break;
+                        } // intentional fallthrough to the "value" handling
 
-                    }
+                      }
 
-                  case 'ClassName':
-                  case 'Enum':
-                  case 'FunctionName':
-                  case 'ImplicitGlobalVariable':
-                  case 'Variable':
-                    // there's already a variable defined to hold the type
-                    return {
-                      type: 'ExportDefaultDeclaration',
-                      declaration: {
-                        type: 'Identifier',
-                        name: referencedId.name
-                      },
-                      exportKind: 'value'
-                    };
-
-                  case 'CatchClause':
-                  case 'Parameter':
-                  case 'TypeParameter':
-                    throw translationError(def.node, `Unexpected variable def type: ${def.type}`);
-
-                  case 'Type':
-                    // fallthrough to the "default" handling
-                    break;
+                    case 'ClassName':
+                    case 'Enum':
+                    case 'FunctionName':
+                    case 'ImplicitGlobalVariable':
+                    case 'Variable':
+                      // there's already a variable defined to hold the type
+                      return {
+                        type: 'ExportDefaultDeclaration',
+                        declaration: {
+                          type: 'Identifier',
+                          name: referencedId.name
+                        },
+                        exportKind: 'value'
+                      };
+
+                    case 'CatchClause':
+                    case 'Parameter':
+                    case 'TypeParameter':
+                      throw translationError(def.node, `Unexpected variable def type: ${def.type}`);
+
+                    case 'Type':
+                      // fallthrough to the "default" handling
+                      break;
+                  }
                 }
               } // intentional fallthrough to the "default" handling
 
@@ -1361,14 +1359,6 @@ const getTransforms = (code, scopeManager) => {
             };
           }
 
-        case '$Subtype':
-        case '$Supertype':
-          {
-            // These types are deprecated and shouldn't be used in any modern code
-            // so let's not even bother trying to figure it out
-            throw unsupportedTranslationError(node, fullTypeName);
-          }
-
         case '$Values':
           {
             // `$Values<T>` => `T[keyof T]`
@@ -1422,8 +1412,32 @@ const getTransforms = (code, scopeManager) => {
 
 
       if (isReactImport(baseId)) {
+        const reactId = {
+          type: 'Identifier',
+          name: `React`
+        };
+
         switch (fullTypeName) {
+          case 'React$Context':
+          case 'React.Context':
+            return {
+              type: 'TSTypeReference',
+              typeName: {
+                type: 'TSQualifiedName',
+                left: reactId,
+                right: {
+                  type: 'Identifier',
+                  name: `Context`
+                }
+              },
+              typeParameters: {
+                type: 'TSTypeParameterInstantiation',
+                params: assertHasExactlyNTypeParameters(1)
+              }
+            };
           // React.Node -> React.ReactNode
+
+          case 'React$Node':
           case 'React.Node':
             {
               assertHasExactlyNTypeParameters(0);
@@ -1431,7 +1445,7 @@ const getTransforms = (code, scopeManager) => {
                 type: 'TSTypeReference',
                 typeName: {
                   type: 'TSQualifiedName',
-                  left: transform.Identifier(baseId, false),
+                  left: reactId,
                   right: {
                     type: 'Identifier',
                     name: `ReactNode`
@@ -1442,13 +1456,14 @@ const getTransforms = (code, scopeManager) => {
             }
           // React.Element<typeof Component> -> React.ReactElement<typeof Component>
 
+          case 'React$Element':
           case 'React.Element':
             {
               return {
                 type: 'TSTypeReference',
                 typeName: {
                   type: 'TSQualifiedName',
-                  left: transform.Identifier(baseId, false),
+                  left: reactId,
                   right: {
                     type: 'Identifier',
                     name: `ReactElement`
@@ -1460,8 +1475,46 @@ const getTransforms = (code, scopeManager) => {
                 }
               };
             }
+          // React.ElementRef<typeof Component> -> React.ElementRef<typeof Component>
+          // React$ElementRef<typeof Component> -> React.ElementRef<typeof Component>
+
+          case 'React$ElementRef':
+          case 'React.ElementRef':
+            return {
+              type: 'TSTypeReference',
+              typeName: {
+                type: 'TSQualifiedName',
+                left: reactId,
+                right: {
+                  type: 'Identifier',
+                  name: `ElementRef`
+                }
+              },
+              typeParameters: {
+                type: 'TSTypeParameterInstantiation',
+                params: assertHasExactlyNTypeParameters(1)
+              }
+            };
+          // React$Fragment -> React.Fragment
+          // React.Fragment -> React.Fragment
+
+          case 'React$FragmentType':
+          case 'React.Fragment':
+            assertHasExactlyNTypeParameters(0);
+            return {
+              type: 'TSTypeReference',
+              typeName: {
+                type: 'TSQualifiedName',
+                left: reactId,
+                right: {
+                  type: 'Identifier',
+                  name: `Fragment`
+                }
+              }
+            };
           // React.MixedElement -> JSX.Element
 
+          case 'React$MixedElement':
           case 'React.MixedElement':
             {
               assertHasExactlyNTypeParameters(0);
@@ -1481,10 +1534,16 @@ const getTransforms = (code, scopeManager) => {
                 typeParameters: undefined
               };
             }
-          // React.AbstractComponent<Config> -> React.ForwardRefExoticComponent<Config>
+          // React.AbstractComponent<Config> -> React.ForwardRefExoticComponent<Config & React.RefAttributes<unknown>>
           // React.AbstractComponent<Config, Instance> -> React.ForwardRefExoticComponent<Config & React.RefAttributes<Instance>>
+          // React$AbstractComponent<Config, Instance> -> React.ForwardRefExoticComponent<Config & React.RefAttributes<Instance>>
+          // React.ComponentType<Config> -> React.ForwardRefExoticComponent<Config & React.RefAttributes<unknown>>
+          // React$ComponentType<Config> -> React.ForwardRefExoticComponent<Config & React.RefAttributes<unknown>>
 
           case 'React.AbstractComponent':
+          case 'React$AbstractComponent':
+          case 'React.ComponentType':
+          case 'React$ComponentType':
             {
               const typeParameters = node.typeParameters;
 
@@ -1499,36 +1558,34 @@ const getTransforms = (code, scopeManager) => {
               }
 
               let newTypeParam = transform.TypeAnnotationType(params[0]);
-
-              if (params[1] != null) {
-                newTypeParam = {
-                  type: 'TSIntersectionType',
-                  types: [newTypeParam, {
-                    type: 'TSTypeReference',
-                    typeName: {
-                      type: 'TSQualifiedName',
-                      left: {
-                        type: 'Identifier',
-                        name: 'React'
-                      },
-                      right: {
-                        type: 'Identifier',
-                        name: 'RefAttributes'
-                      }
+              newTypeParam = {
+                type: 'TSIntersectionType',
+                types: [newTypeParam, {
+                  type: 'TSTypeReference',
+                  typeName: {
+                    type: 'TSQualifiedName',
+                    left: {
+                      type: 'Identifier',
+                      name: 'React'
                     },
-                    typeParameters: {
-                      type: 'TSTypeParameterInstantiation',
-                      params: [transform.TypeAnnotationType(params[1])]
+                    right: {
+                      type: 'Identifier',
+                      name: 'RefAttributes'
                     }
-                  }]
-                };
-              }
-
+                  },
+                  typeParameters: {
+                    type: 'TSTypeParameterInstantiation',
+                    params: [params[1] ? transform.TypeAnnotationType(params[1]) : {
+                      type: 'TSUnknownKeyword'
+                    }]
+                  }
+                }]
+              };
               return {
                 type: 'TSTypeReference',
                 typeName: {
                   type: 'TSQualifiedName',
-                  left: transform.Identifier(baseId, false),
+                  left: reactId,
                   right: {
                     type: 'Identifier',
                     name: `ForwardRefExoticComponent`
@@ -1540,6 +1597,9 @@ const getTransforms = (code, scopeManager) => {
                 }
               };
             }
+
+          default:
+            throw unsupportedTranslationError(node, fullTypeName);
         }
       }
 
@@ -1610,8 +1670,6 @@ const getTransforms = (code, scopeManager) => {
         importKind: importKind != null ? importKind : 'value',
         source: transform.StringLiteral(node.source),
         specifiers: node.specifiers.map(spec => {
-          var _spec$importKind;
-
           switch (spec.type) {
             case 'ImportDefaultSpecifier':
               return {
@@ -1633,7 +1691,7 @@ const getTransforms = (code, scopeManager) => {
 
               return {
                 type: 'ImportSpecifier',
-                importKind: (_spec$importKind = spec.importKind) != null ? _spec$importKind : 'value',
+                importKind: spec.importKind === 'type' ? 'type' : null,
                 imported: transform.Identifier(spec.imported, false),
                 local: transform.Identifier(spec.local, false)
               };

package/dist/flowDefToTSDef.js.flow

@@ -107,7 +107,7 @@ const getTransforms = (code: string, scopeManager: ScopeManager) => {
 
     // No variable found, it must be global. Using the `React` variable is enough in this case.
     if (variableDef == null) {
-      return VALID_REACT_IMPORTS.has(id.name);
+      return VALID_REACT_IMPORTS.has(id.name) || id.name.startsWith('React$');
     }
 
     const def = variableDef.defs[0];
@@ -466,56 +466,51 @@ const getTransforms = (code: string, scopeManager: ScopeManager) => {
             // only Identifiers can be handled here.
             if (referencedId.type === 'Identifier') {
               const exportedVar = topScope.set.get(referencedId.name);
-              if (exportedVar == null || exportedVar.defs.length !== 1) {
-                throw unexpectedTranslationError(
-                  referencedId,
-                  `Unable to find exported variable ${referencedId.name}`,
-                );
-              }
-
-              const def = exportedVar.defs[0];
-              switch (def.type) {
-                case 'ImportBinding': {
-                  // `import type { Wut } from 'mod'; declare export default Wut;`
-                  // `import { type Wut } from 'mod'; declare export default Wut;`
-                  // these cases should be wrapped in a variable because they're exporting a type, not a value
-                  const specifier = def.node;
-                  if (
-                    specifier.importKind === 'type' ||
-                    specifier.parent.importKind === 'type'
-                  ) {
+              if (exportedVar != null && exportedVar.defs.length === 1) {
+                const def = exportedVar.defs[0];
+                switch (def.type) {
+                  case 'ImportBinding': {
+                    // `import type { Wut } from 'mod'; declare export default Wut;`
+                    // `import { type Wut } from 'mod'; declare export default Wut;`
+                    // these cases should be wrapped in a variable because they're exporting a type, not a value
+                    const specifier = def.node;
+                    if (
+                      specifier.importKind === 'type' ||
+                      specifier.parent.importKind === 'type'
+                    ) {
+                      // fallthrough to the "default" handling
+                      break;
+                    }
+
+                    // intentional fallthrough to the "value" handling
+                  }
+                  case 'ClassName':
+                  case 'Enum':
+                  case 'FunctionName':
+                  case 'ImplicitGlobalVariable':
+                  case 'Variable':
+                    // there's already a variable defined to hold the type
+                    return {
+                      type: 'ExportDefaultDeclaration',
+                      declaration: {
+                        type: 'Identifier',
+                        name: referencedId.name,
+                      },
+                      exportKind: 'value',
+                    };
+
+                  case 'CatchClause':
+                  case 'Parameter':
+                  case 'TypeParameter':
+                    throw translationError(
+                      def.node,
+                      `Unexpected variable def type: ${def.type}`,
+                    );
+
+                  case 'Type':
                     // fallthrough to the "default" handling
                     break;
-                  }
-
-                  // intentional fallthrough to the "value" handling
                 }
-                case 'ClassName':
-                case 'Enum':
-                case 'FunctionName':
-                case 'ImplicitGlobalVariable':
-                case 'Variable':
-                  // there's already a variable defined to hold the type
-                  return {
-                    type: 'ExportDefaultDeclaration',
-                    declaration: {
-                      type: 'Identifier',
-                      name: referencedId.name,
-                    },
-                    exportKind: 'value',
-                  };
-
-                case 'CatchClause':
-                case 'Parameter':
-                case 'TypeParameter':
-                  throw translationError(
-                    def.node,
-                    `Unexpected variable def type: ${def.type}`,
-                  );
-
-                case 'Type':
-                  // fallthrough to the "default" handling
-                  break;
               }
             }
 
@@ -1498,13 +1493,6 @@ const getTransforms = (code: string, scopeManager: ScopeManager) => {
           };
         }
 
-        case '$Subtype':
-        case '$Supertype': {
-          // These types are deprecated and shouldn't be used in any modern code
-          // so let's not even bother trying to figure it out
-          throw unsupportedTranslationError(node, fullTypeName);
-        }
-
         case '$Values': {
           // `$Values<T>` => `T[keyof T]`
           const transformedType = assertHasExactlyNTypeParameters(1)[0];
@@ -1560,15 +1548,38 @@ const getTransforms = (code: string, scopeManager: ScopeManager) => {
 
       // React special conversion:
       if (isReactImport(baseId)) {
+        const reactId = {
+          type: 'Identifier',
+          name: `React`,
+        };
+
         switch (fullTypeName) {
+          case 'React$Context':
+          case 'React.Context':
+            return {
+              type: 'TSTypeReference',
+              typeName: {
+                type: 'TSQualifiedName',
+                left: reactId,
+                right: {
+                  type: 'Identifier',
+                  name: `Context`,
+                },
+              },
+              typeParameters: {
+                type: 'TSTypeParameterInstantiation',
+                params: assertHasExactlyNTypeParameters(1),
+              },
+            };
           // React.Node -> React.ReactNode
+          case 'React$Node':
           case 'React.Node': {
             assertHasExactlyNTypeParameters(0);
             return {
               type: 'TSTypeReference',
               typeName: {
                 type: 'TSQualifiedName',
-                left: transform.Identifier(baseId, false),
+                left: reactId,
                 right: {
                   type: 'Identifier',
                   name: `ReactNode`,
@@ -1578,12 +1589,13 @@ const getTransforms = (code: string, scopeManager: ScopeManager) => {
             };
           }
           // React.Element<typeof Component> -> React.ReactElement<typeof Component>
+          case 'React$Element':
           case 'React.Element': {
             return {
               type: 'TSTypeReference',
               typeName: {
                 type: 'TSQualifiedName',
-                left: transform.Identifier(baseId, false),
+                left: reactId,
                 right: {
                   type: 'Identifier',
                   name: `ReactElement`,
@@ -1595,7 +1607,43 @@ const getTransforms = (code: string, scopeManager: ScopeManager) => {
               },
             };
           }
+          // React.ElementRef<typeof Component> -> React.ElementRef<typeof Component>
+          // React$ElementRef<typeof Component> -> React.ElementRef<typeof Component>
+          case 'React$ElementRef':
+          case 'React.ElementRef':
+            return {
+              type: 'TSTypeReference',
+              typeName: {
+                type: 'TSQualifiedName',
+                left: reactId,
+                right: {
+                  type: 'Identifier',
+                  name: `ElementRef`,
+                },
+              },
+              typeParameters: {
+                type: 'TSTypeParameterInstantiation',
+                params: assertHasExactlyNTypeParameters(1),
+              },
+            };
+          // React$Fragment -> React.Fragment
+          // React.Fragment -> React.Fragment
+          case 'React$FragmentType':
+          case 'React.Fragment':
+            assertHasExactlyNTypeParameters(0);
+            return {
+              type: 'TSTypeReference',
+              typeName: {
+                type: 'TSQualifiedName',
+                left: reactId,
+                right: {
+                  type: 'Identifier',
+                  name: `Fragment`,
+                },
+              },
+            };
           // React.MixedElement -> JSX.Element
+          case 'React$MixedElement':
           case 'React.MixedElement': {
             assertHasExactlyNTypeParameters(0);
             return {
@@ -1614,9 +1662,15 @@ const getTransforms = (code: string, scopeManager: ScopeManager) => {
               typeParameters: undefined,
             };
           }
-          // React.AbstractComponent<Config> -> React.ForwardRefExoticComponent<Config>
+          // React.AbstractComponent<Config> -> React.ForwardRefExoticComponent<Config & React.RefAttributes<unknown>>
           // React.AbstractComponent<Config, Instance> -> React.ForwardRefExoticComponent<Config & React.RefAttributes<Instance>>
-          case 'React.AbstractComponent': {
+          // React$AbstractComponent<Config, Instance> -> React.ForwardRefExoticComponent<Config & React.RefAttributes<Instance>>
+          // React.ComponentType<Config> -> React.ForwardRefExoticComponent<Config & React.RefAttributes<unknown>>
+          // React$ComponentType<Config> -> React.ForwardRefExoticComponent<Config & React.RefAttributes<unknown>>
+          case 'React.AbstractComponent':
+          case 'React$AbstractComponent':
+          case 'React.ComponentType':
+          case 'React$ComponentType': {
             const typeParameters = node.typeParameters;
             if (typeParameters == null || typeParameters.params.length === 0) {
               throw translationError(
@@ -1633,38 +1687,42 @@ const getTransforms = (code: string, scopeManager: ScopeManager) => {
             }
 
             let newTypeParam = transform.TypeAnnotationType(params[0]);
-            if (params[1] != null) {
-              newTypeParam = {
-                type: 'TSIntersectionType',
-                types: [
-                  newTypeParam,
-                  {
-                    type: 'TSTypeReference',
-                    typeName: {
-                      type: 'TSQualifiedName',
-                      left: {
-                        type: 'Identifier',
-                        name: 'React',
-                      },
-                      right: {
-                        type: 'Identifier',
-                        name: 'RefAttributes',
-                      },
+            newTypeParam = {
+              type: 'TSIntersectionType',
+              types: [
+                newTypeParam,
+                {
+                  type: 'TSTypeReference',
+                  typeName: {
+                    type: 'TSQualifiedName',
+                    left: {
+                      type: 'Identifier',
+                      name: 'React',
                     },
-                    typeParameters: {
-                      type: 'TSTypeParameterInstantiation',
-                      params: [transform.TypeAnnotationType(params[1])],
+                    right: {
+                      type: 'Identifier',
+                      name: 'RefAttributes',
                     },
                   },
-                ],
-              };
-            }
+                  typeParameters: {
+                    type: 'TSTypeParameterInstantiation',
+                    params: [
+                      params[1]
+                        ? transform.TypeAnnotationType(params[1])
+                        : {
+                            type: 'TSUnknownKeyword',
+                          },
+                    ],
+                  },
+                },
+              ],
+            };
 
             return {
               type: 'TSTypeReference',
               typeName: {
                 type: 'TSQualifiedName',
-                left: transform.Identifier(baseId, false),
+                left: reactId,
                 right: {
                   type: 'Identifier',
                   name: `ForwardRefExoticComponent`,
@@ -1676,6 +1734,8 @@ const getTransforms = (code: string, scopeManager: ScopeManager) => {
               },
             };
           }
+          default:
+            throw unsupportedTranslationError(node, fullTypeName);
         }
       }
 
@@ -1787,7 +1847,7 @@ const getTransforms = (code: string, scopeManager: ScopeManager) => {
               }
               return {
                 type: 'ImportSpecifier',
-                importKind: spec.importKind ?? 'value',
+                importKind: spec.importKind === 'type' ? 'type' : null,
                 imported: transform.Identifier(spec.imported, false),
                 local: transform.Identifier(spec.local, false),
               };

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

@@ -650,7 +650,7 @@ export interface ImportSpecifier extends BaseNode {
   +type: 'ImportSpecifier';
   +local: Identifier;
   +imported: Identifier;
-  +importKind: ImportKind;
+  +importKind: ?ImportKind;
 }
 export type IterationStatement =
   | DoWhileStatement

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flow-api-translator",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "Toolkit for creating Flow and TypeScript compatible libraries from Flow source code.",
   "main": "dist/index.js",
   "license": "MIT",
@@ -12,9 +12,10 @@
     "@babel/code-frame": "^7.16.0",
     "@typescript-eslint/visitor-keys": "^5.42.0",
     "flow-enums-runtime": "^0.0.6",
-    "hermes-estree": "0.10.0",
-    "hermes-parser": "0.10.0",
-    "hermes-transform": "0.10.0"
+    "hermes-eslint": "0.10.1",
+    "hermes-estree": "0.10.1",
+    "hermes-parser": "0.10.1",
+    "hermes-transform": "0.10.1"
   },
   "peerDependencies": {
     "prettier": "^2.7.1"