@react-native/codegen 0.87.0-nightly-20260519-58cd1bf58 → 0.87.0-nightly-20260528-eaf770433

package/lib/CodegenSchema.d.ts

@@ -46,6 +46,10 @@ export interface VoidTypeAnnotation {
   readonly type: 'VoidTypeAnnotation';
 }
 
+export interface ArrayBufferTypeAnnotation {
+  readonly type: 'ArrayBufferTypeAnnotation';
+}
+
 export interface BooleanLiteralTypeAnnotation {
   readonly type: 'BooleanLiteralTypeAnnotation';
   readonly value: boolean;
@@ -417,7 +421,8 @@ export type NativeModuleEventEmitterTypeAnnotation =
   | ArrayTypeAnnotation<NativeModuleEventEmitterBaseTypeAnnotation>;
 
 export type NativeModuleBaseTypeAnnotation =
-  NativeModuleStringTypeAnnotation
+  ArrayBufferTypeAnnotation
+  | NativeModuleStringTypeAnnotation
   | StringLiteralTypeAnnotation
   | StringLiteralUnionTypeAnnotation
   | NativeModuleNumberTypeAnnotation

package/lib/CodegenSchema.js.flow

@@ -68,14 +68,18 @@ export type VoidTypeAnnotation = Readonly<{
   type: 'VoidTypeAnnotation',
 }>;
 
-export type ObjectTypeAnnotation<+T> = Readonly<{
+export type ArrayBufferTypeAnnotation = Readonly<{
+  type: 'ArrayBufferTypeAnnotation',
+}>;
+
+export type ObjectTypeAnnotation<out T> = Readonly<{
   type: 'ObjectTypeAnnotation',
   properties: ReadonlyArray<NamedShape<T>>,
   // metadata for objects that generated from interfaces
   baseTypes?: ReadonlyArray<string>,
 }>;
 
-export type UnionTypeAnnotation<+T> = Readonly<{
+export type UnionTypeAnnotation<out T> = Readonly<{
   type: 'UnionTypeAnnotation',
   types: ReadonlyArray<T>,
 }>;
@@ -89,13 +93,13 @@ export type EventEmitterTypeAnnotation = Readonly<{
   typeAnnotation: NativeModuleEventEmitterTypeAnnotation | $FlowFixMe,
 }>;
 
-type FunctionTypeAnnotation<+P, +R> = Readonly<{
+type FunctionTypeAnnotation<out P, out R> = Readonly<{
   type: 'FunctionTypeAnnotation',
   params: ReadonlyArray<NamedShape<P>>,
   returnTypeAnnotation: R,
 }>;
 
-export type NamedShape<+T> = Readonly<{
+export type NamedShape<out T> = Readonly<{
   name: string,
   optional: boolean,
   typeAnnotation: T,
@@ -191,7 +195,7 @@ export type ComponentCommandArrayTypeAnnotation = ArrayTypeAnnotation<
   | MixedTypeAnnotation,
 >;
 
-export type ArrayTypeAnnotation<+T> = Readonly<{
+export type ArrayTypeAnnotation<out T> = Readonly<{
   type: 'ArrayTypeAnnotation',
   elementType: T,
 }>;
@@ -265,11 +269,11 @@ export type ReservedTypeAnnotation = Readonly<{
 /**
  * NativeModule Types
  */
-export type Nullable<+T extends NativeModuleTypeAnnotation> =
+export type Nullable<out T extends NativeModuleTypeAnnotation> =
   | NullableTypeAnnotation<T>
   | T;
 
-export type NullableTypeAnnotation<+T extends NativeModuleTypeAnnotation> =
+export type NullableTypeAnnotation<out T extends NativeModuleTypeAnnotation> =
   Readonly<{
     type: 'NullableTypeAnnotation',
     typeAnnotation: T,
@@ -317,7 +321,7 @@ export type NativeModuleObjectTypeAnnotation = ObjectTypeAnnotation<
 >;
 
 export type NativeModuleArrayTypeAnnotation<
-  +T extends Nullable<NativeModuleBaseTypeAnnotation>,
+  out T extends Nullable<NativeModuleBaseTypeAnnotation>,
 > = ArrayTypeAnnotation<
   | T
   /**
@@ -411,6 +415,7 @@ export type NativeModuleEventEmitterTypeAnnotation =
   | ArrayTypeAnnotation<NativeModuleEventEmitterBaseTypeAnnotation>;
 
 export type NativeModuleBaseTypeAnnotation =
+  | ArrayBufferTypeAnnotation
   | StringTypeAnnotation
   | StringLiteralTypeAnnotation
   | StringLiteralUnionTypeAnnotation

package/lib/generators/ReservedPrimitiveTypes.js.flow

@@ -28,99 +28,104 @@ export type ReservedPrimitiveName =
   | 'DimensionPrimitive';
 
 type CppTypeInfo = {
-  +typeName: string,
-  +localIncludes: ReadonlyArray<string>,
-  +conversionIncludes: ReadonlyArray<string>,
+  readonly typeName: string,
+  readonly localIncludes: ReadonlyArray<string>,
+  readonly conversionIncludes: ReadonlyArray<string>,
 };
 
 type JavaImportInfo = {
-  +interfaceImports: ReadonlyArray<string>,
-  +delegateImports: ReadonlyArray<string>,
+  readonly interfaceImports: ReadonlyArray<string>,
+  readonly delegateImports: ReadonlyArray<string>,
 };
 
 type ReservedTypeMapping = {
-  +cpp: CppTypeInfo,
-  +java: JavaImportInfo,
+  readonly cpp: CppTypeInfo,
+  readonly java: JavaImportInfo,
 };
 
-const RESERVED_TYPES: {+[ReservedPrimitiveName]: ReservedTypeMapping} = {
-  ColorPrimitive: {
-    cpp: {
-      typeName: 'SharedColor',
-      localIncludes: ['#include <react/renderer/graphics/Color.h>'],
-      conversionIncludes: [],
+const RESERVED_TYPES: {readonly [ReservedPrimitiveName]: ReservedTypeMapping} =
+  {
+    ColorPrimitive: {
+      cpp: {
+        typeName: 'SharedColor',
+        localIncludes: ['#include <react/renderer/graphics/Color.h>'],
+        conversionIncludes: [],
+      },
+      java: {
+        interfaceImports: [],
+        delegateImports: [
+          'import com.facebook.react.bridge.ColorPropConverter;',
+        ],
+      },
     },
-    java: {
-      interfaceImports: [],
-      delegateImports: ['import com.facebook.react.bridge.ColorPropConverter;'],
+    ImageSourcePrimitive: {
+      cpp: {
+        typeName: 'ImageSource',
+        localIncludes: ['#include <react/renderer/imagemanager/primitives.h>'],
+        conversionIncludes: [
+          '#include <react/renderer/components/image/conversions.h>',
+        ],
+      },
+      java: {
+        interfaceImports: ['import com.facebook.react.bridge.ReadableMap;'],
+        delegateImports: ['import com.facebook.react.bridge.ReadableMap;'],
+      },
     },
-  },
-  ImageSourcePrimitive: {
-    cpp: {
-      typeName: 'ImageSource',
-      localIncludes: ['#include <react/renderer/imagemanager/primitives.h>'],
-      conversionIncludes: [
-        '#include <react/renderer/components/image/conversions.h>',
-      ],
+    ImageRequestPrimitive: {
+      cpp: {
+        typeName: 'ImageRequest',
+        localIncludes: [
+          '#include <react/renderer/imagemanager/ImageRequest.h>',
+        ],
+        conversionIncludes: [],
+      },
+      java: {
+        // ImageRequestPrimitive is not used in Java component props
+        interfaceImports: [],
+        delegateImports: [],
+      },
     },
-    java: {
-      interfaceImports: ['import com.facebook.react.bridge.ReadableMap;'],
-      delegateImports: ['import com.facebook.react.bridge.ReadableMap;'],
+    PointPrimitive: {
+      cpp: {
+        typeName: 'Point',
+        localIncludes: ['#include <react/renderer/graphics/Point.h>'],
+        conversionIncludes: [],
+      },
+      java: {
+        interfaceImports: ['import com.facebook.react.bridge.ReadableMap;'],
+        delegateImports: ['import com.facebook.react.bridge.ReadableMap;'],
+      },
     },
-  },
-  ImageRequestPrimitive: {
-    cpp: {
-      typeName: 'ImageRequest',
-      localIncludes: ['#include <react/renderer/imagemanager/ImageRequest.h>'],
-      conversionIncludes: [],
+    EdgeInsetsPrimitive: {
+      cpp: {
+        typeName: 'EdgeInsets',
+        localIncludes: ['#include <react/renderer/graphics/RectangleEdges.h>'],
+        conversionIncludes: [],
+      },
+      java: {
+        interfaceImports: ['import com.facebook.react.bridge.ReadableMap;'],
+        delegateImports: ['import com.facebook.react.bridge.ReadableMap;'],
+      },
     },
-    java: {
-      // ImageRequestPrimitive is not used in Java component props
-      interfaceImports: [],
-      delegateImports: [],
+    DimensionPrimitive: {
+      cpp: {
+        typeName: 'YGValue',
+        localIncludes: [
+          '#include <yoga/Yoga.h>',
+          '#include <react/renderer/core/graphicsConversions.h>',
+        ],
+        conversionIncludes: [
+          '#include <react/renderer/components/view/conversions.h>',
+        ],
+      },
+      java: {
+        interfaceImports: ['import com.facebook.yoga.YogaValue;'],
+        delegateImports: [
+          'import com.facebook.react.bridge.DimensionPropConverter;',
+        ],
+      },
     },
-  },
-  PointPrimitive: {
-    cpp: {
-      typeName: 'Point',
-      localIncludes: ['#include <react/renderer/graphics/Point.h>'],
-      conversionIncludes: [],
-    },
-    java: {
-      interfaceImports: ['import com.facebook.react.bridge.ReadableMap;'],
-      delegateImports: ['import com.facebook.react.bridge.ReadableMap;'],
-    },
-  },
-  EdgeInsetsPrimitive: {
-    cpp: {
-      typeName: 'EdgeInsets',
-      localIncludes: ['#include <react/renderer/graphics/RectangleEdges.h>'],
-      conversionIncludes: [],
-    },
-    java: {
-      interfaceImports: ['import com.facebook.react.bridge.ReadableMap;'],
-      delegateImports: ['import com.facebook.react.bridge.ReadableMap;'],
-    },
-  },
-  DimensionPrimitive: {
-    cpp: {
-      typeName: 'YGValue',
-      localIncludes: [
-        '#include <yoga/Yoga.h>',
-        '#include <react/renderer/core/graphicsConversions.h>',
-      ],
-      conversionIncludes: [
-        '#include <react/renderer/components/view/conversions.h>',
-      ],
-    },
-    java: {
-      interfaceImports: ['import com.facebook.yoga.YogaValue;'],
-      delegateImports: [
-        'import com.facebook.react.bridge.DimensionPropConverter;',
-      ],
-    },
-  },
-};
+  };
 
 function getCppTypeForReservedPrimitive(name: ReservedPrimitiveName): string {
   return RESERVED_TYPES[name].cpp.typeName;

package/lib/generators/components/ComponentsGeneratorUtils.js.flow

@@ -49,13 +49,13 @@ function getNativeTypeFromAnnotation(
           | ObjectTypeAnnotation<PropTypeAnnotation>
           | ReservedPropTypeAnnotation
           | {
-              +default: string,
-              +options: ReadonlyArray<string>,
-              +type: 'StringEnumTypeAnnotation',
+              readonly default: string,
+              readonly options: ReadonlyArray<string>,
+              readonly type: 'StringEnumTypeAnnotation',
             }
           | {
-              +elementType: ObjectTypeAnnotation<PropTypeAnnotation>,
-              +type: 'ArrayTypeAnnotation',
+              readonly elementType: ObjectTypeAnnotation<PropTypeAnnotation>,
+              readonly type: 'ArrayTypeAnnotation',
             },
       },
   nameParts: ReadonlyArray<string>,

package/lib/generators/modules/GenerateModuleH.js

@@ -100,6 +100,8 @@ function serializeArg(moduleName, arg, index, resolveAlias, enumMap) {
       return wrap(val => `${val}.asObject(rt)`);
     case 'MixedTypeAnnotation':
       return wrap(val => `jsi::Value(rt, ${val})`);
+    case 'ArrayBufferTypeAnnotation':
+      return wrap(val => `${val}.asObject(rt).getArrayBuffer(rt)`);
     default:
       realTypeAnnotation.type;
       throw new Error(`Unknown prop type for "${arg.name}, found: ${realTypeAnnotation.type}"`);
@@ -231,6 +233,8 @@ function translatePrimitiveJSTypeToCpp(moduleName, parentObjectAliasName, nullab
       return wrapOptional('jsi::Value', isRequired);
     case 'MixedTypeAnnotation':
       return wrapOptional('jsi::Value', isRequired);
+    case 'ArrayBufferTypeAnnotation':
+      return wrapOptional('jsi::ArrayBuffer', isRequired);
     default:
       realTypeAnnotation.type;
       throw new Error(createErrorMessage(realTypeAnnotation.type));

package/lib/generators/modules/GenerateModuleH.js.flow

@@ -146,6 +146,8 @@ function serializeArg(
       return wrap(val => `${val}.asObject(rt)`);
     case 'MixedTypeAnnotation':
       return wrap(val => `jsi::Value(rt, ${val})`);
+    case 'ArrayBufferTypeAnnotation':
+      return wrap(val => `${val}.asObject(rt).getArrayBuffer(rt)`);
     default:
       realTypeAnnotation.type as empty;
       throw new Error(
@@ -307,6 +309,8 @@ function translatePrimitiveJSTypeToCpp(
       return wrapOptional('jsi::Value', isRequired);
     case 'MixedTypeAnnotation':
       return wrapOptional('jsi::Value', isRequired);
+    case 'ArrayBufferTypeAnnotation':
+      return wrapOptional('jsi::ArrayBuffer', isRequired);
     default:
       realTypeAnnotation.type as empty;
       throw new Error(createErrorMessage(realTypeAnnotation.type));

package/lib/generators/modules/GenerateModuleJavaSpec.js

@@ -202,6 +202,8 @@ function translateFunctionParamToJavaType(param, createErrorMessage, resolveAlia
     case 'FunctionTypeAnnotation':
       imports.add('com.facebook.react.bridge.Callback');
       return wrapOptional('Callback', isRequired);
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error(`${createErrorMessage(realTypeAnnotation.type)} ArrayBuffer is only supported for C++ TurboModules.`);
     default:
       realTypeAnnotation.type;
       throw new Error(createErrorMessage(realTypeAnnotation.type));
@@ -282,6 +284,8 @@ function translateFunctionReturnTypeToJavaType(nullableReturnTypeAnnotation, cre
     case 'ArrayTypeAnnotation':
       imports.add('com.facebook.react.bridge.WritableArray');
       return wrapOptional('WritableArray', isRequired);
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error(`${createErrorMessage(realTypeAnnotation.type)} ArrayBuffer is only supported for C++ TurboModules.`);
     default:
       realTypeAnnotation.type;
       throw new Error(createErrorMessage(realTypeAnnotation.type));
@@ -354,6 +358,8 @@ function getFalsyReturnStatementFromReturnType(nullableReturnTypeAnnotation, cre
       return 'return null;';
     case 'ArrayTypeAnnotation':
       return 'return null;';
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error(`${createErrorMessage(realTypeAnnotation.type)} ArrayBuffer is only supported for C++ TurboModules.`);
     default:
       realTypeAnnotation.type;
       throw new Error(createErrorMessage(realTypeAnnotation.type));

package/lib/generators/modules/GenerateModuleJavaSpec.js.flow

@@ -267,6 +267,10 @@ function translateFunctionParamToJavaType(
     case 'FunctionTypeAnnotation':
       imports.add('com.facebook.react.bridge.Callback');
       return wrapOptional('Callback', isRequired);
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error(
+        `${createErrorMessage(realTypeAnnotation.type)} ArrayBuffer is only supported for C++ TurboModules.`,
+      );
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(createErrorMessage(realTypeAnnotation.type));
@@ -361,6 +365,10 @@ function translateFunctionReturnTypeToJavaType(
     case 'ArrayTypeAnnotation':
       imports.add('com.facebook.react.bridge.WritableArray');
       return wrapOptional('WritableArray', isRequired);
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error(
+        `${createErrorMessage(realTypeAnnotation.type)} ArrayBuffer is only supported for C++ TurboModules.`,
+      );
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(createErrorMessage(realTypeAnnotation.type));
@@ -443,6 +451,10 @@ function getFalsyReturnStatementFromReturnType(
       return 'return null;';
     case 'ArrayTypeAnnotation':
       return 'return null;';
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error(
+        `${createErrorMessage(realTypeAnnotation.type)} ArrayBuffer is only supported for C++ TurboModules.`,
+      );
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(createErrorMessage(realTypeAnnotation.type));

package/lib/generators/modules/GenerateModuleJniCpp.js

@@ -146,6 +146,8 @@ function translateReturnTypeToKind(nullableTypeAnnotation, resolveAlias) {
       return 'ObjectKind';
     case 'ArrayTypeAnnotation':
       return 'ArrayKind';
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error('ArrayBuffer is only supported for C++ TurboModules.');
     default:
       realTypeAnnotation.type;
       throw new Error(`Unknown prop type for returning value, found: ${realTypeAnnotation.type}"`);
@@ -221,6 +223,8 @@ function translateParamTypeToJniType(param, resolveAlias) {
       return 'Lcom/facebook/react/bridge/ReadableArray;';
     case 'FunctionTypeAnnotation':
       return 'Lcom/facebook/react/bridge/Callback;';
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error('ArrayBuffer is only supported for C++ TurboModules.');
     default:
       realTypeAnnotation.type;
       throw new Error(`Unknown prop type for method arg, found: ${realTypeAnnotation.type}"`);
@@ -293,6 +297,8 @@ function translateReturnTypeToJniType(nullableTypeAnnotation, resolveAlias) {
       return 'Lcom/facebook/react/bridge/WritableMap;';
     case 'ArrayTypeAnnotation':
       return 'Lcom/facebook/react/bridge/WritableArray;';
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error('ArrayBuffer is only supported for C++ TurboModules.');
     default:
       realTypeAnnotation.type;
       throw new Error(`Unknown prop type for method return type, found: ${realTypeAnnotation.type}"`);

package/lib/generators/modules/GenerateModuleJniCpp.js.flow

@@ -216,6 +216,8 @@ function translateReturnTypeToKind(
       return 'ObjectKind';
     case 'ArrayTypeAnnotation':
       return 'ArrayKind';
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error('ArrayBuffer is only supported for C++ TurboModules.');
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(
@@ -303,6 +305,8 @@ function translateParamTypeToJniType(
       return 'Lcom/facebook/react/bridge/ReadableArray;';
     case 'FunctionTypeAnnotation':
       return 'Lcom/facebook/react/bridge/Callback;';
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error('ArrayBuffer is only supported for C++ TurboModules.');
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(
@@ -387,6 +391,8 @@ function translateReturnTypeToJniType(
       return 'Lcom/facebook/react/bridge/WritableMap;';
     case 'ArrayTypeAnnotation':
       return 'Lcom/facebook/react/bridge/WritableArray;';
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error('ArrayBuffer is only supported for C++ TurboModules.');
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(

package/lib/generators/modules/GenerateModuleObjCpp/StructCollector.js

@@ -51,6 +51,8 @@ class StructCollector {
         return wrapNullable(nullable, typeAnnotation);
       case 'MixedTypeAnnotation':
         throw new Error('Mixed types are unsupported in structs');
+      case 'ArrayBufferTypeAnnotation':
+        throw new Error('ArrayBuffer is unsupported in TurboModule struct types.');
       case 'UnionTypeAnnotation':
         try {
           const validUnionType = parseValidUnionType(typeAnnotation);

package/lib/generators/modules/GenerateModuleObjCpp/StructCollector.js.flow

@@ -132,6 +132,10 @@ class StructCollector {
         return wrapNullable(nullable, typeAnnotation);
       case 'MixedTypeAnnotation':
         throw new Error('Mixed types are unsupported in structs');
+      case 'ArrayBufferTypeAnnotation':
+        throw new Error(
+          'ArrayBuffer is unsupported in TurboModule struct types.',
+        );
       case 'UnionTypeAnnotation':
         try {
           const validUnionType = parseValidUnionType(typeAnnotation);

package/lib/generators/modules/GenerateModuleObjCpp/serializeMethod.js

@@ -243,6 +243,8 @@ function getReturnObjCType(methodName, nullableTypeAnnotation) {
       }
     case 'GenericObjectTypeAnnotation':
       return wrapOptional('NSDictionary *', isRequired);
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error(`Unsupported return type for ${methodName}: ArrayBuffer is only supported for C++ TurboModules.`);
     default:
       typeAnnotation.type;
       throw new Error(`Unsupported return type for ${methodName}. Found: ${typeAnnotation.type}`);
@@ -307,6 +309,8 @@ function getReturnJSType(methodName, nullableTypeAnnotation) {
           validUnionType;
           throw new Error(`Unsupported union member types`);
       }
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error(`Unsupported return type for ${methodName}: ArrayBuffer is only supported for C++ TurboModules.`);
     default:
       typeAnnotation.type;
       throw new Error(`Unsupported return type for ${methodName}. Found: ${typeAnnotation.type}`);

package/lib/generators/modules/GenerateModuleObjCpp/serializeMethod.js.flow

@@ -387,6 +387,10 @@ function getReturnObjCType(
       }
     case 'GenericObjectTypeAnnotation':
       return wrapOptional('NSDictionary *', isRequired);
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error(
+        `Unsupported return type for ${methodName}: ArrayBuffer is only supported for C++ TurboModules.`,
+      );
     default:
       typeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(
@@ -459,6 +463,10 @@ function getReturnJSType(
           validUnionType as empty;
           throw new Error(`Unsupported union member types`);
       }
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error(
+        `Unsupported return type for ${methodName}: ArrayBuffer is only supported for C++ TurboModules.`,
+      );
     default:
       typeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(

package/lib/parsers/error-utils.js

@@ -80,7 +80,8 @@ function throwIfModuleTypeIsUnsupported(nativeModuleName, propertyValue, propert
 const UnsupportedObjectPropertyTypeToInvalidPropertyValueTypeMap = {
   FunctionTypeAnnotation: 'FunctionTypeAnnotation',
   VoidTypeAnnotation: 'void',
-  PromiseTypeAnnotation: 'Promise'
+  PromiseTypeAnnotation: 'Promise',
+  ArrayBufferTypeAnnotation: 'ArrayBuffer'
 };
 function throwIfPropertyValueTypeIsUnsupported(moduleName, propertyValue, propertyKey, type) {
   const invalidPropertyValueType = UnsupportedObjectPropertyTypeToInvalidPropertyValueTypeMap[type];
@@ -98,7 +99,8 @@ function throwIfArrayElementTypeAnnotationIsUnsupported(hasteModuleName, flowEle
   const TypeMap = {
     FunctionTypeAnnotation: 'FunctionTypeAnnotation',
     VoidTypeAnnotation: 'void',
-    PromiseTypeAnnotation: 'Promise'
+    PromiseTypeAnnotation: 'Promise',
+    ArrayBufferTypeAnnotation: 'ArrayBuffer'
   };
   if (type in TypeMap) {
     throw new UnsupportedArrayElementTypeAnnotationParserError(hasteModuleName, flowElementType, flowArrayType, TypeMap[type]);

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

@@ -218,6 +218,7 @@ const UnsupportedObjectPropertyTypeToInvalidPropertyValueTypeMap = {
   FunctionTypeAnnotation: 'FunctionTypeAnnotation',
   VoidTypeAnnotation: 'void',
   PromiseTypeAnnotation: 'Promise',
+  ArrayBufferTypeAnnotation: 'ArrayBuffer',
 };
 
 function throwIfPropertyValueTypeIsUnsupported(
@@ -277,6 +278,7 @@ function throwIfArrayElementTypeAnnotationIsUnsupported(
     FunctionTypeAnnotation: 'FunctionTypeAnnotation',
     VoidTypeAnnotation: 'void',
     PromiseTypeAnnotation: 'Promise',
+    ArrayBufferTypeAnnotation: 'ArrayBuffer',
     // TODO: Added as a work-around for now until TupleTypeAnnotation are fully supported in both flow and TS
     // Right now they are partially treated as UnionTypeAnnotation
     // UnionTypeAnnotation: 'UnionTypeAnnotation',

package/lib/parsers/errors.js.flow

@@ -128,7 +128,7 @@ class UnsupportedModulePropertyParserError extends ParserError {
 }
 
 class UnsupportedTypeAnnotationParserError extends ParserError {
-  +typeAnnotationType: string;
+  readonly typeAnnotationType: string;
   constructor(
     nativeModuleName: string,
     typeAnnotation: $FlowFixMe,

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

@@ -17,7 +17,7 @@ const {verifyPropNotAlreadyDefined} = require('../../parsers-commons');
 const {getValueFromTypes} = require('../utils.js');
 
 // $FlowFixMe[unsupported-variance-annotation]
-function getTypeAnnotationForArray<+T>(
+function getTypeAnnotationForArray<out T>(
   name: string,
   typeAnnotation: $FlowFixMe,
   defaultValue: $FlowFixMe | null,
@@ -219,7 +219,7 @@ function flattenProperties(
 }
 
 // $FlowFixMe[unsupported-variance-annotation]
-function getTypeAnnotation<+T>(
+function getTypeAnnotation<out T>(
   name: string,
   annotation: $FlowFixMe | ASTNode,
   defaultValue: $FlowFixMe | null,

package/lib/parsers/parsers-commons.js

@@ -129,7 +129,7 @@ function parseObjectProperty(parentObject, property, hasteModuleName, types, ali
     }
   }
   const [propertyTypeAnnotation, isPropertyNullable] = unwrapNullable(translateTypeAnnotation(hasteModuleName, languageTypeAnnotation, types, aliasMap, enumMap, tryParse, cxxOnly, parser));
-  if (propertyTypeAnnotation.type === 'FunctionTypeAnnotation' && !cxxOnly || propertyTypeAnnotation.type === 'PromiseTypeAnnotation' || propertyTypeAnnotation.type === 'VoidTypeAnnotation') {
+  if (propertyTypeAnnotation.type === 'FunctionTypeAnnotation' && !cxxOnly || propertyTypeAnnotation.type === 'PromiseTypeAnnotation' || propertyTypeAnnotation.type === 'VoidTypeAnnotation' || propertyTypeAnnotation.type === 'ArrayBufferTypeAnnotation') {
     throwIfPropertyValueTypeIsUnsupported(hasteModuleName, languageTypeAnnotation, property.key, propertyTypeAnnotation.type);
   }
   return {

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

@@ -107,7 +107,7 @@ function wrapModuleSchema(
 }
 
 // $FlowFixMe[unsupported-variance-annotation]
-function unwrapNullable<+T extends NativeModuleTypeAnnotation>(
+function unwrapNullable<out T extends NativeModuleTypeAnnotation>(
   x: Nullable<T>,
 ): [T, boolean] {
   if (x.type === 'NullableTypeAnnotation') {
@@ -118,7 +118,7 @@ function unwrapNullable<+T extends NativeModuleTypeAnnotation>(
 }
 
 // $FlowFixMe[unsupported-variance-annotation]
-function wrapNullable<+T extends NativeModuleTypeAnnotation>(
+function wrapNullable<out T extends NativeModuleTypeAnnotation>(
   nullable: boolean,
   typeAnnotation: T,
 ): Nullable<T> {
@@ -307,7 +307,8 @@ function parseObjectProperty(
   if (
     (propertyTypeAnnotation.type === 'FunctionTypeAnnotation' && !cxxOnly) ||
     propertyTypeAnnotation.type === 'PromiseTypeAnnotation' ||
-    propertyTypeAnnotation.type === 'VoidTypeAnnotation'
+    propertyTypeAnnotation.type === 'VoidTypeAnnotation' ||
+    propertyTypeAnnotation.type === 'ArrayBufferTypeAnnotation'
   ) {
     throwIfPropertyValueTypeIsUnsupported(
       hasteModuleName,

package/lib/parsers/parsers-primitives.js

@@ -70,6 +70,11 @@ function emitVoid(nullable) {
     type: 'VoidTypeAnnotation'
   });
 }
+function emitArrayBuffer(nullable) {
+  return wrapNullable(nullable, {
+    type: 'ArrayBufferTypeAnnotation'
+  });
+}
 function emitStringish(nullable) {
   return wrapNullable(nullable, {
     type: 'StringTypeAnnotation'
@@ -165,11 +170,9 @@ function emitPromise(hasteModuleName, typeAnnotation, parser, nullable, types, a
       }
     });
   } else {
+    let elementTypeResult;
     try {
-      return wrapNullable(nullable, {
-        type: 'PromiseTypeAnnotation',
-        elementType: translateTypeAnnotation(hasteModuleName, typeAnnotation.typeParameters.params[0], types, aliasMap, enumMap, tryParse, cxxOnly, parser)
-      });
+      elementTypeResult = translateTypeAnnotation(hasteModuleName, typeAnnotation.typeParameters.params[0], types, aliasMap, enumMap, tryParse, cxxOnly, parser);
     } catch {
       return wrapNullable(nullable, {
         type: 'PromiseTypeAnnotation',
@@ -178,6 +181,10 @@ function emitPromise(hasteModuleName, typeAnnotation, parser, nullable, types, a
         }
       });
     }
+    return wrapNullable(nullable, {
+      type: 'PromiseTypeAnnotation',
+      elementType: elementTypeResult
+    });
   }
 }
 function emitGenericObject(nullable) {
@@ -302,7 +309,8 @@ function emitCommonTypes(hasteModuleName, types, typeAnnotation, aliasMap, enumM
     MixedTypeAnnotation: cxxOnly ? emitMixed : emitGenericObject,
     UnsafeMixed: cxxOnly ? emitMixed : emitGenericObject,
     unknown: cxxOnly ? emitMixed : emitGenericObject,
-    UnknownTypeAnnotation: cxxOnly ? emitMixed : emitGenericObject
+    UnknownTypeAnnotation: cxxOnly ? emitMixed : emitGenericObject,
+    ArrayBuffer: emitArrayBuffer
   };
   const typeAnnotationName = parser.convertKeywordToTypeAnnotation(typeAnnotation.type);
   const simpleEmitter = typeMap[typeAnnotationName];
@@ -355,6 +363,7 @@ function emitUnionProp(name, optional, parser, typeAnnotation) {
   };
 }
 module.exports = {
+  emitArrayBuffer,
   emitArrayType,
   emitBoolean,
   emitBooleanLiteral,

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

@@ -11,6 +11,7 @@
 'use strict';
 
 import type {
+  ArrayBufferTypeAnnotation,
   BooleanLiteralTypeAnnotation,
   BooleanTypeAnnotation,
   DoubleTypeAnnotation,
@@ -127,6 +128,14 @@ function emitVoid(nullable: boolean): Nullable<VoidTypeAnnotation> {
   });
 }
 
+function emitArrayBuffer(
+  nullable: boolean,
+): Nullable<ArrayBufferTypeAnnotation> {
+  return wrapNullable(nullable, {
+    type: 'ArrayBufferTypeAnnotation',
+  });
+}
+
 function emitStringish(nullable: boolean): Nullable<StringTypeAnnotation> {
   return wrapNullable(nullable, {
     type: 'StringTypeAnnotation',
@@ -351,20 +360,18 @@ function emitPromise(
       },
     });
   } else {
+    let elementTypeResult;
     try {
-      return wrapNullable(nullable, {
-        type: 'PromiseTypeAnnotation',
-        elementType: translateTypeAnnotation(
-          hasteModuleName,
-          typeAnnotation.typeParameters.params[0],
-          types,
-          aliasMap,
-          enumMap,
-          tryParse,
-          cxxOnly,
-          parser,
-        ),
-      });
+      elementTypeResult = translateTypeAnnotation(
+        hasteModuleName,
+        typeAnnotation.typeParameters.params[0],
+        types,
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        parser,
+      );
     } catch {
       return wrapNullable(nullable, {
         type: 'PromiseTypeAnnotation',
@@ -373,6 +380,11 @@ function emitPromise(
         },
       });
     }
+
+    return wrapNullable(nullable, {
+      type: 'PromiseTypeAnnotation',
+      elementType: elementTypeResult,
+    });
   }
 }
 
@@ -666,6 +678,7 @@ function emitCommonTypes(
     UnsafeMixed: cxxOnly ? emitMixed : emitGenericObject,
     unknown: cxxOnly ? emitMixed : emitGenericObject,
     UnknownTypeAnnotation: cxxOnly ? emitMixed : emitGenericObject,
+    ArrayBuffer: emitArrayBuffer,
   };
 
   const typeAnnotationName = parser.convertKeywordToTypeAnnotation(
@@ -764,6 +777,7 @@ function emitUnionProp(
 }
 
 module.exports = {
+  emitArrayBuffer,
   emitArrayType,
   emitBoolean,
   emitBooleanLiteral,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native/codegen",
-  "version": "0.87.0-nightly-20260519-58cd1bf58",
+  "version": "0.87.0-nightly-20260528-eaf770433",
   "description": "Code generation tools for React Native",
   "license": "MIT",
   "repository": {
@@ -18,7 +18,7 @@
   ],
   "bugs": "https://github.com/facebook/react-native/issues",
   "engines": {
-    "node": "^20.19.4 || ^22.13.0 || ^24.3.0 || >= 25.0.0"
+    "node": "^22.13.0 || ^24.3.0 || >= 26.0.0"
   },
   "scripts": {
     "build": "yarn clean && node scripts/build.js --verbose",