@react-native/codegen 0.72.1

package/lib/parsers/typescript/parseTopLevelType.js.flow

@@ -0,0 +1,243 @@
+/**
+ * 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 {TypeDeclarationMap} from '../utils';
+
+export type LegalDefaultValues = string | number | boolean | null;
+
+type TopLevelTypeInternal = {
+  unions: Array<$FlowFixMe>,
+  optional: boolean,
+  defaultValue?: LegalDefaultValues,
+};
+
+export type TopLevelType = {
+  type: $FlowFixMe,
+  optional: boolean,
+  defaultValue?: LegalDefaultValues,
+};
+
+function getValueFromTypes(
+  value: $FlowFixMe,
+  types: TypeDeclarationMap,
+): $FlowFixMe {
+  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: $FlowFixMe) {
+  return t.type === 'TSNullKeyword' || t.type === 'TSUndefinedKeyword';
+}
+
+function isNullOrVoid(t: $FlowFixMe) {
+  return isNull(t) || t.type === 'TSVoidKeyword';
+}
+
+function couldBeNumericLiteral(type: string) {
+  return type === 'Literal' || type === 'NumericLiteral';
+}
+
+function couldBeSimpleLiteral(type: string) {
+  return (
+    couldBeNumericLiteral(type) ||
+    type === 'StringLiteral' ||
+    type === 'BooleanLiteral'
+  );
+}
+
+function evaluateLiteral(
+  literalNode: $FlowFixMe,
+): string | number | boolean | null {
+  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: $FlowFixMe,
+  result: TopLevelTypeInternal,
+  knownTypes?: TypeDeclarationMap,
+): void {
+  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: $FlowFixMe,
+  knownTypes?: TypeDeclarationMap,
+): TopLevelType {
+  let result: TopLevelTypeInternal = {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: $FlowFixMe,
+  result: Array<$FlowFixMe>,
+  knownTypes?: TypeDeclarationMap,
+): void {
+  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: $FlowFixMe,
+  knownTypes?: TypeDeclarationMap,
+): Array<$FlowFixMe> {
+  const result: Array<$FlowFixMe> = [];
+  handleIntersectionAndParen(type, result, knownTypes);
+  return result;
+}
+
+module.exports = {
+  parseTopLevelType,
+  flattenIntersectionType,
+};

package/lib/parsers/typescript/parser.js

@@ -0,0 +1,105 @@
+/**
+ * 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 _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);
+}
+const _require = require('../errors'),
+  UnsupportedObjectPropertyTypeAnnotationParserError =
+    _require.UnsupportedObjectPropertyTypeAnnotationParserError;
+class TypeScriptParser {
+  constructor() {
+    _defineProperty(
+      this,
+      'typeParameterInstantiation',
+      'TSTypeParameterInstantiation',
+    );
+  }
+  getKeyName(propertyOrIndex, hasteModuleName) {
+    switch (propertyOrIndex.type) {
+      case 'TSPropertySignature':
+        return propertyOrIndex.key.name;
+      case 'TSIndexSignature':
+        return propertyOrIndex.parameters[0].name;
+      default:
+        throw new UnsupportedObjectPropertyTypeAnnotationParserError(
+          hasteModuleName,
+          propertyOrIndex,
+          propertyOrIndex.type,
+          this.language(),
+        );
+    }
+  }
+  getMaybeEnumMemberType(maybeEnumDeclaration) {
+    if (maybeEnumDeclaration.members[0].initializer) {
+      return maybeEnumDeclaration.members[0].initializer.type
+        .replace('NumericLiteral', 'NumberTypeAnnotation')
+        .replace('StringLiteral', 'StringTypeAnnotation');
+    }
+    return 'StringTypeAnnotation';
+  }
+  isEnumDeclaration(maybeEnumDeclaration) {
+    return maybeEnumDeclaration.type === 'TSEnumDeclaration';
+  }
+  language() {
+    return 'TypeScript';
+  }
+  nameForGenericTypeAnnotation(typeAnnotation) {
+    return typeAnnotation.typeName.name;
+  }
+  checkIfInvalidModule(typeArguments) {
+    return (
+      typeArguments.type !== 'TSTypeParameterInstantiation' ||
+      typeArguments.params.length !== 1 ||
+      typeArguments.params[0].type !== 'TSTypeReference' ||
+      typeArguments.params[0].typeName.name !== 'Spec'
+    );
+  }
+  remapUnionTypeAnnotationMemberNames(membersTypes) {
+    const remapLiteral = item => {
+      return item.literal
+        ? item.literal.type
+            .replace('NumericLiteral', 'NumberTypeAnnotation')
+            .replace('StringLiteral', 'StringTypeAnnotation')
+        : 'ObjectTypeAnnotation';
+    };
+    return [...new Set(membersTypes.map(remapLiteral))];
+  }
+}
+module.exports = {
+  TypeScriptParser,
+};

package/lib/parsers/typescript/parser.js.flow

@@ -0,0 +1,87 @@
+/**
+ * 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 {UnionTypeAnnotationMemberType} from '../../CodegenSchema.js';
+import type {ParserType} from '../errors';
+import type {Parser} from '../parser';
+
+const {
+  UnsupportedObjectPropertyTypeAnnotationParserError,
+} = require('../errors');
+
+class TypeScriptParser implements Parser {
+  typeParameterInstantiation: string = 'TSTypeParameterInstantiation';
+
+  getKeyName(propertyOrIndex: $FlowFixMe, hasteModuleName: string): string {
+    switch (propertyOrIndex.type) {
+      case 'TSPropertySignature':
+        return propertyOrIndex.key.name;
+      case 'TSIndexSignature':
+        return propertyOrIndex.parameters[0].name;
+      default:
+        throw new UnsupportedObjectPropertyTypeAnnotationParserError(
+          hasteModuleName,
+          propertyOrIndex,
+          propertyOrIndex.type,
+          this.language(),
+        );
+    }
+  }
+
+  getMaybeEnumMemberType(maybeEnumDeclaration: $FlowFixMe): string {
+    if (maybeEnumDeclaration.members[0].initializer) {
+      return maybeEnumDeclaration.members[0].initializer.type
+        .replace('NumericLiteral', 'NumberTypeAnnotation')
+        .replace('StringLiteral', 'StringTypeAnnotation');
+    }
+
+    return 'StringTypeAnnotation';
+  }
+
+  isEnumDeclaration(maybeEnumDeclaration: $FlowFixMe): boolean {
+    return maybeEnumDeclaration.type === 'TSEnumDeclaration';
+  }
+
+  language(): ParserType {
+    return 'TypeScript';
+  }
+
+  nameForGenericTypeAnnotation(typeAnnotation: $FlowFixMe): string {
+    return typeAnnotation.typeName.name;
+  }
+
+  checkIfInvalidModule(typeArguments: $FlowFixMe): boolean {
+    return (
+      typeArguments.type !== 'TSTypeParameterInstantiation' ||
+      typeArguments.params.length !== 1 ||
+      typeArguments.params[0].type !== 'TSTypeReference' ||
+      typeArguments.params[0].typeName.name !== 'Spec'
+    );
+  }
+
+  remapUnionTypeAnnotationMemberNames(
+    membersTypes: $FlowFixMe[],
+  ): UnionTypeAnnotationMemberType[] {
+    const remapLiteral = (item: $FlowFixMe) => {
+      return item.literal
+        ? item.literal.type
+            .replace('NumericLiteral', 'NumberTypeAnnotation')
+            .replace('StringLiteral', 'StringTypeAnnotation')
+        : 'ObjectTypeAnnotation';
+    };
+
+    return [...new Set(membersTypes.map(remapLiteral))];
+  }
+}
+module.exports = {
+  TypeScriptParser,
+};

package/lib/parsers/typescript/utils.js

@@ -0,0 +1,101 @@
+/**
+ * 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';
+
+const _require = require('./parseTopLevelType'),
+  parseTopLevelType = _require.parseTopLevelType;
+
+/**
+ * TODO(T108222691): Use flow-types for @babel/parser
+ */
+
+function getTypes(ast) {
+  return ast.body.reduce((types, node) => {
+    switch (node.type) {
+      case 'ExportNamedDeclaration': {
+        if (node.declaration) {
+          switch (node.declaration.type) {
+            case 'TSTypeAliasDeclaration':
+            case 'TSInterfaceDeclaration':
+            case 'TSEnumDeclaration': {
+              types[node.declaration.id.name] = node.declaration;
+              break;
+            }
+          }
+        }
+        break;
+      }
+      case 'TSTypeAliasDeclaration':
+      case 'TSInterfaceDeclaration':
+      case 'TSEnumDeclaration': {
+        types[node.id.name] = node;
+        break;
+      }
+    }
+    return types;
+  }, {});
+}
+
+// $FlowFixMe[unclear-type] Use flow-types for @babel/parser
+
+const invariant = require('invariant');
+function resolveTypeAnnotation(
+  // TODO(T108222691): Use flow-types for @babel/parser
+  typeAnnotation,
+  types,
+) {
+  invariant(
+    typeAnnotation != null,
+    'resolveTypeAnnotation(): typeAnnotation cannot be null',
+  );
+  let node =
+    typeAnnotation.type === 'TSTypeAnnotation'
+      ? typeAnnotation.typeAnnotation
+      : typeAnnotation;
+  let nullable = false;
+  let typeAliasResolutionStatus = {
+    successful: false,
+  };
+  for (;;) {
+    const topLevelType = parseTopLevelType(node);
+    nullable = nullable || topLevelType.optional;
+    node = topLevelType.type;
+    if (node.type === 'TSTypeReference') {
+      typeAliasResolutionStatus = {
+        successful: true,
+        aliasName: node.typeName.name,
+      };
+      const resolvedTypeAnnotation = types[node.typeName.name];
+      if (
+        resolvedTypeAnnotation == null ||
+        resolvedTypeAnnotation.type === 'TSEnumDeclaration'
+      ) {
+        break;
+      }
+      invariant(
+        resolvedTypeAnnotation.type === 'TSTypeAliasDeclaration',
+        `GenericTypeAnnotation '${node.typeName.name}' must resolve to a TSTypeAliasDeclaration. Instead, it resolved to a '${resolvedTypeAnnotation.type}'`,
+      );
+      node = resolvedTypeAnnotation.typeAnnotation;
+    } else {
+      break;
+    }
+  }
+  return {
+    nullable: nullable,
+    typeAnnotation: node,
+    typeAliasResolutionStatus,
+  };
+}
+module.exports = {
+  resolveTypeAnnotation,
+  getTypes,
+};

package/lib/parsers/typescript/utils.js.flow

@@ -0,0 +1,115 @@
+/**
+ * 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 {TypeAliasResolutionStatus, TypeDeclarationMap} from '../utils';
+
+const {parseTopLevelType} = require('./parseTopLevelType');
+
+/**
+ * TODO(T108222691): Use flow-types for @babel/parser
+ */
+
+function getTypes(ast: $FlowFixMe): TypeDeclarationMap {
+  return ast.body.reduce((types, node) => {
+    switch (node.type) {
+      case 'ExportNamedDeclaration': {
+        if (node.declaration) {
+          switch (node.declaration.type) {
+            case 'TSTypeAliasDeclaration':
+            case 'TSInterfaceDeclaration':
+            case 'TSEnumDeclaration': {
+              types[node.declaration.id.name] = node.declaration;
+              break;
+            }
+          }
+        }
+        break;
+      }
+      case 'TSTypeAliasDeclaration':
+      case 'TSInterfaceDeclaration':
+      case 'TSEnumDeclaration': {
+        types[node.id.name] = node;
+        break;
+      }
+    }
+    return types;
+  }, {});
+}
+
+// $FlowFixMe[unclear-type] Use flow-types for @babel/parser
+export type ASTNode = Object;
+
+const invariant = require('invariant');
+
+function resolveTypeAnnotation(
+  // TODO(T108222691): Use flow-types for @babel/parser
+  typeAnnotation: $FlowFixMe,
+  types: TypeDeclarationMap,
+): {
+  nullable: boolean,
+  typeAnnotation: $FlowFixMe,
+  typeAliasResolutionStatus: TypeAliasResolutionStatus,
+} {
+  invariant(
+    typeAnnotation != null,
+    'resolveTypeAnnotation(): typeAnnotation cannot be null',
+  );
+
+  let node =
+    typeAnnotation.type === 'TSTypeAnnotation'
+      ? typeAnnotation.typeAnnotation
+      : typeAnnotation;
+  let nullable = false;
+  let typeAliasResolutionStatus: TypeAliasResolutionStatus = {
+    successful: false,
+  };
+
+  for (;;) {
+    const topLevelType = parseTopLevelType(node);
+    nullable = nullable || topLevelType.optional;
+    node = topLevelType.type;
+
+    if (node.type === 'TSTypeReference') {
+      typeAliasResolutionStatus = {
+        successful: true,
+        aliasName: node.typeName.name,
+      };
+      const resolvedTypeAnnotation = types[node.typeName.name];
+      if (
+        resolvedTypeAnnotation == null ||
+        resolvedTypeAnnotation.type === 'TSEnumDeclaration'
+      ) {
+        break;
+      }
+
+      invariant(
+        resolvedTypeAnnotation.type === 'TSTypeAliasDeclaration',
+        `GenericTypeAnnotation '${node.typeName.name}' must resolve to a TSTypeAliasDeclaration. Instead, it resolved to a '${resolvedTypeAnnotation.type}'`,
+      );
+
+      node = resolvedTypeAnnotation.typeAnnotation;
+    } else {
+      break;
+    }
+  }
+
+  return {
+    nullable: nullable,
+    typeAnnotation: node,
+    typeAliasResolutionStatus,
+  };
+}
+
+module.exports = {
+  resolveTypeAnnotation,
+  getTypes,
+};