@react-native/codegen 0.72.1 → 0.72.3

package/lib/parsers/typescript/modules/index.js

@@ -140,59 +140,119 @@ function _iterableToArrayLimit(arr, i) {
 function _arrayWithHoles(arr) {
   if (Array.isArray(arr)) return arr;
 }
-const _require = require('../../utils'),
-  visit = _require.visit,
-  isModuleRegistryCall = _require.isModuleRegistryCall,
-  verifyPlatforms = _require.verifyPlatforms;
-const _require2 = require('../utils'),
-  resolveTypeAnnotation = _require2.resolveTypeAnnotation,
-  getTypes = _require2.getTypes;
-const _require3 = require('../../parsers-commons'),
-  parseObjectProperty = _require3.parseObjectProperty,
-  translateDefault = _require3.translateDefault,
-  buildPropertySchema = _require3.buildPropertySchema;
-const _require4 = require('../../parsers-primitives'),
-  emitArrayType = _require4.emitArrayType,
-  emitBoolean = _require4.emitBoolean,
-  emitDouble = _require4.emitDouble,
-  emitFloat = _require4.emitFloat,
-  emitFunction = _require4.emitFunction,
-  emitNumber = _require4.emitNumber,
-  emitInt32 = _require4.emitInt32,
-  emitObject = _require4.emitObject,
-  emitPromise = _require4.emitPromise,
-  emitRootTag = _require4.emitRootTag,
-  emitVoid = _require4.emitVoid,
-  emitString = _require4.emitString,
-  emitStringish = _require4.emitStringish,
-  emitMixed = _require4.emitMixed,
-  emitUnion = _require4.emitUnion,
-  typeAliasResolution = _require4.typeAliasResolution,
-  translateArrayTypeAnnotation = _require4.translateArrayTypeAnnotation;
-const _require5 = require('../../errors'),
-  UnsupportedGenericParserError = _require5.UnsupportedGenericParserError,
+const _require = require('../parseTopLevelType'),
+  flattenIntersectionType = _require.flattenIntersectionType;
+const _require2 = require('../components/componentsUtils'),
+  flattenProperties = _require2.flattenProperties;
+const _require3 = require('../../utils'),
+  visit = _require3.visit,
+  isModuleRegistryCall = _require3.isModuleRegistryCall,
+  verifyPlatforms = _require3.verifyPlatforms;
+const _require4 = require('../utils'),
+  resolveTypeAnnotation = _require4.resolveTypeAnnotation;
+const _require5 = require('../../parsers-commons'),
+  parseObjectProperty = _require5.parseObjectProperty,
+  buildPropertySchema = _require5.buildPropertySchema;
+const _require6 = require('../../parsers-primitives'),
+  typeEnumResolution = _require6.typeEnumResolution;
+const _require7 = require('../../parsers-primitives'),
+  emitArrayType = _require7.emitArrayType,
+  emitBoolean = _require7.emitBoolean,
+  emitDouble = _require7.emitDouble,
+  emitFloat = _require7.emitFloat,
+  emitFunction = _require7.emitFunction,
+  emitNumber = _require7.emitNumber,
+  emitInt32 = _require7.emitInt32,
+  emitGenericObject = _require7.emitGenericObject,
+  emitObject = _require7.emitObject,
+  emitPromise = _require7.emitPromise,
+  emitRootTag = _require7.emitRootTag,
+  emitVoid = _require7.emitVoid,
+  emitString = _require7.emitString,
+  emitStringish = _require7.emitStringish,
+  emitMixed = _require7.emitMixed,
+  emitUnion = _require7.emitUnion,
+  typeAliasResolution = _require7.typeAliasResolution,
+  translateArrayTypeAnnotation = _require7.translateArrayTypeAnnotation;
+const _require8 = require('../../errors'),
+  UnsupportedGenericParserError = _require8.UnsupportedGenericParserError,
   UnsupportedTypeAnnotationParserError =
-    _require5.UnsupportedTypeAnnotationParserError,
-  IncorrectModuleRegistryCallArgumentTypeParserError =
-    _require5.IncorrectModuleRegistryCallArgumentTypeParserError;
-const _require6 = require('../../error-utils'),
-  throwIfUntypedModule = _require6.throwIfUntypedModule,
+    _require8.UnsupportedTypeAnnotationParserError;
+const _require9 = require('../../error-utils'),
+  throwIfUntypedModule = _require9.throwIfUntypedModule,
   throwIfUnusedModuleInterfaceParserError =
-    _require6.throwIfUnusedModuleInterfaceParserError,
-  throwIfModuleInterfaceNotFound = _require6.throwIfModuleInterfaceNotFound,
-  throwIfModuleInterfaceIsMisnamed = _require6.throwIfModuleInterfaceIsMisnamed,
+    _require9.throwIfUnusedModuleInterfaceParserError,
+  throwIfModuleInterfaceNotFound = _require9.throwIfModuleInterfaceNotFound,
+  throwIfModuleInterfaceIsMisnamed = _require9.throwIfModuleInterfaceIsMisnamed,
   throwIfWrongNumberOfCallExpressionArgs =
-    _require6.throwIfWrongNumberOfCallExpressionArgs,
+    _require9.throwIfWrongNumberOfCallExpressionArgs,
   throwIfMoreThanOneModuleRegistryCalls =
-    _require6.throwIfMoreThanOneModuleRegistryCalls,
+    _require9.throwIfMoreThanOneModuleRegistryCalls,
   throwIfMoreThanOneModuleInterfaceParserError =
-    _require6.throwIfMoreThanOneModuleInterfaceParserError,
+    _require9.throwIfMoreThanOneModuleInterfaceParserError,
   throwIfIncorrectModuleRegistryCallTypeParameterParserError =
-    _require6.throwIfIncorrectModuleRegistryCallTypeParameterParserError;
-const _require7 = require('../parser'),
-  TypeScriptParser = _require7.TypeScriptParser;
+    _require9.throwIfIncorrectModuleRegistryCallTypeParameterParserError,
+  throwIfIncorrectModuleRegistryCallArgument =
+    _require9.throwIfIncorrectModuleRegistryCallArgument,
+  throwIfPartialNotAnnotatingTypeParameter =
+    _require9.throwIfPartialNotAnnotatingTypeParameter,
+  throwIfPartialWithMoreParameter = _require9.throwIfPartialWithMoreParameter;
 const language = 'TypeScript';
-const parser = new TypeScriptParser();
+function translateObjectTypeAnnotation(
+  hasteModuleName,
+  /**
+   * TODO(T108222691): Use flow-types for @babel/parser
+   */
+  nullable,
+  objectMembers,
+  typeResolutionStatus,
+  baseTypes,
+  types,
+  aliasMap,
+  enumMap,
+  tryParse,
+  cxxOnly,
+  parser,
+) {
+  // $FlowFixMe[missing-type-arg]
+  const properties = objectMembers
+    .map(property => {
+      return tryParse(() => {
+        return parseObjectProperty(
+          property,
+          hasteModuleName,
+          types,
+          aliasMap,
+          enumMap,
+          tryParse,
+          cxxOnly,
+          nullable,
+          translateTypeAnnotation,
+          parser,
+        );
+      });
+    })
+    .filter(Boolean);
+  let objectTypeAnnotation;
+  if (baseTypes.length === 0) {
+    objectTypeAnnotation = {
+      type: 'ObjectTypeAnnotation',
+      properties,
+    };
+  } else {
+    objectTypeAnnotation = {
+      type: 'ObjectTypeAnnotation',
+      properties,
+      baseTypes,
+    };
+  }
+  return typeAliasResolution(
+    typeResolutionStatus,
+    objectTypeAnnotation,
+    aliasMap,
+    nullable,
+  );
+}
 function translateTypeAnnotation(
   hasteModuleName,
   /**
@@ -201,8 +261,10 @@ function translateTypeAnnotation(
   typeScriptTypeAnnotation,
   types,
   aliasMap,
+  enumMap,
   tryParse,
   cxxOnly,
+  parser,
 ) {
   const _resolveTypeAnnotatio = resolveTypeAnnotation(
       typeScriptTypeAnnotation,
@@ -210,19 +272,20 @@ function translateTypeAnnotation(
     ),
     nullable = _resolveTypeAnnotatio.nullable,
     typeAnnotation = _resolveTypeAnnotatio.typeAnnotation,
-    typeAliasResolutionStatus = _resolveTypeAnnotatio.typeAliasResolutionStatus;
+    typeResolutionStatus = _resolveTypeAnnotatio.typeResolutionStatus;
   switch (typeAnnotation.type) {
     case 'TSArrayType': {
       return translateArrayTypeAnnotation(
         hasteModuleName,
         types,
         aliasMap,
+        enumMap,
         cxxOnly,
         'Array',
         typeAnnotation.elementType,
         nullable,
-        language,
         translateTypeAnnotation,
+        parser,
       );
     }
     case 'TSTypeOperator': {
@@ -234,12 +297,13 @@ function translateTypeAnnotation(
           hasteModuleName,
           types,
           aliasMap,
+          enumMap,
           cxxOnly,
           'ReadonlyArray',
           typeAnnotation.typeAnnotation.elementType,
           nullable,
-          language,
           translateTypeAnnotation,
+          parser,
         );
       } else {
         throw new UnsupportedGenericParserError(
@@ -262,6 +326,7 @@ function translateTypeAnnotation(
             nullable,
             types,
             aliasMap,
+            enumMap,
             tryParse,
             cxxOnly,
             translateTypeAnnotation,
@@ -275,6 +340,7 @@ function translateTypeAnnotation(
             parser,
             types,
             aliasMap,
+            enumMap,
             cxxOnly,
             nullable,
             translateTypeAnnotation,
@@ -294,46 +360,154 @@ function translateTypeAnnotation(
         }
         case 'UnsafeObject':
         case 'Object': {
-          return emitObject(nullable);
+          return emitGenericObject(nullable);
+        }
+        case 'Partial': {
+          throwIfPartialWithMoreParameter(typeAnnotation);
+          const annotatedElement = parser.extractAnnotatedElement(
+            typeAnnotation,
+            types,
+          );
+          throwIfPartialNotAnnotatingTypeParameter(
+            typeAnnotation,
+            types,
+            parser,
+          );
+          const properties = annotatedElement.typeAnnotation.members.map(
+            member => {
+              return {
+                name: member.key.name,
+                optional: true,
+                typeAnnotation: translateTypeAnnotation(
+                  hasteModuleName,
+                  member.typeAnnotation.typeAnnotation,
+                  types,
+                  aliasMap,
+                  enumMap,
+                  tryParse,
+                  cxxOnly,
+                  parser,
+                ),
+              };
+            },
+          );
+          return emitObject(nullable, properties);
         }
         default: {
-          return translateDefault(
+          throw new UnsupportedGenericParserError(
             hasteModuleName,
             typeAnnotation,
-            types,
-            nullable,
             parser,
           );
         }
       }
     }
+    case 'TSInterfaceDeclaration': {
+      var _typeAnnotation$exten;
+      const baseTypes = (
+        (_typeAnnotation$exten = typeAnnotation.extends) !== null &&
+        _typeAnnotation$exten !== void 0
+          ? _typeAnnotation$exten
+          : []
+      ).map(extend => extend.expression.name);
+      for (const baseType of baseTypes) {
+        // ensure base types exist and appear in aliasMap
+        translateTypeAnnotation(
+          hasteModuleName,
+          {
+            type: 'TSTypeReference',
+            typeName: {
+              type: 'Identifier',
+              name: baseType,
+            },
+          },
+          types,
+          aliasMap,
+          enumMap,
+          tryParse,
+          cxxOnly,
+          parser,
+        );
+      }
+      return translateObjectTypeAnnotation(
+        hasteModuleName,
+        nullable,
+        flattenProperties([typeAnnotation], types),
+        typeResolutionStatus,
+        baseTypes,
+        types,
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        parser,
+      );
+    }
+    case 'TSIntersectionType': {
+      return translateObjectTypeAnnotation(
+        hasteModuleName,
+        nullable,
+        flattenProperties(
+          flattenIntersectionType(typeAnnotation, types),
+          types,
+        ),
+        typeResolutionStatus,
+        [],
+        types,
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        parser,
+      );
+    }
     case 'TSTypeLiteral': {
-      const objectTypeAnnotation = {
-        type: 'ObjectTypeAnnotation',
-        // $FlowFixMe[missing-type-arg]
-        properties: typeAnnotation.members
-          .map(property => {
-            return tryParse(() => {
-              return parseObjectProperty(
-                property,
-                hasteModuleName,
-                types,
-                aliasMap,
-                tryParse,
-                cxxOnly,
-                nullable,
-                translateTypeAnnotation,
-                parser,
-              );
-            });
-          })
-          .filter(Boolean),
-      };
-      return typeAliasResolution(
-        typeAliasResolutionStatus,
-        objectTypeAnnotation,
+      // if there is TSIndexSignature, then it is a dictionary
+      if (typeAnnotation.members) {
+        const indexSignatures = typeAnnotation.members.filter(
+          member => member.type === 'TSIndexSignature',
+        );
+        if (indexSignatures.length > 0) {
+          // check the property type to prevent developers from using unsupported types
+          // the return value from `translateTypeAnnotation` is unused
+          const propertyType = indexSignatures[0].typeAnnotation;
+          translateTypeAnnotation(
+            hasteModuleName,
+            propertyType,
+            types,
+            aliasMap,
+            enumMap,
+            tryParse,
+            cxxOnly,
+            parser,
+          );
+          // no need to do further checking
+          return emitGenericObject(nullable);
+        }
+      }
+      return translateObjectTypeAnnotation(
+        hasteModuleName,
+        nullable,
+        typeAnnotation.members,
+        typeResolutionStatus,
+        [],
+        types,
         aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        parser,
+      );
+    }
+    case 'TSEnumDeclaration': {
+      return typeEnumResolution(
+        typeAnnotation,
+        typeResolutionStatus,
         nullable,
+        hasteModuleName,
+        language,
+        enumMap,
+        parser,
       );
     }
     case 'TSBooleanKeyword': {
@@ -355,10 +529,11 @@ function translateTypeAnnotation(
         typeAnnotation,
         types,
         aliasMap,
+        enumMap,
         tryParse,
         cxxOnly,
         translateTypeAnnotation,
-        language,
+        parser,
       );
     }
     case 'TSUnionType': {
@@ -380,17 +555,6 @@ function translateTypeAnnotation(
     }
   }
 }
-function isModuleInterface(node) {
-  var _node$extends;
-  return (
-    node.type === 'TSInterfaceDeclaration' &&
-    ((_node$extends = node.extends) === null || _node$extends === void 0
-      ? void 0
-      : _node$extends.length) === 1 &&
-    node.extends[0].type === 'TSExpressionWithTypeArguments' &&
-    node.extends[0].expression.name === 'TurboModule'
-  );
-}
 function buildModuleSchema(
   hasteModuleName,
   /**
@@ -398,9 +562,12 @@ function buildModuleSchema(
    */
   ast,
   tryParse,
+  parser,
 ) {
-  const types = getTypes(ast);
-  const moduleSpecs = Object.values(types).filter(isModuleInterface);
+  const types = parser.getTypes(ast);
+  const moduleSpecs = Object.values(types).filter(t =>
+    parser.isModuleInterface(t),
+  );
   throwIfModuleInterfaceNotFound(
     moduleSpecs.length,
     hasteModuleName,
@@ -430,13 +597,11 @@ function buildModuleSchema(
       hasteModuleName,
       moduleSpec,
       callExpressions,
-      language,
     );
     throwIfMoreThanOneModuleRegistryCalls(
       hasteModuleName,
       callExpressions,
       callExpressions.length,
-      language,
     );
     const callExpression = callExpressions[0];
     const typeParameters = callExpression.typeParameters;
@@ -446,18 +611,12 @@ function buildModuleSchema(
       callExpression,
       methodName,
       callExpression.arguments.length,
-      language,
     );
-    if (callExpression.arguments[0].type !== 'StringLiteral') {
-      const type = callExpression.arguments[0].type;
-      throw new IncorrectModuleRegistryCallArgumentTypeParserError(
-        hasteModuleName,
-        callExpression.arguments[0],
-        methodName,
-        type,
-        language,
-      );
-    }
+    throwIfIncorrectModuleRegistryCallArgument(
+      hasteModuleName,
+      callExpression.arguments[0],
+      methodName,
+    );
     const $moduleName = callExpression.arguments[0].value;
     throwIfUntypedModule(
       typeParameters,
@@ -465,7 +624,6 @@ function buildModuleSchema(
       callExpression,
       methodName,
       $moduleName,
-      language,
     );
     throwIfIncorrectModuleRegistryCallTypeParameterParserError(
       hasteModuleName,
@@ -494,30 +652,37 @@ function buildModuleSchema(
     )
     .map(property => {
       const aliasMap = {};
+      const enumMap = {};
       return tryParse(() => ({
         aliasMap: aliasMap,
+        enumMap: enumMap,
         propertyShape: buildPropertySchema(
           hasteModuleName,
           property,
           types,
           aliasMap,
+          enumMap,
           tryParse,
           cxxOnly,
-          language,
           resolveTypeAnnotation,
           translateTypeAnnotation,
+          parser,
         ),
       }));
     })
     .filter(Boolean)
     .reduce(
-      (moduleSchema, {aliasMap, propertyShape}) => {
+      (moduleSchema, {aliasMap, enumMap, propertyShape}) => {
         return {
           type: 'NativeModule',
-          aliases: _objectSpread(
-            _objectSpread({}, moduleSchema.aliases),
+          aliasMap: _objectSpread(
+            _objectSpread({}, moduleSchema.aliasMap),
             aliasMap,
           ),
+          enumMap: _objectSpread(
+            _objectSpread({}, moduleSchema.enumMap),
+            enumMap,
+          ),
           spec: {
             properties: [...moduleSchema.spec.properties, propertyShape],
           },
@@ -527,7 +692,8 @@ function buildModuleSchema(
       },
       {
         type: 'NativeModule',
-        aliases: {},
+        aliasMap: {},
+        enumMap: {},
         spec: {
           properties: [],
         },