@react-native/codegen 0.72.1 → 0.72.2

package/lib/parsers/flow/parser.js

@@ -38,9 +38,22 @@ function _toPrimitive(input, hint) {
   }
   return (hint === 'string' ? String : Number)(input);
 }
-const _require = require('../errors'),
+// $FlowFixMe[untyped-import] there's no flowtype flow-parser
+const flowParser = require('flow-parser');
+const _require = require('../parsers-commons'),
+  buildSchema = _require.buildSchema;
+const _require2 = require('./Visitor'),
+  Visitor = _require2.Visitor;
+const _require3 = require('./components'),
+  buildComponentSchema = _require3.buildComponentSchema;
+const _require4 = require('./components/schema'),
+  wrapComponentSchema = _require4.wrapComponentSchema;
+const _require5 = require('./modules'),
+  buildModuleSchema = _require5.buildModuleSchema;
+const fs = require('fs');
+const _require6 = require('../errors'),
   UnsupportedObjectPropertyTypeAnnotationParserError =
-    _require.UnsupportedObjectPropertyTypeAnnotationParserError;
+    _require6.UnsupportedObjectPropertyTypeAnnotationParserError;
 class FlowParser {
   constructor() {
     _defineProperty(
@@ -49,37 +62,19 @@ class FlowParser {
       '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');
+  isProperty(property) {
+    return property.type === 'ObjectTypeProperty';
   }
-  isEnumDeclaration(maybeEnumDeclaration) {
-    return maybeEnumDeclaration.type === 'EnumDeclaration';
+  getKeyName(property, hasteModuleName) {
+    if (!this.isProperty(property)) {
+      throw new UnsupportedObjectPropertyTypeAnnotationParserError(
+        hasteModuleName,
+        property,
+        property.type,
+        this.language(),
+      );
+    }
+    return property.key.name;
   }
   language() {
     return 'Flow';
@@ -103,6 +98,101 @@ class FlowParser {
     };
     return [...new Set(membersTypes.map(remapLiteral))];
   }
+  parseFile(filename) {
+    const contents = fs.readFileSync(filename, 'utf8');
+    return this.parseString(contents, filename);
+  }
+  parseString(contents, filename) {
+    return buildSchema(
+      contents,
+      filename,
+      wrapComponentSchema,
+      buildComponentSchema,
+      buildModuleSchema,
+      Visitor,
+      this,
+    );
+  }
+  parseModuleFixture(filename) {
+    const contents = fs.readFileSync(filename, 'utf8');
+    return this.parseString(contents, 'path/NativeSampleTurboModule.js');
+  }
+  getAst(contents) {
+    return flowParser.parse(contents, {
+      enums: true,
+    });
+  }
+  getFunctionTypeAnnotationParameters(functionTypeAnnotation) {
+    return functionTypeAnnotation.params;
+  }
+  getFunctionNameFromParameter(parameter) {
+    return parameter.name;
+  }
+  getParameterName(parameter) {
+    return parameter.name.name;
+  }
+  getParameterTypeAnnotation(parameter) {
+    return parameter.typeAnnotation;
+  }
+  getFunctionTypeAnnotationReturnType(functionTypeAnnotation) {
+    return functionTypeAnnotation.returnType;
+  }
+  parseEnumMembersType(typeAnnotation) {
+    const enumMembersType =
+      typeAnnotation.type === 'EnumStringBody'
+        ? 'StringTypeAnnotation'
+        : typeAnnotation.type === 'EnumNumberBody'
+        ? 'NumberTypeAnnotation'
+        : null;
+    if (!enumMembersType) {
+      throw new Error(
+        `Unknown enum type annotation type. Got: ${typeAnnotation.type}. Expected: EnumStringBody or EnumNumberBody.`,
+      );
+    }
+    return enumMembersType;
+  }
+  validateEnumMembersSupported(typeAnnotation, enumMembersType) {
+    if (!typeAnnotation.members || typeAnnotation.members.length === 0) {
+      // passing mixed members to flow would result in a flow error
+      // if the tool is launched ignoring that error, the enum would appear like not having enums
+      throw new Error(
+        'Enums should have at least one member and member values can not be mixed- they all must be either blank, number, or string values.',
+      );
+    }
+    typeAnnotation.members.forEach(member => {
+      if (
+        enumMembersType === 'StringTypeAnnotation' &&
+        (!member.init || typeof member.init.value === 'string')
+      ) {
+        return;
+      }
+      if (
+        enumMembersType === 'NumberTypeAnnotation' &&
+        member.init &&
+        typeof member.init.value === 'number'
+      ) {
+        return;
+      }
+      throw new Error(
+        'Enums can not be mixed- they all must be either blank, number, or string values.',
+      );
+    });
+  }
+  parseEnumMembers(typeAnnotation) {
+    return typeAnnotation.members.map(member => {
+      var _member$init$value, _member$init;
+      return {
+        name: member.id.name,
+        value:
+          (_member$init$value =
+            (_member$init = member.init) === null || _member$init === void 0
+              ? void 0
+              : _member$init.value) !== null && _member$init$value !== void 0
+            ? _member$init$value
+            : member.id.name,
+      };
+    });
+  }
 }
 module.exports = {
   FlowParser,

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

@@ -10,10 +10,29 @@
 
 'use strict';
 
-import type {UnionTypeAnnotationMemberType} from '../../CodegenSchema.js';
+import type {
+  UnionTypeAnnotationMemberType,
+  SchemaType,
+  NamedShape,
+  Nullable,
+  NativeModuleParamTypeAnnotation,
+  NativeModuleEnumMemberType,
+  NativeModuleEnumMembers,
+} from '../../CodegenSchema';
 import type {ParserType} from '../errors';
 import type {Parser} from '../parser';
 
+// $FlowFixMe[untyped-import] there's no flowtype flow-parser
+const flowParser = require('flow-parser');
+
+const {buildSchema} = require('../parsers-commons');
+const {Visitor} = require('./Visitor');
+const {buildComponentSchema} = require('./components');
+const {wrapComponentSchema} = require('./components/schema');
+const {buildModuleSchema} = require('./modules');
+
+const fs = require('fs');
+
 const {
   UnsupportedObjectPropertyTypeAnnotationParserError,
 } = require('../errors');
@@ -21,31 +40,20 @@ const {
 class FlowParser 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');
+  isProperty(property: $FlowFixMe): boolean {
+    return property.type === 'ObjectTypeProperty';
   }
 
-  isEnumDeclaration(maybeEnumDeclaration: $FlowFixMe): boolean {
-    return maybeEnumDeclaration.type === 'EnumDeclaration';
+  getKeyName(property: $FlowFixMe, hasteModuleName: string): string {
+    if (!this.isProperty(property)) {
+      throw new UnsupportedObjectPropertyTypeAnnotationParserError(
+        hasteModuleName,
+        property,
+        property.type,
+        this.language(),
+      );
+    }
+    return property.key.name;
   }
 
   language(): ParserType {
@@ -76,6 +84,118 @@ class FlowParser implements Parser {
 
     return [...new Set(membersTypes.map(remapLiteral))];
   }
+
+  parseFile(filename: string): SchemaType {
+    const contents = fs.readFileSync(filename, 'utf8');
+
+    return this.parseString(contents, filename);
+  }
+
+  parseString(contents: string, filename: ?string): SchemaType {
+    return buildSchema(
+      contents,
+      filename,
+      wrapComponentSchema,
+      buildComponentSchema,
+      buildModuleSchema,
+      Visitor,
+      this,
+    );
+  }
+
+  parseModuleFixture(filename: string): SchemaType {
+    const contents = fs.readFileSync(filename, 'utf8');
+
+    return this.parseString(contents, 'path/NativeSampleTurboModule.js');
+  }
+
+  getAst(contents: string): $FlowFixMe {
+    return flowParser.parse(contents, {
+      enums: true,
+    });
+  }
+
+  getFunctionTypeAnnotationParameters(
+    functionTypeAnnotation: $FlowFixMe,
+  ): $ReadOnlyArray<$FlowFixMe> {
+    return functionTypeAnnotation.params;
+  }
+
+  getFunctionNameFromParameter(
+    parameter: NamedShape<Nullable<NativeModuleParamTypeAnnotation>>,
+  ): $FlowFixMe {
+    return parameter.name;
+  }
+
+  getParameterName(parameter: $FlowFixMe): string {
+    return parameter.name.name;
+  }
+
+  getParameterTypeAnnotation(parameter: $FlowFixMe): $FlowFixMe {
+    return parameter.typeAnnotation;
+  }
+
+  getFunctionTypeAnnotationReturnType(
+    functionTypeAnnotation: $FlowFixMe,
+  ): $FlowFixMe {
+    return functionTypeAnnotation.returnType;
+  }
+
+  parseEnumMembersType(typeAnnotation: $FlowFixMe): NativeModuleEnumMemberType {
+    const enumMembersType: ?NativeModuleEnumMemberType =
+      typeAnnotation.type === 'EnumStringBody'
+        ? 'StringTypeAnnotation'
+        : typeAnnotation.type === 'EnumNumberBody'
+        ? 'NumberTypeAnnotation'
+        : null;
+    if (!enumMembersType) {
+      throw new Error(
+        `Unknown enum type annotation type. Got: ${typeAnnotation.type}. Expected: EnumStringBody or EnumNumberBody.`,
+      );
+    }
+    return enumMembersType;
+  }
+
+  validateEnumMembersSupported(
+    typeAnnotation: $FlowFixMe,
+    enumMembersType: NativeModuleEnumMemberType,
+  ): void {
+    if (!typeAnnotation.members || typeAnnotation.members.length === 0) {
+      // passing mixed members to flow would result in a flow error
+      // if the tool is launched ignoring that error, the enum would appear like not having enums
+      throw new Error(
+        'Enums should have at least one member and member values can not be mixed- they all must be either blank, number, or string values.',
+      );
+    }
+
+    typeAnnotation.members.forEach(member => {
+      if (
+        enumMembersType === 'StringTypeAnnotation' &&
+        (!member.init || typeof member.init.value === 'string')
+      ) {
+        return;
+      }
+
+      if (
+        enumMembersType === 'NumberTypeAnnotation' &&
+        member.init &&
+        typeof member.init.value === 'number'
+      ) {
+        return;
+      }
+
+      throw new Error(
+        'Enums can not be mixed- they all must be either blank, number, or string values.',
+      );
+    });
+  }
+
+  parseEnumMembers(typeAnnotation: $FlowFixMe): NativeModuleEnumMembers {
+    return typeAnnotation.members.map(member => ({
+      name: member.id.name,
+      value: member.init?.value ?? member.id.name,
+    }));
+  }
 }
 
 module.exports = {

package/lib/parsers/flow/utils.js

@@ -61,38 +61,52 @@ function resolveTypeAnnotation(
   );
   let node = typeAnnotation;
   let nullable = false;
-  let typeAliasResolutionStatus = {
+  let typeResolutionStatus = {
     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'
-      ) {
+      continue;
+    }
+    if (node.type !== 'GenericTypeAnnotation') {
+      break;
+    }
+    const resolvedTypeAnnotation = types[node.id.name];
+    if (resolvedTypeAnnotation == null) {
+      break;
+    }
+    switch (resolvedTypeAnnotation.type) {
+      case 'TypeAlias': {
+        typeResolutionStatus = {
+          successful: true,
+          type: 'alias',
+          name: node.id.name,
+        };
+        node = resolvedTypeAnnotation.right;
         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;
+      case 'EnumDeclaration': {
+        typeResolutionStatus = {
+          successful: true,
+          type: 'enum',
+          name: node.id.name,
+        };
+        node = resolvedTypeAnnotation.body;
+        break;
+      }
+      default: {
+        throw new TypeError(
+          `A non GenericTypeAnnotation must be a type declaration ('TypeAlias') or enum ('EnumDeclaration'). Instead, got the unsupported ${resolvedTypeAnnotation.type}.`,
+        );
+      }
     }
   }
   return {
     nullable: nullable,
     typeAnnotation: node,
-    typeAliasResolutionStatus,
+    typeResolutionStatus,
   };
 }
 function getValueFromTypes(value, types) {

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

@@ -10,7 +10,7 @@
 
 'use strict';
 
-import type {TypeAliasResolutionStatus, TypeDeclarationMap} from '../utils';
+import type {TypeResolutionStatus, TypeDeclarationMap} from '../utils';
 
 /**
  * This FlowFixMe is supposed to refer to an InterfaceDeclaration or TypeAlias
@@ -61,7 +61,7 @@ function resolveTypeAnnotation(
 ): {
   nullable: boolean,
   typeAnnotation: $FlowFixMe,
-  typeAliasResolutionStatus: TypeAliasResolutionStatus,
+  typeResolutionStatus: TypeResolutionStatus,
 } {
   invariant(
     typeAnnotation != null,
@@ -70,7 +70,7 @@ function resolveTypeAnnotation(
 
   let node = typeAnnotation;
   let nullable = false;
-  let typeAliasResolutionStatus: TypeAliasResolutionStatus = {
+  let typeResolutionStatus: TypeResolutionStatus = {
     successful: false,
   };
 
@@ -78,34 +78,49 @@ function resolveTypeAnnotation(
     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;
-      }
+      continue;
+    }
 
-      invariant(
-        resolvedTypeAnnotation.type === 'TypeAlias',
-        `GenericTypeAnnotation '${node.id.name}' must resolve to a TypeAlias. Instead, it resolved to a '${resolvedTypeAnnotation.type}'`,
-      );
+    if (node.type !== 'GenericTypeAnnotation') {
+      break;
+    }
 
-      node = resolvedTypeAnnotation.right;
-    } else {
+    const resolvedTypeAnnotation = types[node.id.name];
+    if (resolvedTypeAnnotation == null) {
       break;
     }
+
+    switch (resolvedTypeAnnotation.type) {
+      case 'TypeAlias': {
+        typeResolutionStatus = {
+          successful: true,
+          type: 'alias',
+          name: node.id.name,
+        };
+        node = resolvedTypeAnnotation.right;
+        break;
+      }
+      case 'EnumDeclaration': {
+        typeResolutionStatus = {
+          successful: true,
+          type: 'enum',
+          name: node.id.name,
+        };
+        node = resolvedTypeAnnotation.body;
+        break;
+      }
+      default: {
+        throw new TypeError(
+          `A non GenericTypeAnnotation must be a type declaration ('TypeAlias') or enum ('EnumDeclaration'). Instead, got the unsupported ${resolvedTypeAnnotation.type}.`,
+        );
+      }
+    }
   }
 
   return {
     nullable: nullable,
     typeAnnotation: node,
-    typeAliasResolutionStatus,
+    typeResolutionStatus,
   };
 }
 

package/lib/parsers/parser.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ */
+
+import type { SchemaType } from "../CodegenSchema";
+import type { ParserType } from "./errors";
+
+// useful members only for downstream
+export interface Parser {
+    language(): ParserType;
+    parseFile(filename: string): SchemaType;
+    parseString(contents: string, filename?: string): SchemaType;
+    parseModuleFixture(filename: string): SchemaType;
+}

package/lib/parsers/parser.js.flow

@@ -10,7 +10,15 @@
 
 'use strict';
 
-import type {UnionTypeAnnotationMemberType} from '../CodegenSchema.js';
+import type {
+  UnionTypeAnnotationMemberType,
+  SchemaType,
+  NamedShape,
+  Nullable,
+  NativeModuleParamTypeAnnotation,
+  NativeModuleEnumMemberType,
+  NativeModuleEnumMembers,
+} from '../CodegenSchema';
 import type {ParserType} from './errors';
 
 /**
@@ -24,25 +32,17 @@ export interface Parser {
   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.
+   * Given a declaration, it returns true if it is a property
    */
-  getKeyName(propertyOrIndex: $FlowFixMe, hasteModuleName: string): string;
+  isProperty(property: $FlowFixMe): boolean;
   /**
-   * 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.
+   * Given a property declaration, it returns the key name.
+   * @parameter property: an object containing a property declaration.
+   * @parameter hasteModuleName: a string with the native module name.
+   * @returns: the key name.
+   * @throws if property does not contain a property declaration.
    */
-  isEnumDeclaration(maybeEnumDeclaration: $FlowFixMe): boolean;
+  getKeyName(property: $FlowFixMe, hasteModuleName: string): string;
   /**
    * @returns: the Parser language.
    */
@@ -67,4 +67,89 @@ export interface Parser {
   remapUnionTypeAnnotationMemberNames(
     types: $FlowFixMe,
   ): UnionTypeAnnotationMemberType[];
+  /**
+   * Given the name of a file, it returns a Schema.
+   * @parameter filename: the name of the file.
+   * @returns: the Schema of the file.
+   */
+  parseFile(filename: string): SchemaType;
+  /**
+   * Given the content of a file, it returns a Schema.
+   * @parameter contents: the content of the file.
+   * @parameter filename: the name of the file.
+   * @returns: the Schema of the file.
+   */
+  parseString(contents: string, filename: ?string): SchemaType;
+  /**
+   * Given the name of a file, it returns a Schema.
+   * @parameter filename: the name of the file.
+   * @returns: the Schema of the file.
+   */
+  parseModuleFixture(filename: string): SchemaType;
+
+  /**
+   * Given the content of a file, it returns an AST.
+   * @parameter contents: the content of the file.
+   * @returns: the AST of the file.
+   */
+  getAst(contents: string): $FlowFixMe;
+
+  /**
+   * Given a FunctionTypeAnnotation, it returns an array of its parameters.
+   * @parameter functionTypeAnnotation: a FunctionTypeAnnotation
+   * @returns: the parameters of the FunctionTypeAnnotation.
+   */
+  getFunctionTypeAnnotationParameters(
+    functionTypeAnnotation: $FlowFixMe,
+  ): $ReadOnlyArray<$FlowFixMe>;
+
+  /**
+   * Given a parameter, it returns the function name of the parameter.
+   * @parameter parameter: a parameter of a FunctionTypeAnnotation.
+   * @returns: the function name of the parameter.
+   */
+  getFunctionNameFromParameter(
+    parameter: NamedShape<Nullable<NativeModuleParamTypeAnnotation>>,
+  ): $FlowFixMe;
+
+  /**
+   * Given a parameter, it returns its name.
+   * @parameter parameter: a parameter of a FunctionTypeAnnotation.
+   * @returns: the name of the parameter.
+   */
+  getParameterName(parameter: $FlowFixMe): string;
+
+  /**
+   * Given a parameter, it returns its typeAnnotation.
+   * @parameter parameter: a parameter of a FunctionTypeAnnotation.
+   * @returns: the typeAnnotation of the parameter.
+   */
+  getParameterTypeAnnotation(param: $FlowFixMe): $FlowFixMe;
+
+  /**
+   * Given a FunctionTypeAnnotation, it returns its returnType.
+   * @parameter functionTypeAnnotation: a FunctionTypeAnnotation
+   * @returns: the returnType of the FunctionTypeAnnotation.
+   */
+  getFunctionTypeAnnotationReturnType(
+    functionTypeAnnotation: $FlowFixMe,
+  ): $FlowFixMe;
+
+  /**
+   * Calculates an enum's members type
+   */
+  parseEnumMembersType(typeAnnotation: $FlowFixMe): NativeModuleEnumMemberType;
+
+  /**
+   * Throws if enum mebers are not supported
+   */
+  validateEnumMembersSupported(
+    typeAnnotation: $FlowFixMe,
+    enumMembersType: NativeModuleEnumMemberType,
+  ): void;
+
+  /**
+   * Calculates enum's members
+   */
+  parseEnumMembers(typeAnnotation: $FlowFixMe): NativeModuleEnumMembers;
 }