@react-native/codegen 0.72.1

package/lib/parsers/parsers-commons.js

@@ -0,0 +1,448 @@
+/**
+ * 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 _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('./error-utils'),
+  throwIfPropertyValueTypeIsUnsupported =
+    _require.throwIfPropertyValueTypeIsUnsupported,
+  throwIfUnsupportedFunctionParamTypeAnnotationParserError =
+    _require.throwIfUnsupportedFunctionParamTypeAnnotationParserError,
+  throwIfUnsupportedFunctionReturnTypeAnnotationParserError =
+    _require.throwIfUnsupportedFunctionReturnTypeAnnotationParserError,
+  throwIfModuleTypeIsUnsupported = _require.throwIfModuleTypeIsUnsupported;
+const _require2 = require('./errors'),
+  MissingTypeParameterGenericParserError =
+    _require2.MissingTypeParameterGenericParserError,
+  MoreThanOneTypeParameterGenericParserError =
+    _require2.MoreThanOneTypeParameterGenericParserError,
+  UnsupportedEnumDeclarationParserError =
+    _require2.UnsupportedEnumDeclarationParserError,
+  UnsupportedGenericParserError = _require2.UnsupportedGenericParserError,
+  UnsupportedObjectPropertyTypeAnnotationParserError =
+    _require2.UnsupportedObjectPropertyTypeAnnotationParserError,
+  UnnamedFunctionParamParserError = _require2.UnnamedFunctionParamParserError;
+const invariant = require('invariant');
+function wrapModuleSchema(nativeModuleSchema, hasteModuleName) {
+  return {
+    modules: {
+      [hasteModuleName]: nativeModuleSchema,
+    },
+  };
+}
+function unwrapNullable(x) {
+  if (x.type === 'NullableTypeAnnotation') {
+    return [x.typeAnnotation, true];
+  }
+  return [x, false];
+}
+function wrapNullable(nullable, typeAnnotation) {
+  if (!nullable) {
+    return typeAnnotation;
+  }
+  return {
+    type: 'NullableTypeAnnotation',
+    typeAnnotation,
+  };
+}
+function assertGenericTypeAnnotationHasExactlyOneTypeParameter(
+  moduleName,
+  /**
+   * TODO(T108222691): Use flow-types for @babel/parser
+   */
+  typeAnnotation,
+  parser,
+) {
+  if (typeAnnotation.typeParameters == null) {
+    throw new MissingTypeParameterGenericParserError(
+      moduleName,
+      typeAnnotation,
+      parser,
+    );
+  }
+  const typeAnnotationType = parser.typeParameterInstantiation;
+  invariant(
+    typeAnnotation.typeParameters.type === typeAnnotationType,
+    `assertGenericTypeAnnotationHasExactlyOneTypeParameter: Type parameters must be an AST node of type '${typeAnnotationType}'`,
+  );
+  if (typeAnnotation.typeParameters.params.length !== 1) {
+    throw new MoreThanOneTypeParameterGenericParserError(
+      moduleName,
+      typeAnnotation,
+      parser,
+    );
+  }
+}
+function isObjectProperty(property, language) {
+  switch (language) {
+    case 'Flow':
+      return (
+        property.type === 'ObjectTypeProperty' ||
+        property.type === 'ObjectTypeIndexer'
+      );
+    case 'TypeScript':
+      return (
+        property.type === 'TSPropertySignature' ||
+        property.type === 'TSIndexSignature'
+      );
+    default:
+      return false;
+  }
+}
+function parseObjectProperty(
+  property,
+  hasteModuleName,
+  types,
+  aliasMap,
+  tryParse,
+  cxxOnly,
+  nullable,
+  translateTypeAnnotation,
+  parser,
+) {
+  const language = parser.language();
+  if (!isObjectProperty(property, language)) {
+    throw new UnsupportedObjectPropertyTypeAnnotationParserError(
+      hasteModuleName,
+      property,
+      property.type,
+      language,
+    );
+  }
+  const _property$optional = property.optional,
+    optional = _property$optional === void 0 ? false : _property$optional;
+  const name = parser.getKeyName(property, hasteModuleName);
+  const languageTypeAnnotation =
+    language === 'TypeScript'
+      ? property.typeAnnotation.typeAnnotation
+      : property.value;
+  if (
+    property.type === 'ObjectTypeIndexer' ||
+    property.type === 'TSIndexSignature'
+  ) {
+    return {
+      name,
+      optional,
+      typeAnnotation: wrapNullable(nullable, {
+        type: 'GenericObjectTypeAnnotation',
+      }), //TODO: use `emitObject` for typeAnnotation
+    };
+  }
+
+  const _unwrapNullable = unwrapNullable(
+      translateTypeAnnotation(
+        hasteModuleName,
+        languageTypeAnnotation,
+        types,
+        aliasMap,
+        tryParse,
+        cxxOnly,
+      ),
+    ),
+    _unwrapNullable2 = _slicedToArray(_unwrapNullable, 2),
+    propertyTypeAnnotation = _unwrapNullable2[0],
+    isPropertyNullable = _unwrapNullable2[1];
+  if (
+    propertyTypeAnnotation.type === 'FunctionTypeAnnotation' ||
+    propertyTypeAnnotation.type === 'PromiseTypeAnnotation' ||
+    propertyTypeAnnotation.type === 'VoidTypeAnnotation'
+  ) {
+    throwIfPropertyValueTypeIsUnsupported(
+      hasteModuleName,
+      languageTypeAnnotation,
+      property.key,
+      propertyTypeAnnotation.type,
+      language,
+    );
+  }
+  return {
+    name,
+    optional,
+    typeAnnotation: wrapNullable(isPropertyNullable, propertyTypeAnnotation),
+  };
+}
+function translateDefault(
+  hasteModuleName,
+  typeAnnotation,
+  types,
+  nullable,
+  parser,
+) {
+  const maybeEnumDeclaration =
+    types[parser.nameForGenericTypeAnnotation(typeAnnotation)];
+  if (maybeEnumDeclaration && parser.isEnumDeclaration(maybeEnumDeclaration)) {
+    const memberType = parser.getMaybeEnumMemberType(maybeEnumDeclaration);
+    if (
+      memberType === 'NumberTypeAnnotation' ||
+      memberType === 'StringTypeAnnotation'
+    ) {
+      return wrapNullable(nullable, {
+        type: 'EnumDeclaration',
+        memberType: memberType,
+      });
+    } else {
+      throw new UnsupportedEnumDeclarationParserError(
+        hasteModuleName,
+        typeAnnotation,
+        memberType,
+        parser.language(),
+      );
+    }
+  }
+  throw new UnsupportedGenericParserError(
+    hasteModuleName,
+    typeAnnotation,
+    parser,
+  );
+}
+function getTypeAnnotationParameters(typeAnnotation, language) {
+  return language === 'Flow'
+    ? typeAnnotation.params
+    : typeAnnotation.parameters;
+}
+function getFunctionNameFromParameter(param, language) {
+  return language === 'Flow' ? param.name : param.typeAnnotation;
+}
+function getParameterName(param, language) {
+  return language === 'Flow' ? param.name.name : param.name;
+}
+function getParameterTypeAnnotation(param, language) {
+  return language === 'Flow'
+    ? param.typeAnnotation
+    : param.typeAnnotation.typeAnnotation;
+}
+function getTypeAnnotationReturnType(typeAnnotation, language) {
+  return language === 'Flow'
+    ? typeAnnotation.returnType
+    : typeAnnotation.typeAnnotation.typeAnnotation;
+}
+function translateFunctionTypeAnnotation(
+  hasteModuleName,
+  // TODO(T108222691): Use flow-types for @babel/parser
+  // TODO(T71778680): This is a FunctionTypeAnnotation. Type this.
+  typeAnnotation,
+  types,
+  aliasMap,
+  tryParse,
+  cxxOnly,
+  translateTypeAnnotation,
+  language,
+) {
+  const params = [];
+  for (const param of getTypeAnnotationParameters(typeAnnotation, language)) {
+    const parsedParam = tryParse(() => {
+      if (getFunctionNameFromParameter(param, language) == null) {
+        throw new UnnamedFunctionParamParserError(
+          param,
+          hasteModuleName,
+          language,
+        );
+      }
+      const paramName = getParameterName(param, language);
+      const _unwrapNullable3 = unwrapNullable(
+          translateTypeAnnotation(
+            hasteModuleName,
+            getParameterTypeAnnotation(param, language),
+            types,
+            aliasMap,
+            tryParse,
+            cxxOnly,
+          ),
+        ),
+        _unwrapNullable4 = _slicedToArray(_unwrapNullable3, 2),
+        paramTypeAnnotation = _unwrapNullable4[0],
+        isParamTypeAnnotationNullable = _unwrapNullable4[1];
+      if (
+        paramTypeAnnotation.type === 'VoidTypeAnnotation' ||
+        paramTypeAnnotation.type === 'PromiseTypeAnnotation'
+      ) {
+        return throwIfUnsupportedFunctionParamTypeAnnotationParserError(
+          hasteModuleName,
+          param.typeAnnotation,
+          paramName,
+          paramTypeAnnotation.type,
+        );
+      }
+      return {
+        name: paramName,
+        optional: Boolean(param.optional),
+        typeAnnotation: wrapNullable(
+          isParamTypeAnnotationNullable,
+          paramTypeAnnotation,
+        ),
+      };
+    });
+    if (parsedParam != null) {
+      params.push(parsedParam);
+    }
+  }
+  const _unwrapNullable5 = unwrapNullable(
+      translateTypeAnnotation(
+        hasteModuleName,
+        getTypeAnnotationReturnType(typeAnnotation, language),
+        types,
+        aliasMap,
+        tryParse,
+        cxxOnly,
+      ),
+    ),
+    _unwrapNullable6 = _slicedToArray(_unwrapNullable5, 2),
+    returnTypeAnnotation = _unwrapNullable6[0],
+    isReturnTypeAnnotationNullable = _unwrapNullable6[1];
+  throwIfUnsupportedFunctionReturnTypeAnnotationParserError(
+    hasteModuleName,
+    typeAnnotation,
+    'FunctionTypeAnnotation',
+    language,
+    cxxOnly,
+    returnTypeAnnotation.type,
+  );
+  return {
+    type: 'FunctionTypeAnnotation',
+    returnTypeAnnotation: wrapNullable(
+      isReturnTypeAnnotationNullable,
+      returnTypeAnnotation,
+    ),
+    params,
+  };
+}
+function buildPropertySchema(
+  hasteModuleName,
+  // TODO(T108222691): [TS] Use flow-types for @babel/parser
+  // TODO(T71778680): [Flow] This is an ObjectTypeProperty containing either:
+  // - a FunctionTypeAnnotation or GenericTypeAnnotation
+  // - a NullableTypeAnnoation containing a FunctionTypeAnnotation or GenericTypeAnnotation
+  // Flow type this node
+  property,
+  types,
+  aliasMap,
+  tryParse,
+  cxxOnly,
+  language,
+  resolveTypeAnnotation,
+  translateTypeAnnotation,
+) {
+  let nullable = false;
+  let key = property.key,
+    value = property.value;
+  const methodName = key.name;
+  if (language === 'TypeScript') {
+    value =
+      property.type === 'TSMethodSignature'
+        ? property
+        : property.typeAnnotation;
+  }
+  var _resolveTypeAnnotatio = resolveTypeAnnotation(value, types);
+  nullable = _resolveTypeAnnotatio.nullable;
+  value = _resolveTypeAnnotatio.typeAnnotation;
+  throwIfModuleTypeIsUnsupported(
+    hasteModuleName,
+    property.value,
+    key.name,
+    value.type,
+    language,
+  );
+  return {
+    name: methodName,
+    optional: Boolean(property.optional),
+    typeAnnotation: wrapNullable(
+      nullable,
+      translateFunctionTypeAnnotation(
+        hasteModuleName,
+        value,
+        types,
+        aliasMap,
+        tryParse,
+        cxxOnly,
+        translateTypeAnnotation,
+        language,
+      ),
+    ),
+  };
+}
+module.exports = {
+  wrapModuleSchema,
+  unwrapNullable,
+  wrapNullable,
+  assertGenericTypeAnnotationHasExactlyOneTypeParameter,
+  isObjectProperty,
+  parseObjectProperty,
+  translateDefault,
+  translateFunctionTypeAnnotation,
+  buildPropertySchema,
+};