flow-api-translator 0.18.2 → 0.19.1

package/dist/flowDefToTSDef.js

@@ -944,6 +944,21 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 exportKind: 'value'
               }];
             }
+          // TS doesn't support direct default export for declare'd functions
+
+          case 'DeclareHook':
+            {
+              const functionDecl = transform.DeclareHook(declaration);
+              const name = declaration.id.name;
+              return [functionDecl, {
+                type: 'ExportDefaultDeclaration',
+                declaration: {
+                  type: 'Identifier',
+                  name
+                },
+                exportKind: 'value'
+              }];
+            }
           // Flow's declare export default Identifier is ambiguous.
           // the Identifier might reference a type, or it might reference a value
           // - If it's a value, then that's all good, TS supports that.
@@ -1077,6 +1092,12 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                   exportKind: 'value'
                 }];
 
+              case 'DeclareHook':
+                return [{
+                  declaration: transform.DeclareHook(node.declaration),
+                  exportKind: 'value'
+                }];
+
               case 'DeclareFunction':
                 return [{
                   declaration: transform.DeclareFunction(node.declaration),
@@ -1252,6 +1273,27 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       }];
     },
 
+    DeclareHook(node) {
+      // the hook params/returnType are stored as an annotation on the ID...
+      const id = transform.Identifier(node.id, false);
+      const functionInfo = transform.FunctionTypeAnnotation(node.id.typeAnnotation.typeAnnotation);
+      return {
+        type: 'TSDeclareFunction',
+        async: false,
+        body: undefined,
+        declare: true,
+        expression: false,
+        generator: false,
+        id: {
+          type: 'Identifier',
+          name: id.name
+        },
+        params: functionInfo.params,
+        returnType: functionInfo.returnType,
+        typeParameters: functionInfo.typeParameters
+      };
+    },
+
     DeclareFunction(node) {
       // the function information is stored as an annotation on the ID...
       const id = transform.Identifier(node.id, false);
@@ -1391,6 +1433,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         switch (node.declaration.type) {
           case 'ClassDeclaration':
           case 'ComponentDeclaration':
+          case 'HookDeclaration':
           case 'FunctionDeclaration':
           case 'VariableDeclaration':
             // These cases shouldn't happen in flow defs because they have their own special
@@ -1451,7 +1494,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     FunctionTypeAnnotation(node) {
       const params = node.params.map(transform.FunctionTypeParam);
 
-      if (node.this != null) {
+      if (node.type === 'FunctionTypeAnnotation' && node.this != null) {
         params.unshift({
           type: 'Identifier',
           name: 'this',
@@ -1759,7 +1802,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               },
               typeParameters: {
                 type: 'TSTypeParameterInstantiation',
-                params: assertHasExactlyNTypeParameters(1)
+                params: assertHasExactlyNTypeParameters(2)
               }
             };
           }

package/dist/flowDefToTSDef.js.flow

@@ -1034,6 +1034,23 @@ const getTransforms = (
             ];
           }
 
+          // TS doesn't support direct default export for declare'd functions
+          case 'DeclareHook': {
+            const functionDecl = transform.DeclareHook(declaration);
+            const name = declaration.id.name;
+            return [
+              functionDecl,
+              {
+                type: 'ExportDefaultDeclaration',
+                declaration: {
+                  type: 'Identifier',
+                  name,
+                },
+                exportKind: 'value',
+              },
+            ];
+          }
+
           // Flow's declare export default Identifier is ambiguous.
           // the Identifier might reference a type, or it might reference a value
           // - If it's a value, then that's all good, TS supports that.
@@ -1177,6 +1194,13 @@ const getTransforms = (
                     exportKind: 'value',
                   },
                 ];
+              case 'DeclareHook':
+                return [
+                  {
+                    declaration: transform.DeclareHook(node.declaration),
+                    exportKind: 'value',
+                  },
+                ];
               case 'DeclareFunction':
                 return [
                   {
@@ -1377,6 +1401,29 @@ const getTransforms = (
         },
       ];
     },
+    DeclareHook(node: FlowESTree.DeclareHook): TSESTree.TSDeclareFunction {
+      // the hook params/returnType are stored as an annotation on the ID...
+      const id = transform.Identifier(node.id, false);
+      const functionInfo = transform.FunctionTypeAnnotation(
+        node.id.typeAnnotation.typeAnnotation,
+      );
+
+      return {
+        type: 'TSDeclareFunction',
+        async: false,
+        body: undefined,
+        declare: true,
+        expression: false,
+        generator: false,
+        id: {
+          type: 'Identifier',
+          name: id.name,
+        },
+        params: functionInfo.params,
+        returnType: functionInfo.returnType,
+        typeParameters: functionInfo.typeParameters,
+      };
+    },
     DeclareFunction(
       node: FlowESTree.DeclareFunction,
     ): TSESTree.TSDeclareFunction {
@@ -1557,6 +1604,7 @@ const getTransforms = (
         switch (node.declaration.type) {
           case 'ClassDeclaration':
           case 'ComponentDeclaration':
+          case 'HookDeclaration':
           case 'FunctionDeclaration':
           case 'VariableDeclaration':
             // These cases shouldn't happen in flow defs because they have their own special
@@ -1617,10 +1665,10 @@ const getTransforms = (
       };
     },
     FunctionTypeAnnotation(
-      node: FlowESTree.FunctionTypeAnnotation,
+      node: FlowESTree.FunctionTypeAnnotation | FlowESTree.HookTypeAnnotation,
     ): TSESTree.TSFunctionType {
       const params = node.params.map(transform.FunctionTypeParam);
-      if (node.this != null) {
+      if (node.type === 'FunctionTypeAnnotation' && node.this != null) {
         params.unshift({
           type: 'Identifier',
           name: 'this',
@@ -1949,7 +1997,7 @@ const getTransforms = (
             },
             typeParameters: {
               type: 'TSTypeParameterInstantiation',
-              params: assertHasExactlyNTypeParameters(1),
+              params: assertHasExactlyNTypeParameters(2),
             },
           };
         }

package/dist/flowToFlowDef.js

@@ -271,6 +271,12 @@ function convertStatement(stmt, context) {
         return [result, deps];
       }
 
+    case 'HookDeclaration':
+      {
+        const [result, deps] = convertHookDeclaration(stmt, context);
+        return [result, deps];
+      }
+
     case 'FunctionDeclaration':
       {
         const [result, deps] = convertFunctionDeclaration(stmt, context);
@@ -317,6 +323,7 @@ function convertStatement(stmt, context) {
     case 'DeclareVariable':
     case 'DeclareFunction':
     case 'DeclareModule':
+    case 'DeclareNamespace':
     case 'DeclareInterface':
     case 'DeclareTypeAlias':
     case 'DeclareOpaqueType':
@@ -513,6 +520,16 @@ function convertExportDeclaration(decl, opts, context) {
         }), deps];
       }
 
+    case 'HookDeclaration':
+      {
+        const [declDecl, deps] = convertHookDeclaration(decl, context);
+        return [opts.default ? _hermesTransform.t.DeclareExportDefaultDeclaration({
+          declaration: declDecl
+        }) : _hermesTransform.t.DeclareExportDeclarationNamedWithDeclaration({
+          declaration: declDecl
+        }), deps];
+      }
+
     case 'FunctionDeclaration':
       {
         const [declDecl, deps] = convertFunctionDeclaration(decl, context);
@@ -906,6 +923,32 @@ function convertComponentParameters(params, context) {
   }, [[], null, []]);
 }
 
+function convertHookDeclaration(hook, context) {
+  var _hook$returnType;
+
+  const id = hook.id;
+  const returnType = (_hook$returnType = hook.returnType) != null ? _hook$returnType : // $FlowFixMe[incompatible-type]
+  _hermesTransform.t.TypeAnnotation({
+    typeAnnotation: _hermesTransform.t.VoidTypeAnnotation()
+  });
+  const [resultReturnType, returnDeps] = convertTypeAnnotation(returnType, hook, context);
+  const [resultParams, restParam, paramsDeps] = convertFunctionParameters(hook.params, context);
+  const [resultTypeParams, typeParamsDeps] = convertTypeParameterDeclarationOrNull(hook.typeParameters, context);
+
+  const resultFunc = _hermesTransform.t.FunctionTypeAnnotation({
+    params: resultParams,
+    returnType: resultReturnType,
+    rest: restParam,
+    typeParameters: resultTypeParams
+  });
+
+  const funcDeps = [...paramsDeps, ...returnDeps, ...typeParamsDeps];
+  return [_hermesTransform.t.DeclareHook({
+    name: id.name,
+    functionType: resultFunc
+  }), [...funcDeps]];
+}
+
 function convertFunctionDeclaration(func, context) {
   const id = func.id;
 

package/dist/flowToFlowDef.js.flow

@@ -24,6 +24,7 @@ import type {
   ComponentTypeParameter,
   DeclareClass,
   DeclareComponent,
+  DeclareHook,
   DeclareFunction,
   DeclareOpaqueType,
   DeclareVariable,
@@ -36,6 +37,7 @@ import type {
   FunctionParameter,
   FunctionTypeAnnotation,
   FunctionTypeParam,
+  HookDeclaration,
   Identifier,
   ImportDeclaration,
   InterfaceDeclaration,
@@ -372,6 +374,10 @@ function convertStatement(
       const [result, deps] = convertComponentDeclaration(stmt, context);
       return [result, deps];
     }
+    case 'HookDeclaration': {
+      const [result, deps] = convertHookDeclaration(stmt, context);
+      return [result, deps];
+    }
     case 'FunctionDeclaration': {
       const [result, deps] = convertFunctionDeclaration(stmt, context);
       return [result, deps];
@@ -404,6 +410,7 @@ function convertStatement(
     case 'DeclareVariable':
     case 'DeclareFunction':
     case 'DeclareModule':
+    case 'DeclareNamespace':
     case 'DeclareInterface':
     case 'DeclareTypeAlias':
     case 'DeclareOpaqueType':
@@ -642,6 +649,19 @@ function convertExportDeclaration(
         deps,
       ];
     }
+    case 'HookDeclaration': {
+      const [declDecl, deps] = convertHookDeclaration(decl, context);
+      return [
+        opts.default
+          ? t.DeclareExportDefaultDeclaration({
+              declaration: declDecl,
+            })
+          : t.DeclareExportDeclarationNamedWithDeclaration({
+              declaration: declDecl,
+            }),
+        deps,
+      ];
+    }
     case 'FunctionDeclaration': {
       const [declDecl, deps] = convertFunctionDeclaration(decl, context);
       return [
@@ -1224,6 +1244,48 @@ function convertComponentParameters(
   );
 }
 
+function convertHookDeclaration(
+  hook: HookDeclaration,
+  context: TranslationContext,
+): TranslatedResult<DeclareHook> {
+  const id = hook.id;
+  const returnType: TypeAnnotation =
+    hook.returnType ??
+    // $FlowFixMe[incompatible-type]
+    t.TypeAnnotation({typeAnnotation: t.VoidTypeAnnotation()});
+
+  const [resultReturnType, returnDeps] = convertTypeAnnotation(
+    returnType,
+    hook,
+    context,
+  );
+
+  const [resultParams, restParam, paramsDeps] = convertFunctionParameters(
+    hook.params,
+    context,
+  );
+
+  const [resultTypeParams, typeParamsDeps] =
+    convertTypeParameterDeclarationOrNull(hook.typeParameters, context);
+
+  const resultFunc = t.FunctionTypeAnnotation({
+    params: resultParams,
+    returnType: resultReturnType,
+    rest: restParam,
+    typeParameters: resultTypeParams,
+  });
+
+  const funcDeps = [...paramsDeps, ...returnDeps, ...typeParamsDeps];
+
+  return [
+    t.DeclareHook({
+      name: id.name,
+      functionType: resultFunc,
+    }),
+    [...funcDeps],
+  ];
+}
+
 function convertFunctionDeclaration(
   func: FunctionDeclaration,
   context: TranslationContext,

package/package.json

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