@react-native/codegen 0.72.2 → 0.72.4

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

@@ -10,192 +10,34 @@
 
 '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) ||
-    _iterableToArrayLimit(arr, i) ||
-    _unsupportedIterableToArray(arr, i) ||
-    _nonIterableRest()
-  );
-}
-function _nonIterableRest() {
-  throw new TypeError(
-    'Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.',
-  );
-}
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === 'string') return _arrayLikeToArray(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === 'Object' && o.constructor) n = o.constructor.name;
-  if (n === 'Map' || n === 'Set') return Array.from(o);
-  if (n === 'Arguments' || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
-    return _arrayLikeToArray(o, minLen);
-}
-function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
-  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-  return arr2;
-}
-function _iterableToArrayLimit(arr, i) {
-  var _i =
-    null == arr
-      ? null
-      : ('undefined' != typeof Symbol && arr[Symbol.iterator]) ||
-        arr['@@iterator'];
-  if (null != _i) {
-    var _s,
-      _e,
-      _x,
-      _r,
-      _arr = [],
-      _n = !0,
-      _d = !1;
-    try {
-      if (((_x = (_i = _i.call(arr)).next), 0 === i)) {
-        if (Object(_i) !== _i) return;
-        _n = !1;
-      } else
-        for (
-          ;
-          !(_n = (_s = _x.call(_i)).done) &&
-          (_arr.push(_s.value), _arr.length !== i);
-          _n = !0
-        );
-    } catch (err) {
-      (_d = !0), (_e = err);
-    } finally {
-      try {
-        if (!_n && null != _i.return && ((_r = _i.return()), Object(_r) !== _r))
-          return;
-      } finally {
-        if (_d) throw _e;
-      }
-    }
-    return _arr;
-  }
-}
-function _arrayWithHoles(arr) {
-  if (Array.isArray(arr)) return arr;
-}
 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,
-  getTypes = _require4.getTypes;
-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,
+const _require3 = require('../utils'),
+  resolveTypeAnnotation = _require3.resolveTypeAnnotation;
+const _require4 = require('../../parsers-commons'),
+  parseObjectProperty = _require4.parseObjectProperty;
+const _require5 = require('../../parsers-primitives'),
+  emitArrayType = _require5.emitArrayType,
+  emitBoolean = _require5.emitBoolean,
+  emitFunction = _require5.emitFunction,
+  emitNumber = _require5.emitNumber,
+  emitGenericObject = _require5.emitGenericObject,
+  emitPromise = _require5.emitPromise,
+  emitRootTag = _require5.emitRootTag,
+  emitVoid = _require5.emitVoid,
+  emitString = _require5.emitString,
+  emitMixed = _require5.emitMixed,
+  emitUnion = _require5.emitUnion,
+  emitCommonTypes = _require5.emitCommonTypes,
+  typeAliasResolution = _require5.typeAliasResolution,
+  typeEnumResolution = _require5.typeEnumResolution,
+  translateArrayTypeAnnotation = _require5.translateArrayTypeAnnotation;
+const _require6 = require('../../errors'),
+  UnsupportedGenericParserError = _require6.UnsupportedGenericParserError,
   UnsupportedTypeAnnotationParserError =
-    _require8.UnsupportedTypeAnnotationParserError,
-  IncorrectModuleRegistryCallArgumentTypeParserError =
-    _require8.IncorrectModuleRegistryCallArgumentTypeParserError;
-const _require9 = require('../../error-utils'),
-  throwIfUntypedModule = _require9.throwIfUntypedModule,
-  throwIfUnusedModuleInterfaceParserError =
-    _require9.throwIfUnusedModuleInterfaceParserError,
-  throwIfModuleInterfaceNotFound = _require9.throwIfModuleInterfaceNotFound,
-  throwIfModuleInterfaceIsMisnamed = _require9.throwIfModuleInterfaceIsMisnamed,
-  throwIfWrongNumberOfCallExpressionArgs =
-    _require9.throwIfWrongNumberOfCallExpressionArgs,
-  throwIfMoreThanOneModuleRegistryCalls =
-    _require9.throwIfMoreThanOneModuleRegistryCalls,
-  throwIfMoreThanOneModuleInterfaceParserError =
-    _require9.throwIfMoreThanOneModuleInterfaceParserError,
-  throwIfIncorrectModuleRegistryCallTypeParameterParserError =
-    _require9.throwIfIncorrectModuleRegistryCallTypeParameterParserError;
-const language = 'TypeScript';
+    _require6.UnsupportedTypeAnnotationParserError;
 function translateObjectTypeAnnotation(
   hasteModuleName,
   /**
@@ -251,6 +93,73 @@ function translateObjectTypeAnnotation(
     nullable,
   );
 }
+function translateTypeReferenceAnnotation(
+  typeName,
+  nullable,
+  typeAnnotation,
+  hasteModuleName,
+  types,
+  aliasMap,
+  enumMap,
+  tryParse,
+  cxxOnly,
+  parser,
+) {
+  switch (typeName) {
+    case 'RootTag': {
+      return emitRootTag(nullable);
+    }
+    case 'Promise': {
+      return emitPromise(
+        hasteModuleName,
+        typeAnnotation,
+        parser,
+        nullable,
+        types,
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        translateTypeAnnotation,
+      );
+    }
+    case 'Array':
+    case 'ReadonlyArray': {
+      return emitArrayType(
+        hasteModuleName,
+        typeAnnotation,
+        parser,
+        types,
+        aliasMap,
+        enumMap,
+        cxxOnly,
+        nullable,
+        translateTypeAnnotation,
+      );
+    }
+    default: {
+      const commonType = emitCommonTypes(
+        hasteModuleName,
+        types,
+        typeAnnotation,
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        nullable,
+        parser,
+      );
+      if (!commonType) {
+        throw new UnsupportedGenericParserError(
+          hasteModuleName,
+          typeAnnotation,
+          parser,
+        );
+      }
+      return commonType;
+    }
+  }
+}
 function translateTypeAnnotation(
   hasteModuleName,
   /**
@@ -312,95 +221,18 @@ function translateTypeAnnotation(
       }
     }
     case 'TSTypeReference': {
-      switch (typeAnnotation.typeName.name) {
-        case 'RootTag': {
-          return emitRootTag(nullable);
-        }
-        case 'Promise': {
-          return emitPromise(
-            hasteModuleName,
-            typeAnnotation,
-            parser,
-            nullable,
-            types,
-            aliasMap,
-            enumMap,
-            tryParse,
-            cxxOnly,
-            translateTypeAnnotation,
-          );
-        }
-        case 'Array':
-        case 'ReadonlyArray': {
-          return emitArrayType(
-            hasteModuleName,
-            typeAnnotation,
-            parser,
-            types,
-            aliasMap,
-            enumMap,
-            cxxOnly,
-            nullable,
-            translateTypeAnnotation,
-          );
-        }
-        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].typeName.name];
-          if (!annotatedElement) {
-            throw new Error(
-              'Partials only support annotating a type parameter.',
-            );
-          }
-          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: {
-          throw new UnsupportedGenericParserError(
-            hasteModuleName,
-            typeAnnotation,
-            parser,
-          );
-        }
-      }
+      return translateTypeReferenceAnnotation(
+        typeAnnotation.typeName.name,
+        nullable,
+        typeAnnotation,
+        hasteModuleName,
+        types,
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        parser,
+      );
     }
     case 'TSInterfaceDeclaration': {
       var _typeAnnotation$exten;
@@ -505,7 +337,6 @@ function translateTypeAnnotation(
         typeResolutionStatus,
         nullable,
         hasteModuleName,
-        language,
         enumMap,
         parser,
       );
@@ -550,173 +381,11 @@ function translateTypeAnnotation(
       throw new UnsupportedTypeAnnotationParserError(
         hasteModuleName,
         typeAnnotation,
-        language,
+        parser.language(),
       );
     }
   }
 }
-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,
-  /**
-   * TODO(T108222691): Use flow-types for @babel/parser
-   */
-  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 typeParameters = callExpression.typeParameters;
-    const methodName = callExpression.callee.property.name;
-    throwIfWrongNumberOfCallExpressionArgs(
-      hasteModuleName,
-      callExpression,
-      methodName,
-      callExpression.arguments.length,
-    );
-    if (callExpression.arguments[0].type !== 'StringLiteral') {
-      const type = callExpression.arguments[0].type;
-      throw new IncorrectModuleRegistryCallArgumentTypeParserError(
-        hasteModuleName,
-        callExpression.arguments[0],
-        methodName,
-        type,
-      );
-    }
-    const $moduleName = callExpression.arguments[0].value;
-    throwIfUntypedModule(
-      typeParameters,
-      hasteModuleName,
-      callExpression,
-      methodName,
-      $moduleName,
-    );
-    throwIfIncorrectModuleRegistryCallTypeParameterParserError(
-      hasteModuleName,
-      typeParameters,
-      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.body
-    .filter(
-      property =>
-        property.type === 'TSMethodSignature' ||
-        property.type === 'TSPropertySignature',
-    )
-    .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}) => {
-        return {
-          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: moduleName,
-        excludedPlatforms:
-          excludedPlatforms.length !== 0 ? [...excludedPlatforms] : undefined,
-      },
-    );
-}
 module.exports = {
-  buildModuleSchema,
   typeScriptTranslateTypeAnnotation: translateTypeAnnotation,
 };