@react-native/codegen 0.78.0-nightly-20250107-c8552519b → 0.78.0-nightly-20250109-cfec590f6

package/lib/CodegenSchema.d.ts

@@ -142,6 +142,19 @@ export type ComponentArrayTypeAnnotation = ArrayTypeAnnotation<
   | ArrayTypeAnnotation<ObjectTypeAnnotation<PropTypeAnnotation>>
 >;
 
+export type ComponentCommandArrayTypeAnnotation = ArrayTypeAnnotation<
+  | BooleanTypeAnnotation
+  | StringTypeAnnotation
+  | DoubleTypeAnnotation
+  | FloatTypeAnnotation
+  | Int32TypeAnnotation
+  // Mixed is not great. This generally means its a type alias to another type
+  // like an object or union. Ideally we'd encode that type in the schema so the compat-check can
+  // validate those deeper objects for breaking changes and the generators can do something smarter.
+  // As of now, the generators just create ReadableMap or (const NSArray *) which are untyped
+  | MixedTypeAnnotation
+>;
+
 export interface ArrayTypeAnnotation<T> {
   readonly type: 'ArrayTypeAnnotation';
   readonly elementType: T;
@@ -206,7 +219,7 @@ export type CommandParamTypeAnnotation =
   | DoubleTypeAnnotation
   | FloatTypeAnnotation
   | StringTypeAnnotation
-  | ComponentArrayTypeAnnotation;
+  | ComponentCommandArrayTypeAnnotation;
 
 export interface ReservedTypeAnnotation {
   readonly type: 'ReservedTypeAnnotation';

package/lib/CodegenSchema.js.flow

@@ -158,6 +158,19 @@ export type ComponentArrayTypeAnnotation = ArrayTypeAnnotation<
   | ArrayTypeAnnotation<ObjectTypeAnnotation<PropTypeAnnotation>>,
 >;
 
+export type ComponentCommandArrayTypeAnnotation = ArrayTypeAnnotation<
+  | BooleanTypeAnnotation
+  | StringTypeAnnotation
+  | DoubleTypeAnnotation
+  | FloatTypeAnnotation
+  | Int32TypeAnnotation
+  // Mixed is not great. This generally means its a type alias to another type
+  // like an object or union. Ideally we'd encode that type in the schema so the compat-check can
+  // validate those deeper objects for breaking changes and the generators can do something smarter.
+  // As of now, the generators just create ReadableMap or (const NSArray *) which are untyped
+  | MixedTypeAnnotation,
+>;
+
 export type ArrayTypeAnnotation<+T> = $ReadOnly<{
   type: 'ArrayTypeAnnotation',
   elementType: T,
@@ -222,7 +235,7 @@ export type CommandParamTypeAnnotation =
   | DoubleTypeAnnotation
   | FloatTypeAnnotation
   | StringTypeAnnotation
-  | ComponentArrayTypeAnnotation;
+  | ComponentCommandArrayTypeAnnotation;
 
 export type ReservedTypeAnnotation = $ReadOnly<{
   type: 'ReservedTypeAnnotation',
@@ -412,6 +425,14 @@ type NativeModuleReturnOnlyTypeAnnotation =
   | NativeModulePromiseTypeAnnotation
   | VoidTypeAnnotation;
 
+// Add the allowed component reserved types to the native module union
+export type CompleteReservedTypeAnnotation =
+  | ReservedTypeAnnotation
+  | {
+      type: 'ReservedTypeAnnotation',
+      name: ReservedPropTypeAnnotation['name'],
+    };
+
 // Used by compatibility check which needs to handle all possible types
 // This will eventually also include the union of all view manager types
 export type CompleteTypeAnnotation =
@@ -421,7 +442,8 @@ export type CompleteTypeAnnotation =
   | EventEmitterTypeAnnotation
   | NativeModuleEnumDeclarationWithMembers
   | UnsafeAnyTypeAnnotation
-  // Native Module event emitters and methods
-  | ObjectTypeAnnotation<
-      Nullable<NativeModuleFunctionTypeAnnotation> | EventEmitterTypeAnnotation,
-    >;
+  | ArrayTypeAnnotation<CompleteTypeAnnotation>
+  | ObjectTypeAnnotation<CompleteTypeAnnotation>
+  // Components
+  | CommandTypeAnnotation
+  | CompleteReservedTypeAnnotation;

package/lib/generators/components/__test_fixtures__/fixtures.js

@@ -1665,6 +1665,16 @@ const COMMANDS = {
                       type: 'BooleanTypeAnnotation',
                     },
                   },
+                  {
+                    name: 'locations',
+                    optional: false,
+                    typeAnnotation: {
+                      type: 'ArrayTypeAnnotation',
+                      elementType: {
+                        type: 'MixedTypeAnnotation',
+                      },
+                    },
+                  },
                 ],
                 returnTypeAnnotation: {
                   type: 'VoidTypeAnnotation',

package/lib/generators/components/__test_fixtures__/fixtures.js.flow

@@ -1693,6 +1693,16 @@ const COMMANDS: SchemaType = {
                       type: 'BooleanTypeAnnotation',
                     },
                   },
+                  {
+                    name: 'locations',
+                    optional: false,
+                    typeAnnotation: {
+                      type: 'ArrayTypeAnnotation',
+                      elementType: {
+                        type: 'MixedTypeAnnotation',
+                      },
+                    },
+                  },
                 ],
                 returnTypeAnnotation: {
                   type: 'VoidTypeAnnotation',

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

@@ -939,10 +939,18 @@ interface NativeCommands {
     z: Double,
     animated: boolean,
   ): void;
+  +arrayArgs: (
+    viewRef: React.ElementRef<NativeType>,
+    booleanArray: $ReadOnlyArray<boolean>,
+    stringArray: $ReadOnlyArray<string>,
+    floatArray: $ReadOnlyArray<Float>,
+    intArray: $ReadOnlyArray<Int32>,
+    doubleArray: $ReadOnlyArray<Double>,
+  ) => void;
 }
 
 export const Commands = codegenNativeCommands<NativeCommands>({
-  supportedCommands: ['handleRootTag', 'hotspotUpdate', 'scrollTo'],
+  supportedCommands: ['handleRootTag', 'hotspotUpdate', 'scrollTo', 'arrayArgs'],
 });
 
 export default (codegenNativeComponent<ModuleProps>(
@@ -972,6 +980,10 @@ import type {HostComponent} from 'react-native';
 export type Boolean = boolean;
 export type Int = Int32;
 export type Void = void;
+export type Locations = {
+  x: number,
+  y: number,
+}
 
 export type ModuleProps = $ReadOnly<{|
   ...ViewProps,
@@ -993,6 +1005,7 @@ interface NativeCommands {
     overlayColorsReadOnly: $ReadOnlyArray<string>,
     overlayColorsArray: Array<string>,
     overlayColorsArrayAnnotation: string[],
+    overlayLocations: $ReadOnlyArray<Locations>,
   ) => void;
 }
 

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

@@ -951,10 +951,18 @@ interface NativeCommands {
     z: Double,
     animated: boolean,
   ): void;
+  +arrayArgs: (
+    viewRef: React.ElementRef<NativeType>,
+    booleanArray: $ReadOnlyArray<boolean>,
+    stringArray: $ReadOnlyArray<string>,
+    floatArray: $ReadOnlyArray<Float>,
+    intArray: $ReadOnlyArray<Int32>,
+    doubleArray: $ReadOnlyArray<Double>,
+  ) => void;
 }
 
 export const Commands = codegenNativeCommands<NativeCommands>({
-  supportedCommands: ['handleRootTag', 'hotspotUpdate', 'scrollTo'],
+  supportedCommands: ['handleRootTag', 'hotspotUpdate', 'scrollTo', 'arrayArgs'],
 });
 
 export default (codegenNativeComponent<ModuleProps>(
@@ -985,6 +993,10 @@ import type {HostComponent} from 'react-native';
 export type Boolean = boolean;
 export type Int = Int32;
 export type Void = void;
+export type Locations = {
+  x: number,
+  y: number,
+}
 
 export type ModuleProps = $ReadOnly<{|
   ...ViewProps,
@@ -1006,6 +1018,7 @@ interface NativeCommands {
     overlayColorsReadOnly: $ReadOnlyArray<string>,
     overlayColorsArray: Array<string>,
     overlayColorsArrayAnnotation: string[],
+    overlayLocations: $ReadOnlyArray<Locations>,
   ) => void;
 }
 

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

@@ -81,19 +81,15 @@ function buildCommandSchema(property, types) {
         }
         returnType = {
           type: 'ArrayTypeAnnotation',
-          elementType: {
-            // TODO: T172453752 support complex type annotation for array element
-            type: paramValue.typeParameters.params[0].type,
-          },
+          elementType: getCommandArrayElementTypeType(
+            paramValue.typeParameters.params[0],
+          ),
         };
         break;
       case 'ArrayTypeAnnotation':
         returnType = {
           type: 'ArrayTypeAnnotation',
-          elementType: {
-            // TODO: T172453752 support complex type annotation for array element
-            type: paramValue.elementType.type,
-          },
+          elementType: getCommandArrayElementTypeType(paramValue.elementType),
         };
         break;
       default:
@@ -120,6 +116,64 @@ function buildCommandSchema(property, types) {
     },
   };
 }
+function getCommandArrayElementTypeType(inputType) {
+  var _inputType$id;
+  // TODO: T172453752 support more complex type annotation for array element
+  if (typeof inputType !== 'object') {
+    throw new Error('Expected an object');
+  }
+  const type =
+    inputType === null || inputType === void 0 ? void 0 : inputType.type;
+  if (inputType == null || typeof type !== 'string') {
+    throw new Error('Command array element type must be a string');
+  }
+  switch (type) {
+    case 'BooleanTypeAnnotation':
+      return {
+        type: 'BooleanTypeAnnotation',
+      };
+    case 'StringTypeAnnotation':
+      return {
+        type: 'StringTypeAnnotation',
+      };
+    case 'GenericTypeAnnotation':
+      const name =
+        typeof inputType.id === 'object'
+          ? (_inputType$id = inputType.id) === null || _inputType$id === void 0
+            ? void 0
+            : _inputType$id.name
+          : null;
+      if (typeof name !== 'string') {
+        throw new Error(
+          'Expected GenericTypeAnnotation AST name to be a string',
+        );
+      }
+      switch (name) {
+        case 'Int32':
+          return {
+            type: 'Int32TypeAnnotation',
+          };
+        case 'Float':
+          return {
+            type: 'FloatTypeAnnotation',
+          };
+        case 'Double':
+          return {
+            type: 'DoubleTypeAnnotation',
+          };
+        default:
+          // This is not a great solution. This generally means its a type alias to another type
+          // like an object or union. Ideally we'd encode that in the schema so the compat-check can
+          // validate those deeper objects for breaking changes and the generators can do something smarter.
+          // As of now, the generators just create ReadableMap or (const NSArray *) which are untyped
+          return {
+            type: 'MixedTypeAnnotation',
+          };
+      }
+    default:
+      throw new Error(`Unsupported array element type ${type}`);
+  }
+}
 function getCommands(commandTypeAST, types) {
   return commandTypeAST
     .filter(property => property.type === 'ObjectTypeProperty')

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

@@ -13,6 +13,7 @@
 import type {
   CommandParamTypeAnnotation,
   CommandTypeAnnotation,
+  ComponentCommandArrayTypeAnnotation,
   NamedShape,
 } from '../../../CodegenSchema.js';
 import type {TypeDeclarationMap} from '../../utils';
@@ -109,19 +110,15 @@ function buildCommandSchema(
         }
         returnType = {
           type: 'ArrayTypeAnnotation',
-          elementType: {
-            // TODO: T172453752 support complex type annotation for array element
-            type: paramValue.typeParameters.params[0].type,
-          },
+          elementType: getCommandArrayElementTypeType(
+            paramValue.typeParameters.params[0],
+          ),
         };
         break;
       case 'ArrayTypeAnnotation':
         returnType = {
           type: 'ArrayTypeAnnotation',
-          elementType: {
-            // TODO: T172453752 support complex type annotation for array element
-            type: paramValue.elementType.type,
-          },
+          elementType: getCommandArrayElementTypeType(paramValue.elementType),
         };
         break;
       default:
@@ -151,6 +148,66 @@ function buildCommandSchema(
   };
 }
 
+type Allowed = ComponentCommandArrayTypeAnnotation['elementType'];
+
+function getCommandArrayElementTypeType(inputType: mixed): Allowed {
+  // TODO: T172453752 support more complex type annotation for array element
+  if (typeof inputType !== 'object') {
+    throw new Error('Expected an object');
+  }
+
+  const type = inputType?.type;
+
+  if (inputType == null || typeof type !== 'string') {
+    throw new Error('Command array element type must be a string');
+  }
+
+  switch (type) {
+    case 'BooleanTypeAnnotation':
+      return {
+        type: 'BooleanTypeAnnotation',
+      };
+    case 'StringTypeAnnotation':
+      return {
+        type: 'StringTypeAnnotation',
+      };
+    case 'GenericTypeAnnotation':
+      const name = typeof inputType.id === 'object' ? inputType.id?.name : null;
+
+      if (typeof name !== 'string') {
+        throw new Error(
+          'Expected GenericTypeAnnotation AST name to be a string',
+        );
+      }
+
+      switch (name) {
+        case 'Int32':
+          return {
+            type: 'Int32TypeAnnotation',
+          };
+        case 'Float':
+          return {
+            type: 'FloatTypeAnnotation',
+          };
+        case 'Double':
+          return {
+            type: 'DoubleTypeAnnotation',
+          };
+        default:
+          // This is not a great solution. This generally means its a type alias to another type
+          // like an object or union. Ideally we'd encode that in the schema so the compat-check can
+          // validate those deeper objects for breaking changes and the generators can do something smarter.
+          // As of now, the generators just create ReadableMap or (const NSArray *) which are untyped
+          return {
+            type: 'MixedTypeAnnotation',
+          };
+      }
+
+    default:
+      throw new Error(`Unsupported array element type ${type}`);
+  }
+}
+
 function getCommands(
   commandTypeAST: $ReadOnlyArray<EventTypeAST>,
   types: TypeDeclarationMap,

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

@@ -1052,10 +1052,18 @@ type NativeType = HostComponent<ModuleProps>;
      z: Double,
      animated: boolean,
    ): void;
+   readonly arrayArgs: (
+    viewRef: React.ElementRef<NativeType>,
+    booleanArray: ReadOnlyArray<boolean>,
+    stringArray: ReadOnlyArray<string>,
+    floatArray: ReadOnlyArray<Float>,
+    intArray: ReadOnlyArray<Int32>,
+    doubleArray: ReadOnlyArray<Double>,
+  ) => void;
  }
 
  export const Commands = codegenNativeCommands<NativeCommands>({
-   supportedCommands: ['handleRootTag', 'hotspotUpdate', 'scrollTo'],
+   supportedCommands: ['handleRootTag', 'hotspotUpdate', 'scrollTo', 'arrayArgs'],
  });
 
 export default codegenNativeComponent<ModuleProps>(
@@ -1082,6 +1090,10 @@ import type {HostComponent} from 'react-native';
 export type Boolean = boolean;
 export type Int = Int32;
 export type Void = void;
+export type Locations = {
+  x: number,
+  y: number,
+}
 
 export interface ModuleProps extends ViewProps {
   // No props or events
@@ -1099,6 +1111,7 @@ export type AddOverlays = (
   overlayColorsReadOnly: ReadOnlyArray<string>,
   overlayColorsArray: Array<string>,
   overlayColorsArrayAnnotation: string[],
+  overlayLocations: ReadOnlyArray<Locations>,
 ) => Void;
 
 interface NativeCommands {

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

@@ -1065,10 +1065,18 @@ type NativeType = HostComponent<ModuleProps>;
      z: Double,
      animated: boolean,
    ): void;
+   readonly arrayArgs: (
+    viewRef: React.ElementRef<NativeType>,
+    booleanArray: ReadOnlyArray<boolean>,
+    stringArray: ReadOnlyArray<string>,
+    floatArray: ReadOnlyArray<Float>,
+    intArray: ReadOnlyArray<Int32>,
+    doubleArray: ReadOnlyArray<Double>,
+  ) => void;
  }
 
  export const Commands = codegenNativeCommands<NativeCommands>({
-   supportedCommands: ['handleRootTag', 'hotspotUpdate', 'scrollTo'],
+   supportedCommands: ['handleRootTag', 'hotspotUpdate', 'scrollTo', 'arrayArgs'],
  });
 
 export default codegenNativeComponent<ModuleProps>(
@@ -1096,6 +1104,10 @@ import type {HostComponent} from 'react-native';
 export type Boolean = boolean;
 export type Int = Int32;
 export type Void = void;
+export type Locations = {
+  x: number,
+  y: number,
+}
 
 export interface ModuleProps extends ViewProps {
   // No props or events
@@ -1113,6 +1125,7 @@ export type AddOverlays = (
   overlayColorsReadOnly: ReadOnlyArray<string>,
   overlayColorsArray: Array<string>,
   overlayColorsArrayAnnotation: string[],
+  overlayLocations: ReadOnlyArray<Locations>,
 ) => Void;
 
 interface NativeCommands {

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

@@ -72,19 +72,15 @@ function buildCommandSchemaInternal(name, optional, parameters, types) {
         }
         returnType = {
           type: 'ArrayTypeAnnotation',
-          elementType: getPrimitiveTypeAnnotation(
-            // TODO: T172453752 support complex type annotation for array element
-            paramValue.typeParameters.params[0].type,
+          elementType: getCommandArrayElementTypeType(
+            paramValue.typeParameters.params[0],
           ),
         };
         break;
       case 'TSArrayType':
         returnType = {
           type: 'ArrayTypeAnnotation',
-          elementType: {
-            // TODO: T172453752 support complex type annotation for array element
-            type: getPrimitiveTypeAnnotation(paramValue.elementType.type).type,
-          },
+          elementType: getCommandArrayElementTypeType(paramValue.elementType),
         };
         break;
       default:
@@ -111,6 +107,43 @@ function buildCommandSchemaInternal(name, optional, parameters, types) {
     },
   };
 }
+function getCommandArrayElementTypeType(inputType) {
+  // TODO: T172453752 support more complex type annotation for array element
+
+  if (inputType == null || typeof inputType !== 'object') {
+    throw new Error(`Expected an object, received ${typeof inputType}`);
+  }
+  const type = inputType.type;
+  if (typeof type !== 'string') {
+    throw new Error('Command array element type must be a string');
+  }
+
+  // This is not a great solution. This generally means its a type alias to another type
+  // like an object or union. Ideally we'd encode that in the schema so the compat-check can
+  // validate those deeper objects for breaking changes and the generators can do something smarter.
+  // As of now, the generators just create ReadableMap or (const NSArray *) which are untyped
+  if (type === 'TSTypeReference') {
+    var _inputType$typeName;
+    const name =
+      typeof inputType.typeName === 'object'
+        ? (_inputType$typeName = inputType.typeName) === null ||
+          _inputType$typeName === void 0
+          ? void 0
+          : _inputType$typeName.name
+        : null;
+    if (typeof name !== 'string') {
+      throw new Error('Expected TSTypeReference AST name to be a string');
+    }
+    try {
+      return getPrimitiveTypeAnnotation(name);
+    } catch (e) {
+      return {
+        type: 'MixedTypeAnnotation',
+      };
+    }
+  }
+  return getPrimitiveTypeAnnotation(type);
+}
 function buildCommandSchema(property, types) {
   if (property.type === 'TSPropertySignature') {
     const topLevelType = parseTopLevelType(

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

@@ -11,7 +11,9 @@
 'use strict';
 
 import type {
+  CommandParamTypeAnnotation,
   CommandTypeAnnotation,
+  ComponentCommandArrayTypeAnnotation,
   NamedShape,
 } from '../../../CodegenSchema.js';
 import type {TypeDeclarationMap} from '../../utils';
@@ -53,7 +55,7 @@ function buildCommandSchemaInternal(
       paramValue.type === 'TSTypeReference'
         ? paramValue.typeName.name
         : paramValue.type;
-    let returnType;
+    let returnType: CommandParamTypeAnnotation;
 
     switch (type) {
       case 'RootTag':
@@ -78,19 +80,15 @@ function buildCommandSchemaInternal(
         }
         returnType = {
           type: 'ArrayTypeAnnotation',
-          elementType: getPrimitiveTypeAnnotation(
-            // TODO: T172453752 support complex type annotation for array element
-            paramValue.typeParameters.params[0].type,
+          elementType: getCommandArrayElementTypeType(
+            paramValue.typeParameters.params[0],
           ),
         };
         break;
       case 'TSArrayType':
         returnType = {
           type: 'ArrayTypeAnnotation',
-          elementType: {
-            // TODO: T172453752 support complex type annotation for array element
-            type: getPrimitiveTypeAnnotation(paramValue.elementType.type).type,
-          },
+          elementType: getCommandArrayElementTypeType(paramValue.elementType),
         };
         break;
       default:
@@ -120,6 +118,44 @@ function buildCommandSchemaInternal(
   };
 }
 
+function getCommandArrayElementTypeType(
+  inputType: mixed,
+): ComponentCommandArrayTypeAnnotation['elementType'] {
+  // TODO: T172453752 support more complex type annotation for array element
+
+  if (inputType == null || typeof inputType !== 'object') {
+    throw new Error(`Expected an object, received ${typeof inputType}`);
+  }
+
+  const type = inputType.type;
+  if (typeof type !== 'string') {
+    throw new Error('Command array element type must be a string');
+  }
+
+  // This is not a great solution. This generally means its a type alias to another type
+  // like an object or union. Ideally we'd encode that in the schema so the compat-check can
+  // validate those deeper objects for breaking changes and the generators can do something smarter.
+  // As of now, the generators just create ReadableMap or (const NSArray *) which are untyped
+  if (type === 'TSTypeReference') {
+    const name =
+      typeof inputType.typeName === 'object' ? inputType.typeName?.name : null;
+
+    if (typeof name !== 'string') {
+      throw new Error('Expected TSTypeReference AST name to be a string');
+    }
+
+    try {
+      return getPrimitiveTypeAnnotation(name);
+    } catch (e) {
+      return {
+        type: 'MixedTypeAnnotation',
+      };
+    }
+  }
+
+  return getPrimitiveTypeAnnotation(type);
+}
+
 function buildCommandSchema(
   property: EventTypeAST,
   types: TypeDeclarationMap,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native/codegen",
-  "version": "0.78.0-nightly-20250107-c8552519b",
+  "version": "0.78.0-nightly-20250109-cfec590f6",
   "description": "Code generation tools for React Native",
   "license": "MIT",
   "repository": {