@react-native/codegen 0.88.0-nightly-20260806-65008fcdd → 0.88.0-nightly-20260807-5fb3ebce1

package/lib/generators/modules/GenerateModuleJavaSpec.js

@@ -12,7 +12,8 @@ const {
 } = require('../Utils');
 const {
   createAliasResolver,
-  getModules
+  getModules,
+  throwIfUnsupportedPromiseArrayBuffer
 } = require('./Utils');
 function FileTemplate(config) {
   const {
@@ -118,6 +119,7 @@ function translateEventEmitterTypeToJavaType(eventEmitter, imports) {
     case 'FloatTypeAnnotation':
     case 'Int32TypeAnnotation':
     case 'VoidTypeAnnotation':
+    case 'ArrayBufferTypeAnnotation':
       throw new Error(`Unsupported eventType for ${eventEmitter.name}. Found: ${eventEmitter.typeAnnotation.typeAnnotation.type}`);
     default:
       typeAnnotation.type;
@@ -203,7 +205,8 @@ function translateFunctionParamToJavaType(param, createErrorMessage, resolveAlia
       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.`);
+      imports.add('java.nio.ByteBuffer');
+      return wrapOptional('ByteBuffer', isRequired);
     default:
       realTypeAnnotation.type;
       throw new Error(createErrorMessage(realTypeAnnotation.type));
@@ -285,7 +288,8 @@ function translateFunctionReturnTypeToJavaType(nullableReturnTypeAnnotation, cre
       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.`);
+      imports.add('java.nio.ByteBuffer');
+      return wrapOptional('ByteBuffer', isRequired);
     default:
       realTypeAnnotation.type;
       throw new Error(createErrorMessage(realTypeAnnotation.type));
@@ -359,7 +363,7 @@ function getFalsyReturnStatementFromReturnType(nullableReturnTypeAnnotation, cre
     case 'ArrayTypeAnnotation':
       return 'return null;';
     case 'ArrayBufferTypeAnnotation':
-      throw new Error(`${createErrorMessage(realTypeAnnotation.type)} ArrayBuffer is only supported for C++ TurboModules.`);
+      return 'return null;';
     default:
       realTypeAnnotation.type;
       throw new Error(createErrorMessage(realTypeAnnotation.type));
@@ -447,6 +451,7 @@ module.exports = {
           return buildGetConstantsMethod(method, imports, resolveAlias);
         }
         const [methodTypeAnnotation] = unwrapNullable(method.typeAnnotation);
+        throwIfUnsupportedPromiseArrayBuffer(method.name, methodTypeAnnotation.returnTypeAnnotation);
         const translatedReturnType = translateFunctionReturnTypeToJavaType(methodTypeAnnotation.returnTypeAnnotation, typeName => `Unsupported return type for method ${method.name}. Found: ${typeName}`, resolveAlias, imports);
         const returningPromise = methodTypeAnnotation.returnTypeAnnotation.type === 'PromiseTypeAnnotation';
         const isSyncMethod = methodTypeAnnotation.returnTypeAnnotation.type !== 'VoidTypeAnnotation' && !returningPromise;

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

@@ -25,7 +25,11 @@ import type {AliasResolver} from './Utils';
 const {unwrapNullable} = require('../../parsers/parsers-commons');
 const {wrapOptional} = require('../TypeUtils/Java');
 const {parseValidUnionType, toPascalCase} = require('../Utils');
-const {createAliasResolver, getModules} = require('./Utils');
+const {
+  createAliasResolver,
+  getModules,
+  throwIfUnsupportedPromiseArrayBuffer,
+} = require('./Utils');
 
 type FilesOutput = Map<string, string>;
 
@@ -170,6 +174,7 @@ function translateEventEmitterTypeToJavaType(
     case 'FloatTypeAnnotation':
     case 'Int32TypeAnnotation':
     case 'VoidTypeAnnotation':
+    case 'ArrayBufferTypeAnnotation':
       // TODO: Add support for these types
       throw new Error(
         `Unsupported eventType for ${eventEmitter.name}. Found: ${eventEmitter.typeAnnotation.typeAnnotation.type}`,
@@ -268,9 +273,8 @@ function translateFunctionParamToJavaType(
       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.`,
-      );
+      imports.add('java.nio.ByteBuffer');
+      return wrapOptional('ByteBuffer', isRequired);
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(createErrorMessage(realTypeAnnotation.type));
@@ -366,9 +370,8 @@ function translateFunctionReturnTypeToJavaType(
       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.`,
-      );
+      imports.add('java.nio.ByteBuffer');
+      return wrapOptional('ByteBuffer', isRequired);
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(createErrorMessage(realTypeAnnotation.type));
@@ -452,9 +455,7 @@ function getFalsyReturnStatementFromReturnType(
     case 'ArrayTypeAnnotation':
       return 'return null;';
     case 'ArrayBufferTypeAnnotation':
-      throw new Error(
-        `${createErrorMessage(realTypeAnnotation.type)} ArrayBuffer is only supported for C++ TurboModules.`,
-      );
+      return 'return null;';
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(createErrorMessage(realTypeAnnotation.type));
@@ -589,6 +590,11 @@ module.exports = {
             method.typeAnnotation,
           );
 
+        throwIfUnsupportedPromiseArrayBuffer(
+          method.name,
+          methodTypeAnnotation.returnTypeAnnotation,
+        );
+
         // Handle return type
         const translatedReturnType = translateFunctionReturnTypeToJavaType(
           methodTypeAnnotation.returnTypeAnnotation,

package/lib/generators/modules/GenerateModuleJniCpp.js

@@ -8,7 +8,8 @@ const {
 } = require('../Utils');
 const {
   createAliasResolver,
-  getModules
+  getModules,
+  throwIfUnsupportedPromiseArrayBuffer
 } = require('./Utils');
 const HostFunctionTemplate = ({
   hasteModuleName,
@@ -147,7 +148,7 @@ function translateReturnTypeToKind(nullableTypeAnnotation, resolveAlias) {
     case 'ArrayTypeAnnotation':
       return 'ArrayKind';
     case 'ArrayBufferTypeAnnotation':
-      throw new Error('ArrayBuffer is only supported for C++ TurboModules.');
+      return 'ArrayBufferKind';
     default:
       realTypeAnnotation.type;
       throw new Error(`Unknown prop type for returning value, found: ${realTypeAnnotation.type}"`);
@@ -224,7 +225,7 @@ function translateParamTypeToJniType(param, resolveAlias) {
     case 'FunctionTypeAnnotation':
       return 'Lcom/facebook/react/bridge/Callback;';
     case 'ArrayBufferTypeAnnotation':
-      throw new Error('ArrayBuffer is only supported for C++ TurboModules.');
+      return 'Ljava/nio/ByteBuffer;';
     default:
       realTypeAnnotation.type;
       throw new Error(`Unknown prop type for method arg, found: ${realTypeAnnotation.type}"`);
@@ -298,7 +299,7 @@ function translateReturnTypeToJniType(nullableTypeAnnotation, resolveAlias) {
     case 'ArrayTypeAnnotation':
       return 'Lcom/facebook/react/bridge/WritableArray;';
     case 'ArrayBufferTypeAnnotation':
-      throw new Error('ArrayBuffer is only supported for C++ TurboModules.');
+      return 'Ljava/nio/ByteBuffer;';
     default:
       realTypeAnnotation.type;
       throw new Error(`Unknown prop type for method return type, found: ${realTypeAnnotation.type}"`);
@@ -336,6 +337,7 @@ function translateMethodForImplementation(hasteModuleName, property, resolveAlia
   const {
     returnTypeAnnotation
   } = propertyTypeAnnotation;
+  throwIfUnsupportedPromiseArrayBuffer(property.name, returnTypeAnnotation);
   if (property.name === 'getConstants' && returnTypeAnnotation.type === 'ObjectTypeAnnotation' && returnTypeAnnotation.properties.length === 0) {
     return '';
   }

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

@@ -24,7 +24,11 @@ import type {AliasResolver} from './Utils';
 
 const {unwrapNullable} = require('../../parsers/parsers-commons');
 const {parseValidUnionType} = require('../Utils');
-const {createAliasResolver, getModules} = require('./Utils');
+const {
+  createAliasResolver,
+  getModules,
+  throwIfUnsupportedPromiseArrayBuffer,
+} = require('./Utils');
 
 type FilesOutput = Map<string, string>;
 
@@ -35,7 +39,8 @@ type JSReturnType =
   | 'NumberKind'
   | 'PromiseKind'
   | 'ObjectKind'
-  | 'ArrayKind';
+  | 'ArrayKind'
+  | 'ArrayBufferKind';
 
 const HostFunctionTemplate = ({
   hasteModuleName,
@@ -217,7 +222,7 @@ function translateReturnTypeToKind(
     case 'ArrayTypeAnnotation':
       return 'ArrayKind';
     case 'ArrayBufferTypeAnnotation':
-      throw new Error('ArrayBuffer is only supported for C++ TurboModules.');
+      return 'ArrayBufferKind';
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(
@@ -306,7 +311,7 @@ function translateParamTypeToJniType(
     case 'FunctionTypeAnnotation':
       return 'Lcom/facebook/react/bridge/Callback;';
     case 'ArrayBufferTypeAnnotation':
-      throw new Error('ArrayBuffer is only supported for C++ TurboModules.');
+      return 'Ljava/nio/ByteBuffer;';
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(
@@ -392,7 +397,7 @@ function translateReturnTypeToJniType(
     case 'ArrayTypeAnnotation':
       return 'Lcom/facebook/react/bridge/WritableArray;';
     case 'ArrayBufferTypeAnnotation':
-      throw new Error('ArrayBuffer is only supported for C++ TurboModules.');
+      return 'Ljava/nio/ByteBuffer;';
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(
@@ -448,6 +453,8 @@ function translateMethodForImplementation(
     unwrapNullable<NativeModuleFunctionTypeAnnotation>(property.typeAnnotation);
   const {returnTypeAnnotation} = propertyTypeAnnotation;
 
+  throwIfUnsupportedPromiseArrayBuffer(property.name, returnTypeAnnotation);
+
   if (
     property.name === 'getConstants' &&
     returnTypeAnnotation.type === 'ObjectTypeAnnotation' &&

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

@@ -11,6 +11,9 @@ const {
   capitalize,
   parseValidUnionType
 } = require('../../Utils');
+const {
+  throwIfUnsupportedPromiseArrayBuffer
+} = require('../Utils');
 const {
   getNamespacedStructName
 } = require('./Utils');
@@ -51,6 +54,7 @@ function serializeMethod(hasteModuleName, property, structCollector, resolveAlia
       });
     }
   });
+  throwIfUnsupportedPromiseArrayBuffer(methodName, propertyTypeAnnotation.returnTypeAnnotation);
   const [returnTypeAnnotation] = unwrapNullable(propertyTypeAnnotation.returnTypeAnnotation);
   if (returnTypeAnnotation.type === 'PromiseTypeAnnotation') {
     methodParams.push({

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

@@ -26,6 +26,7 @@ const {
 } = require('../../../parsers/parsers-commons');
 const {wrapOptional} = require('../../TypeUtils/Objective-C');
 const {capitalize, parseValidUnionType} = require('../../Utils');
+const {throwIfUnsupportedPromiseArrayBuffer} = require('../Utils');
 const {getNamespacedStructName} = require('./Utils');
 const invariant = require('invariant');
 
@@ -103,6 +104,11 @@ function serializeMethod(
     }
   });
 
+  throwIfUnsupportedPromiseArrayBuffer(
+    methodName,
+    propertyTypeAnnotation.returnTypeAnnotation,
+  );
+
   // Unwrap returnTypeAnnotation, so we check if the return type is Promise
   // TODO(T76719514): Disallow nullable PromiseTypeAnnotations
   const [returnTypeAnnotation] = unwrapNullable(

package/lib/generators/modules/Utils.js

@@ -30,9 +30,23 @@ function isArrayRecursiveMember(parentObjectAliasName, nullableTypeAnnotation) {
   const [typeAnnotation] = unwrapNullable(nullableTypeAnnotation);
   return parentObjectAliasName !== undefined && typeAnnotation.type === 'ArrayTypeAnnotation' && ((_typeAnnotation$eleme = typeAnnotation.elementType) === null || _typeAnnotation$eleme === void 0 ? void 0 : _typeAnnotation$eleme.name) === parentObjectAliasName;
 }
+function throwIfUnsupportedPromiseArrayBuffer(methodName, nullableReturnTypeAnnotation) {
+  const [returnTypeAnnotation] = unwrapNullable(nullableReturnTypeAnnotation);
+  if (returnTypeAnnotation.type !== 'PromiseTypeAnnotation') {
+    return;
+  }
+  let elementType = returnTypeAnnotation.elementType;
+  if (elementType.type === 'NullableTypeAnnotation') {
+    elementType = elementType.typeAnnotation;
+  }
+  if (elementType.type === 'ArrayBufferTypeAnnotation') {
+    throw new Error(`Unsupported return type for method "${methodName}": Promise<ArrayBuffer> is not ` + 'supported for Android (Java/Kotlin) or iOS (ObjC) TurboModules. Use a C++ ' + '(Cxx) TurboModule, return the ArrayBuffer from a synchronous method, or resolve ' + 'the Promise with a different type. ArrayBuffer is still supported as a method ' + 'argument and as a synchronous return value on all platforms.');
+  }
+}
 module.exports = {
   createAliasResolver,
   getModules,
   isDirectRecursiveMember,
-  isArrayRecursiveMember
+  isArrayRecursiveMember,
+  throwIfUnsupportedPromiseArrayBuffer
 };

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

@@ -13,6 +13,7 @@
 import type {
   NativeModuleAliasMap,
   NativeModuleObjectTypeAnnotation,
+  NativeModuleReturnTypeAnnotation,
   NativeModuleSchema,
   NativeModuleTypeAnnotation,
   Nullable,
@@ -77,9 +78,50 @@ function isArrayRecursiveMember(
   );
 }
 
+// Platform-native (Java/Kotlin and ObjC) TurboModules copy ArrayBuffer
+// arguments and return ArrayBuffers zero-copy from synchronous methods, but
+// `Promise<ArrayBuffer>` is not part of their contract.
+//
+// On Android it cannot work: the resolve path serializes through
+// folly::dynamic, which cannot carry raw bytes. On iOS the resolve path is a
+// direct ObjC->jsi conversion that would in fact produce an ArrayBuffer for an
+// NSMutableData, so the limitation there is not technical — the guard is
+// applied to ObjC as well to keep one cross-platform contract, so a spec that
+// compiles for iOS cannot fail to build for Android.
+//
+// Reject `Promise<ArrayBuffer>` at codegen time for both native platforms so
+// the unsupported case surfaces as a build error rather than a runtime failure
+// or a silent iOS/Android divergence.
+function throwIfUnsupportedPromiseArrayBuffer(
+  methodName: string,
+  nullableReturnTypeAnnotation: Nullable<NativeModuleReturnTypeAnnotation>,
+): void {
+  const [returnTypeAnnotation] =
+    unwrapNullable<NativeModuleReturnTypeAnnotation>(
+      nullableReturnTypeAnnotation,
+    );
+  if (returnTypeAnnotation.type !== 'PromiseTypeAnnotation') {
+    return;
+  }
+  let elementType = returnTypeAnnotation.elementType;
+  if (elementType.type === 'NullableTypeAnnotation') {
+    elementType = elementType.typeAnnotation;
+  }
+  if (elementType.type === 'ArrayBufferTypeAnnotation') {
+    throw new Error(
+      `Unsupported return type for method "${methodName}": Promise<ArrayBuffer> is not ` +
+        'supported for Android (Java/Kotlin) or iOS (ObjC) TurboModules. Use a C++ ' +
+        '(Cxx) TurboModule, return the ArrayBuffer from a synchronous method, or resolve ' +
+        'the Promise with a different type. ArrayBuffer is still supported as a method ' +
+        'argument and as a synchronous return value on all platforms.',
+    );
+  }
+}
+
 module.exports = {
   createAliasResolver,
   getModules,
   isDirectRecursiveMember,
   isArrayRecursiveMember,
+  throwIfUnsupportedPromiseArrayBuffer,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native/codegen",
-  "version": "0.88.0-nightly-20260806-65008fcdd",
+  "version": "0.88.0-nightly-20260807-5fb3ebce1",
   "description": "Code generation tools for React Native",
   "license": "MIT",
   "repository": {