@react-native/codegen 0.72.2 → 0.72.4

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

@@ -10,68 +10,6 @@
 
 'use strict';
 
-function ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
-  if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    enumerableOnly &&
-      (symbols = symbols.filter(function (sym) {
-        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-      })),
-      keys.push.apply(keys, symbols);
-  }
-  return keys;
-}
-function _objectSpread(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = null != arguments[i] ? arguments[i] : {};
-    i % 2
-      ? ownKeys(Object(source), !0).forEach(function (key) {
-          _defineProperty(target, key, source[key]);
-        })
-      : Object.getOwnPropertyDescriptors
-      ? Object.defineProperties(
-          target,
-          Object.getOwnPropertyDescriptors(source),
-        )
-      : ownKeys(Object(source)).forEach(function (key) {
-          Object.defineProperty(
-            target,
-            key,
-            Object.getOwnPropertyDescriptor(source, key),
-          );
-        });
-  }
-  return target;
-}
-function _defineProperty(obj, key, value) {
-  key = _toPropertyKey(key);
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true,
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
-function _toPropertyKey(arg) {
-  var key = _toPrimitive(arg, 'string');
-  return typeof key === 'symbol' ? key : String(key);
-}
-function _toPrimitive(input, hint) {
-  if (typeof input !== 'object' || input === null) return input;
-  var prim = input[Symbol.toPrimitive];
-  if (prim !== undefined) {
-    var res = prim.call(input, hint || 'default');
-    if (typeof res !== 'object') return res;
-    throw new TypeError('@@toPrimitive must return a primitive value.');
-  }
-  return (hint === 'string' ? String : Number)(input);
-}
 function _slicedToArray(arr, i) {
   return (
     _arrayWithHoles(arr) ||
@@ -140,60 +78,33 @@ 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'),
-  unwrapNullable = _require3.unwrapNullable,
-  wrapNullable = _require3.wrapNullable,
+const _require = require('../utils'),
+  resolveTypeAnnotation = _require.resolveTypeAnnotation;
+const _require2 = require('../../parsers-commons'),
+  unwrapNullable = _require2.unwrapNullable,
+  wrapNullable = _require2.wrapNullable,
   assertGenericTypeAnnotationHasExactlyOneTypeParameter =
-    _require3.assertGenericTypeAnnotationHasExactlyOneTypeParameter,
-  parseObjectProperty = _require3.parseObjectProperty,
-  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,
-  emitGenericObject = _require4.emitGenericObject,
-  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,
-  typeEnumResolution = _require4.typeEnumResolution;
-const _require5 = require('../../errors'),
+    _require2.assertGenericTypeAnnotationHasExactlyOneTypeParameter,
+  parseObjectProperty = _require2.parseObjectProperty;
+const _require3 = require('../../parsers-primitives'),
+  emitArrayType = _require3.emitArrayType,
+  emitBoolean = _require3.emitBoolean,
+  emitFunction = _require3.emitFunction,
+  emitNumber = _require3.emitNumber,
+  emitGenericObject = _require3.emitGenericObject,
+  emitPromise = _require3.emitPromise,
+  emitRootTag = _require3.emitRootTag,
+  emitVoid = _require3.emitVoid,
+  emitString = _require3.emitString,
+  emitMixed = _require3.emitMixed,
+  emitUnion = _require3.emitUnion,
+  emitCommonTypes = _require3.emitCommonTypes,
+  typeAliasResolution = _require3.typeAliasResolution,
+  typeEnumResolution = _require3.typeEnumResolution;
+const _require4 = require('../../errors'),
   UnsupportedTypeAnnotationParserError =
-    _require5.UnsupportedTypeAnnotationParserError,
-  IncorrectModuleRegistryCallArgumentTypeParserError =
-    _require5.IncorrectModuleRegistryCallArgumentTypeParserError,
-  UnsupportedGenericParserError = _require5.UnsupportedGenericParserError;
-const _require6 = require('../../error-utils'),
-  throwIfModuleInterfaceNotFound = _require6.throwIfModuleInterfaceNotFound,
-  throwIfModuleInterfaceIsMisnamed = _require6.throwIfModuleInterfaceIsMisnamed,
-  throwIfUnusedModuleInterfaceParserError =
-    _require6.throwIfUnusedModuleInterfaceParserError,
-  throwIfWrongNumberOfCallExpressionArgs =
-    _require6.throwIfWrongNumberOfCallExpressionArgs,
-  throwIfMoreThanOneModuleRegistryCalls =
-    _require6.throwIfMoreThanOneModuleRegistryCalls,
-  throwIfIncorrectModuleRegistryCallTypeParameterParserError =
-    _require6.throwIfIncorrectModuleRegistryCallTypeParameterParserError,
-  throwIfUntypedModule = _require6.throwIfUntypedModule,
-  throwIfMoreThanOneModuleInterfaceParserError =
-    _require6.throwIfMoreThanOneModuleInterfaceParserError;
-const language = 'Flow';
+    _require4.UnsupportedTypeAnnotationParserError,
+  UnsupportedGenericParserError = _require4.UnsupportedGenericParserError;
 function translateTypeAnnotation(
   hasteModuleName,
   /**
@@ -271,59 +182,26 @@ function translateTypeAnnotation(
             isParamNullable = _unwrapNullable2[1];
           return wrapNullable(nullable || isParamNullable, paramType);
         }
-        case 'Stringish': {
-          return emitStringish(nullable);
-        }
-        case 'Int32': {
-          return emitInt32(nullable);
-        }
-        case 'Double': {
-          return emitDouble(nullable);
-        }
-        case 'Float': {
-          return emitFloat(nullable);
-        }
-        case 'UnsafeObject':
-        case 'Object': {
-          return emitGenericObject(nullable);
-        }
-        case '$Partial': {
-          if (typeAnnotation.typeParameters.params.length !== 1) {
-            throw new Error(
-              'Partials only support annotating exactly one parameter.',
-            );
-          }
-          const annotatedElement =
-            types[typeAnnotation.typeParameters.params[0].id.name];
-          if (!annotatedElement) {
-            throw new Error(
-              'Partials only support annotating a type parameter.',
-            );
-          }
-          const properties = annotatedElement.right.properties.map(prop => {
-            return {
-              name: prop.key.name,
-              optional: true,
-              typeAnnotation: translateTypeAnnotation(
-                hasteModuleName,
-                prop.value,
-                types,
-                aliasMap,
-                enumMap,
-                tryParse,
-                cxxOnly,
-                parser,
-              ),
-            };
-          });
-          return emitObject(nullable, properties);
-        }
         default: {
-          throw new UnsupportedGenericParserError(
+          const commonType = emitCommonTypes(
             hasteModuleName,
+            types,
             typeAnnotation,
+            aliasMap,
+            enumMap,
+            tryParse,
+            cxxOnly,
+            nullable,
             parser,
           );
+          if (!commonType) {
+            throw new UnsupportedGenericParserError(
+              hasteModuleName,
+              typeAnnotation,
+              parser,
+            );
+          }
+          return commonType;
         }
       }
     }
@@ -430,7 +308,6 @@ function translateTypeAnnotation(
         typeResolutionStatus,
         nullable,
         hasteModuleName,
-        language,
         enumMap,
         parser,
       );
@@ -439,164 +316,11 @@ function translateTypeAnnotation(
       throw new UnsupportedTypeAnnotationParserError(
         hasteModuleName,
         typeAnnotation,
-        language,
+        parser.language(),
       );
     }
   }
 }
-function isModuleInterface(node) {
-  return (
-    node.type === 'InterfaceDeclaration' &&
-    node.extends.length === 1 &&
-    node.extends[0].type === 'InterfaceExtends' &&
-    node.extends[0].id.name === 'TurboModule'
-  );
-}
-function buildModuleSchema(
-  hasteModuleName,
-  /**
-   * TODO(T71778680): Flow-type this node.
-   */
-  ast,
-  tryParse,
-  parser,
-) {
-  const types = getTypes(ast);
-  const moduleSpecs = Object.values(types).filter(isModuleInterface);
-  throwIfModuleInterfaceNotFound(
-    moduleSpecs.length,
-    hasteModuleName,
-    ast,
-    language,
-  );
-  throwIfMoreThanOneModuleInterfaceParserError(
-    hasteModuleName,
-    moduleSpecs,
-    language,
-  );
-  const _moduleSpecs = _slicedToArray(moduleSpecs, 1),
-    moduleSpec = _moduleSpecs[0];
-  throwIfModuleInterfaceIsMisnamed(hasteModuleName, moduleSpec.id, language);
-
-  // Parse Module Name
-  const moduleName = (() => {
-    const callExpressions = [];
-    visit(ast, {
-      CallExpression(node) {
-        if (isModuleRegistryCall(node)) {
-          callExpressions.push(node);
-        }
-      },
-    });
-    throwIfUnusedModuleInterfaceParserError(
-      hasteModuleName,
-      moduleSpec,
-      callExpressions,
-    );
-    throwIfMoreThanOneModuleRegistryCalls(
-      hasteModuleName,
-      callExpressions,
-      callExpressions.length,
-    );
-    const callExpression = callExpressions[0];
-    const typeArguments = callExpression.typeArguments;
-    const methodName = callExpression.callee.property.name;
-    throwIfWrongNumberOfCallExpressionArgs(
-      hasteModuleName,
-      callExpression,
-      methodName,
-      callExpression.arguments.length,
-    );
-    if (callExpression.arguments[0].type !== 'Literal') {
-      const type = callExpression.arguments[0].type;
-      throw new IncorrectModuleRegistryCallArgumentTypeParserError(
-        hasteModuleName,
-        callExpression.arguments[0],
-        methodName,
-        type,
-      );
-    }
-    const $moduleName = callExpression.arguments[0].value;
-    throwIfUntypedModule(
-      typeArguments,
-      hasteModuleName,
-      callExpression,
-      methodName,
-      $moduleName,
-    );
-    throwIfIncorrectModuleRegistryCallTypeParameterParserError(
-      hasteModuleName,
-      typeArguments,
-      methodName,
-      $moduleName,
-      parser,
-    );
-    return $moduleName;
-  })();
-
-  // Some module names use platform suffix to indicate platform-exclusive modules.
-  // Eventually this should be made explicit in the Flow type itself.
-  // Also check the hasteModuleName for platform suffix.
-  // Note: this shape is consistent with ComponentSchema.
-  const _verifyPlatforms = verifyPlatforms(hasteModuleName, moduleName),
-    cxxOnly = _verifyPlatforms.cxxOnly,
-    excludedPlatforms = _verifyPlatforms.excludedPlatforms;
-
-  // $FlowFixMe[missing-type-arg]
-  return moduleSpec.body.properties
-    .filter(property => property.type === 'ObjectTypeProperty')
-    .map(property => {
-      const aliasMap = {};
-      const enumMap = {};
-      return tryParse(() => ({
-        aliasMap: aliasMap,
-        enumMap: enumMap,
-        propertyShape: buildPropertySchema(
-          hasteModuleName,
-          property,
-          types,
-          aliasMap,
-          enumMap,
-          tryParse,
-          cxxOnly,
-          resolveTypeAnnotation,
-          translateTypeAnnotation,
-          parser,
-        ),
-      }));
-    })
-    .filter(Boolean)
-    .reduce(
-      (moduleSchema, {aliasMap, enumMap, propertyShape}) => ({
-        type: 'NativeModule',
-        aliasMap: _objectSpread(
-          _objectSpread({}, moduleSchema.aliasMap),
-          aliasMap,
-        ),
-        enumMap: _objectSpread(
-          _objectSpread({}, moduleSchema.enumMap),
-          enumMap,
-        ),
-        spec: {
-          properties: [...moduleSchema.spec.properties, propertyShape],
-        },
-        moduleName: moduleSchema.moduleName,
-        excludedPlatforms: moduleSchema.excludedPlatforms,
-      }),
-      {
-        type: 'NativeModule',
-        aliasMap: {},
-        enumMap: {},
-        spec: {
-          properties: [],
-        },
-        moduleName,
-        excludedPlatforms:
-          excludedPlatforms.length !== 0 ? [...excludedPlatforms] : undefined,
-      },
-    );
-}
 module.exports = {
-  buildModuleSchema,
   flowTranslateTypeAnnotation: translateTypeAnnotation,
 };