@react-native/codegen 0.72.1

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

@@ -0,0 +1,435 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import type {
+  NamedShape,
+  NativeModuleAliasMap,
+  NativeModuleBaseTypeAnnotation,
+  NativeModulePropertyShape,
+  NativeModuleTypeAnnotation,
+  NativeModuleSchema,
+  Nullable,
+} from '../../../CodegenSchema';
+
+import type {ParserErrorCapturer, TypeDeclarationMap} from '../../utils';
+
+const {visit, isModuleRegistryCall, verifyPlatforms} = require('../../utils');
+const {resolveTypeAnnotation, getTypes} = require('../utils');
+
+const {
+  parseObjectProperty,
+  translateDefault,
+  buildPropertySchema,
+} = require('../../parsers-commons');
+
+const {
+  emitArrayType,
+  emitBoolean,
+  emitDouble,
+  emitFloat,
+  emitFunction,
+  emitNumber,
+  emitInt32,
+  emitObject,
+  emitPromise,
+  emitRootTag,
+  emitVoid,
+  emitString,
+  emitStringish,
+  emitMixed,
+  emitUnion,
+  typeAliasResolution,
+  translateArrayTypeAnnotation,
+} = require('../../parsers-primitives');
+
+const {
+  UnsupportedGenericParserError,
+  UnsupportedTypeAnnotationParserError,
+  IncorrectModuleRegistryCallArgumentTypeParserError,
+} = require('../../errors');
+
+const {
+  throwIfUntypedModule,
+  throwIfUnusedModuleInterfaceParserError,
+  throwIfModuleInterfaceNotFound,
+  throwIfModuleInterfaceIsMisnamed,
+  throwIfWrongNumberOfCallExpressionArgs,
+  throwIfMoreThanOneModuleRegistryCalls,
+  throwIfMoreThanOneModuleInterfaceParserError,
+  throwIfIncorrectModuleRegistryCallTypeParameterParserError,
+} = require('../../error-utils');
+
+const {TypeScriptParser} = require('../parser');
+
+const language = 'TypeScript';
+const parser = new TypeScriptParser();
+
+function translateTypeAnnotation(
+  hasteModuleName: string,
+  /**
+   * TODO(T108222691): Use flow-types for @babel/parser
+   */
+  typeScriptTypeAnnotation: $FlowFixMe,
+  types: TypeDeclarationMap,
+  aliasMap: {...NativeModuleAliasMap},
+  tryParse: ParserErrorCapturer,
+  cxxOnly: boolean,
+): Nullable<NativeModuleTypeAnnotation> {
+  const {nullable, typeAnnotation, typeAliasResolutionStatus} =
+    resolveTypeAnnotation(typeScriptTypeAnnotation, types);
+
+  switch (typeAnnotation.type) {
+    case 'TSArrayType': {
+      return translateArrayTypeAnnotation(
+        hasteModuleName,
+        types,
+        aliasMap,
+        cxxOnly,
+        'Array',
+        typeAnnotation.elementType,
+        nullable,
+        language,
+        translateTypeAnnotation,
+      );
+    }
+    case 'TSTypeOperator': {
+      if (
+        typeAnnotation.operator === 'readonly' &&
+        typeAnnotation.typeAnnotation.type === 'TSArrayType'
+      ) {
+        return translateArrayTypeAnnotation(
+          hasteModuleName,
+          types,
+          aliasMap,
+          cxxOnly,
+          'ReadonlyArray',
+          typeAnnotation.typeAnnotation.elementType,
+          nullable,
+          language,
+          translateTypeAnnotation,
+        );
+      } else {
+        throw new UnsupportedGenericParserError(
+          hasteModuleName,
+          typeAnnotation,
+          parser,
+        );
+      }
+    }
+    case 'TSTypeReference': {
+      switch (typeAnnotation.typeName.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 '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 'TSTypeLiteral': {
+      const objectTypeAnnotation = {
+        type: 'ObjectTypeAnnotation',
+        // $FlowFixMe[missing-type-arg]
+        properties: (typeAnnotation.members: Array<$FlowFixMe>)
+          .map<?NamedShape<Nullable<NativeModuleBaseTypeAnnotation>>>(
+            property => {
+              return tryParse(() => {
+                return parseObjectProperty(
+                  property,
+                  hasteModuleName,
+                  types,
+                  aliasMap,
+                  tryParse,
+                  cxxOnly,
+                  nullable,
+                  translateTypeAnnotation,
+                  parser,
+                );
+              });
+            },
+          )
+          .filter(Boolean),
+      };
+
+      return typeAliasResolution(
+        typeAliasResolutionStatus,
+        objectTypeAnnotation,
+        aliasMap,
+        nullable,
+      );
+    }
+    case 'TSBooleanKeyword': {
+      return emitBoolean(nullable);
+    }
+    case 'TSNumberKeyword': {
+      return emitNumber(nullable);
+    }
+    case 'TSVoidKeyword': {
+      return emitVoid(nullable);
+    }
+    case 'TSStringKeyword': {
+      return emitString(nullable);
+    }
+    case 'TSFunctionType': {
+      return emitFunction(
+        nullable,
+        hasteModuleName,
+        typeAnnotation,
+        types,
+        aliasMap,
+        tryParse,
+        cxxOnly,
+        translateTypeAnnotation,
+        language,
+      );
+    }
+    case 'TSUnionType': {
+      return emitUnion(nullable, hasteModuleName, typeAnnotation, parser);
+    }
+    case 'TSUnknownKeyword': {
+      if (cxxOnly) {
+        return emitMixed(nullable);
+      }
+      // Fallthrough
+    }
+    default: {
+      throw new UnsupportedTypeAnnotationParserError(
+        hasteModuleName,
+        typeAnnotation,
+        language,
+      );
+    }
+  }
+}
+
+function isModuleInterface(node: $FlowFixMe) {
+  return (
+    node.type === 'TSInterfaceDeclaration' &&
+    node.extends?.length === 1 &&
+    node.extends[0].type === 'TSExpressionWithTypeArguments' &&
+    node.extends[0].expression.name === 'TurboModule'
+  );
+}
+
+function buildModuleSchema(
+  hasteModuleName: string,
+  /**
+   * TODO(T108222691): Use flow-types for @babel/parser
+   */
+  ast: $FlowFixMe,
+  tryParse: ParserErrorCapturer,
+): NativeModuleSchema {
+  const types = getTypes(ast);
+  const moduleSpecs = (Object.values(types): $ReadOnlyArray<$FlowFixMe>).filter(
+    isModuleInterface,
+  );
+
+  throwIfModuleInterfaceNotFound(
+    moduleSpecs.length,
+    hasteModuleName,
+    ast,
+    language,
+  );
+
+  throwIfMoreThanOneModuleInterfaceParserError(
+    hasteModuleName,
+    moduleSpecs,
+    language,
+  );
+
+  const [moduleSpec] = moduleSpecs;
+
+  throwIfModuleInterfaceIsMisnamed(hasteModuleName, moduleSpec.id, language);
+
+  // Parse Module Name
+  const moduleName = ((): string => {
+    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;
+    const {typeParameters} = callExpression;
+    const methodName = callExpression.callee.property.name;
+
+    throwIfWrongNumberOfCallExpressionArgs(
+      hasteModuleName,
+      callExpression,
+      methodName,
+      callExpression.arguments.length,
+      language,
+    );
+
+    if (callExpression.arguments[0].type !== 'StringLiteral') {
+      const {type} = callExpression.arguments[0];
+      throw new IncorrectModuleRegistryCallArgumentTypeParserError(
+        hasteModuleName,
+        callExpression.arguments[0],
+        methodName,
+        type,
+        language,
+      );
+    }
+
+    const $moduleName = callExpression.arguments[0].value;
+
+    throwIfUntypedModule(
+      typeParameters,
+      hasteModuleName,
+      callExpression,
+      methodName,
+      $moduleName,
+      language,
+    );
+
+    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 {cxxOnly, excludedPlatforms} = verifyPlatforms(
+    hasteModuleName,
+    moduleName,
+  );
+
+  // $FlowFixMe[missing-type-arg]
+  return (moduleSpec.body.body: $ReadOnlyArray<$FlowFixMe>)
+    .filter(
+      property =>
+        property.type === 'TSMethodSignature' ||
+        property.type === 'TSPropertySignature',
+    )
+    .map<?{
+      aliasMap: NativeModuleAliasMap,
+      propertyShape: NativeModulePropertyShape,
+    }>(property => {
+      const aliasMap: {...NativeModuleAliasMap} = {};
+
+      return tryParse(() => ({
+        aliasMap: aliasMap,
+        propertyShape: buildPropertySchema(
+          hasteModuleName,
+          property,
+          types,
+          aliasMap,
+          tryParse,
+          cxxOnly,
+          language,
+          resolveTypeAnnotation,
+          translateTypeAnnotation,
+        ),
+      }));
+    })
+    .filter(Boolean)
+    .reduce(
+      (moduleSchema: NativeModuleSchema, {aliasMap, propertyShape}) => {
+        return {
+          type: 'NativeModule',
+          aliases: {...moduleSchema.aliases, ...aliasMap},
+          spec: {
+            properties: [...moduleSchema.spec.properties, propertyShape],
+          },
+          moduleName: moduleSchema.moduleName,
+          excludedPlatforms: moduleSchema.excludedPlatforms,
+        };
+      },
+      {
+        type: 'NativeModule',
+        aliases: {},
+        spec: {properties: []},
+        moduleName: moduleName,
+        excludedPlatforms:
+          excludedPlatforms.length !== 0 ? [...excludedPlatforms] : undefined,
+      },
+    );
+}
+
+module.exports = {
+  buildModuleSchema,
+  typeScriptTranslateTypeAnnotation: translateTypeAnnotation,
+};

package/lib/parsers/typescript/parseTopLevelType.js

@@ -0,0 +1,203 @@
+/**
+ * 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 getValueFromTypes(value, types) {
+  switch (value.type) {
+    case 'TSTypeReference':
+      if (types[value.typeName.name]) {
+        return getValueFromTypes(types[value.typeName.name], types);
+      } else {
+        return value;
+      }
+    case 'TSTypeAliasDeclaration':
+      return getValueFromTypes(value.typeAnnotation, types);
+    default:
+      return value;
+  }
+}
+function isNull(t) {
+  return t.type === 'TSNullKeyword' || t.type === 'TSUndefinedKeyword';
+}
+function isNullOrVoid(t) {
+  return isNull(t) || t.type === 'TSVoidKeyword';
+}
+function couldBeNumericLiteral(type) {
+  return type === 'Literal' || type === 'NumericLiteral';
+}
+function couldBeSimpleLiteral(type) {
+  return (
+    couldBeNumericLiteral(type) ||
+    type === 'StringLiteral' ||
+    type === 'BooleanLiteral'
+  );
+}
+function evaluateLiteral(literalNode) {
+  const valueType = literalNode.type;
+  if (valueType === 'TSLiteralType') {
+    const literal = literalNode.literal;
+    if (couldBeSimpleLiteral(literal.type)) {
+      if (
+        typeof literal.value === 'string' ||
+        typeof literal.value === 'number' ||
+        typeof literal.value === 'boolean'
+      ) {
+        return literal.value;
+      }
+    } else if (
+      literal.type === 'UnaryExpression' &&
+      literal.operator === '-' &&
+      couldBeNumericLiteral(literal.argument.type) &&
+      typeof literal.argument.value === 'number'
+    ) {
+      return -literal.argument.value;
+    }
+  } else if (isNull(literalNode)) {
+    return null;
+  }
+  throw new Error(
+    'The default value in WithDefault must be string, number, boolean or null .',
+  );
+}
+function handleUnionAndParen(type, result, knownTypes) {
+  switch (type.type) {
+    case 'TSParenthesizedType': {
+      handleUnionAndParen(type.typeAnnotation, result, knownTypes);
+      break;
+    }
+    case 'TSUnionType': {
+      // the order is important
+      // result.optional must be set first
+      for (const t of type.types) {
+        if (isNullOrVoid(t)) {
+          result.optional = true;
+        }
+      }
+      for (const t of type.types) {
+        if (!isNullOrVoid(t)) {
+          handleUnionAndParen(t, result, knownTypes);
+        }
+      }
+      break;
+    }
+    case 'TSTypeReference':
+      if (type.typeName.name === 'Readonly') {
+        handleUnionAndParen(type.typeParameters.params[0], result, knownTypes);
+      } else if (type.typeName.name === 'WithDefault') {
+        if (result.optional) {
+          throw new Error(
+            'WithDefault<> is optional and does not need to be marked as optional. Please remove the union of undefined and/or null',
+          );
+        }
+        if (type.typeParameters.params.length !== 2) {
+          throw new Error(
+            'WithDefault requires two parameters: type and default value.',
+          );
+        }
+        if (result.defaultValue !== undefined) {
+          throw new Error(
+            'Multiple WithDefault is not allowed nested or in a union type.',
+          );
+        }
+        result.optional = true;
+        result.defaultValue = evaluateLiteral(type.typeParameters.params[1]);
+        handleUnionAndParen(type.typeParameters.params[0], result, knownTypes);
+      } else if (!knownTypes) {
+        result.unions.push(type);
+      } else {
+        const resolvedType = getValueFromTypes(type, knownTypes);
+        if (
+          resolvedType.type === 'TSTypeReference' &&
+          resolvedType.typeName.name === type.typeName.name
+        ) {
+          result.unions.push(type);
+        } else {
+          handleUnionAndParen(resolvedType, result, knownTypes);
+        }
+      }
+      break;
+    default:
+      result.unions.push(type);
+  }
+}
+function parseTopLevelType(type, knownTypes) {
+  let result = {
+    unions: [],
+    optional: false,
+  };
+  handleUnionAndParen(type, result, knownTypes);
+  if (result.unions.length === 0) {
+    throw new Error('Union type could not be just null or undefined.');
+  } else if (result.unions.length === 1) {
+    return {
+      type: result.unions[0],
+      optional: result.optional,
+      defaultValue: result.defaultValue,
+    };
+  } else {
+    return {
+      type: {
+        type: 'TSUnionType',
+        types: result.unions,
+      },
+      optional: result.optional,
+      defaultValue: result.defaultValue,
+    };
+  }
+}
+function handleIntersectionAndParen(type, result, knownTypes) {
+  switch (type.type) {
+    case 'TSParenthesizedType': {
+      handleIntersectionAndParen(type.typeAnnotation, result, knownTypes);
+      break;
+    }
+    case 'TSIntersectionType': {
+      for (const t of type.types) {
+        handleIntersectionAndParen(t, result, knownTypes);
+      }
+      break;
+    }
+    case 'TSTypeReference':
+      if (type.typeName.name === 'Readonly') {
+        handleIntersectionAndParen(
+          type.typeParameters.params[0],
+          result,
+          knownTypes,
+        );
+      } else if (type.typeName.name === 'WithDefault') {
+        throw new Error('WithDefault<> is now allowed in intersection types.');
+      } else if (!knownTypes) {
+        result.push(type);
+      } else {
+        const resolvedType = getValueFromTypes(type, knownTypes);
+        if (
+          resolvedType.type === 'TSTypeReference' &&
+          resolvedType.typeName.name === type.typeName.name
+        ) {
+          result.push(type);
+        } else {
+          handleIntersectionAndParen(resolvedType, result, knownTypes);
+        }
+      }
+      break;
+    default:
+      result.push(type);
+  }
+}
+function flattenIntersectionType(type, knownTypes) {
+  const result = [];
+  handleIntersectionAndParen(type, result, knownTypes);
+  return result;
+}
+module.exports = {
+  parseTopLevelType,
+  flattenIntersectionType,
+};