@react-native/codegen 0.72.2 → 0.72.3

package/lib/parsers/parser.js.flow

@@ -20,6 +20,7 @@ import type {
   NativeModuleEnumMembers,
 } from '../CodegenSchema';
 import type {ParserType} from './errors';
+import type {TypeDeclarationMap} from './utils';
 
 /**
  * This is the main interface for Parsers of various languages.
@@ -152,4 +153,25 @@ export interface Parser {
    * Calculates enum's members
    */
   parseEnumMembers(typeAnnotation: $FlowFixMe): NativeModuleEnumMembers;
+
+  /**
+   * Given a node, it returns true if it is a module interface
+   */
+  isModuleInterface(node: $FlowFixMe): boolean;
+
+  /**
+   * Given a typeAnnotation, it returns the annotated element.
+   * @paramater typeAnnotation: the annotation for a type.
+   * @paramater types: a map of type declarations.
+   * @returns: the annotated element.
+   */
+  extractAnnotatedElement(
+    typeAnnotation: $FlowFixMe,
+    types: TypeDeclarationMap,
+  ): $FlowFixMe;
+
+  /**
+   * Given the AST, returns the TypeDeclarationMap
+   */
+  getTypes(ast: $FlowFixMe): TypeDeclarationMap;
 }

package/lib/parsers/parserMock.js

@@ -150,4 +150,18 @@ export class MockedParser {
           },
         ];
   }
+  isModuleInterface(node) {
+    return (
+      node.type === 'InterfaceDeclaration' &&
+      node.extends.length === 1 &&
+      node.extends[0].type === 'InterfaceExtends' &&
+      node.extends[0].id.name === 'TurboModule'
+    );
+  }
+  extractAnnotatedElement(typeAnnotation, types) {
+    return types[typeAnnotation.typeParameters.params[0].id.name];
+  }
+  getTypes(ast) {
+    return {};
+  }
 }

package/lib/parsers/parserMock.js.flow

@@ -21,6 +21,7 @@ import type {
   NativeModuleEnumMemberType,
   NativeModuleEnumMembers,
 } from '../CodegenSchema';
+import type {TypeDeclarationMap} from './utils';
 
 // $FlowFixMe[untyped-import] there's no flowtype flow-parser
 const flowParser = require('flow-parser');
@@ -159,4 +160,24 @@ export class MockedParser implements Parser {
           },
         ];
   }
+
+  isModuleInterface(node: $FlowFixMe): boolean {
+    return (
+      node.type === 'InterfaceDeclaration' &&
+      node.extends.length === 1 &&
+      node.extends[0].type === 'InterfaceExtends' &&
+      node.extends[0].id.name === 'TurboModule'
+    );
+  }
+
+  extractAnnotatedElement(
+    typeAnnotation: $FlowFixMe,
+    types: TypeDeclarationMap,
+  ): $FlowFixMe {
+    return types[typeAnnotation.typeParameters.params[0].id.name];
+  }
+
+  getTypes(ast: $FlowFixMe): TypeDeclarationMap {
+    return {};
+  }
 }

package/lib/parsers/parsers-commons.js

@@ -369,7 +369,7 @@ function buildSchemaFromConfigType(
 ) {
   switch (configType) {
     case 'component': {
-      return wrapComponentSchema(buildComponentSchema(ast));
+      return wrapComponentSchema(buildComponentSchema(ast, parser));
     }
     case 'module': {
       if (filename === undefined || filename === null) {

package/lib/parsers/parsers-commons.js.flow

@@ -26,7 +26,7 @@ import type {
 import type {Parser} from './parser';
 import type {ParserType} from './errors';
 import type {ParserErrorCapturer, TypeDeclarationMap} from './utils';
-import type {ComponentSchemaBuilderConfig} from './flow/components/schema';
+import type {ComponentSchemaBuilderConfig} from './schema.js';
 
 const {
   getConfigType,
@@ -345,7 +345,10 @@ function buildSchemaFromConfigType(
   filename: ?string,
   ast: $FlowFixMe,
   wrapComponentSchema: (config: ComponentSchemaBuilderConfig) => SchemaType,
-  buildComponentSchema: (ast: $FlowFixMe) => ComponentSchemaBuilderConfig,
+  buildComponentSchema: (
+    ast: $FlowFixMe,
+    parser: Parser,
+  ) => ComponentSchemaBuilderConfig,
   buildModuleSchema: (
     hasteModuleName: string,
     ast: $FlowFixMe,
@@ -356,7 +359,7 @@ function buildSchemaFromConfigType(
 ): SchemaType {
   switch (configType) {
     case 'component': {
-      return wrapComponentSchema(buildComponentSchema(ast));
+      return wrapComponentSchema(buildComponentSchema(ast, parser));
     }
     case 'module': {
       if (filename === undefined || filename === null) {
@@ -398,7 +401,10 @@ function buildSchema(
   contents: string,
   filename: ?string,
   wrapComponentSchema: (config: ComponentSchemaBuilderConfig) => SchemaType,
-  buildComponentSchema: (ast: $FlowFixMe) => ComponentSchemaBuilderConfig,
+  buildComponentSchema: (
+    ast: $FlowFixMe,
+    parser: Parser,
+  ) => ComponentSchemaBuilderConfig,
   buildModuleSchema: (
     hasteModuleName: string,
     ast: $FlowFixMe,

package/lib/parsers/{flow/components/schema.js.flow → schema.js.flow}

@@ -4,8 +4,8 @@
  * 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
+ * @flow strict
  */
 
 'use strict';
@@ -18,7 +18,7 @@ import type {
   ExtendsPropsShape,
   SchemaType,
   OptionsShape,
-} from '../../../CodegenSchema.js';
+} from '../CodegenSchema.js';
 
 export type ComponentSchemaBuilderConfig = $ReadOnly<{
   filename: string,

package/lib/parsers/typescript/components/index.js

@@ -72,21 +72,19 @@ function _toPrimitive(input, hint) {
   }
   return (hint === 'string' ? String : Number)(input);
 }
-const _require = require('../utils'),
-  getTypes = _require.getTypes;
-const _require2 = require('./commands'),
-  getCommands = _require2.getCommands;
-const _require3 = require('./events'),
-  getEvents = _require3.getEvents;
-const _require4 = require('./extends'),
-  categorizeProps = _require4.categorizeProps;
-const _require5 = require('./options'),
-  getCommandOptions = _require5.getCommandOptions,
-  getOptions = _require5.getOptions;
-const _require6 = require('./props'),
-  getProps = _require6.getProps;
-const _require7 = require('./componentsUtils.js'),
-  getProperties = _require7.getProperties;
+const _require = require('./commands'),
+  getCommands = _require.getCommands;
+const _require2 = require('./events'),
+  getEvents = _require2.getEvents;
+const _require3 = require('./extends'),
+  categorizeProps = _require3.categorizeProps;
+const _require4 = require('./options'),
+  getCommandOptions = _require4.getCommandOptions,
+  getOptions = _require4.getOptions;
+const _require5 = require('./props'),
+  getProps = _require5.getProps;
+const _require6 = require('./componentsUtils.js'),
+  getProperties = _require6.getProperties;
 
 /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
  * LTI update could not be added via codemod */
@@ -231,16 +229,14 @@ function getCommandProperties(
 // $FlowFixMe[unclear-type] TODO(T108222691): Use flow-types for @babel/parser
 
 // $FlowFixMe[signature-verification-failure] TODO(T108222691): Use flow-types for @babel/parser
-/* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
- * LTI update could not be added via codemod */
-function buildComponentSchema(ast) {
+function buildComponentSchema(ast, parser) {
   const _findComponentConfig = findComponentConfig(ast),
     componentName = _findComponentConfig.componentName,
     propsTypeName = _findComponentConfig.propsTypeName,
     commandTypeName = _findComponentConfig.commandTypeName,
     commandOptionsExpression = _findComponentConfig.commandOptionsExpression,
     optionsExpression = _findComponentConfig.optionsExpression;
-  const types = getTypes(ast);
+  const types = parser.getTypes(ast);
   const propProperties = getProperties(propsTypeName, types);
   const commandOptions = getCommandOptions(commandOptionsExpression);
   const commandProperties = getCommandProperties(

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

@@ -10,11 +10,11 @@
 
 'use strict';
 import type {ExtendsPropsShape} from '../../../CodegenSchema.js';
+import type {Parser} from '../../parser';
 import type {TypeDeclarationMap} from '../../utils';
 import type {CommandOptions} from './options';
-import type {ComponentSchemaBuilderConfig} from './schema.js';
+import type {ComponentSchemaBuilderConfig} from '../../schema.js';
 
-const {getTypes} = require('../utils');
 const {getCommands} = require('./commands');
 const {getEvents} = require('./events');
 const {categorizeProps} = require('./extends');
@@ -185,9 +185,10 @@ function getCommandProperties(
 type PropsAST = Object;
 
 // $FlowFixMe[signature-verification-failure] TODO(T108222691): Use flow-types for @babel/parser
-/* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
- * LTI update could not be added via codemod */
-function buildComponentSchema(ast): ComponentSchemaBuilderConfig {
+function buildComponentSchema(
+  ast: $FlowFixMe,
+  parser: Parser,
+): ComponentSchemaBuilderConfig {
   const {
     componentName,
     propsTypeName,
@@ -196,7 +197,7 @@ function buildComponentSchema(ast): ComponentSchemaBuilderConfig {
     optionsExpression,
   } = findComponentConfig(ast);
 
-  const types = getTypes(ast);
+  const types = parser.getTypes(ast);
 
   const propProperties = getProperties(propsTypeName, types);
   const commandOptions = getCommandOptions(commandOptionsExpression);

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

@@ -149,8 +149,7 @@ const _require3 = require('../../utils'),
   isModuleRegistryCall = _require3.isModuleRegistryCall,
   verifyPlatforms = _require3.verifyPlatforms;
 const _require4 = require('../utils'),
-  resolveTypeAnnotation = _require4.resolveTypeAnnotation,
-  getTypes = _require4.getTypes;
+  resolveTypeAnnotation = _require4.resolveTypeAnnotation;
 const _require5 = require('../../parsers-commons'),
   parseObjectProperty = _require5.parseObjectProperty,
   buildPropertySchema = _require5.buildPropertySchema;
@@ -178,9 +177,7 @@ const _require7 = require('../../parsers-primitives'),
 const _require8 = require('../../errors'),
   UnsupportedGenericParserError = _require8.UnsupportedGenericParserError,
   UnsupportedTypeAnnotationParserError =
-    _require8.UnsupportedTypeAnnotationParserError,
-  IncorrectModuleRegistryCallArgumentTypeParserError =
-    _require8.IncorrectModuleRegistryCallArgumentTypeParserError;
+    _require8.UnsupportedTypeAnnotationParserError;
 const _require9 = require('../../error-utils'),
   throwIfUntypedModule = _require9.throwIfUntypedModule,
   throwIfUnusedModuleInterfaceParserError =
@@ -194,7 +191,12 @@ const _require9 = require('../../error-utils'),
   throwIfMoreThanOneModuleInterfaceParserError =
     _require9.throwIfMoreThanOneModuleInterfaceParserError,
   throwIfIncorrectModuleRegistryCallTypeParameterParserError =
-    _require9.throwIfIncorrectModuleRegistryCallTypeParameterParserError;
+    _require9.throwIfIncorrectModuleRegistryCallTypeParameterParserError,
+  throwIfIncorrectModuleRegistryCallArgument =
+    _require9.throwIfIncorrectModuleRegistryCallArgument,
+  throwIfPartialNotAnnotatingTypeParameter =
+    _require9.throwIfPartialNotAnnotatingTypeParameter,
+  throwIfPartialWithMoreParameter = _require9.throwIfPartialWithMoreParameter;
 const language = 'TypeScript';
 function translateObjectTypeAnnotation(
   hasteModuleName,
@@ -361,18 +363,16 @@ function translateTypeAnnotation(
           return emitGenericObject(nullable);
         }
         case 'Partial': {
-          if (typeAnnotation.typeParameters.params.length !== 1) {
-            throw new Error(
-              'Partials only support annotating exactly one parameter.',
-            );
-          }
-          const annotatedElement =
-            types[typeAnnotation.typeParameters.params[0].typeName.name];
-          if (!annotatedElement) {
-            throw new Error(
-              'Partials only support annotating a type parameter.',
-            );
-          }
+          throwIfPartialWithMoreParameter(typeAnnotation);
+          const annotatedElement = parser.extractAnnotatedElement(
+            typeAnnotation,
+            types,
+          );
+          throwIfPartialNotAnnotatingTypeParameter(
+            typeAnnotation,
+            types,
+            parser,
+          );
           const properties = annotatedElement.typeAnnotation.members.map(
             member => {
               return {
@@ -555,17 +555,6 @@ function translateTypeAnnotation(
     }
   }
 }
-function isModuleInterface(node) {
-  var _node$extends;
-  return (
-    node.type === 'TSInterfaceDeclaration' &&
-    ((_node$extends = node.extends) === null || _node$extends === void 0
-      ? void 0
-      : _node$extends.length) === 1 &&
-    node.extends[0].type === 'TSExpressionWithTypeArguments' &&
-    node.extends[0].expression.name === 'TurboModule'
-  );
-}
 function buildModuleSchema(
   hasteModuleName,
   /**
@@ -575,8 +564,10 @@ function buildModuleSchema(
   tryParse,
   parser,
 ) {
-  const types = getTypes(ast);
-  const moduleSpecs = Object.values(types).filter(isModuleInterface);
+  const types = parser.getTypes(ast);
+  const moduleSpecs = Object.values(types).filter(t =>
+    parser.isModuleInterface(t),
+  );
   throwIfModuleInterfaceNotFound(
     moduleSpecs.length,
     hasteModuleName,
@@ -621,15 +612,11 @@ function buildModuleSchema(
       methodName,
       callExpression.arguments.length,
     );
-    if (callExpression.arguments[0].type !== 'StringLiteral') {
-      const type = callExpression.arguments[0].type;
-      throw new IncorrectModuleRegistryCallArgumentTypeParserError(
-        hasteModuleName,
-        callExpression.arguments[0],
-        methodName,
-        type,
-      );
-    }
+    throwIfIncorrectModuleRegistryCallArgument(
+      hasteModuleName,
+      callExpression.arguments[0],
+      methodName,
+    );
     const $moduleName = callExpression.arguments[0].value;
     throwIfUntypedModule(
       typeParameters,

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

@@ -31,7 +31,7 @@ const {flattenIntersectionType} = require('../parseTopLevelType');
 const {flattenProperties} = require('../components/componentsUtils');
 
 const {visit, isModuleRegistryCall, verifyPlatforms} = require('../../utils');
-const {resolveTypeAnnotation, getTypes} = require('../utils');
+const {resolveTypeAnnotation} = require('../utils');
 
 const {
   parseObjectProperty,
@@ -63,7 +63,6 @@ const {
 const {
   UnsupportedGenericParserError,
   UnsupportedTypeAnnotationParserError,
-  IncorrectModuleRegistryCallArgumentTypeParserError,
 } = require('../../errors');
 
 const {
@@ -75,6 +74,9 @@ const {
   throwIfMoreThanOneModuleRegistryCalls,
   throwIfMoreThanOneModuleInterfaceParserError,
   throwIfIncorrectModuleRegistryCallTypeParameterParserError,
+  throwIfIncorrectModuleRegistryCallArgument,
+  throwIfPartialNotAnnotatingTypeParameter,
+  throwIfPartialWithMoreParameter,
 } = require('../../error-utils');
 
 const language = 'TypeScript';
@@ -243,20 +245,18 @@ function translateTypeAnnotation(
           return emitGenericObject(nullable);
         }
         case 'Partial': {
-          if (typeAnnotation.typeParameters.params.length !== 1) {
-            throw new Error(
-              'Partials only support annotating exactly one parameter.',
-            );
-          }
+          throwIfPartialWithMoreParameter(typeAnnotation);
 
-          const annotatedElement =
-            types[typeAnnotation.typeParameters.params[0].typeName.name];
+          const annotatedElement = parser.extractAnnotatedElement(
+            typeAnnotation,
+            types,
+          );
 
-          if (!annotatedElement) {
-            throw new Error(
-              'Partials only support annotating a type parameter.',
-            );
-          }
+          throwIfPartialNotAnnotatingTypeParameter(
+            typeAnnotation,
+            types,
+            parser,
+          );
 
           const properties = annotatedElement.typeAnnotation.members.map(
             member => {
@@ -436,15 +436,6 @@ function translateTypeAnnotation(
   }
 }
 
-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,
   /**
@@ -454,9 +445,9 @@ function buildModuleSchema(
   tryParse: ParserErrorCapturer,
   parser: Parser,
 ): NativeModuleSchema {
-  const types = getTypes(ast);
+  const types = parser.getTypes(ast);
   const moduleSpecs = (Object.values(types): $ReadOnlyArray<$FlowFixMe>).filter(
-    isModuleInterface,
+    t => parser.isModuleInterface(t),
   );
 
   throwIfModuleInterfaceNotFound(
@@ -510,15 +501,11 @@ function buildModuleSchema(
       callExpression.arguments.length,
     );
 
-    if (callExpression.arguments[0].type !== 'StringLiteral') {
-      const {type} = callExpression.arguments[0];
-      throw new IncorrectModuleRegistryCallArgumentTypeParserError(
-        hasteModuleName,
-        callExpression.arguments[0],
-        methodName,
-        type,
-      );
-    }
+    throwIfIncorrectModuleRegistryCallArgument(
+      hasteModuleName,
+      callExpression.arguments[0],
+      methodName,
+    );
 
     const $moduleName = callExpression.arguments[0].value;
 

package/lib/parsers/typescript/parser.js

@@ -46,7 +46,7 @@ const _require2 = require('./Visitor'),
   Visitor = _require2.Visitor;
 const _require3 = require('./components'),
   buildComponentSchema = _require3.buildComponentSchema;
-const _require4 = require('./components/schema'),
+const _require4 = require('../schema.js'),
   wrapComponentSchema = _require4.wrapComponentSchema;
 const _require5 = require('./modules'),
   buildModuleSchema = _require5.buildModuleSchema;
@@ -205,6 +205,50 @@ class TypeScriptParser {
       };
     });
   }
+  isModuleInterface(node) {
+    var _node$extends;
+    return (
+      node.type === 'TSInterfaceDeclaration' &&
+      ((_node$extends = node.extends) === null || _node$extends === void 0
+        ? void 0
+        : _node$extends.length) === 1 &&
+      node.extends[0].type === 'TSExpressionWithTypeArguments' &&
+      node.extends[0].expression.name === 'TurboModule'
+    );
+  }
+  extractAnnotatedElement(typeAnnotation, types) {
+    return types[typeAnnotation.typeParameters.params[0].typeName.name];
+  }
+
+  /**
+   * TODO(T108222691): Use flow-types for @babel/parser
+   */
+  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;
+    }, {});
+  }
 }
 module.exports = {
   TypeScriptParser,

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

@@ -21,6 +21,7 @@ import type {
 } from '../../CodegenSchema';
 import type {ParserType} from '../errors';
 import type {Parser} from '../parser';
+import type {TypeDeclarationMap} from '../utils';
 
 // $FlowFixMe[untyped-import] Use flow-types for @babel/parser
 const babelParser = require('@babel/parser');
@@ -28,7 +29,7 @@ const babelParser = require('@babel/parser');
 const {buildSchema} = require('../parsers-commons');
 const {Visitor} = require('./Visitor');
 const {buildComponentSchema} = require('./components');
-const {wrapComponentSchema} = require('./components/schema');
+const {wrapComponentSchema} = require('../schema.js');
 const {buildModuleSchema} = require('./modules');
 
 const fs = require('fs');
@@ -192,6 +193,52 @@ class TypeScriptParser implements Parser {
       value: member.initializer?.value ?? member.id.name,
     }));
   }
+
+  isModuleInterface(node: $FlowFixMe): boolean {
+    return (
+      node.type === 'TSInterfaceDeclaration' &&
+      node.extends?.length === 1 &&
+      node.extends[0].type === 'TSExpressionWithTypeArguments' &&
+      node.extends[0].expression.name === 'TurboModule'
+    );
+  }
+
+  extractAnnotatedElement(
+    typeAnnotation: $FlowFixMe,
+    types: TypeDeclarationMap,
+  ): $FlowFixMe {
+    return types[typeAnnotation.typeParameters.params[0].typeName.name];
+  }
+
+  /**
+   * TODO(T108222691): Use flow-types for @babel/parser
+   */
+  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;
+    }, {});
+  }
 }
 module.exports = {
   TypeScriptParser,

package/lib/parsers/typescript/utils.js

@@ -13,36 +13,6 @@
 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');
@@ -117,5 +87,4 @@ function resolveTypeAnnotation(
 }
 module.exports = {
   resolveTypeAnnotation,
-  getTypes,
 };