@react-native/codegen 0.72.4 → 0.73.0

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

@@ -26,8 +26,11 @@ const _require6 = require('../../error-utils'),
 const _require7 = require('../../parsers-commons'),
   createComponentConfig = _require7.createComponentConfig,
   findNativeComponentType = _require7.findNativeComponentType,
+  propertyNames = _require7.propertyNames,
   getCommandOptions = _require7.getCommandOptions,
-  getOptions = _require7.getOptions;
+  getOptions = _require7.getOptions,
+  getCommandTypeNameAndOptionsExpression =
+    _require7.getCommandTypeNameAndOptionsExpression;
 
 // $FlowFixMe[signature-verification-failure] TODO(T108222691): Use flow-types for @babel/parser
 function findComponentConfig(ast, parser) {
@@ -49,67 +52,33 @@ function findComponentConfig(ast, parser) {
     node => node.type === 'ExportNamedDeclaration',
   );
   const commandsTypeNames = namedExports
-    .map(statement => {
-      let callExpression;
-      let calleeName;
-      try {
-        callExpression = statement.declaration.declarations[0].init;
-        calleeName = callExpression.callee.name;
-      } catch (e) {
-        return;
-      }
-      if (calleeName !== 'codegenNativeCommands') {
-        return;
-      }
-
-      // const statement.declaration.declarations[0].init
-      if (callExpression.arguments.length !== 1) {
-        throw new Error(
-          'codegenNativeCommands must be passed options including the supported commands',
-        );
-      }
-      const typeArgumentParam = callExpression.typeParameters.params[0];
-      if (typeArgumentParam.type !== 'TSTypeReference') {
-        throw new Error(
-          "codegenNativeCommands doesn't support inline definitions. Specify a file local type alias",
-        );
-      }
-      return {
-        commandTypeName: typeArgumentParam.typeName.name,
-        commandOptionsExpression: callExpression.arguments[0],
-      };
-    })
+    .map(statement => getCommandTypeNameAndOptionsExpression(statement, parser))
     .filter(Boolean);
   throwIfMoreThanOneCodegenNativecommands(commandsTypeNames);
   return createComponentConfig(foundConfig, commandsTypeNames);
 }
-function getCommandProperties(
-  /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
-   * LTI update could not be added via codemod */
-  commandTypeName,
-  types,
-  commandOptions,
-) {
+function getCommandProperties(ast, parser) {
+  const _findComponentConfig = findComponentConfig(ast, parser),
+    commandTypeName = _findComponentConfig.commandTypeName,
+    commandOptionsExpression = _findComponentConfig.commandOptionsExpression;
   if (commandTypeName == null) {
     return [];
   }
+  const types = parser.getTypes(ast);
   const typeAlias = types[commandTypeName];
   if (typeAlias.type !== 'TSInterfaceDeclaration') {
     throw new Error(
       `The type argument for codegenNativeCommands must be an interface, received ${typeAlias.type}`,
     );
   }
-  let properties;
-  try {
-    properties = typeAlias.body.body;
-  } catch (e) {
+  const properties = parser.bodyProperties(typeAlias);
+  if (!properties) {
     throw new Error(
       `Failed to find type definition for "${commandTypeName}", please check that you have a valid codegen typescript file`,
     );
   }
-  const typeScriptPropertyNames = properties
-    .map(property => property && property.key && property.key.name)
-    .filter(Boolean);
+  const typeScriptPropertyNames = propertyNames(properties);
+  const commandOptions = getCommandOptions(commandOptionsExpression);
   if (commandOptions == null || commandOptions.supportedCommands == null) {
     throw new Error(
       'codegenNativeCommands must be given an options object with supportedCommands array',
@@ -135,20 +104,13 @@ function getCommandProperties(
 
 // $FlowFixMe[signature-verification-failure] TODO(T108222691): Use flow-types for @babel/parser
 function buildComponentSchema(ast, parser) {
-  const _findComponentConfig = findComponentConfig(ast, parser),
-    componentName = _findComponentConfig.componentName,
-    propsTypeName = _findComponentConfig.propsTypeName,
-    commandTypeName = _findComponentConfig.commandTypeName,
-    commandOptionsExpression = _findComponentConfig.commandOptionsExpression,
-    optionsExpression = _findComponentConfig.optionsExpression;
+  const _findComponentConfig2 = findComponentConfig(ast, parser),
+    componentName = _findComponentConfig2.componentName,
+    propsTypeName = _findComponentConfig2.propsTypeName,
+    optionsExpression = _findComponentConfig2.optionsExpression;
   const types = parser.getTypes(ast);
   const propProperties = getProperties(propsTypeName, types);
-  const commandOptions = getCommandOptions(commandOptionsExpression);
-  const commandProperties = getCommandProperties(
-    commandTypeName,
-    types,
-    commandOptions,
-  );
+  const commandProperties = getCommandProperties(ast, parser);
   const options = getOptions(optionsExpression);
   const extendsProps = [];
   const componentPropAsts = [];

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

@@ -11,8 +11,6 @@
 'use strict';
 import type {ExtendsPropsShape} from '../../../CodegenSchema.js';
 import type {Parser} from '../../parser';
-import type {TypeDeclarationMap} from '../../utils';
-import type {CommandOptions} from '../../parsers-commons';
 import type {ComponentSchemaBuilderConfig} from '../../schema.js';
 
 const {getCommands} = require('./commands');
@@ -24,8 +22,10 @@ const {throwIfMoreThanOneCodegenNativecommands} = require('../../error-utils');
 const {
   createComponentConfig,
   findNativeComponentType,
+  propertyNames,
   getCommandOptions,
   getOptions,
+  getCommandTypeNameAndOptionsExpression,
 } = require('../../parsers-commons');
 
 // $FlowFixMe[signature-verification-failure] TODO(T108222691): Use flow-types for @babel/parser
@@ -54,40 +54,7 @@ function findComponentConfig(ast: $FlowFixMe, parser: Parser) {
   );
 
   const commandsTypeNames = namedExports
-    .map(statement => {
-      let callExpression;
-      let calleeName;
-      try {
-        callExpression = statement.declaration.declarations[0].init;
-        calleeName = callExpression.callee.name;
-      } catch (e) {
-        return;
-      }
-
-      if (calleeName !== 'codegenNativeCommands') {
-        return;
-      }
-
-      // const statement.declaration.declarations[0].init
-      if (callExpression.arguments.length !== 1) {
-        throw new Error(
-          'codegenNativeCommands must be passed options including the supported commands',
-        );
-      }
-
-      const typeArgumentParam = callExpression.typeParameters.params[0];
-
-      if (typeArgumentParam.type !== 'TSTypeReference') {
-        throw new Error(
-          "codegenNativeCommands doesn't support inline definitions. Specify a file local type alias",
-        );
-      }
-
-      return {
-        commandTypeName: typeArgumentParam.typeName.name,
-        commandOptionsExpression: callExpression.arguments[0],
-      };
-    })
+    .map(statement => getCommandTypeNameAndOptionsExpression(statement, parser))
     .filter(Boolean);
 
   throwIfMoreThanOneCodegenNativecommands(commandsTypeNames);
@@ -95,17 +62,16 @@ function findComponentConfig(ast: $FlowFixMe, parser: Parser) {
   return createComponentConfig(foundConfig, commandsTypeNames);
 }
 
-function getCommandProperties(
-  /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
-   * LTI update could not be added via codemod */
-  commandTypeName,
-  types: TypeDeclarationMap,
-  commandOptions: ?CommandOptions,
-) {
+function getCommandProperties(ast: $FlowFixMe, parser: Parser) {
+  const {commandTypeName, commandOptionsExpression} = findComponentConfig(
+    ast,
+    parser,
+  );
   if (commandTypeName == null) {
     return [];
   }
 
+  const types = parser.getTypes(ast);
   const typeAlias = types[commandTypeName];
 
   if (typeAlias.type !== 'TSInterfaceDeclaration') {
@@ -114,19 +80,16 @@ function getCommandProperties(
     );
   }
 
-  let properties;
-  try {
-    properties = typeAlias.body.body;
-  } catch (e) {
+  const properties = parser.bodyProperties(typeAlias);
+  if (!properties) {
     throw new Error(
       `Failed to find type definition for "${commandTypeName}", please check that you have a valid codegen typescript file`,
     );
   }
 
-  const typeScriptPropertyNames = properties
-    .map(property => property && property.key && property.key.name)
-    .filter(Boolean);
+  const typeScriptPropertyNames = propertyNames(properties);
 
+  const commandOptions = getCommandOptions(commandOptionsExpression);
   if (commandOptions == null || commandOptions.supportedCommands == null) {
     throw new Error(
       'codegenNativeCommands must be given an options object with supportedCommands array',
@@ -158,24 +121,16 @@ function buildComponentSchema(
   ast: $FlowFixMe,
   parser: Parser,
 ): ComponentSchemaBuilderConfig {
-  const {
-    componentName,
-    propsTypeName,
-    commandTypeName,
-    commandOptionsExpression,
-    optionsExpression,
-  } = findComponentConfig(ast, parser);
+  const {componentName, propsTypeName, optionsExpression} = findComponentConfig(
+    ast,
+    parser,
+  );
 
   const types = parser.getTypes(ast);
 
   const propProperties = getProperties(propsTypeName, types);
-  const commandOptions = getCommandOptions(commandOptionsExpression);
 
-  const commandProperties = getCommandProperties(
-    commandTypeName,
-    types,
-    commandOptions,
-  );
+  const commandProperties = getCommandProperties(ast, parser);
 
   const options = getOptions(optionsExpression);
 

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

@@ -20,15 +20,10 @@ const _require4 = require('../../parsers-commons'),
   parseObjectProperty = _require4.parseObjectProperty;
 const _require5 = require('../../parsers-primitives'),
   emitArrayType = _require5.emitArrayType,
-  emitBoolean = _require5.emitBoolean,
   emitFunction = _require5.emitFunction,
-  emitNumber = _require5.emitNumber,
   emitGenericObject = _require5.emitGenericObject,
   emitPromise = _require5.emitPromise,
   emitRootTag = _require5.emitRootTag,
-  emitVoid = _require5.emitVoid,
-  emitString = _require5.emitString,
-  emitMixed = _require5.emitMixed,
   emitUnion = _require5.emitUnion,
   emitCommonTypes = _require5.emitCommonTypes,
   typeAliasResolution = _require5.typeAliasResolution,
@@ -341,18 +336,6 @@ function translateTypeAnnotation(
         parser,
       );
     }
-    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,
@@ -370,19 +353,26 @@ function translateTypeAnnotation(
     case 'TSUnionType': {
       return emitUnion(nullable, hasteModuleName, typeAnnotation, parser);
     }
-    case 'TSUnknownKeyword': {
-      if (cxxOnly) {
-        return emitMixed(nullable);
-      }
-      // Fallthrough
-    }
-
     default: {
-      throw new UnsupportedTypeAnnotationParserError(
+      const commonType = emitCommonTypes(
         hasteModuleName,
+        types,
         typeAnnotation,
-        parser.language(),
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        nullable,
+        parser,
       );
+      if (!commonType) {
+        throw new UnsupportedTypeAnnotationParserError(
+          hasteModuleName,
+          typeAnnotation,
+          parser.language(),
+        );
+      }
+      return commonType;
     }
   }
 }

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

@@ -34,15 +34,10 @@ const {parseObjectProperty} = require('../../parsers-commons');
 
 const {
   emitArrayType,
-  emitBoolean,
   emitFunction,
-  emitNumber,
   emitGenericObject,
   emitPromise,
   emitRootTag,
-  emitVoid,
-  emitString,
-  emitMixed,
   emitUnion,
   emitCommonTypes,
   typeAliasResolution,
@@ -353,18 +348,6 @@ function translateTypeAnnotation(
         parser,
       );
     }
-    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,
@@ -382,18 +365,27 @@ function translateTypeAnnotation(
     case 'TSUnionType': {
       return emitUnion(nullable, hasteModuleName, typeAnnotation, parser);
     }
-    case 'TSUnknownKeyword': {
-      if (cxxOnly) {
-        return emitMixed(nullable);
-      }
-      // Fallthrough
-    }
     default: {
-      throw new UnsupportedTypeAnnotationParserError(
+      const commonType = emitCommonTypes(
         hasteModuleName,
+        types,
         typeAnnotation,
-        parser.language(),
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        nullable,
+        parser,
       );
+
+      if (!commonType) {
+        throw new UnsupportedTypeAnnotationParserError(
+          hasteModuleName,
+          typeAnnotation,
+          parser.language(),
+        );
+      }
+      return commonType;
     }
   }
 }

package/lib/parsers/typescript/parser.js

@@ -86,7 +86,13 @@ class TypeScriptParser {
     return 'TypeScript';
   }
   nameForGenericTypeAnnotation(typeAnnotation) {
-    return typeAnnotation.typeName.name;
+    var _typeAnnotation$typeN;
+    return typeAnnotation === null || typeAnnotation === void 0
+      ? void 0
+      : (_typeAnnotation$typeN = typeAnnotation.typeName) === null ||
+        _typeAnnotation$typeN === void 0
+      ? void 0
+      : _typeAnnotation$typeN.name;
   }
   checkIfInvalidModule(typeArguments) {
     return (
@@ -224,6 +230,9 @@ class TypeScriptParser {
       node.extends[0].expression.name === 'TurboModule'
     );
   }
+  isGenericTypeAnnotation(type) {
+    return type === 'TSTypeReference';
+  }
   extractAnnotatedElement(typeAnnotation, types) {
     return types[typeAnnotation.typeParameters.params[0].typeName.name];
   }
@@ -306,6 +315,24 @@ class TypeScriptParser {
   getAnnotatedElementProperties(annotatedElement) {
     return annotatedElement.typeAnnotation.members;
   }
+  bodyProperties(typeAlias) {
+    return typeAlias.body.body;
+  }
+  convertKeywordToTypeAnnotation(keyword) {
+    switch (keyword) {
+      case 'TSBooleanKeyword':
+        return 'BooleanTypeAnnotation';
+      case 'TSNumberKeyword':
+        return 'NumberTypeAnnotation';
+      case 'TSVoidKeyword':
+        return 'VoidTypeAnnotation';
+      case 'TSStringKeyword':
+        return 'StringTypeAnnotation';
+      case 'TSUnknownKeyword':
+        return 'MixedTypeAnnotation';
+    }
+    return keyword;
+  }
 }
 module.exports = {
   TypeScriptParser,

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

@@ -67,7 +67,7 @@ class TypeScriptParser implements Parser {
   }
 
   nameForGenericTypeAnnotation(typeAnnotation: $FlowFixMe): string {
-    return typeAnnotation.typeName.name;
+    return typeAnnotation?.typeName?.name;
   }
 
   checkIfInvalidModule(typeArguments: $FlowFixMe): boolean {
@@ -210,6 +210,10 @@ class TypeScriptParser implements Parser {
     );
   }
 
+  isGenericTypeAnnotation(type: $FlowFixMe): boolean {
+    return type === 'TSTypeReference';
+  }
+
   extractAnnotatedElement(
     typeAnnotation: $FlowFixMe,
     types: TypeDeclarationMap,
@@ -303,6 +307,27 @@ class TypeScriptParser implements Parser {
   getAnnotatedElementProperties(annotatedElement: $FlowFixMe): $FlowFixMe {
     return annotatedElement.typeAnnotation.members;
   }
+
+  bodyProperties(typeAlias: TypeDeclarationMap): $ReadOnlyArray<$FlowFixMe> {
+    return typeAlias.body.body;
+  }
+
+  convertKeywordToTypeAnnotation(keyword: string): string {
+    switch (keyword) {
+      case 'TSBooleanKeyword':
+        return 'BooleanTypeAnnotation';
+      case 'TSNumberKeyword':
+        return 'NumberTypeAnnotation';
+      case 'TSVoidKeyword':
+        return 'VoidTypeAnnotation';
+      case 'TSStringKeyword':
+        return 'StringTypeAnnotation';
+      case 'TSUnknownKeyword':
+        return 'MixedTypeAnnotation';
+    }
+
+    return keyword;
+  }
 }
 
 module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native/codegen",
-  "version": "0.72.4",
+  "version": "0.73.0",
   "description": "⚛️ Code generation tools for React Native",
   "homepage": "https://github.com/facebook/react-native/tree/HEAD/packages/react-native-codegen",
   "repository": {