flow-api-translator 0.21.1 → 0.23.0

package/dist/TSDefToFlowDef.js

@@ -56,15 +56,7 @@ function TSDefToFlowDef(originalCode, ast, opts) {
     interpreter: null,
     tokens: [],
     loc: ast.loc,
-    docblock: {
-      comment: { ...DUMMY_COMMON,
-        type: 'Block',
-        value: ''
-      },
-      directives: {
-        flow: []
-      }
-    }
+    docblock: null
   };
   const [transform, code] = getTransforms(originalCode, opts);
 

package/dist/TSDefToFlowDef.js.flow

@@ -61,10 +61,7 @@ export function TSDefToFlowDef(
     interpreter: null,
     tokens: [],
     loc: ast.loc,
-    docblock: {
-      comment: {...DUMMY_COMMON, type: 'Block', value: ''},
-      directives: {flow: []},
-    },
+    docblock: null,
   };
 
   const [transform, code] = getTransforms(originalCode, opts);

package/dist/flowDefToTSDef.js

@@ -1731,6 +1731,28 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         return [];
       };
 
+      function assertHasTypeParametersInRange(min, max) {
+        const {
+          typeParameters
+        } = node;
+
+        if (typeParameters == null) {
+          if (min > 0) {
+            throw translationError(node, `Expected between ${min} and ${max} type parameters with \`${fullTypeName}\`, but got none.`);
+          }
+
+          return [];
+        }
+
+        const params = typeParameters.params;
+
+        if (params.length < min || params.length > max) {
+          throw translationError(node, `Expected between ${min} and ${max} type parameters with \`${fullTypeName}\`, but got ${params.length}.`);
+        }
+
+        return typeParameters.params.map(transformTypeAnnotationType);
+      }
+
       switch (fullTypeName) {
         case '$Call':
         case '$ObjMap':
@@ -2054,6 +2076,90 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               }
             };
           }
+
+        case 'StringPrefix':
+          {
+            var _params$;
+
+            // `StringPrefix<foo>` => `foo${string}`
+            // `StringPrefix<foo, T>` => `foo${T}`
+            const params = assertHasTypeParametersInRange(1, 2);
+            const prefix = params[0];
+
+            if (prefix.type !== 'TSLiteralType' || typeof prefix.literal.value !== 'string') {
+              throw translationError(node, 'Expected a string literal for the first type parameter.');
+            }
+
+            const prefixStr = prefix.literal.value;
+            const remainder = (_params$ = params[1]) != null ? _params$ : {
+              type: 'TSStringKeyword',
+              loc: DUMMY_LOC
+            };
+            return {
+              type: 'TSTemplateLiteralType',
+              loc: DUMMY_LOC,
+              quasis: [{
+                type: 'TemplateElement',
+                loc: DUMMY_LOC,
+                value: {
+                  raw: prefixStr,
+                  cooked: prefixStr
+                },
+                tail: false
+              }, {
+                type: 'TemplateElement',
+                loc: DUMMY_LOC,
+                value: {
+                  raw: '',
+                  cooked: ''
+                },
+                tail: true
+              }],
+              types: [remainder]
+            };
+          }
+
+        case 'StringSuffix':
+          {
+            var _params$2;
+
+            // `StringSuffix<foo>` => `${string}foo`
+            // `StringSuffix<foo, T>` => `${T}foo`
+            const params = assertHasTypeParametersInRange(1, 2);
+            const suffix = params[0];
+
+            if (suffix.type !== 'TSLiteralType' || typeof suffix.literal.value !== 'string') {
+              throw translationError(node, 'Expected a string literal for the first type parameter.');
+            }
+
+            const suffixStr = suffix.literal.value;
+            const remainder = (_params$2 = params[1]) != null ? _params$2 : {
+              type: 'TSStringKeyword',
+              loc: DUMMY_LOC
+            };
+            return {
+              type: 'TSTemplateLiteralType',
+              loc: DUMMY_LOC,
+              quasis: [{
+                type: 'TemplateElement',
+                loc: DUMMY_LOC,
+                value: {
+                  raw: '',
+                  cooked: ''
+                },
+                tail: false
+              }, {
+                type: 'TemplateElement',
+                loc: DUMMY_LOC,
+                value: {
+                  raw: suffixStr,
+                  cooked: suffixStr
+                },
+                tail: true
+              }],
+              types: [remainder]
+            };
+          }
       } // React special conversion:
 
 
@@ -3214,44 +3320,57 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
     TupleTypeAnnotation(node) {
       const allReadOnly = node.types.length > 0 && node.types.every(element => element.type === 'TupleTypeLabeledElement' && element.variance != null && element.variance.kind === 'plus');
-      const tupleAnnot = {
-        type: 'TSTupleType',
-        loc: DUMMY_LOC,
-        elementTypes: node.types.map(element => {
-          switch (element.type) {
-            case 'TupleTypeLabeledElement':
-              if (!allReadOnly && element.variance != null) {
-                return unsupportedAnnotation(element, 'tuple type element variance annotations');
-              }
+      const elems = node.types.map(element => {
+        switch (element.type) {
+          case 'TupleTypeLabeledElement':
+            if (!allReadOnly && element.variance != null) {
+              return unsupportedAnnotation(element, 'tuple type element variance annotations');
+            }
 
+            return {
+              type: 'TSNamedTupleMember',
+              loc: DUMMY_LOC,
+              label: transform.Identifier(element.label),
+              optional: element.optional,
+              elementType: transformTypeAnnotationType(element.elementType)
+            };
+
+          case 'TupleTypeSpreadElement':
+            {
+              const annot = transformTypeAnnotationType(element.typeAnnotation);
               return {
-                type: 'TSNamedTupleMember',
+                type: 'TSRestType',
                 loc: DUMMY_LOC,
-                label: transform.Identifier(element.label),
-                optional: element.optional,
-                elementType: transformTypeAnnotationType(element.elementType)
-              };
-
-            case 'TupleTypeSpreadElement':
-              {
-                const annot = transformTypeAnnotationType(element.typeAnnotation);
-                return {
-                  type: 'TSRestType',
+                typeAnnotation: element.label != null ? {
+                  type: 'TSNamedTupleMember',
                   loc: DUMMY_LOC,
-                  typeAnnotation: element.label != null ? {
-                    type: 'TSNamedTupleMember',
-                    loc: DUMMY_LOC,
-                    label: transform.Identifier(element.label),
-                    optional: false,
-                    elementType: annot
-                  } : annot
-                };
-              }
+                  label: transform.Identifier(element.label),
+                  optional: false,
+                  elementType: annot
+                } : annot
+              };
+            }
 
-            default:
-              return transformTypeAnnotationType(element);
+          default:
+            return transformTypeAnnotationType(element);
+        }
+      });
+      const elementTypes = node.inexact ? [...elems, {
+        type: 'TSRestType',
+        loc: DUMMY_LOC,
+        typeAnnotation: {
+          type: 'TSArrayType',
+          loc: DUMMY_LOC,
+          elementType: {
+            type: 'TSUnknownKeyword',
+            loc: DUMMY_LOC
           }
-        })
+        }
+      }] : elems;
+      const tupleAnnot = {
+        type: 'TSTupleType',
+        loc: DUMMY_LOC,
+        elementTypes
       };
       return allReadOnly ? {
         type: 'TSTypeOperator',

package/dist/flowDefToTSDef.js.flow

@@ -1915,6 +1915,31 @@ const getTransforms = (
         return [];
       };
 
+      function assertHasTypeParametersInRange(
+        min: number,
+        max: number,
+      ): $ReadOnlyArray<TSESTree.TypeNode> {
+        const {typeParameters} = node;
+        if (typeParameters == null) {
+          if (min > 0) {
+            throw translationError(
+              node,
+              `Expected between ${min} and ${max} type parameters with \`${fullTypeName}\`, but got none.`,
+            );
+          }
+          return [];
+        }
+        const params = typeParameters.params;
+        if (params.length < min || params.length > max) {
+          throw translationError(
+            node,
+            `Expected between ${min} and ${max} type parameters with \`${fullTypeName}\`, but got ${params.length}.`,
+          );
+        }
+
+        return typeParameters.params.map(transformTypeAnnotationType);
+      }
+
       switch (fullTypeName) {
         case '$Call':
         case '$ObjMap':
@@ -2242,6 +2267,100 @@ const getTransforms = (
             },
           };
         }
+
+        case 'StringPrefix': {
+          // `StringPrefix<foo>` => `foo${string}`
+          // `StringPrefix<foo, T>` => `foo${T}`
+          const params = assertHasTypeParametersInRange(1, 2);
+          const prefix = params[0];
+          if (
+            prefix.type !== 'TSLiteralType' ||
+            typeof prefix.literal.value !== 'string'
+          ) {
+            throw translationError(
+              node,
+              'Expected a string literal for the first type parameter.',
+            );
+          }
+          const prefixStr = prefix.literal.value;
+          const remainder = params[1] ?? {
+            type: 'TSStringKeyword',
+            loc: DUMMY_LOC,
+          };
+
+          return {
+            type: 'TSTemplateLiteralType',
+            loc: DUMMY_LOC,
+            quasis: [
+              {
+                type: 'TemplateElement',
+                loc: DUMMY_LOC,
+                value: {
+                  raw: prefixStr,
+                  cooked: prefixStr,
+                },
+                tail: false,
+              },
+              {
+                type: 'TemplateElement',
+                loc: DUMMY_LOC,
+                value: {
+                  raw: '',
+                  cooked: '',
+                },
+                tail: true,
+              },
+            ],
+            types: [remainder],
+          };
+        }
+
+        case 'StringSuffix': {
+          // `StringSuffix<foo>` => `${string}foo`
+          // `StringSuffix<foo, T>` => `${T}foo`
+          const params = assertHasTypeParametersInRange(1, 2);
+          const suffix = params[0];
+          if (
+            suffix.type !== 'TSLiteralType' ||
+            typeof suffix.literal.value !== 'string'
+          ) {
+            throw translationError(
+              node,
+              'Expected a string literal for the first type parameter.',
+            );
+          }
+          const suffixStr = suffix.literal.value;
+          const remainder = params[1] ?? {
+            type: 'TSStringKeyword',
+            loc: DUMMY_LOC,
+          };
+
+          return {
+            type: 'TSTemplateLiteralType',
+            loc: DUMMY_LOC,
+            quasis: [
+              {
+                type: 'TemplateElement',
+                loc: DUMMY_LOC,
+                value: {
+                  raw: '',
+                  cooked: '',
+                },
+                tail: false,
+              },
+              {
+                type: 'TemplateElement',
+                loc: DUMMY_LOC,
+                value: {
+                  raw: suffixStr,
+                  cooked: suffixStr,
+                },
+                tail: true,
+              },
+            ],
+            types: [remainder],
+          };
+        }
       }
 
       // React special conversion:
@@ -3501,46 +3620,66 @@ const getTransforms = (
             element.variance != null &&
             element.variance.kind === 'plus',
         );
+      const elems = node.types.map(element => {
+        switch (element.type) {
+          case 'TupleTypeLabeledElement':
+            if (!allReadOnly && element.variance != null) {
+              return unsupportedAnnotation(
+                element,
+                'tuple type element variance annotations',
+              );
+            }
+            return {
+              type: 'TSNamedTupleMember',
+              loc: DUMMY_LOC,
+              label: transform.Identifier(element.label),
+              optional: element.optional,
+              elementType: transformTypeAnnotationType(element.elementType),
+            };
+          case 'TupleTypeSpreadElement': {
+            const annot = transformTypeAnnotationType(element.typeAnnotation);
+            return {
+              type: 'TSRestType',
+              loc: DUMMY_LOC,
+              typeAnnotation:
+                element.label != null
+                  ? {
+                      type: 'TSNamedTupleMember',
+                      loc: DUMMY_LOC,
+                      label: transform.Identifier(element.label),
+                      optional: false,
+                      elementType: annot,
+                    }
+                  : annot,
+            };
+          }
+          default:
+            return transformTypeAnnotationType(element);
+        }
+      });
+
+      const elementTypes = node.inexact
+        ? [
+            ...elems,
+            {
+              type: 'TSRestType',
+              loc: DUMMY_LOC,
+              typeAnnotation: {
+                type: 'TSArrayType',
+                loc: DUMMY_LOC,
+                elementType: {
+                  type: 'TSUnknownKeyword',
+                  loc: DUMMY_LOC,
+                },
+              },
+            },
+          ]
+        : elems;
+
       const tupleAnnot: TSESTree.TSTupleType = {
         type: 'TSTupleType',
         loc: DUMMY_LOC,
-        elementTypes: node.types.map(element => {
-          switch (element.type) {
-            case 'TupleTypeLabeledElement':
-              if (!allReadOnly && element.variance != null) {
-                return unsupportedAnnotation(
-                  element,
-                  'tuple type element variance annotations',
-                );
-              }
-              return {
-                type: 'TSNamedTupleMember',
-                loc: DUMMY_LOC,
-                label: transform.Identifier(element.label),
-                optional: element.optional,
-                elementType: transformTypeAnnotationType(element.elementType),
-              };
-            case 'TupleTypeSpreadElement': {
-              const annot = transformTypeAnnotationType(element.typeAnnotation);
-              return {
-                type: 'TSRestType',
-                loc: DUMMY_LOC,
-                typeAnnotation:
-                  element.label != null
-                    ? {
-                        type: 'TSNamedTupleMember',
-                        loc: DUMMY_LOC,
-                        label: transform.Identifier(element.label),
-                        optional: false,
-                        elementType: annot,
-                      }
-                    : annot,
-              };
-            }
-            default:
-              return transformTypeAnnotationType(element);
-          }
-        }),
+        elementTypes,
       };
       return allReadOnly
         ? {

package/dist/flowToFlowDef.js

@@ -751,23 +751,83 @@ function convertClassDeclaration(class_, context) {
   }), [...typeParamsDeps, ...implementsDeps, ...superClassDeps, ...bodyDeps]];
 }
 
-function convertSuperClass(superClass, superTypeParameters, context) {
-  if (superClass == null) {
-    return EMPTY_TRANSLATION_RESULT;
+function convertExpressionToIdentifier(node, context) {
+  if (node.type === 'Identifier') {
+    return _hermesTransform.t.Identifier({
+      name: node.name
+    });
   }
 
-  if (superClass.type !== 'Identifier') {
-    throw (0, _ErrorUtils.translationError)(superClass, `SuperClass: Non identifier super type of "${superClass.type}" not supported`, context);
+  if (node.type === 'MemberExpression') {
+    const {
+      property,
+      object
+    } = node;
+
+    if (property.type === 'Identifier' && object.type !== 'Super') {
+      return _hermesTransform.t.QualifiedTypeIdentifier({
+        qualification: convertExpressionToIdentifier(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)(superClass, context);
+  const superDeps = (0, _FlowAnalyze.analyzeTypeDependencies)(nodeForDependencies, context);
   return [_hermesTransform.t.InterfaceExtends({
-    id: (0, _hermesTransform.asDetachedNode)(superClass),
+    id: detachedId,
     typeParameters: resultTypeParams
   }), [...typeParamsDeps, ...superDeps]];
 }
 
+function convertSuperClass(superClass, superTypeParameters, context) {
+  if (superClass == null) {
+    return EMPTY_TRANSLATION_RESULT;
+  }
+
+  switch (superClass.type) {
+    case 'Identifier':
+      {
+        return convertSuperClassHelper((0, _hermesTransform.asDetachedNode)(superClass), superClass, superTypeParameters, context);
+      }
+
+    case 'MemberExpression':
+      {
+        return convertSuperClassHelper(convertExpressionToIdentifier(superClass, context), superClass, superTypeParameters, context);
+      }
+
+    case 'TypeCastExpression':
+      {
+        const typeAnnotation = superClass.typeAnnotation.typeAnnotation;
+
+        if (typeAnnotation.type === 'GenericTypeAnnotation') {
+          return convertSuperClassHelper((0, _hermesTransform.asDetachedNode)(typeAnnotation.id), typeAnnotation, superTypeParameters, context);
+        }
+
+        if (typeAnnotation.type === 'TypeofTypeAnnotation') {
+          const typeofArg = typeAnnotation.argument;
+
+          if (typeofArg.type === 'Identifier') {
+            return convertSuperClassHelper((0, _hermesTransform.asDetachedNode)(typeofArg), typeofArg, typeAnnotation.typeArguments, context);
+          }
+        }
+
+        throw (0, _ErrorUtils.translationError)(superClass, `SuperClass: Typecast super type of "${typeAnnotation.type}" not supported`, context);
+      }
+
+    default:
+      {
+        throw (0, _ErrorUtils.translationError)(superClass, `SuperClass: Non identifier super type of "${superClass.type}" not supported`, context);
+      }
+  }
+}
+
 function convertClassBody(body, context) {
   const [resultProperties, deps] = convertArray(body.body, member => convertClassMember(member, context));
   return [_hermesTransform.t.ObjectTypeAnnotation({

package/dist/flowToFlowDef.js.flow

@@ -49,6 +49,7 @@ import type {
   ObjectTypeAnnotation,
   ObjectTypeProperty,
   OpaqueType,
+  QualifiedTypeIdentifier,
   Program,
   RestElement,
   Statement,
@@ -977,34 +978,116 @@ function convertClassDeclaration(
   ];
 }
 
-function convertSuperClass(
-  superClass: ?Expression,
-  superTypeParameters: ?TypeParameterInstantiation,
+function convertExpressionToIdentifier(
+  node: Expression,
   context: TranslationContext,
-): TranslatedResultOrNull<InterfaceExtends> {
-  if (superClass == null) {
-    return EMPTY_TRANSLATION_RESULT;
+): DetachedNode<Identifier> | DetachedNode<QualifiedTypeIdentifier> {
+  if (node.type === 'Identifier') {
+    return t.Identifier({name: node.name});
   }
 
-  if (superClass.type !== 'Identifier') {
-    throw translationError(
-      superClass,
-      `SuperClass: Non identifier super type of "${superClass.type}" not supported`,
-      context,
-    );
+  if (node.type === 'MemberExpression') {
+    const {property, object} = node;
+    if (property.type === 'Identifier' && object.type !== 'Super') {
+      return t.QualifiedTypeIdentifier({
+        qualification: convertExpressionToIdentifier(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,
+  superTypeParameters: ?TypeParameterInstantiation,
+  context: TranslationContext,
+): TranslatedResultOrNull<InterfaceExtends> {
   const [resultTypeParams, typeParamsDeps] =
     convertTypeParameterInstantiationOrNull(superTypeParameters, context);
-  const superDeps = analyzeTypeDependencies(superClass, context);
+  const superDeps = analyzeTypeDependencies(nodeForDependencies, context);
   return [
     t.InterfaceExtends({
-      id: asDetachedNode(superClass),
+      id: detachedId,
       typeParameters: resultTypeParams,
     }),
     [...typeParamsDeps, ...superDeps],
   ];
 }
 
+function convertSuperClass(
+  superClass: ?Expression,
+  superTypeParameters: ?TypeParameterInstantiation,
+  context: TranslationContext,
+): TranslatedResultOrNull<InterfaceExtends> {
+  if (superClass == null) {
+    return EMPTY_TRANSLATION_RESULT;
+  }
+
+  switch (superClass.type) {
+    case 'Identifier': {
+      return convertSuperClassHelper(
+        asDetachedNode(superClass),
+        superClass,
+        superTypeParameters,
+        context,
+      );
+    }
+    case 'MemberExpression': {
+      return convertSuperClassHelper(
+        convertExpressionToIdentifier(superClass, context),
+        superClass,
+        superTypeParameters,
+        context,
+      );
+    }
+    case 'TypeCastExpression': {
+      const typeAnnotation = superClass.typeAnnotation.typeAnnotation;
+
+      if (typeAnnotation.type === 'GenericTypeAnnotation') {
+        return convertSuperClassHelper(
+          asDetachedNode(typeAnnotation.id),
+          typeAnnotation,
+          superTypeParameters,
+          context,
+        );
+      }
+
+      if (typeAnnotation.type === 'TypeofTypeAnnotation') {
+        const typeofArg = typeAnnotation.argument;
+
+        if (typeofArg.type === 'Identifier') {
+          return convertSuperClassHelper(
+            asDetachedNode(typeofArg),
+            typeofArg,
+            typeAnnotation.typeArguments,
+            context,
+          );
+        }
+      }
+
+      throw translationError(
+        superClass,
+        `SuperClass: Typecast super type of "${typeAnnotation.type}" not supported`,
+        context,
+      );
+    }
+    default: {
+      throw translationError(
+        superClass,
+        `SuperClass: Non identifier super type of "${superClass.type}" not supported`,
+        context,
+      );
+    }
+  }
+}
+
 function convertClassBody(
   body: ClassBody,
   context: TranslationContext,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flow-api-translator",
-  "version": "0.21.1",
+  "version": "0.23.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.21.1",
-    "hermes-estree": "0.21.1",
-    "hermes-parser": "0.21.1",
-    "hermes-transform": "0.21.1",
+    "hermes-eslint": "0.23.0",
+    "hermes-estree": "0.23.0",
+    "hermes-parser": "0.23.0",
+    "hermes-transform": "0.23.0",
     "typescript": "5.3.2"
   },
   "peerDependencies": {