@react-native/codegen 0.72.1

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

@@ -0,0 +1,528 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ */
+
+'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('../../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,
+  assertGenericTypeAnnotationHasExactlyOneTypeParameter =
+    _require3.assertGenericTypeAnnotationHasExactlyOneTypeParameter,
+  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'),
+  UnsupportedTypeAnnotationParserError =
+    _require5.UnsupportedTypeAnnotationParserError,
+  IncorrectModuleRegistryCallArgumentTypeParserError =
+    _require5.IncorrectModuleRegistryCallArgumentTypeParserError;
+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 _require7 = require('../parser'),
+  FlowParser = _require7.FlowParser;
+const language = 'Flow';
+const parser = new FlowParser();
+function translateTypeAnnotation(
+  hasteModuleName,
+  /**
+   * TODO(T71778680): Flow-type this node.
+   */
+  flowTypeAnnotation,
+  types,
+  aliasMap,
+  tryParse,
+  cxxOnly,
+) {
+  const _resolveTypeAnnotatio = resolveTypeAnnotation(
+      flowTypeAnnotation,
+      types,
+    ),
+    nullable = _resolveTypeAnnotatio.nullable,
+    typeAnnotation = _resolveTypeAnnotatio.typeAnnotation,
+    typeAliasResolutionStatus = _resolveTypeAnnotatio.typeAliasResolutionStatus;
+  switch (typeAnnotation.type) {
+    case 'GenericTypeAnnotation': {
+      switch (typeAnnotation.id.name) {
+        case 'RootTag': {
+          return emitRootTag(nullable);
+        }
+        case 'Promise': {
+          return emitPromise(
+            hasteModuleName,
+            typeAnnotation,
+            parser,
+            nullable,
+            types,
+            aliasMap,
+            tryParse,
+            cxxOnly,
+            translateTypeAnnotation,
+          );
+        }
+        case 'Array':
+        case '$ReadOnlyArray': {
+          return emitArrayType(
+            hasteModuleName,
+            typeAnnotation,
+            parser,
+            types,
+            aliasMap,
+            cxxOnly,
+            nullable,
+            translateTypeAnnotation,
+          );
+        }
+        case '$ReadOnly': {
+          assertGenericTypeAnnotationHasExactlyOneTypeParameter(
+            hasteModuleName,
+            typeAnnotation,
+            parser,
+          );
+          const _unwrapNullable = unwrapNullable(
+              translateTypeAnnotation(
+                hasteModuleName,
+                typeAnnotation.typeParameters.params[0],
+                types,
+                aliasMap,
+                tryParse,
+                cxxOnly,
+              ),
+            ),
+            _unwrapNullable2 = _slicedToArray(_unwrapNullable, 2),
+            paramType = _unwrapNullable2[0],
+            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 emitObject(nullable);
+        }
+        default: {
+          return translateDefault(
+            hasteModuleName,
+            typeAnnotation,
+            types,
+            nullable,
+            parser,
+          );
+        }
+      }
+    }
+    case 'ObjectTypeAnnotation': {
+      const objectTypeAnnotation = {
+        type: 'ObjectTypeAnnotation',
+        // $FlowFixMe[missing-type-arg]
+        properties: [...typeAnnotation.properties, ...typeAnnotation.indexers]
+          .map(property => {
+            return tryParse(() => {
+              return parseObjectProperty(
+                property,
+                hasteModuleName,
+                types,
+                aliasMap,
+                tryParse,
+                cxxOnly,
+                nullable,
+                translateTypeAnnotation,
+                parser,
+              );
+            });
+          })
+          .filter(Boolean),
+      };
+      return typeAliasResolution(
+        typeAliasResolutionStatus,
+        objectTypeAnnotation,
+        aliasMap,
+        nullable,
+      );
+    }
+    case 'BooleanTypeAnnotation': {
+      return emitBoolean(nullable);
+    }
+    case 'NumberTypeAnnotation': {
+      return emitNumber(nullable);
+    }
+    case 'VoidTypeAnnotation': {
+      return emitVoid(nullable);
+    }
+    case 'StringTypeAnnotation': {
+      return emitString(nullable);
+    }
+    case 'FunctionTypeAnnotation': {
+      return emitFunction(
+        nullable,
+        hasteModuleName,
+        typeAnnotation,
+        types,
+        aliasMap,
+        tryParse,
+        cxxOnly,
+        translateTypeAnnotation,
+        language,
+      );
+    }
+    case 'UnionTypeAnnotation': {
+      return emitUnion(nullable, hasteModuleName, typeAnnotation, parser);
+    }
+    case 'StringLiteralTypeAnnotation': {
+      // 'a' is a special case for 'a' | 'b' but the type name is different
+      return wrapNullable(nullable, {
+        type: 'UnionTypeAnnotation',
+        memberType: 'StringTypeAnnotation',
+      });
+    }
+    case 'MixedTypeAnnotation': {
+      if (cxxOnly) {
+        return emitMixed(nullable);
+      }
+      // Fallthrough
+    }
+
+    default: {
+      throw new UnsupportedTypeAnnotationParserError(
+        hasteModuleName,
+        typeAnnotation,
+        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,
+) {
+  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,
+      language,
+    );
+    throwIfMoreThanOneModuleRegistryCalls(
+      hasteModuleName,
+      callExpressions,
+      callExpressions.length,
+      language,
+    );
+    const callExpression = callExpressions[0];
+    const typeArguments = callExpression.typeArguments;
+    const methodName = callExpression.callee.property.name;
+    throwIfWrongNumberOfCallExpressionArgs(
+      hasteModuleName,
+      callExpression,
+      methodName,
+      callExpression.arguments.length,
+      language,
+    );
+    if (callExpression.arguments[0].type !== 'Literal') {
+      const type = callExpression.arguments[0].type;
+      throw new IncorrectModuleRegistryCallArgumentTypeParserError(
+        hasteModuleName,
+        callExpression.arguments[0],
+        methodName,
+        type,
+        language,
+      );
+    }
+    const $moduleName = callExpression.arguments[0].value;
+    throwIfUntypedModule(
+      typeArguments,
+      hasteModuleName,
+      callExpression,
+      methodName,
+      $moduleName,
+      language,
+    );
+    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 = {};
+      return tryParse(() => ({
+        aliasMap: aliasMap,
+        propertyShape: buildPropertySchema(
+          hasteModuleName,
+          property,
+          types,
+          aliasMap,
+          tryParse,
+          cxxOnly,
+          language,
+          resolveTypeAnnotation,
+          translateTypeAnnotation,
+        ),
+      }));
+    })
+    .filter(Boolean)
+    .reduce(
+      (moduleSchema, {aliasMap, propertyShape}) => ({
+        type: 'NativeModule',
+        aliases: _objectSpread(
+          _objectSpread({}, moduleSchema.aliases),
+          aliasMap,
+        ),
+        spec: {
+          properties: [...moduleSchema.spec.properties, propertyShape],
+        },
+        moduleName: moduleSchema.moduleName,
+        excludedPlatforms: moduleSchema.excludedPlatforms,
+      }),
+      {
+        type: 'NativeModule',
+        aliases: {},
+        spec: {
+          properties: [],
+        },
+        moduleName,
+        excludedPlatforms:
+          excludedPlatforms.length !== 0 ? [...excludedPlatforms] : undefined,
+      },
+    );
+}
+module.exports = {
+  buildModuleSchema,
+  flowTranslateTypeAnnotation: translateTypeAnnotation,
+};