flow-api-translator 0.27.0 → 0.28.0

package/dist/flowDefToTSDef.js

@@ -1957,6 +1957,20 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             return unsupportedAnnotation(node, fullTypeName);
           }
 
+        case '$ArrayBufferView':
+          {
+            // `$ArrayBufferView` => `ArrayBufferView`
+            return {
+              type: 'TSTypeReference',
+              loc: DUMMY_LOC,
+              typeName: {
+                type: 'Identifier',
+                loc: DUMMY_LOC,
+                name: 'ArrayBufferView'
+              }
+            };
+          }
+
         case '$ArrayLike':
           {
             // `$ArrayLike<T>` => `ArrayLike<T>`
@@ -2543,8 +2557,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }
               };
             }
-          // React.ElementRef<typeof Component> -> React.ElementRef<typeof Component>
-          // React$ElementRef<typeof Component> -> React.ElementRef<typeof Component>
+          // React.ElementRef<typeof Component> -> React.ComponentRef<typeof Component>
+          // React$ElementRef<typeof Component> -> React.ComponentRef<typeof Component>
 
           case 'React$ElementRef':
           case 'React.ElementRef':
@@ -2558,7 +2572,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 right: {
                   type: 'Identifier',
                   loc: DUMMY_LOC,
-                  name: `ElementRef`
+                  name: `ComponentRef`
                 }
               },
               typeParameters: {
@@ -3211,8 +3225,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         type T = { ...T1, ...T2, ...T3, b: string  };
         // becomes
         type T =
-          & Omit<T1, keyof (T2 | T3 | { b: string })>
-          & Omit<T2, keyof (T3 | { b: string })>
+          & Omit<T1, keyof T2 | keyof T3 | keyof { b: string }>
+          & Omit<T2, keyof T3 | keyof { b: string }>
           & Omit<T3, keyof { b: string }>
           & { b: string };
         ```
@@ -3276,14 +3290,19 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               type: 'TSTypeParameterInstantiation',
               loc: DUMMY_LOC,
               params: [currentType, {
-                type: 'TSTypeOperator',
+                type: 'TSUnionType',
                 loc: DUMMY_LOC,
-                operator: 'keyof',
-                typeAnnotation: {
-                  type: 'TSUnionType',
+                types: [...remainingTypes.map(t => ({
+                  type: 'TSTypeOperator',
                   loc: DUMMY_LOC,
-                  types: [...remainingTypes, objectType]
-                }
+                  operator: 'keyof',
+                  typeAnnotation: t
+                })), {
+                  type: 'TSTypeOperator',
+                  loc: DUMMY_LOC,
+                  operator: 'keyof',
+                  typeAnnotation: objectType
+                }]
               }]
             }
           });

package/dist/flowDefToTSDef.js.flow

@@ -2173,6 +2173,19 @@ 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 {
@@ -2765,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 {
@@ -2779,7 +2792,7 @@ const getTransforms = (
                 right: {
                   type: 'Identifier',
                   loc: DUMMY_LOC,
-                  name: `ElementRef`,
+                  name: `ComponentRef`,
                 },
               },
               typeParameters: {
@@ -3495,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 };
         ```
@@ -3577,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,
+                    },
+                  ],
                 },
               ],
             },

package/dist/flowToFlowDef.js

@@ -1113,19 +1113,19 @@ function convertAFunction(func, context) {
 }
 
 function convertFunctionParameters(params, context) {
-  return params.reduce(([resultParams, restParam, paramsDeps], param) => {
+  return params.reduce(([resultParams, restParam, paramsDeps], param, index) => {
     switch (param.type) {
       case 'Identifier':
       case 'ArrayPattern':
       case 'ObjectPattern':
         {
-          const [resultParam, deps] = convertBindingNameToFunctionTypeParam(param, context);
+          const [resultParam, deps] = convertBindingNameToFunctionTypeParam(param, context, index, false);
           return [[...resultParams, resultParam], restParam, [...paramsDeps, ...deps]];
         }
 
       case 'AssignmentPattern':
         {
-          const [resultParam, deps] = convertBindingNameToFunctionTypeParam(param.left, context);
+          const [resultParam, deps] = convertBindingNameToFunctionTypeParam(param.left, context, index, true);
           return [[...resultParams, resultParam], restParam, [...paramsDeps, ...deps]];
         }
 
@@ -1136,22 +1136,22 @@ function convertFunctionParameters(params, context) {
           }
 
           const [resultParam, deps] = convertBindingNameToFunctionTypeParam( // $FlowFixMe[incompatible-call] I dont think these other cases are possible
-          param.argument, context);
+          param.argument, context, index, false);
           return [resultParams, resultParam, [...paramsDeps, ...deps]];
         }
     }
   }, [[], null, []]);
 }
 
-function convertBindingNameToFunctionTypeParam(pat, context) {
-  const name = pat.type === 'Identifier' ? pat.name : null;
+function convertBindingNameToFunctionTypeParam(pat, context, index, isAssignment) {
+  const name = pat.type === 'Identifier' ? pat.name : `$$PARAM_${index}$$`;
   const [resultParamTypeAnnotation, paramDeps] = convertTypeAnnotation(pat.typeAnnotation, pat, context);
   return [_hermesTransform.t.FunctionTypeParam({
     name: name != null ? _hermesTransform.t.Identifier({
       name
     }) : null,
     typeAnnotation: resultParamTypeAnnotation,
-    optional: pat.type === 'Identifier' ? pat.optional : false
+    optional: isAssignment || (pat.type === 'Identifier' ? pat.optional : false)
   }), paramDeps];
 }
 

package/dist/flowToFlowDef.js.flow

@@ -1549,7 +1549,7 @@ function convertFunctionParameters(
   context: TranslationContext,
 ): TranslatedFunctionParametersResults {
   return params.reduce<TranslatedFunctionParametersResults>(
-    ([resultParams, restParam, paramsDeps], param) => {
+    ([resultParams, restParam, paramsDeps], param, index) => {
       switch (param.type) {
         case 'Identifier':
         case 'ArrayPattern':
@@ -1557,6 +1557,8 @@ function convertFunctionParameters(
           const [resultParam, deps] = convertBindingNameToFunctionTypeParam(
             param,
             context,
+            index,
+            false,
           );
           return [
             [...resultParams, resultParam],
@@ -1568,6 +1570,8 @@ function convertFunctionParameters(
           const [resultParam, deps] = convertBindingNameToFunctionTypeParam(
             param.left,
             context,
+            index,
+            true,
           );
           return [
             [...resultParams, resultParam],
@@ -1587,6 +1591,8 @@ function convertFunctionParameters(
             // $FlowFixMe[incompatible-call] I dont think these other cases are possible
             param.argument,
             context,
+            index,
+            false,
           );
           return [resultParams, resultParam, [...paramsDeps, ...deps]];
         }
@@ -1599,8 +1605,10 @@ function convertFunctionParameters(
 function convertBindingNameToFunctionTypeParam(
   pat: BindingName,
   context: TranslationContext,
+  index: number,
+  isAssignment: boolean,
 ): TranslatedResult<FunctionTypeParam> {
-  const name = pat.type === 'Identifier' ? pat.name : null;
+  const name = pat.type === 'Identifier' ? pat.name : `$$PARAM_${index}$$`;
   const [resultParamTypeAnnotation, paramDeps] = convertTypeAnnotation(
     pat.typeAnnotation,
     pat,
@@ -1610,7 +1618,8 @@ function convertBindingNameToFunctionTypeParam(
     t.FunctionTypeParam({
       name: name != null ? t.Identifier({name}) : null,
       typeAnnotation: resultParamTypeAnnotation,
-      optional: pat.type === 'Identifier' ? pat.optional : false,
+      optional:
+        isAssignment || (pat.type === 'Identifier' ? pat.optional : false),
     }),
     paramDeps,
   ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flow-api-translator",
-  "version": "0.27.0",
+  "version": "0.28.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.27.0",
-    "hermes-estree": "0.27.0",
-    "hermes-parser": "0.27.0",
-    "hermes-transform": "0.27.0",
+    "hermes-eslint": "0.28.0",
+    "hermes-estree": "0.28.0",
+    "hermes-parser": "0.28.0",
+    "hermes-transform": "0.28.0",
     "typescript": "5.3.2"
   },
   "peerDependencies": {