flow-api-translator 0.26.0 → 0.28.0

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];
@@ -1057,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]];
         }
 
@@ -1080,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

@@ -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,
         }),
@@ -1458,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':
@@ -1466,6 +1557,8 @@ function convertFunctionParameters(
           const [resultParam, deps] = convertBindingNameToFunctionTypeParam(
             param,
             context,
+            index,
+            false,
           );
           return [
             [...resultParams, resultParam],
@@ -1477,6 +1570,8 @@ function convertFunctionParameters(
           const [resultParam, deps] = convertBindingNameToFunctionTypeParam(
             param.left,
             context,
+            index,
+            true,
           );
           return [
             [...resultParams, resultParam],
@@ -1496,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]];
         }
@@ -1508,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,
@@ -1519,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/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.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.26.0",
-    "hermes-estree": "0.26.0",
-    "hermes-parser": "0.26.0",
-    "hermes-transform": "0.26.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": {