flow-api-translator 0.330.0 → 0.332.0

package/dist/flowDefToTSDef.js.flow

@@ -29,6 +29,7 @@ import {removeAtFlowFromDocblock} from './utils/DocblockUtils';
 import {
   ensureTypeIncludesUndefined,
   extractPropertyKeyLiterals,
+  getDefaultExportBindingName,
 } from './utils/TSNodeUtils';
 import {EOL} from 'os';
 
@@ -745,6 +746,66 @@ const getTransforms = (
     return () => `$$IMPORT_TYPEOF_${++typeof_import_count}$$`;
   })();
 
+  function transformImportTypeReference(
+    node:
+      | FlowESTree.ImportType
+      | FlowESTree.Identifier
+      | FlowESTree.QualifiedTypeIdentifier
+      | FlowESTree.QualifiedTypeofIdentifier,
+    typeArguments: TSESTree.TSTypeParameterInstantiation | null = null,
+  ): TSESTree.TSImportType | null {
+    const names: Array<FlowESTree.Identifier> = [];
+    let current = node;
+    while (
+      current.type === 'QualifiedTypeIdentifier' ||
+      current.type === 'QualifiedTypeofIdentifier'
+    ) {
+      names.unshift(current.id);
+      current = current.qualification;
+    }
+    if (current.type !== 'ImportType') {
+      return null;
+    }
+
+    let qualifier: TSESTree.EntityName | null = null;
+    for (const name of names) {
+      const identifier: TSESTree.Identifier = {
+        type: 'Identifier',
+        loc: DUMMY_LOC,
+        name: name.name,
+      };
+      qualifier =
+        qualifier == null
+          ? identifier
+          : {
+              type: 'TSQualifiedName',
+              loc: DUMMY_LOC,
+              left: qualifier,
+              right: identifier,
+            };
+    }
+
+    const source: TSESTree.StringLiteral = {
+      type: 'Literal',
+      loc: DUMMY_LOC,
+      raw: current.argument.raw,
+      value: current.argument.value,
+    };
+    return {
+      type: 'TSImportType',
+      loc: DUMMY_LOC,
+      argument: {
+        type: 'TSLiteralType',
+        loc: DUMMY_LOC,
+        literal: source,
+      },
+      options: null,
+      qualifier,
+      source,
+      typeArguments,
+    };
+  }
+
   const transformTypeAnnotationType = (
     node: FlowESTree.TypeAnnotationType,
   ): TSESTree.TypeNode => {
@@ -799,8 +860,12 @@ const getTransforms = (
         return transform.SymbolTypeAnnotation(node);
       case 'ThisTypeAnnotation':
         return transform.ThisTypeAnnotation(node);
+      case 'TemplateLiteralTypeAnnotation':
+        return transform.TemplateLiteralTypeAnnotation(node);
       case 'TupleTypeAnnotation':
         return transform.TupleTypeAnnotation(node);
+      case 'TupleTypeElement':
+        return transform.TupleTypeElement(node);
       case 'TypeofTypeAnnotation':
         return transform.TypeofTypeAnnotation(node);
       case 'UnionTypeAnnotation':
@@ -811,6 +876,8 @@ const getTransforms = (
         return transform.TypePredicateAnnotation(node);
       case 'ConditionalTypeAnnotation':
         return transform.ConditionalTypeAnnotation(node);
+      case 'ConstructorTypeAnnotation':
+        return transform.ConstructorTypeAnnotation(node);
       case 'InferTypeAnnotation':
         return transform.InferTypeAnnotation(node);
       case 'KeyofTypeAnnotation':
@@ -830,6 +897,83 @@ const getTransforms = (
     }
   };
 
+  /*
+  Flow can export a bare type, eg
+  ```
+  declare export default TypeName;
+  declare module.exports: TypeName;
+  ```
+  but TS can only export values, so declare a temporary variable to hold the
+  type and reference that in the export declaration:
+  ```
+  declare const SPECIFIER: TypeName;
+  declare type SPECIFIER = typeof SPECIFIER;
+  ```
+  */
+  const declareTypeAsVariable = (
+    specifier: string,
+    type: FlowESTree.TypeAnnotationType,
+  ): [TSESTree.VariableDeclaration, TSESTree.TSTypeAliasDeclaration] => [
+    {
+      type: 'VariableDeclaration',
+      loc: DUMMY_LOC,
+      declarations: [
+        {
+          type: 'VariableDeclarator',
+          loc: DUMMY_LOC,
+          id: {
+            type: 'Identifier',
+            loc: DUMMY_LOC,
+            name: specifier,
+            typeAnnotation: {
+              type: 'TSTypeAnnotation',
+              loc: DUMMY_LOC,
+              typeAnnotation: transformTypeAnnotationType(type),
+            },
+          },
+          init: null,
+        },
+      ],
+      declare: true,
+      kind: 'const',
+    },
+    {
+      type: 'TSTypeAliasDeclaration',
+      declare: true,
+      id: {
+        type: 'Identifier',
+        decorators: [],
+        name: specifier,
+        optional: false,
+        loc: DUMMY_LOC,
+      },
+      typeAnnotation: {
+        type: 'TSTypeQuery',
+        exprName: {
+          type: 'Identifier',
+          decorators: [],
+          name: specifier,
+          optional: false,
+          loc: DUMMY_LOC,
+        },
+        loc: DUMMY_LOC,
+      },
+      loc: DUMMY_LOC,
+    },
+  ];
+
+  // Whether `name` is bound at the top level by a class declaration, which is
+  // the one case where `typeof name` can be re-exported as `name` itself and
+  // keep both its value and its type meaning.
+  const isDeclaredClass = (name: string): boolean => {
+    const exportedVar = topScope.set.get(name);
+    return (
+      exportedVar != null &&
+      exportedVar.defs.length === 1 &&
+      exportedVar.defs[0].type === 'ClassName'
+    );
+  };
+
   const wellKnownSymbols = new Set([
     'iterator',
     'asyncIterator',
@@ -1127,6 +1271,29 @@ const getTransforms = (
       }
 
       const superClass = node.extends.length > 0 ? node.extends[0] : undefined;
+      let superClassExpression: TSESTree.LeftHandSideExpression | null = null;
+      let superTypeArguments: TSESTree.TSTypeParameterInstantiation | void;
+      if (superClass != null) {
+        switch (superClass.type) {
+          case 'DeclareClassExtendsCall':
+            return unsupportedDeclaration(
+              superClass,
+              'mixin class extends clauses',
+              node.id,
+              true,
+              node.typeParameters,
+            );
+          case 'InterfaceExtends':
+            superClassExpression =
+              superClass.id.type === 'QualifiedTypeIdentifier'
+                ? transform.QualifiedTypeIdentifier(superClass.id)
+                : transform.Identifier(superClass.id as $FlowFixMe, false);
+            superTypeArguments = transform.TypeParameterInstantiation(
+              superClass.typeParameters,
+            );
+            break;
+        }
+      }
 
       return {
         type: 'ClassDeclaration',
@@ -1142,15 +1309,8 @@ const getTransforms = (
           node.implements == null
             ? undefined
             : node.implements.map(transform.ClassImplements),
-        superClass:
-          superClass == null
-            ? null
-            : superClass.id.type === 'QualifiedTypeIdentifier'
-              ? transform.QualifiedTypeIdentifier(superClass.id)
-              : transform.Identifier(superClass.id as $FlowFixMe, false),
-        superTypeArguments: transform.TypeParameterInstantiation(
-          superClass?.typeParameters,
-        ),
+        superClass: superClassExpression,
+        superTypeArguments,
         typeParameters:
           node.typeParameters == null
             ? undefined
@@ -1209,6 +1369,14 @@ const getTransforms = (
           // TS doesn't support direct default export for declare'd functions
           case 'DeclareFunction': {
             const functionDecl = transform.DeclareFunction(declaration);
+            if (declaration.id == null) {
+              return {
+                type: 'ExportDefaultDeclaration',
+                loc: DUMMY_LOC,
+                declaration: functionDecl,
+                exportKind: 'value',
+              };
+            }
             const name = declaration.id.name;
             return [
               functionDecl,
@@ -1332,97 +1500,33 @@ const getTransforms = (
           case 'TypeofTypeAnnotation': {
             if (
               declaration.type === 'TypeofTypeAnnotation' &&
-              declaration.argument.type === 'Identifier'
+              declaration.argument.type === 'Identifier' &&
+              isDeclaredClass(declaration.argument.name)
             ) {
-              const name = declaration.argument.name;
-              const exportedVar = topScope.set.get(name);
-              if (exportedVar != null && exportedVar.defs.length === 1) {
-                const def = exportedVar.defs[0];
-
-                switch (def.type) {
-                  case 'ClassName': {
-                    return {
-                      type: 'ExportDefaultDeclaration',
-                      declaration: {
-                        type: 'Identifier',
-                        decorators: [],
-                        name,
-                        optional: false,
-                        loc: DUMMY_LOC,
-                      },
-                      exportKind: 'value',
-                      loc: DUMMY_LOC,
-                    };
-                  }
-                }
-              }
+              return {
+                type: 'ExportDefaultDeclaration',
+                declaration: {
+                  type: 'Identifier',
+                  decorators: [],
+                  name: declaration.argument.name,
+                  optional: false,
+                  loc: DUMMY_LOC,
+                },
+                exportKind: 'value',
+                loc: DUMMY_LOC,
+              };
             }
 
             // intentional fallthrough to the "default" handling
           }
 
           default: {
-            /*
-            flow allows syntax like
-            ```
-            declare export default TypeName;
-            ```
-            but TS does not, so we have to declare a temporary variable to
-            reference in the export declaration:
-            ```
-            declare const $$EXPORT_DEFAULT_DECLARATION$$: TypeName;
-            export default $$EXPORT_DEFAULT_DECLARATION$$;
-            ```
-            */
-            const SPECIFIER = '$$EXPORT_DEFAULT_DECLARATION$$';
+            const SPECIFIER = getDefaultExportBindingName(
+              declaration,
+              opts.useSemanticDefaultExportNames === true,
+            );
             return [
-              {
-                type: 'VariableDeclaration',
-                loc: DUMMY_LOC,
-                declarations: [
-                  {
-                    type: 'VariableDeclarator',
-                    loc: DUMMY_LOC,
-                    id: {
-                      type: 'Identifier',
-                      loc: DUMMY_LOC,
-                      name: SPECIFIER,
-                      typeAnnotation: {
-                        type: 'TSTypeAnnotation',
-                        loc: DUMMY_LOC,
-                        typeAnnotation:
-                          transformTypeAnnotationType(declaration),
-                      },
-                    },
-                    init: null,
-                  },
-                ],
-                declare: true,
-                kind: 'const',
-              },
-              {
-                type: 'TSTypeAliasDeclaration',
-                declare: true,
-                id: {
-                  type: 'Identifier',
-                  decorators: [],
-                  name: SPECIFIER,
-                  optional: false,
-                  loc: DUMMY_LOC,
-                },
-                typeAnnotation: {
-                  type: 'TSTypeQuery',
-                  exprName: {
-                    type: 'Identifier',
-                    decorators: [],
-                    name: SPECIFIER,
-                    optional: false,
-                    loc: DUMMY_LOC,
-                  },
-                  loc: DUMMY_LOC,
-                },
-                loc: DUMMY_LOC,
-              },
+              ...declareTypeAsVariable(SPECIFIER, declaration),
               {
                 type: 'ExportDefaultDeclaration',
                 loc: DUMMY_LOC,
@@ -1494,6 +1598,17 @@ const getTransforms = (
                     exportKind: 'type',
                   },
                 ];
+              case 'DeclareNamespace':
+                return [
+                  {
+                    declaration: unsupportedDeclaration(
+                      node.declaration,
+                      'namespaces',
+                      node.declaration.id,
+                    ),
+                    exportKind: 'value',
+                  },
+                ];
               case 'DeclareOpaqueType':
                 return [
                   {
@@ -1788,11 +1903,12 @@ const getTransforms = (
     DeclareFunction(
       node: FlowESTree.DeclareFunction,
     ): TSESTree.TSDeclareFunction {
-      // the function information is stored as an annotation on the ID...
-      const id = transform.Identifier(node.id, false);
-      const functionInfo = transform.FunctionTypeAnnotation(
-        node.id.typeAnnotation.typeAnnotation,
-      );
+      const annotation = node.id?.typeAnnotation ?? node.typeAnnotation;
+      if (annotation == null) {
+        throw translationError(node, 'Declare function is missing its type');
+      }
+      const functionType = annotation.typeAnnotation;
+      const functionInfo = transform.FunctionTypeAnnotation(functionType);
 
       return {
         type: 'TSDeclareFunction',
@@ -1802,11 +1918,14 @@ const getTransforms = (
         declare: true,
         expression: false,
         generator: false,
-        id: {
-          type: 'Identifier',
-          loc: DUMMY_LOC,
-          name: id.name,
-        },
+        id:
+          node.id == null
+            ? null
+            : {
+                type: 'Identifier',
+                loc: DUMMY_LOC,
+                name: node.id.name,
+              },
         params: functionInfo.params,
         returnType: functionInfo.returnType,
         typeParameters: functionInfo.typeParameters,
@@ -1974,8 +2093,65 @@ const getTransforms = (
     },
     DeclareModuleExports(
       node: FlowESTree.DeclareModuleExports,
-    ): TSESTree.TypeNode {
-      throw translationError(node, 'CommonJS exports are not supported.');
+    ):
+      | TSESTree.TSExportAssignment
+      | [
+          TSESTree.VariableDeclaration,
+          TSESTree.TSTypeAliasDeclaration,
+          TSESTree.TSExportAssignment,
+        ] {
+      // TS forbids `export = ` in a module that has any other export, so a
+      // module combining the two has no faithful translation.
+      if (
+        node.parent.type === 'Program' &&
+        node.parent.body.some(
+          statement =>
+            statement.type === 'DeclareExportAllDeclaration' ||
+            statement.type === 'DeclareExportDeclaration' ||
+            statement.type === 'ExportAllDeclaration' ||
+            statement.type === 'ExportDefaultDeclaration' ||
+            statement.type === 'ExportNamedDeclaration',
+        )
+      ) {
+        throw translationError(
+          node,
+          'CommonJS exports cannot be combined with ES module exports.',
+        );
+      }
+
+      // `declare module.exports: T` is TS's `export = <value>`, which - like
+      // `export default` - can only name a value.
+      const type = node.typeAnnotation.typeAnnotation;
+
+      if (
+        type.type === 'TypeofTypeAnnotation' &&
+        type.argument.type === 'Identifier' &&
+        isDeclaredClass(type.argument.name)
+      ) {
+        return {
+          type: 'TSExportAssignment',
+          loc: DUMMY_LOC,
+          expression: {
+            type: 'Identifier',
+            loc: DUMMY_LOC,
+            name: type.argument.name,
+          },
+        };
+      }
+
+      const SPECIFIER = '$$MODULE_EXPORTS$$';
+      return [
+        ...declareTypeAsVariable(SPECIFIER, type),
+        {
+          type: 'TSExportAssignment',
+          loc: DUMMY_LOC,
+          expression: {
+            type: 'Identifier',
+            loc: DUMMY_LOC,
+            name: SPECIFIER,
+          },
+        },
+      ];
     },
     ExistsTypeAnnotation(
       node: FlowESTree.ExistsTypeAnnotation,
@@ -2086,8 +2262,48 @@ const getTransforms = (
         loc: DUMMY_LOC,
         exported: transform.Identifier(node.exported, false),
         local: transform.Identifier(node.local, false),
-        // flow does not support inline exportKind for named exports
-        exportKind: 'value',
+        exportKind: node.exportKind,
+      };
+    },
+    ConstructorTypeAnnotation(
+      node: FlowESTree.ConstructorTypeAnnotation,
+    ): TSESTree.TSConstructorType {
+      const params = node.params.map(transform.FunctionTypeParam);
+      if (node.rest != null) {
+        const rest = node.rest;
+        params.push({
+          type: 'RestElement',
+          loc: DUMMY_LOC,
+          argument:
+            rest.name == null
+              ? {
+                  type: 'Identifier',
+                  loc: DUMMY_LOC,
+                  name: '$$REST$$',
+                }
+              : transform.Identifier(rest.name, false),
+          typeAnnotation: {
+            type: 'TSTypeAnnotation',
+            loc: DUMMY_LOC,
+            typeAnnotation: transformTypeAnnotationType(rest.typeAnnotation),
+          },
+        });
+      }
+
+      return {
+        type: 'TSConstructorType',
+        loc: DUMMY_LOC,
+        abstract: node.abstract,
+        params,
+        returnType: {
+          type: 'TSTypeAnnotation',
+          loc: DUMMY_LOC,
+          typeAnnotation: transformTypeAnnotationType(node.returnType),
+        },
+        typeParameters:
+          node.typeParameters == null
+            ? undefined
+            : transform.TypeParameterDeclaration(node.typeParameters),
       };
     },
     FunctionTypeAnnotation(
@@ -2136,7 +2352,10 @@ const getTransforms = (
         returnType: {
           type: 'TSTypeAnnotation',
           loc: DUMMY_LOC,
-          typeAnnotation: transformTypeAnnotationType(node.returnType),
+          typeAnnotation:
+            node.returnType == null
+              ? {type: 'TSAnyKeyword', loc: DUMMY_LOC}
+              : transformTypeAnnotationType(node.returnType),
         },
         typeParameters:
           node.typeParameters == null
@@ -2163,6 +2382,14 @@ const getTransforms = (
     GenericTypeAnnotation(
       node: FlowESTree.GenericTypeAnnotation,
     ): TSESTree.TypeNode {
+      const importType = transformImportTypeReference(
+        node.id,
+        transform.TypeParameterInstantiation(node.typeParameters) ?? null,
+      );
+      if (importType != null) {
+        return importType;
+      }
+
       const [fullTypeName, baseId] = (() => {
         let names: Array<string> = [];
         let currentNode = node.id;
@@ -3189,13 +3416,19 @@ const getTransforms = (
         }
       }
 
+      const typeName =
+        node.id.type === 'Identifier'
+          ? transform.Identifier(node.id, false)
+          : node.id.type === 'QualifiedTypeIdentifier'
+            ? transform.QualifiedTypeIdentifier(node.id)
+            : null;
+      if (typeName == null) {
+        throw unexpectedTranslationError(node, 'Unreachable import type');
+      }
       return {
         type: 'TSTypeReference',
         loc: DUMMY_LOC,
-        typeName:
-          node.id.type === 'Identifier'
-            ? transform.Identifier(node.id, false)
-            : transform.QualifiedTypeIdentifier(node.id),
+        typeName,
         typeArguments: transform.TypeParameterInstantiation(
           node.typeParameters,
         ),
@@ -3503,11 +3736,15 @@ const getTransforms = (
           },
           constraint: transformTypeAnnotationType(prop.sourceType),
           readonly:
-            prop.variance?.kind === 'plus' ||
-            prop.variance?.kind === 'readonly',
+            prop.varianceOp ??
+            (prop.variance?.kind === 'plus' ||
+              prop.variance?.kind === 'readonly'),
           optional: prop.optional === 'Optional',
           typeAnnotation: transformTypeAnnotationType(prop.propType),
-          nameType: null,
+          nameType:
+            prop.nameType == null
+              ? null
+              : transformTypeAnnotationType(prop.nameType),
         };
 
         return tsProp;
@@ -3557,6 +3794,10 @@ const getTransforms = (
             );
           }
 
+          if (property.type === 'ObjectTypePrivateField') {
+            return unsupportedAnnotation(property, 'private type fields');
+          }
+
           members.push({
             start: property.range[0],
             node: transform.ObjectTypeProperty(property),
@@ -3678,6 +3919,8 @@ const getTransforms = (
               property,
               'object type with mapped type property',
             );
+          } else if (property.type === 'ObjectTypePrivateField') {
+            return unsupportedAnnotation(property, 'private type fields');
           } else {
             members.push({
               start: property.range[0],
@@ -3772,6 +4015,9 @@ const getTransforms = (
       node: FlowESTree.ObjectTypeIndexer,
     ): TSESTree.TSIndexSignature | TSESTree.TSPropertySignatureComputedName {
       if (node.key.type === 'GenericTypeAnnotation') {
+        if (node.key.id.type === 'ImportType') {
+          throw translationError(node, 'Unsupported import type indexer key');
+        }
         const ident =
           node.key.id.type === 'Identifier' ? node.key.id : node.key.id.id;
         return {
@@ -3975,14 +4221,18 @@ const getTransforms = (
       node: FlowESTree.QualifiedTypeIdentifier,
     ): TSESTree.TSQualifiedName {
       const qual = node.qualification;
+      if (qual.type === 'ImportType') {
+        throw unexpectedTranslationError(qual, 'Unreachable import type');
+      }
+      const left =
+        qual.type === 'Identifier'
+          ? transform.Identifier(qual, false)
+          : transform.QualifiedTypeIdentifier(qual);
 
       return {
         type: 'TSQualifiedName',
         loc: DUMMY_LOC,
-        left:
-          qual.type === 'Identifier'
-            ? transform.Identifier(qual, false)
-            : transform.QualifiedTypeIdentifier(qual),
+        left,
         right: transform.Identifier(node.id, false),
       };
     },
@@ -3990,14 +4240,18 @@ const getTransforms = (
       node: FlowESTree.QualifiedTypeofIdentifier,
     ): TSESTree.TSQualifiedName {
       const qual = node.qualification;
+      if (qual.type === 'ImportType') {
+        throw unexpectedTranslationError(qual, 'Unreachable import type');
+      }
+      const left =
+        qual.type === 'Identifier'
+          ? transform.Identifier(qual, false)
+          : transform.QualifiedTypeofIdentifier(qual);
 
       return {
         type: 'TSQualifiedName',
         loc: DUMMY_LOC,
-        left:
-          qual.type === 'Identifier'
-            ? transform.Identifier(qual, false)
-            : transform.QualifiedTypeofIdentifier(qual),
+        left,
         right: transform.Identifier(node.id, false),
       };
     },
@@ -4059,6 +4313,24 @@ const getTransforms = (
         loc: DUMMY_LOC,
       };
     },
+    TemplateLiteralTypeAnnotation(
+      node: FlowESTree.TemplateLiteralTypeAnnotation,
+    ): TSESTree.TSTemplateLiteralType {
+      return {
+        type: 'TSTemplateLiteralType',
+        loc: DUMMY_LOC,
+        quasis: node.quasis.map(quasi => ({
+          type: 'TemplateElement',
+          loc: DUMMY_LOC,
+          tail: quasi.tail,
+          value: {
+            cooked: quasi.value.cooked,
+            raw: quasi.value.raw,
+          },
+        })),
+        types: node.types.map(transformTypeAnnotationType),
+      };
+    },
     TupleTypeAnnotation(
       node: FlowESTree.TupleTypeAnnotation,
     ): TSESTree.TSTupleType | TSESTree.TSTypeOperator {
@@ -4141,6 +4413,16 @@ const getTransforms = (
           }
         : tupleAnnot;
     },
+    TupleTypeElement(node: FlowESTree.TupleTypeElement): TSESTree.TypeNode {
+      const elementType = transformTypeAnnotationType(node.elementType);
+      return node.optional
+        ? {
+            type: 'TSOptionalType',
+            loc: DUMMY_LOC,
+            typeAnnotation: elementType,
+          }
+        : elementType;
+    },
     TypeAlias(node: FlowESTree.TypeAlias): TSESTree.TSTypeAliasDeclaration {
       return transform.DeclareTypeAlias(node);
     },
@@ -4154,6 +4436,30 @@ const getTransforms = (
     TypeofTypeAnnotation(
       node: FlowESTree.TypeofTypeAnnotation,
     ): TSESTree.TSTypeQuery {
+      if (node.argument.type === 'ImportType') {
+        const importType = transformImportTypeReference(node.argument);
+        if (importType == null) {
+          throw unexpectedTranslationError(node, 'Invalid import type');
+        }
+        return {
+          type: 'TSTypeQuery',
+          loc: DUMMY_LOC,
+          exprName: importType,
+          typeArguments: undefined,
+        };
+      }
+      const importType =
+        node.argument.type === 'QualifiedTypeofIdentifier'
+          ? transformImportTypeReference(node.argument)
+          : null;
+      if (importType != null) {
+        return {
+          type: 'TSTypeQuery',
+          loc: DUMMY_LOC,
+          exprName: importType,
+          typeArguments: undefined,
+        };
+      }
       switch (node.argument.type) {
         case 'Identifier':
           return {
@@ -4169,6 +4475,11 @@ const getTransforms = (
             exprName: transform.QualifiedTypeofIdentifier(node.argument),
             typeArguments: undefined,
           };
+        default:
+          throw unexpectedTranslationError(
+            node.argument,
+            'Unexpected typeof annotation argument',
+          );
       }
     },
     TypeParameter(node: FlowESTree.TypeParameter): TSESTree.TSTypeParameter {
@@ -4326,8 +4637,15 @@ const getTransforms = (
         typeAnnotation: transformTypeAnnotationType(node.argument),
       };
     },
-    TypeOperator(node: FlowESTree.RendersType): TSESTree.TypeNode {
+    TypeOperator(node: FlowESTree.TypeOperator): TSESTree.TypeNode {
       switch (node.operator) {
+        case 'unique':
+          return {
+            type: 'TSTypeOperator',
+            loc: DUMMY_LOC,
+            operator: 'unique',
+            typeAnnotation: transformTypeAnnotationType(node.typeAnnotation),
+          };
         case 'renders':
         case 'renders?':
         case 'renders*': {