@react-native/codegen 0.84.0-nightly-20251203-a5e6addc6 → 0.84.0-nightly-20251205-95cc1e767

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

@@ -23,6 +23,7 @@ import type {
 import type {AliasResolver} from './Utils';
 
 const {unwrapNullable} = require('../../parsers/parsers-commons');
+const {parseValidUnionType} = require('../Utils');
 const {createAliasResolver, getModules} = require('./Utils');
 
 type FilesOutput = Map<string, string>;
@@ -167,8 +168,6 @@ function translateReturnTypeToKind(
       return 'StringKind';
     case 'StringLiteralTypeAnnotation':
       return 'StringKind';
-    case 'StringLiteralUnionTypeAnnotation':
-      return 'StringKind';
     case 'BooleanTypeAnnotation':
       return 'BooleanKind';
     case 'BooleanLiteralTypeAnnotation':
@@ -185,17 +184,19 @@ function translateReturnTypeToKind(
           );
       }
     case 'UnionTypeAnnotation':
-      switch (typeAnnotation.memberType) {
-        case 'NumberTypeAnnotation':
+      const validUnionType = parseValidUnionType(realTypeAnnotation);
+      switch (validUnionType) {
+        case 'boolean':
+          return 'BooleanKind';
+        case 'number':
           return 'NumberKind';
-        case 'ObjectTypeAnnotation':
+        case 'object':
           return 'ObjectKind';
-        case 'StringTypeAnnotation':
+        case 'string':
           return 'StringKind';
         default:
-          throw new Error(
-            `Unsupported union member returning value, found: ${realTypeAnnotation.memberType}"`,
-          );
+          (validUnionType: empty);
+          throw new Error(`Unsupported union member type`);
       }
     case 'NumberTypeAnnotation':
       return 'NumberKind';
@@ -254,8 +255,6 @@ function translateParamTypeToJniType(
       return 'Ljava/lang/String;';
     case 'StringLiteralTypeAnnotation':
       return 'Ljava/lang/String;';
-    case 'StringLiteralUnionTypeAnnotation':
-      return 'Ljava/lang/String;';
     case 'BooleanTypeAnnotation':
       return !isRequired ? 'Ljava/lang/Boolean;' : 'Z';
     case 'BooleanLiteralTypeAnnotation':
@@ -272,17 +271,19 @@ function translateParamTypeToJniType(
           );
       }
     case 'UnionTypeAnnotation':
-      switch (typeAnnotation.memberType) {
-        case 'NumberTypeAnnotation':
+      const validUnionType = parseValidUnionType(realTypeAnnotation);
+      switch (validUnionType) {
+        case 'boolean':
+          return !isRequired ? 'Ljava/lang/Boolean;' : 'Z';
+        case 'number':
           return !isRequired ? 'Ljava/lang/Double;' : 'D';
-        case 'ObjectTypeAnnotation':
+        case 'object':
           return 'Lcom/facebook/react/bridge/ReadableMap;';
-        case 'StringTypeAnnotation':
+        case 'string':
           return 'Ljava/lang/String;';
         default:
-          throw new Error(
-            `Unsupported union prop value, found: ${realTypeAnnotation.memberType}"`,
-          );
+          (validUnionType: empty);
+          throw new Error(`Unsupported union member type`);
       }
     case 'NumberTypeAnnotation':
       return !isRequired ? 'Ljava/lang/Double;' : 'D';
@@ -338,8 +339,6 @@ function translateReturnTypeToJniType(
       return 'Ljava/lang/String;';
     case 'StringLiteralTypeAnnotation':
       return 'Ljava/lang/String;';
-    case 'StringLiteralUnionTypeAnnotation':
-      return 'Ljava/lang/String;';
     case 'BooleanTypeAnnotation':
       return nullable ? 'Ljava/lang/Boolean;' : 'Z';
     case 'BooleanLiteralTypeAnnotation':
@@ -356,17 +355,19 @@ function translateReturnTypeToJniType(
           );
       }
     case 'UnionTypeAnnotation':
-      switch (typeAnnotation.memberType) {
-        case 'NumberTypeAnnotation':
+      const validUnionType = parseValidUnionType(realTypeAnnotation);
+      switch (validUnionType) {
+        case 'boolean':
+          return nullable ? 'Ljava/lang/Boolean;' : 'Z';
+        case 'number':
           return nullable ? 'Ljava/lang/Double;' : 'D';
-        case 'ObjectTypeAnnotation':
-          return 'Lcom/facebook/react/bridge/WritableMap;';
-        case 'StringTypeAnnotation':
+        case 'object':
+          return 'Lcom/facebook/react/bridge/ReadableMap;';
+        case 'string':
           return 'Ljava/lang/String;';
         default:
-          throw new Error(
-            `Unsupported union member type, found: ${realTypeAnnotation.memberType}"`,
-          );
+          (validUnionType: empty);
+          throw new Error(`Unsupported union member type`);
       }
     case 'NumberTypeAnnotation':
       return nullable ? 'Ljava/lang/Double;' : 'D';

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

@@ -41,7 +41,11 @@ const {
   unwrapNullable,
   wrapNullable,
 } = require('../../../parsers/parsers-commons');
-const {capitalize} = require('../../Utils');
+const {
+  HeterogeneousUnionError,
+  capitalize,
+  parseValidUnionType,
+} = require('../../Utils');
 class StructCollector {
   constructor() {
     _defineProperty(this, '_structs', new Map());
@@ -89,27 +93,37 @@ class StructCollector {
       case 'MixedTypeAnnotation':
         throw new Error('Mixed types are unsupported in structs');
       case 'UnionTypeAnnotation':
-        switch (typeAnnotation.memberType) {
-          case 'StringTypeAnnotation':
-            return wrapNullable(nullable, {
-              type: 'StringTypeAnnotation',
-            });
-          case 'NumberTypeAnnotation':
-            return wrapNullable(nullable, {
-              type: 'NumberTypeAnnotation',
-            });
-          case 'ObjectTypeAnnotation':
-            // This isn't smart enough to actually know how to generate the
-            // options on the native side. So we just treat it as an unknown object type
-            return wrapNullable(nullable, {
-              type: 'GenericObjectTypeAnnotation',
-            });
-          default:
-            typeAnnotation.memberType;
-            throw new Error(
-              'Union types are unsupported in structs' +
-                JSON.stringify(typeAnnotation),
-            );
+        try {
+          const validUnionType = parseValidUnionType(typeAnnotation);
+          switch (validUnionType) {
+            case 'boolean':
+              return wrapNullable(nullable, {
+                type: 'BooleanTypeAnnotation',
+              });
+            case 'number':
+              return wrapNullable(nullable, {
+                type: 'NumberTypeAnnotation',
+              });
+            case 'object':
+              // This isn't smart enough to actually know how to generate the
+              // options on the native side. So we just treat it as an unknown object type
+              return wrapNullable(nullable, {
+                type: 'GenericObjectTypeAnnotation',
+              });
+            case 'string':
+              return wrapNullable(nullable, {
+                type: 'StringTypeAnnotation',
+              });
+            default:
+              validUnionType;
+              throw new Error(`Unsupported union member types`);
+          }
+        } catch (ex) {
+          // TODO(T247151345): Implement proper heterogeneous union support.
+          if (ex instanceof HeterogeneousUnionError) {
+            return wrapNullable(nullable, typeAnnotation);
+          }
+          throw ex;
         }
       default: {
         return wrapNullable(nullable, typeAnnotation);

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

@@ -23,11 +23,11 @@ import type {
   NativeModuleNumberTypeAnnotation,
   NativeModuleObjectTypeAnnotation,
   NativeModuleTypeAliasTypeAnnotation,
+  NativeModuleUnionTypeAnnotation,
   Nullable,
   NumberLiteralTypeAnnotation,
   ReservedTypeAnnotation,
   StringLiteralTypeAnnotation,
-  StringLiteralUnionTypeAnnotation,
   StringTypeAnnotation,
 } from '../../../CodegenSchema';
 import type {AliasResolver} from '../Utils';
@@ -36,7 +36,11 @@ const {
   unwrapNullable,
   wrapNullable,
 } = require('../../../parsers/parsers-commons');
-const {capitalize} = require('../../Utils');
+const {
+  HeterogeneousUnionError,
+  capitalize,
+  parseValidUnionType,
+} = require('../../Utils');
 
 type StructContext = 'CONSTANTS' | 'REGULAR';
 
@@ -63,7 +67,7 @@ export type StructProperty = $ReadOnly<{
 export type StructTypeAnnotation =
   | StringTypeAnnotation
   | StringLiteralTypeAnnotation
-  | StringLiteralUnionTypeAnnotation
+  | NativeModuleUnionTypeAnnotation
   | NativeModuleNumberTypeAnnotation
   | NumberLiteralTypeAnnotation
   | BooleanLiteralTypeAnnotation
@@ -129,27 +133,38 @@ class StructCollector {
       case 'MixedTypeAnnotation':
         throw new Error('Mixed types are unsupported in structs');
       case 'UnionTypeAnnotation':
-        switch (typeAnnotation.memberType) {
-          case 'StringTypeAnnotation':
-            return wrapNullable(nullable, {
-              type: 'StringTypeAnnotation',
-            });
-          case 'NumberTypeAnnotation':
-            return wrapNullable(nullable, {
-              type: 'NumberTypeAnnotation',
-            });
-          case 'ObjectTypeAnnotation':
-            // This isn't smart enough to actually know how to generate the
-            // options on the native side. So we just treat it as an unknown object type
-            return wrapNullable(nullable, {
-              type: 'GenericObjectTypeAnnotation',
-            });
-          default:
-            (typeAnnotation.memberType: empty);
-            throw new Error(
-              'Union types are unsupported in structs' +
-                JSON.stringify(typeAnnotation),
-            );
+        try {
+          const validUnionType = parseValidUnionType(typeAnnotation);
+          switch (validUnionType) {
+            case 'boolean':
+              return wrapNullable(nullable, {
+                type: 'BooleanTypeAnnotation',
+              });
+            case 'number':
+              return wrapNullable(nullable, {
+                type: 'NumberTypeAnnotation',
+              });
+            case 'object':
+              // This isn't smart enough to actually know how to generate the
+              // options on the native side. So we just treat it as an unknown object type
+              return wrapNullable(nullable, {
+                type: 'GenericObjectTypeAnnotation',
+              });
+            case 'string':
+              return wrapNullable(nullable, {
+                type: 'StringTypeAnnotation',
+              });
+            default:
+              (validUnionType: empty);
+              throw new Error(`Unsupported union member types`);
+          }
+        } catch (ex) {
+          // TODO(T247151345): Implement proper heterogeneous union support.
+          if (ex instanceof HeterogeneousUnionError) {
+            return wrapNullable(nullable, typeAnnotation);
+          }
+
+          throw ex;
         }
       default: {
         return wrapNullable(nullable, typeAnnotation);

package/lib/generators/modules/GenerateModuleObjCpp/header/serializeConstantsStruct.js

@@ -80,8 +80,9 @@ function toObjCType(
       return 'NSString *';
     case 'StringLiteralTypeAnnotation':
       return 'NSString *';
-    case 'StringLiteralUnionTypeAnnotation':
-      return 'NSString *';
+    case 'UnionTypeAnnotation':
+      // TODO(T247151345): Implement proper heterogeneous union support. This is unsafe.
+      return 'NSObject *';
     case 'NumberTypeAnnotation':
       return wrapCxxOptional('double', isRequired);
     case 'NumberLiteralTypeAnnotation':
@@ -160,7 +161,7 @@ function toObjCValue(
       return value;
     case 'StringLiteralTypeAnnotation':
       return value;
-    case 'StringLiteralUnionTypeAnnotation':
+    case 'UnionTypeAnnotation':
       return value;
     case 'NumberTypeAnnotation':
       return wrapPrimitive('double');

package/lib/generators/modules/GenerateModuleObjCpp/header/serializeConstantsStruct.js.flow

@@ -96,8 +96,9 @@ function toObjCType(
       return 'NSString *';
     case 'StringLiteralTypeAnnotation':
       return 'NSString *';
-    case 'StringLiteralUnionTypeAnnotation':
-      return 'NSString *';
+    case 'UnionTypeAnnotation':
+      // TODO(T247151345): Implement proper heterogeneous union support. This is unsafe.
+      return 'NSObject *';
     case 'NumberTypeAnnotation':
       return wrapCxxOptional('double', isRequired);
     case 'NumberLiteralTypeAnnotation':
@@ -183,7 +184,7 @@ function toObjCValue(
       return value;
     case 'StringLiteralTypeAnnotation':
       return value;
-    case 'StringLiteralUnionTypeAnnotation':
+    case 'UnionTypeAnnotation':
       return value;
     case 'NumberTypeAnnotation':
       return wrapPrimitive('double');

package/lib/generators/modules/GenerateModuleObjCpp/header/serializeRegularStruct.js

@@ -68,8 +68,9 @@ function toObjCType(
       return 'NSString *';
     case 'StringLiteralTypeAnnotation':
       return 'NSString *';
-    case 'StringLiteralUnionTypeAnnotation':
-      return 'NSString *';
+    case 'UnionTypeAnnotation':
+      // TODO(T247151345): Implement proper heterogeneous union support. This is unsafe.
+      return 'NSObject *';
     case 'NumberTypeAnnotation':
       return wrapCxxOptional('double', isRequired);
     case 'NumberLiteralTypeAnnotation':
@@ -149,8 +150,10 @@ function toObjCValue(
       return RCTBridgingTo('String');
     case 'StringLiteralTypeAnnotation':
       return RCTBridgingTo('String');
-    case 'StringLiteralUnionTypeAnnotation':
-      return RCTBridgingTo('String');
+    case 'UnionTypeAnnotation':
+      return !isRequired
+        ? `!RCTNilIfNull(${value}) ? std::optional<NSObject *>{} : std::optional<NSObject *>(${value})`
+        : value;
     case 'NumberTypeAnnotation':
       return RCTBridgingTo('Double');
     case 'NumberLiteralTypeAnnotation':

package/lib/generators/modules/GenerateModuleObjCpp/header/serializeRegularStruct.js.flow

@@ -87,8 +87,9 @@ function toObjCType(
       return 'NSString *';
     case 'StringLiteralTypeAnnotation':
       return 'NSString *';
-    case 'StringLiteralUnionTypeAnnotation':
-      return 'NSString *';
+    case 'UnionTypeAnnotation':
+      // TODO(T247151345): Implement proper heterogeneous union support. This is unsafe.
+      return 'NSObject *';
     case 'NumberTypeAnnotation':
       return wrapCxxOptional('double', isRequired);
     case 'NumberLiteralTypeAnnotation':
@@ -173,8 +174,10 @@ function toObjCValue(
       return RCTBridgingTo('String');
     case 'StringLiteralTypeAnnotation':
       return RCTBridgingTo('String');
-    case 'StringLiteralUnionTypeAnnotation':
-      return RCTBridgingTo('String');
+    case 'UnionTypeAnnotation':
+      return !isRequired
+        ? `!RCTNilIfNull(${value}) ? std::optional<NSObject *>{} : std::optional<NSObject *>(${value})`
+        : value;
     case 'NumberTypeAnnotation':
       return RCTBridgingTo('Double');
     case 'NumberLiteralTypeAnnotation':

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

@@ -8,16 +8,29 @@
  * @format
  */
 
-const {toPascalCase} = require('../../Utils');
+const {parseValidUnionType, toPascalCase} = require('../../Utils');
 function getEventEmitterTypeObjCType(eventEmitter) {
-  const type = eventEmitter.typeAnnotation.typeAnnotation.type;
-  switch (type) {
+  const typeAnnotation = eventEmitter.typeAnnotation.typeAnnotation;
+  switch (typeAnnotation.type) {
     case 'StringTypeAnnotation':
       return 'NSString *_Nonnull';
     case 'StringLiteralTypeAnnotation':
       return 'NSString *_Nonnull';
-    case 'StringLiteralUnionTypeAnnotation':
-      return 'NSString *_Nonnull';
+    case 'UnionTypeAnnotation':
+      const validUnionType = parseValidUnionType(typeAnnotation);
+      switch (validUnionType) {
+        case 'boolean':
+          return 'BOOL';
+        case 'number':
+          return 'NSNumber *_Nonnull';
+        case 'object':
+          return 'NSDictionary *';
+        case 'string':
+          return 'NSString *_Nonnull';
+        default:
+          validUnionType;
+          throw new Error(`Unsupported union member type`);
+      }
     case 'NumberTypeAnnotation':
     case 'NumberLiteralTypeAnnotation':
       return 'NSNumber *_Nonnull';
@@ -39,7 +52,7 @@ function getEventEmitterTypeObjCType(eventEmitter) {
         `Unsupported eventType for ${eventEmitter.name}. Found: ${eventEmitter.typeAnnotation.typeAnnotation.type}`,
       );
     default:
-      type;
+      typeAnnotation.type;
       throw new Error(
         `Unsupported eventType for ${eventEmitter.name}. Found: ${eventEmitter.typeAnnotation.typeAnnotation.type}`,
       );

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

@@ -10,20 +10,33 @@
 
 import type {NativeModuleEventEmitterShape} from '../../../CodegenSchema';
 
-const {toPascalCase} = require('../../Utils');
+const {parseValidUnionType, toPascalCase} = require('../../Utils');
 
 function getEventEmitterTypeObjCType(
   eventEmitter: NativeModuleEventEmitterShape,
 ): string {
-  const type = eventEmitter.typeAnnotation.typeAnnotation.type;
+  const typeAnnotation = eventEmitter.typeAnnotation.typeAnnotation;
 
-  switch (type) {
+  switch (typeAnnotation.type) {
     case 'StringTypeAnnotation':
       return 'NSString *_Nonnull';
     case 'StringLiteralTypeAnnotation':
       return 'NSString *_Nonnull';
-    case 'StringLiteralUnionTypeAnnotation':
-      return 'NSString *_Nonnull';
+    case 'UnionTypeAnnotation':
+      const validUnionType = parseValidUnionType(typeAnnotation);
+      switch (validUnionType) {
+        case 'boolean':
+          return 'BOOL';
+        case 'number':
+          return 'NSNumber *_Nonnull';
+        case 'object':
+          return 'NSDictionary *';
+        case 'string':
+          return 'NSString *_Nonnull';
+        default:
+          (validUnionType: empty);
+          throw new Error(`Unsupported union member type`);
+      }
     case 'NumberTypeAnnotation':
     case 'NumberLiteralTypeAnnotation':
       return 'NSNumber *_Nonnull';
@@ -45,7 +58,7 @@ function getEventEmitterTypeObjCType(
         `Unsupported eventType for ${eventEmitter.name}. Found: ${eventEmitter.typeAnnotation.typeAnnotation.type}`,
       );
     default:
-      (type: empty);
+      (typeAnnotation.type: empty);
       throw new Error(
         `Unsupported eventType for ${eventEmitter.name}. Found: ${eventEmitter.typeAnnotation.typeAnnotation.type}`,
       );

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

@@ -15,7 +15,7 @@ const {
   wrapNullable,
 } = require('../../../parsers/parsers-commons');
 const {wrapOptional} = require('../../TypeUtils/Objective-C');
-const {capitalize} = require('../../Utils');
+const {capitalize, parseValidUnionType} = require('../../Utils');
 const {getNamespacedStructName} = require('./Utils');
 const invariant = require('invariant');
 const ProtocolMethodTemplate = ({returnObjCType, methodName, params}) =>
@@ -210,8 +210,9 @@ function getParamObjCType(
       return notStruct(wrapOptional('NSString *', !nullable));
     case 'StringLiteralTypeAnnotation':
       return notStruct(wrapOptional('NSString *', !nullable));
-    case 'StringLiteralUnionTypeAnnotation':
-      return notStruct(wrapOptional('NSString *', !nullable));
+    case 'UnionTypeAnnotation':
+      // TODO(T247151345): Implement proper heterogeneous union support. This is unsafe.
+      return notStruct(wrapOptional('NSObject *', !nullable));
     case 'NumberTypeAnnotation':
       return notStruct(isRequired ? 'double' : 'NSNumber *');
     case 'NumberLiteralTypeAnnotation':
@@ -284,10 +285,6 @@ function getReturnObjCType(methodName, nullableTypeAnnotation) {
       // TODO: Can NSString * returns not be _Nullable?
       // In the legacy codegen, we don't surround NSSTring * with _Nullable
       return wrapOptional('NSString *', isRequired);
-    case 'StringLiteralUnionTypeAnnotation':
-      // TODO: Can NSString * returns not be _Nullable?
-      // In the legacy codegen, we don't surround NSSTring * with _Nullable
-      return wrapOptional('NSString *', isRequired);
     case 'NumberTypeAnnotation':
       return wrapOptional('NSNumber *', isRequired);
     case 'NumberLiteralTypeAnnotation':
@@ -314,19 +311,21 @@ function getReturnObjCType(methodName, nullableTypeAnnotation) {
           );
       }
     case 'UnionTypeAnnotation':
-      switch (typeAnnotation.memberType) {
-        case 'NumberTypeAnnotation':
+      const validUnionType = parseValidUnionType(typeAnnotation);
+      switch (validUnionType) {
+        case 'boolean':
           return wrapOptional('NSNumber *', isRequired);
-        case 'ObjectTypeAnnotation':
+        case 'number':
+          return wrapOptional('NSNumber *', isRequired);
+        case 'object':
           return wrapOptional('NSDictionary *', isRequired);
-        case 'StringTypeAnnotation':
+        case 'string':
           // TODO: Can NSString * returns not be _Nullable?
           // In the legacy codegen, we don't surround NSSTring * with _Nullable
           return wrapOptional('NSString *', isRequired);
         default:
-          throw new Error(
-            `Unsupported union return type for ${methodName}, found: ${typeAnnotation.memberType}"`,
-          );
+          validUnionType;
+          throw new Error(`Unsupported union member type`);
       }
     case 'GenericObjectTypeAnnotation':
       return wrapOptional('NSDictionary *', isRequired);
@@ -356,8 +355,6 @@ function getReturnJSType(methodName, nullableTypeAnnotation) {
       return 'StringKind';
     case 'StringLiteralTypeAnnotation':
       return 'StringKind';
-    case 'StringLiteralUnionTypeAnnotation':
-      return 'StringKind';
     case 'NumberTypeAnnotation':
       return 'NumberKind';
     case 'NumberLiteralTypeAnnotation':
@@ -386,17 +383,19 @@ function getReturnJSType(methodName, nullableTypeAnnotation) {
           );
       }
     case 'UnionTypeAnnotation':
-      switch (typeAnnotation.memberType) {
-        case 'NumberTypeAnnotation':
+      const validUnionType = parseValidUnionType(typeAnnotation);
+      switch (validUnionType) {
+        case 'boolean':
+          return 'BooleanKind';
+        case 'number':
           return 'NumberKind';
-        case 'ObjectTypeAnnotation':
+        case 'object':
           return 'ObjectKind';
-        case 'StringTypeAnnotation':
+        case 'string':
           return 'StringKind';
         default:
-          throw new Error(
-            `Unsupported return type for ${methodName}. Found: ${typeAnnotation.type}`,
-          );
+          validUnionType;
+          throw new Error(`Unsupported union member types`);
       }
     default:
       typeAnnotation.type;