@react-native/codegen 0.74.0 → 0.75.0-nightly-20240221-a1171f79f

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

@@ -11,69 +11,66 @@
 'use strict';
 
 import type {
-  Nullable,
+  EventTypeAnnotation,
+  EventTypeShape,
   NamedShape,
   NativeModuleAliasMap,
   NativeModuleBaseTypeAnnotation,
-  NativeModuleSchema,
-  NativeModuleTypeAnnotation,
+  NativeModuleEnumMap,
   NativeModuleFunctionTypeAnnotation,
   NativeModuleParamTypeAnnotation,
   NativeModulePropertyShape,
-  SchemaType,
-  NativeModuleEnumMap,
+  NativeModuleSchema,
+  NativeModuleTypeAnnotation,
+  Nullable,
+  ObjectTypeAnnotation,
   OptionsShape,
   PropTypeAnnotation,
-  EventTypeAnnotation,
-  ObjectTypeAnnotation,
-  EventTypeShape,
+  SchemaType,
 } from '../CodegenSchema.js';
-
-import type {Parser} from './parser';
 import type {ParserType} from './errors';
+import type {Parser} from './parser';
+import type {ComponentSchemaBuilderConfig} from './schema.js';
 import type {
   ParserErrorCapturer,
-  TypeDeclarationMap,
   PropAST,
+  TypeDeclarationMap,
   TypeResolutionStatus,
 } from './utils';
-import type {ComponentSchemaBuilderConfig} from './schema.js';
-
-const {
-  getConfigType,
-  extractNativeModuleName,
-  createParserErrorCapturer,
-  visit,
-  isModuleRegistryCall,
-  verifyPlatforms,
-} = require('./utils');
 
 const {
-  throwIfPropertyValueTypeIsUnsupported,
-  throwIfUnsupportedFunctionParamTypeAnnotationParserError,
-  throwIfUnsupportedFunctionReturnTypeAnnotationParserError,
-  throwIfModuleTypeIsUnsupported,
-  throwIfUnusedModuleInterfaceParserError,
-  throwIfMoreThanOneModuleRegistryCalls,
-  throwIfWrongNumberOfCallExpressionArgs,
-  throwIfUntypedModule,
-  throwIfIncorrectModuleRegistryCallTypeParameterParserError,
+  throwIfConfigNotfound,
   throwIfIncorrectModuleRegistryCallArgument,
-  throwIfModuleInterfaceNotFound,
-  throwIfMoreThanOneModuleInterfaceParserError,
+  throwIfIncorrectModuleRegistryCallTypeParameterParserError,
   throwIfModuleInterfaceIsMisnamed,
+  throwIfModuleInterfaceNotFound,
+  throwIfModuleTypeIsUnsupported,
   throwIfMoreThanOneCodegenNativecommands,
-  throwIfConfigNotfound,
   throwIfMoreThanOneConfig,
+  throwIfMoreThanOneModuleInterfaceParserError,
+  throwIfMoreThanOneModuleRegistryCalls,
+  throwIfPropertyValueTypeIsUnsupported,
   throwIfTypeAliasIsNotInterface,
+  throwIfUnsupportedFunctionParamTypeAnnotationParserError,
+  throwIfUnsupportedFunctionReturnTypeAnnotationParserError,
+  throwIfUntypedModule,
+  throwIfUnusedModuleInterfaceParserError,
+  throwIfWrongNumberOfCallExpressionArgs,
 } = require('./error-utils');
-
 const {
   MissingTypeParameterGenericParserError,
   MoreThanOneTypeParameterGenericParserError,
   UnnamedFunctionParamParserError,
+  UnsupportedObjectDirectRecursivePropertyParserError,
 } = require('./errors');
-
+const {
+  createParserErrorCapturer,
+  extractNativeModuleName,
+  getConfigType,
+  isModuleRegistryCall,
+  verifyPlatforms,
+  visit,
+} = require('./utils');
 const invariant = require('invariant');
 
 export type CommandOptions = $ReadOnly<{
@@ -175,6 +172,7 @@ function isObjectProperty(property: $FlowFixMe, language: ParserType): boolean {
 }
 
 function parseObjectProperty(
+  parentObject?: $FlowFixMe,
   property: $FlowFixMe,
   hasteModuleName: string,
   types: TypeDeclarationMap,
@@ -195,6 +193,41 @@ function parseObjectProperty(
       ? property.typeAnnotation.typeAnnotation
       : property.value;
 
+  // Handle recursive types
+  if (parentObject) {
+    const propertyType = parser.getResolveTypeAnnotationFN()(
+      languageTypeAnnotation,
+      types,
+      parser,
+    );
+    if (
+      propertyType.typeResolutionStatus.successful === true &&
+      propertyType.typeResolutionStatus.type === 'alias' &&
+      (language === 'TypeScript'
+        ? parentObject.typeName &&
+          parentObject.typeName.name === languageTypeAnnotation.typeName?.name
+        : parentObject.id &&
+          parentObject.id.name === languageTypeAnnotation.id?.name)
+    ) {
+      if (!optional) {
+        throw new UnsupportedObjectDirectRecursivePropertyParserError(
+          name,
+          languageTypeAnnotation,
+          hasteModuleName,
+        );
+      }
+      return {
+        name,
+        optional,
+        typeAnnotation: {
+          type: 'TypeAliasTypeAnnotation',
+          name: propertyType.typeResolutionStatus.name,
+        },
+      };
+    }
+  }
+
+  // Handle non-recursive types
   const [propertyTypeAnnotation, isPropertyNullable] =
     unwrapNullable<$FlowFixMe>(
       translateTypeAnnotation(
@@ -210,7 +243,7 @@ function parseObjectProperty(
     );
 
   if (
-    propertyTypeAnnotation.type === 'FunctionTypeAnnotation' ||
+    (propertyTypeAnnotation.type === 'FunctionTypeAnnotation' && !cxxOnly) ||
     propertyTypeAnnotation.type === 'PromiseTypeAnnotation' ||
     propertyTypeAnnotation.type === 'VoidTypeAnnotation'
   ) {
@@ -484,7 +517,7 @@ function buildSchema(
     return {modules: {}};
   }
 
-  const ast = parser.getAst(contents);
+  const ast = parser.getAst(contents, filename);
   const configType = getConfigType(ast, Visitor);
 
   return buildSchemaFromConfigType(
@@ -707,6 +740,7 @@ function findNativeComponentType(
   // expression so we need to go one level deeper
   if (
     declaration.type === 'TSAsExpression' ||
+    declaration.type === 'AsExpression' ||
     declaration.type === 'TypeCastExpression'
   ) {
     declaration = declaration.expression;

package/lib/parsers/parsers-primitives.js

@@ -78,26 +78,26 @@ function _iterableToArrayLimit(arr, i) {
 function _arrayWithHoles(arr) {
   if (Array.isArray(arr)) return arr;
 }
-const _require = require('./errors'),
-  UnsupportedUnionTypeAnnotationParserError =
-    _require.UnsupportedUnionTypeAnnotationParserError,
-  UnsupportedTypeAnnotationParserError =
-    _require.UnsupportedTypeAnnotationParserError,
-  ParserError = _require.ParserError;
-const _require2 = require('./error-utils'),
+const _require = require('./error-utils'),
   throwIfArrayElementTypeAnnotationIsUnsupported =
-    _require2.throwIfArrayElementTypeAnnotationIsUnsupported,
+    _require.throwIfArrayElementTypeAnnotationIsUnsupported,
   throwIfPartialNotAnnotatingTypeParameter =
-    _require2.throwIfPartialNotAnnotatingTypeParameter,
-  throwIfPartialWithMoreParameter = _require2.throwIfPartialWithMoreParameter;
-const _require3 = require('./parsers-utils'),
-  nullGuard = _require3.nullGuard;
-const _require4 = require('./parsers-commons'),
+    _require.throwIfPartialNotAnnotatingTypeParameter,
+  throwIfPartialWithMoreParameter = _require.throwIfPartialWithMoreParameter;
+const _require2 = require('./errors'),
+  ParserError = _require2.ParserError,
+  UnsupportedTypeAnnotationParserError =
+    _require2.UnsupportedTypeAnnotationParserError,
+  UnsupportedUnionTypeAnnotationParserError =
+    _require2.UnsupportedUnionTypeAnnotationParserError;
+const _require3 = require('./parsers-commons'),
   assertGenericTypeAnnotationHasExactlyOneTypeParameter =
-    _require4.assertGenericTypeAnnotationHasExactlyOneTypeParameter,
-  wrapNullable = _require4.wrapNullable,
-  unwrapNullable = _require4.unwrapNullable,
-  translateFunctionTypeAnnotation = _require4.translateFunctionTypeAnnotation;
+    _require3.assertGenericTypeAnnotationHasExactlyOneTypeParameter,
+  translateFunctionTypeAnnotation = _require3.translateFunctionTypeAnnotation,
+  unwrapNullable = _require3.unwrapNullable,
+  wrapNullable = _require3.wrapNullable;
+const _require4 = require('./parsers-utils'),
+  nullGuard = _require4.nullGuard;
 const _require5 = require('./utils'),
   isModuleRegistryCall = _require5.isModuleRegistryCall;
 function emitBoolean(nullable) {

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

@@ -11,57 +11,55 @@
 'use strict';
 
 import type {
-  Nullable,
   BooleanTypeAnnotation,
   DoubleTypeAnnotation,
   EventTypeAnnotation,
   Int32TypeAnnotation,
   NamedShape,
   NativeModuleAliasMap,
-  NativeModuleEnumMap,
   NativeModuleBaseTypeAnnotation,
-  NativeModuleTypeAnnotation,
+  NativeModuleEnumDeclaration,
+  NativeModuleEnumMap,
   NativeModuleFloatTypeAnnotation,
   NativeModuleFunctionTypeAnnotation,
   NativeModuleGenericObjectTypeAnnotation,
   NativeModuleMixedTypeAnnotation,
   NativeModuleNumberTypeAnnotation,
+  NativeModuleObjectTypeAnnotation,
   NativeModulePromiseTypeAnnotation,
   NativeModuleTypeAliasTypeAnnotation,
+  NativeModuleTypeAnnotation,
   NativeModuleUnionTypeAnnotation,
+  Nullable,
   ObjectTypeAnnotation,
   ReservedTypeAnnotation,
   StringTypeAnnotation,
   VoidTypeAnnotation,
-  NativeModuleObjectTypeAnnotation,
-  NativeModuleEnumDeclaration,
 } from '../CodegenSchema';
 import type {Parser} from './parser';
 import type {
   ParserErrorCapturer,
-  TypeResolutionStatus,
   TypeDeclarationMap,
+  TypeResolutionStatus,
 } from './utils';
 
-const {
-  UnsupportedUnionTypeAnnotationParserError,
-  UnsupportedTypeAnnotationParserError,
-  ParserError,
-} = require('./errors');
-
 const {
   throwIfArrayElementTypeAnnotationIsUnsupported,
   throwIfPartialNotAnnotatingTypeParameter,
   throwIfPartialWithMoreParameter,
 } = require('./error-utils');
-const {nullGuard} = require('./parsers-utils');
+const {
+  ParserError,
+  UnsupportedTypeAnnotationParserError,
+  UnsupportedUnionTypeAnnotationParserError,
+} = require('./errors');
 const {
   assertGenericTypeAnnotationHasExactlyOneTypeParameter,
-  wrapNullable,
-  unwrapNullable,
   translateFunctionTypeAnnotation,
+  unwrapNullable,
+  wrapNullable,
 } = require('./parsers-commons');
-
+const {nullGuard} = require('./parsers-utils');
 const {isModuleRegistryCall} = require('./utils');
 
 function emitBoolean(nullable: boolean): Nullable<BooleanTypeAnnotation> {

package/lib/parsers/schema.js.flow

@@ -11,13 +11,13 @@
 'use strict';
 
 import type {
+  CommandTypeAnnotation,
   EventTypeShape,
+  ExtendsPropsShape,
   NamedShape,
-  CommandTypeAnnotation,
+  OptionsShape,
   PropTypeAnnotation,
-  ExtendsPropsShape,
   SchemaType,
-  OptionsShape,
 } from '../CodegenSchema.js';
 
 export type ComponentSchemaBuilderConfig = $ReadOnly<{

package/lib/parsers/typescript/components/__test_fixtures__/fixtures.js

@@ -1094,13 +1094,20 @@ export type ScrollTo = (
   y: Int,
   animated: Boolean,
 ) => Void;
+export type AddOverlays = (
+  viewRef: React.ElementRef<NativeType>,
+  overlayColorsReadOnly: ReadOnlyArray<string>,
+  overlayColorsArray: Array<string>,
+  overlayColorsArrayAnnotation: string[],
+) => Void;
 
 interface NativeCommands {
   readonly scrollTo: ScrollTo;
+  readonly addOverlays: AddOverlays;
 }
 
 export const Commands = codegenNativeCommands<NativeCommands>({
-  supportedCommands: ['scrollTo'],
+  supportedCommands: ['scrollTo', 'addOverlays'],
 });
 
 export default codegenNativeComponent<ModuleProps>('Module') as NativeType;

package/lib/parsers/typescript/components/__test_fixtures__/fixtures.js.flow

@@ -1108,13 +1108,20 @@ export type ScrollTo = (
   y: Int,
   animated: Boolean,
 ) => Void;
+export type AddOverlays = (
+  viewRef: React.ElementRef<NativeType>,
+  overlayColorsReadOnly: ReadOnlyArray<string>,
+  overlayColorsArray: Array<string>,
+  overlayColorsArrayAnnotation: string[],
+) => Void;
 
 interface NativeCommands {
   readonly scrollTo: ScrollTo;
+  readonly addOverlays: AddOverlays;
 }
 
 export const Commands = codegenNativeCommands<NativeCommands>({
-  supportedCommands: ['scrollTo'],
+  supportedCommands: ['scrollTo', 'addOverlays'],
 });
 
 export default codegenNativeComponent<ModuleProps>('Module') as NativeType;

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

@@ -12,6 +12,8 @@
 
 const _require = require('../parseTopLevelType'),
   parseTopLevelType = _require.parseTopLevelType;
+const _require2 = require('./componentsUtils'),
+  getPrimitiveTypeAnnotation = _require2.getPrimitiveTypeAnnotation;
 
 // $FlowFixMe[unclear-type] there's no flowtype for ASTs
 
@@ -55,28 +57,34 @@ function buildCommandSchemaInternal(name, optional, parameters, types) {
         };
         break;
       case 'TSBooleanKeyword':
-        returnType = {
-          type: 'BooleanTypeAnnotation',
-        };
-        break;
       case 'Int32':
-        returnType = {
-          type: 'Int32TypeAnnotation',
-        };
-        break;
       case 'Double':
-        returnType = {
-          type: 'DoubleTypeAnnotation',
-        };
-        break;
       case 'Float':
+      case 'TSStringKeyword':
+        returnType = getPrimitiveTypeAnnotation(type);
+        break;
+      case 'Array':
+      case 'ReadOnlyArray':
+        if (!paramValue.type === 'TSTypeReference') {
+          throw new Error(
+            'Array and ReadOnlyArray are TSTypeReference for array',
+          );
+        }
         returnType = {
-          type: 'FloatTypeAnnotation',
+          type: 'ArrayTypeAnnotation',
+          elementType: getPrimitiveTypeAnnotation(
+            // TODO: T172453752 support complex type annotation for array element
+            paramValue.typeParameters.params[0].type,
+          ),
         };
         break;
-      case 'TSStringKeyword':
+      case 'TSArrayType':
         returnType = {
-          type: 'StringTypeAnnotation',
+          type: 'ArrayTypeAnnotation',
+          elementType: {
+            // TODO: T172453752 support complex type annotation for array element
+            type: getPrimitiveTypeAnnotation(paramValue.elementType.type).type,
+          },
         };
         break;
       default:

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

@@ -11,11 +11,13 @@
 'use strict';
 
 import type {
-  NamedShape,
   CommandTypeAnnotation,
+  NamedShape,
 } from '../../../CodegenSchema.js';
 import type {TypeDeclarationMap} from '../../utils';
+
 const {parseTopLevelType} = require('../parseTopLevelType');
+const {getPrimitiveTypeAnnotation} = require('./componentsUtils');
 
 // $FlowFixMe[unclear-type] there's no flowtype for ASTs
 type EventTypeAST = Object;
@@ -61,28 +63,34 @@ function buildCommandSchemaInternal(
         };
         break;
       case 'TSBooleanKeyword':
-        returnType = {
-          type: 'BooleanTypeAnnotation',
-        };
-        break;
       case 'Int32':
-        returnType = {
-          type: 'Int32TypeAnnotation',
-        };
-        break;
       case 'Double':
-        returnType = {
-          type: 'DoubleTypeAnnotation',
-        };
-        break;
       case 'Float':
+      case 'TSStringKeyword':
+        returnType = getPrimitiveTypeAnnotation(type);
+        break;
+      case 'Array':
+      case 'ReadOnlyArray':
+        if (!paramValue.type === 'TSTypeReference') {
+          throw new Error(
+            'Array and ReadOnlyArray are TSTypeReference for array',
+          );
+        }
         returnType = {
-          type: 'FloatTypeAnnotation',
+          type: 'ArrayTypeAnnotation',
+          elementType: getPrimitiveTypeAnnotation(
+            // TODO: T172453752 support complex type annotation for array element
+            paramValue.typeParameters.params[0].type,
+          ),
         };
         break;
-      case 'TSStringKeyword':
+      case 'TSArrayType':
         returnType = {
-          type: 'StringTypeAnnotation',
+          type: 'ArrayTypeAnnotation',
+          elementType: {
+            // TODO: T172453752 support complex type annotation for array element
+            type: getPrimitiveTypeAnnotation(paramValue.elementType.type).type,
+          },
         };
         break;
       default:

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

@@ -10,11 +10,11 @@
 
 'use strict';
 
-const _require = require('../parseTopLevelType'),
-  parseTopLevelType = _require.parseTopLevelType,
-  flattenIntersectionType = _require.flattenIntersectionType;
-const _require2 = require('../../parsers-commons'),
-  verifyPropNotAlreadyDefined = _require2.verifyPropNotAlreadyDefined;
+const _require = require('../../parsers-commons'),
+  verifyPropNotAlreadyDefined = _require.verifyPropNotAlreadyDefined;
+const _require2 = require('../parseTopLevelType'),
+  flattenIntersectionType = _require2.flattenIntersectionType,
+  parseTopLevelType = _require2.parseTopLevelType;
 function getUnionOfLiterals(name, forArray, elementTypes, defaultValue, types) {
   var _elementTypes$0$liter, _elementTypes$0$liter2;
   elementTypes.reduce((lastType, currType) => {
@@ -147,6 +147,33 @@ function buildObjectType(rawProperties, types, parser, buildSchema) {
     properties,
   };
 }
+function getPrimitiveTypeAnnotation(type) {
+  switch (type) {
+    case 'Int32':
+      return {
+        type: 'Int32TypeAnnotation',
+      };
+    case 'Double':
+      return {
+        type: 'DoubleTypeAnnotation',
+      };
+    case 'Float':
+      return {
+        type: 'FloatTypeAnnotation',
+      };
+    case 'TSBooleanKeyword':
+      return {
+        type: 'BooleanTypeAnnotation',
+      };
+    case 'Stringish':
+    case 'TSStringKeyword':
+      return {
+        type: 'StringTypeAnnotation',
+      };
+    default:
+      throw new Error(`Unknown primitive type "${type}"`);
+  }
+}
 function getCommonTypeAnnotation(
   name,
   forArray,
@@ -214,26 +241,12 @@ function getCommonTypeAnnotation(
         types,
       );
     case 'Int32':
-      return {
-        type: 'Int32TypeAnnotation',
-      };
     case 'Double':
-      return {
-        type: 'DoubleTypeAnnotation',
-      };
     case 'Float':
-      return {
-        type: 'FloatTypeAnnotation',
-      };
     case 'TSBooleanKeyword':
-      return {
-        type: 'BooleanTypeAnnotation',
-      };
     case 'Stringish':
     case 'TSStringKeyword':
-      return {
-        type: 'StringTypeAnnotation',
-      };
+      return getPrimitiveTypeAnnotation(type);
     case 'UnsafeMixed':
       return {
         type: 'MixedTypeAnnotation',
@@ -472,5 +485,6 @@ function flattenProperties(typeDefinition, types, parser) {
 module.exports = {
   getSchemaInfo,
   getTypeAnnotation,
+  getPrimitiveTypeAnnotation,
   flattenProperties,
 };

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

@@ -9,13 +9,15 @@
  */
 
 'use strict';
+
+import type {BuildSchemaFN, Parser} from '../../parser';
+import type {ASTNode, PropAST, TypeDeclarationMap} from '../../utils';
+
+const {verifyPropNotAlreadyDefined} = require('../../parsers-commons');
 const {
-  parseTopLevelType,
   flattenIntersectionType,
+  parseTopLevelType,
 } = require('../parseTopLevelType');
-const {verifyPropNotAlreadyDefined} = require('../../parsers-commons');
-import type {TypeDeclarationMap, PropAST, ASTNode} from '../../utils';
-import type {BuildSchemaFN, Parser} from '../../parser';
 
 function getUnionOfLiterals(
   name: string,
@@ -157,6 +159,34 @@ function buildObjectType<T>(
   };
 }
 
+function getPrimitiveTypeAnnotation(type: string): $FlowFixMe {
+  switch (type) {
+    case 'Int32':
+      return {
+        type: 'Int32TypeAnnotation',
+      };
+    case 'Double':
+      return {
+        type: 'DoubleTypeAnnotation',
+      };
+    case 'Float':
+      return {
+        type: 'FloatTypeAnnotation',
+      };
+    case 'TSBooleanKeyword':
+      return {
+        type: 'BooleanTypeAnnotation',
+      };
+    case 'Stringish':
+    case 'TSStringKeyword':
+      return {
+        type: 'StringTypeAnnotation',
+      };
+    default:
+      throw new Error(`Unknown primitive type "${type}"`);
+  }
+}
+
 function getCommonTypeAnnotation<T>(
   name: string,
   forArray: boolean,
@@ -224,26 +254,12 @@ function getCommonTypeAnnotation<T>(
         types,
       );
     case 'Int32':
-      return {
-        type: 'Int32TypeAnnotation',
-      };
     case 'Double':
-      return {
-        type: 'DoubleTypeAnnotation',
-      };
     case 'Float':
-      return {
-        type: 'FloatTypeAnnotation',
-      };
     case 'TSBooleanKeyword':
-      return {
-        type: 'BooleanTypeAnnotation',
-      };
     case 'Stringish':
     case 'TSStringKeyword':
-      return {
-        type: 'StringTypeAnnotation',
-      };
+      return getPrimitiveTypeAnnotation(type);
     case 'UnsafeMixed':
       return {
         type: 'MixedTypeAnnotation',
@@ -512,5 +528,6 @@ function flattenProperties(
 module.exports = {
   getSchemaInfo,
   getTypeAnnotation,
+  getPrimitiveTypeAnnotation,
   flattenProperties,
 };