@react-native/codegen 0.72.1

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

@@ -0,0 +1,123 @@
+/**
+ * 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';
+
+/**
+ * This FlowFixMe is supposed to refer to an InterfaceDeclaration or TypeAlias
+ * declaration type. Unfortunately, we don't have those types, because flow-parser
+ * generates them, and flow-parser is not type-safe. In the future, we should find
+ * a way to get these types from our flow parser library.
+ *
+ * TODO(T71778680): Flow type AST Nodes
+ */
+
+function getTypes(ast: $FlowFixMe): TypeDeclarationMap {
+  return ast.body.reduce((types, node) => {
+    if (node.type === 'ExportNamedDeclaration' && node.exportKind === 'type') {
+      if (
+        node.declaration != null &&
+        (node.declaration.type === 'TypeAlias' ||
+          node.declaration.type === 'InterfaceDeclaration')
+      ) {
+        types[node.declaration.id.name] = node.declaration;
+      }
+    } else if (
+      node.type === 'ExportNamedDeclaration' &&
+      node.exportKind === 'value' &&
+      node.declaration &&
+      node.declaration.type === 'EnumDeclaration'
+    ) {
+      types[node.declaration.id.name] = node.declaration;
+    } else if (
+      node.type === 'TypeAlias' ||
+      node.type === 'InterfaceDeclaration' ||
+      node.type === 'EnumDeclaration'
+    ) {
+      types[node.id.name] = node;
+    }
+    return types;
+  }, {});
+}
+
+// $FlowFixMe[unclear-type] there's no flowtype for ASTs
+export type ASTNode = Object;
+
+const invariant = require('invariant');
+
+function resolveTypeAnnotation(
+  // TODO(T71778680): This is an Flow TypeAnnotation. Flow-type this
+  typeAnnotation: $FlowFixMe,
+  types: TypeDeclarationMap,
+): {
+  nullable: boolean,
+  typeAnnotation: $FlowFixMe,
+  typeAliasResolutionStatus: TypeAliasResolutionStatus,
+} {
+  invariant(
+    typeAnnotation != null,
+    'resolveTypeAnnotation(): typeAnnotation cannot be null',
+  );
+
+  let node = typeAnnotation;
+  let nullable = false;
+  let typeAliasResolutionStatus: TypeAliasResolutionStatus = {
+    successful: false,
+  };
+
+  for (;;) {
+    if (node.type === 'NullableTypeAnnotation') {
+      nullable = true;
+      node = node.typeAnnotation;
+    } else if (node.type === 'GenericTypeAnnotation') {
+      typeAliasResolutionStatus = {
+        successful: true,
+        aliasName: node.id.name,
+      };
+      const resolvedTypeAnnotation = types[node.id.name];
+      if (
+        resolvedTypeAnnotation == null ||
+        resolvedTypeAnnotation.type === 'EnumDeclaration'
+      ) {
+        break;
+      }
+
+      invariant(
+        resolvedTypeAnnotation.type === 'TypeAlias',
+        `GenericTypeAnnotation '${node.id.name}' must resolve to a TypeAlias. Instead, it resolved to a '${resolvedTypeAnnotation.type}'`,
+      );
+
+      node = resolvedTypeAnnotation.right;
+    } else {
+      break;
+    }
+  }
+
+  return {
+    nullable: nullable,
+    typeAnnotation: node,
+    typeAliasResolutionStatus,
+  };
+}
+
+function getValueFromTypes(value: ASTNode, types: TypeDeclarationMap): ASTNode {
+  if (value.type === 'GenericTypeAnnotation' && types[value.id.name]) {
+    return getValueFromTypes(types[value.id.name].right, types);
+  }
+  return value;
+}
+
+module.exports = {
+  getValueFromTypes,
+  resolveTypeAnnotation,
+  getTypes,
+};

package/lib/parsers/parser.js

@@ -0,0 +1,11 @@
+/**
+ * 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';

package/lib/parsers/parser.js.flow

@@ -0,0 +1,70 @@
+/**
+ * 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';
+
+/**
+ * This is the main interface for Parsers of various languages.
+ * It exposes all the methods that contain language-specific logic.
+ */
+export interface Parser {
+  /**
+   * This is the TypeParameterInstantiation value
+   */
+  typeParameterInstantiation: string;
+
+  /**
+   * Given a property or an index declaration, it returns the key name.
+   * @parameter propertyOrIndex: an object containing a property or an index declaration.
+   * @parameter hasteModuleName: a string with the native module name.
+   * @returns: the key name.
+   * @throws if propertyOrIndex does not contain a property or an index declaration.
+   */
+  getKeyName(propertyOrIndex: $FlowFixMe, hasteModuleName: string): string;
+  /**
+   * Given a type declaration, it possibly returns the name of the Enum type.
+   * @parameter maybeEnumDeclaration: an object possibly containing an Enum declaration.
+   * @returns: the name of the Enum type.
+   */
+  getMaybeEnumMemberType(maybeEnumDeclaration: $FlowFixMe): string;
+  /**
+   * Given a type declaration, it returns a boolean specifying if is an Enum declaration.
+   * @parameter maybeEnumDeclaration: an object possibly containing an Enum declaration.
+   * @returns: a boolean specifying if is an Enum declaration.
+   */
+  isEnumDeclaration(maybeEnumDeclaration: $FlowFixMe): boolean;
+  /**
+   * @returns: the Parser language.
+   */
+  language(): ParserType;
+  /**
+   * Given a type annotation for a generic type, it returns the type name.
+   * @parameter typeAnnotation: the annotation for a type in the AST.
+   * @returns: the name of the type.
+   */
+  nameForGenericTypeAnnotation(typeAnnotation: $FlowFixMe): string;
+  /**
+   * Given a type arguments, it returns a boolean specifying if the Module is Invalid.
+   * @parameter typeArguments: the type arguments.
+   * @returns: a boolean specifying if the Module is Invalid.
+   */
+  checkIfInvalidModule(typeArguments: $FlowFixMe): boolean;
+  /**
+   * Given a union annotation members types, it returns an array of remaped members names without duplicates.
+   * @parameter membersTypes: union annotation members types
+   * @returns: an array of remaped members names without duplicates.
+   */
+  remapUnionTypeAnnotationMemberNames(
+    types: $FlowFixMe,
+  ): UnionTypeAnnotationMemberType[];
+}

package/lib/parsers/parserMock.js

@@ -0,0 +1,96 @@
+/**
+ * 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;
+export class MockedParser {
+  constructor() {
+    _defineProperty(
+      this,
+      'typeParameterInstantiation',
+      'TypeParameterInstantiation',
+    );
+  }
+  getKeyName(propertyOrIndex, hasteModuleName) {
+    var _propertyOrIndex$id$n, _propertyOrIndex$id;
+    switch (propertyOrIndex.type) {
+      case 'ObjectTypeProperty':
+        return propertyOrIndex.key.name;
+      case 'ObjectTypeIndexer':
+        // flow index name is optional
+        return (_propertyOrIndex$id$n =
+          (_propertyOrIndex$id = propertyOrIndex.id) === null ||
+          _propertyOrIndex$id === void 0
+            ? void 0
+            : _propertyOrIndex$id.name) !== null &&
+          _propertyOrIndex$id$n !== void 0
+          ? _propertyOrIndex$id$n
+          : 'key';
+      default:
+        throw new UnsupportedObjectPropertyTypeAnnotationParserError(
+          hasteModuleName,
+          propertyOrIndex,
+          propertyOrIndex.type,
+          this.language(),
+        );
+    }
+  }
+  getMaybeEnumMemberType(maybeEnumDeclaration) {
+    return maybeEnumDeclaration.body.type
+      .replace('EnumNumberBody', 'NumberTypeAnnotation')
+      .replace('EnumStringBody', 'StringTypeAnnotation');
+  }
+  isEnumDeclaration(maybeEnumDeclaration) {
+    return maybeEnumDeclaration.type === 'EnumDeclaration';
+  }
+  language() {
+    return 'Flow';
+  }
+  nameForGenericTypeAnnotation(typeAnnotation) {
+    return typeAnnotation.id.name;
+  }
+  checkIfInvalidModule(typeArguments) {
+    return false;
+  }
+  remapUnionTypeAnnotationMemberNames(membersTypes) {
+    return [];
+  }
+}

package/lib/parsers/parserMock.js.flow

@@ -0,0 +1,68 @@
+/**
+ * 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 {Parser} from './parser';
+import type {ParserType} from './errors';
+
+const {
+  UnsupportedObjectPropertyTypeAnnotationParserError,
+} = require('./errors');
+
+export class MockedParser implements Parser {
+  typeParameterInstantiation: string = 'TypeParameterInstantiation';
+
+  getKeyName(propertyOrIndex: $FlowFixMe, hasteModuleName: string): string {
+    switch (propertyOrIndex.type) {
+      case 'ObjectTypeProperty':
+        return propertyOrIndex.key.name;
+      case 'ObjectTypeIndexer':
+        // flow index name is optional
+        return propertyOrIndex.id?.name ?? 'key';
+      default:
+        throw new UnsupportedObjectPropertyTypeAnnotationParserError(
+          hasteModuleName,
+          propertyOrIndex,
+          propertyOrIndex.type,
+          this.language(),
+        );
+    }
+  }
+
+  getMaybeEnumMemberType(maybeEnumDeclaration: $FlowFixMe): string {
+    return maybeEnumDeclaration.body.type
+      .replace('EnumNumberBody', 'NumberTypeAnnotation')
+      .replace('EnumStringBody', 'StringTypeAnnotation');
+  }
+
+  isEnumDeclaration(maybeEnumDeclaration: $FlowFixMe): boolean {
+    return maybeEnumDeclaration.type === 'EnumDeclaration';
+  }
+
+  language(): ParserType {
+    return 'Flow';
+  }
+
+  nameForGenericTypeAnnotation(typeAnnotation: $FlowFixMe): string {
+    return typeAnnotation.id.name;
+  }
+
+  checkIfInvalidModule(typeArguments: $FlowFixMe): boolean {
+    return false;
+  }
+
+  remapUnionTypeAnnotationMemberNames(
+    membersTypes: $FlowFixMe[],
+  ): UnionTypeAnnotationMemberType[] {
+    return [];
+  }
+}