@react-native/compatibility-check 0.84.0-nightly-20251204-5bb3a6d68 → 0.84.0-nightly-20251205-95cc1e767

package/dist/ComparisonResult.d.ts

@@ -77,6 +77,11 @@ export type MembersComparisonResult = {
   missingMembers?: Array<NativeModuleEnumMember>;
   errorMembers?: Array<{ member: string; fault?: TypeComparisonError }>;
 };
+export type UnionMembersComparisonResult = {
+  addedMembers?: Array<CompleteTypeAnnotation>;
+  missingMembers?: Array<CompleteTypeAnnotation>;
+  errorMembers?: Array<{ member: string; fault?: TypeComparisonError }>;
+};
 export type NullableComparisonResult = {
   typeRefined: boolean;
   optionsReduced: boolean;
@@ -90,6 +95,7 @@ export type ComparisonResult =
   | { status: "nullableChange"; nullableLog: NullableComparisonResult }
   | { status: "properties"; propertyLog: PropertiesComparisonResult }
   | { status: "members"; memberLog: MembersComparisonResult }
+  | { status: "unionMembers"; memberLog: UnionMembersComparisonResult }
   | { status: "functionChange"; functionChangeLog: FunctionComparisonResult }
   | { status: "positionalTypeChange"; changeLog: PositionalComparisonResult }
   | { status: "error"; errorLog: TypeComparisonError };
@@ -99,6 +105,9 @@ export declare function isPropertyLogEmpty(
 export declare function isMemberLogEmpty(
   result: MembersComparisonResult,
 ): boolean;
+export declare function isUnionMemberLogEmpty(
+  result: UnionMembersComparisonResult,
+): boolean;
 export declare function isFunctionLogEmpty(
   result: FunctionComparisonResult,
 ): boolean;

package/dist/ComparisonResult.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.isFunctionLogEmpty = isFunctionLogEmpty;
 exports.isMemberLogEmpty = isMemberLogEmpty;
 exports.isPropertyLogEmpty = isPropertyLogEmpty;
+exports.isUnionMemberLogEmpty = isUnionMemberLogEmpty;
 exports.makeError = makeError;
 exports.memberComparisonError = memberComparisonError;
 exports.positionalComparisonError = positionalComparisonError;
@@ -25,6 +26,9 @@ function isPropertyLogEmpty(result) {
 function isMemberLogEmpty(result) {
   return !(result.addedMembers || result.missingMembers || result.errorMembers);
 }
+function isUnionMemberLogEmpty(result) {
+  return !(result.addedMembers || result.missingMembers || result.errorMembers);
+}
 function isFunctionLogEmpty(result) {
   return !(result.returnType || result.parameterTypes);
 }

package/dist/ComparisonResult.js.flow

@@ -109,6 +109,14 @@ export type MembersComparisonResult = {
     fault?: TypeComparisonError,
   }>,
 };
+export type UnionMembersComparisonResult = {
+  addedMembers?: Array<CompleteTypeAnnotation>,
+  missingMembers?: Array<CompleteTypeAnnotation>,
+  errorMembers?: Array<{
+    member: string,
+    fault?: TypeComparisonError,
+  }>,
+};
 export type NullableComparisonResult = {
   /* Four possible cases of change:
      void goes to T?   :: typeRefined !optionsReduced
@@ -130,6 +138,7 @@ export type ComparisonResult =
   | { status: "nullableChange", nullableLog: NullableComparisonResult }
   | { status: "properties", propertyLog: PropertiesComparisonResult }
   | { status: "members", memberLog: MembersComparisonResult }
+  | { status: "unionMembers", memberLog: UnionMembersComparisonResult }
   | { status: "functionChange", functionChangeLog: FunctionComparisonResult }
   | { status: "positionalTypeChange", changeLog: PositionalComparisonResult }
   | { status: "error", errorLog: TypeComparisonError };
@@ -142,6 +151,10 @@ declare export function isMemberLogEmpty(
   result: MembersComparisonResult,
 ): boolean;
 
+declare export function isUnionMemberLogEmpty(
+  result: UnionMembersComparisonResult,
+): boolean;
+
 declare export function isFunctionLogEmpty(
   result: FunctionComparisonResult,
 ): boolean;

package/dist/ErrorFormatting.js

@@ -7,6 +7,7 @@ exports.formatDiffSet = formatDiffSet;
 exports.formatErrorMessage = formatErrorMessage;
 exports.formatErrorStore = formatErrorStore;
 exports.formatNativeSpecErrorStore = formatNativeSpecErrorStore;
+var _Utils = require("@react-native/codegen/src/generators/Utils");
 function indentedLineStart(indent) {
   return "\n" + "  ".repeat(indent);
 }
@@ -172,25 +173,61 @@ function formatTypeAnnotation(annotation) {
         annotation.value.includes(" ")
         ? `'${annotation.value}'`
         : annotation.value;
-    case "StringLiteralUnionTypeAnnotation":
-      return (
-        "(" +
-        annotation.types
-          .map((stringLit) => formatTypeAnnotation(stringLit))
-          .join(" | ") +
-        ")"
-      );
+    case "UnionTypeAnnotation":
+      const validUnionType = (0, _Utils.parseValidUnionType)(annotation);
+      switch (validUnionType) {
+        case "boolean":
+          if (
+            annotation.types.every(
+              ({ type }) => type === "BooleanLiteralTypeAnnotation",
+            )
+          ) {
+            return (
+              "(" +
+              annotation.types
+                .map((boolLit) => formatTypeAnnotation(boolLit))
+                .join(" | ") +
+              ")"
+            );
+          }
+          return `Union<boolean>`;
+        case "number":
+          if (
+            annotation.types.every(
+              ({ type }) => type === "NumberLiteralTypeAnnotation",
+            )
+          ) {
+            return (
+              "(" +
+              annotation.types
+                .map((numLit) => formatTypeAnnotation(numLit))
+                .join(" | ") +
+              ")"
+            );
+          }
+          return `Union<number>`;
+        case "object":
+          return `Union<Object>`;
+        case "string":
+          if (
+            annotation.types.every(
+              ({ type }) => type === "StringLiteralTypeAnnotation",
+            )
+          ) {
+            return (
+              "(" +
+              annotation.types
+                .map((stringLit) => formatTypeAnnotation(stringLit))
+                .join(" | ") +
+              ")"
+            );
+          }
+          return `Union<string>`;
+        default:
+          throw new Error(`Unsupported union member type`);
+      }
     case "StringTypeAnnotation":
       return "string";
-    case "UnionTypeAnnotation": {
-      const shortHandType =
-        annotation.memberType === "StringTypeAnnotation"
-          ? "string"
-          : annotation.memberType === "ObjectTypeAnnotation"
-            ? "Object"
-            : "number";
-      return `Union<${shortHandType}>`;
-    }
     case "PromiseTypeAnnotation":
       return "Promise<" + formatTypeAnnotation(annotation.elementType) + ">";
     case "EventEmitterTypeAnnotation":

package/dist/SortTypeAnnotations.js

@@ -156,21 +156,15 @@ function compareTypeAnnotationForSorting(
         EQUALITY_MSG,
       );
       return typeA.value.localeCompare(typeB.value);
-    case "StringLiteralUnionTypeAnnotation":
+    case "UnionTypeAnnotation":
       (0, _invariant.default)(
-        typeB.type === "StringLiteralUnionTypeAnnotation",
+        typeB.type === "UnionTypeAnnotation",
         EQUALITY_MSG,
       );
       return compareAnnotationArraysForSorting(
         [originalPositionA, typeA.types],
         [originalPositionB, typeB.types],
       );
-    case "UnionTypeAnnotation":
-      (0, _invariant.default)(
-        typeB.type === "UnionTypeAnnotation",
-        EQUALITY_MSG,
-      );
-      return 0;
     case "VoidTypeAnnotation":
       return 0;
     case "ReservedTypeAnnotation":
@@ -279,8 +273,6 @@ function typeAnnotationArbitraryOrder(annotation) {
       return 15;
     case "BooleanLiteralTypeAnnotation":
       return 16;
-    case "StringLiteralUnionTypeAnnotation":
-      return 17;
     case "StringTypeAnnotation":
       return 18;
     case "StringLiteralTypeAnnotation":

package/dist/TypeDiffing.d.ts

@@ -11,6 +11,7 @@
 import type {
   ComparisonResult,
   MembersComparisonResult,
+  UnionMembersComparisonResult,
 } from "./ComparisonResult";
 import type {
   BooleanLiteralTypeAnnotation,
@@ -53,6 +54,10 @@ export declare function compareEnumDeclarationMemberArrays(
   newer: Array<NativeModuleEnumMember>,
   older: Array<NativeModuleEnumMember>,
 ): MembersComparisonResult;
+export declare function compareUnionMemberArrays(
+  newer: Array<CompleteTypeAnnotation>,
+  older: Array<CompleteTypeAnnotation>,
+): UnionMembersComparisonResult;
 export declare function compareEnumDeclarationWithMembers(
   newerDeclaration: NativeModuleEnumDeclarationWithMembers,
   olderDeclaration: NativeModuleEnumDeclarationWithMembers,

package/dist/TypeDiffing.js

@@ -16,6 +16,7 @@ exports.compareStringLiteralTypes = compareStringLiteralTypes;
 exports.compareStringLiteralUnionTypes = compareStringLiteralUnionTypes;
 exports.compareTypeAnnotation = compareTypeAnnotation;
 exports.compareTypes = compareTypes;
+exports.compareUnionMemberArrays = compareUnionMemberArrays;
 exports.compareUnionTypes = compareUnionTypes;
 var _ComparisonResult = require("./ComparisonResult");
 var _SortTypeAnnotations = require("./SortTypeAnnotations.js");
@@ -190,12 +191,6 @@ function compareTypeAnnotation(
         EQUALITY_MSG,
       );
       return compareBooleanLiteralTypes(newerAnnotation, olderAnnotation);
-    case "StringLiteralUnionTypeAnnotation":
-      (0, _invariant.default)(
-        olderAnnotation.type === "StringLiteralUnionTypeAnnotation",
-        EQUALITY_MSG,
-      );
-      return compareStringLiteralUnionTypes(newerAnnotation, olderAnnotation);
     case "StringLiteralTypeAnnotation":
       (0, _invariant.default)(
         olderAnnotation.type === "StringLiteralTypeAnnotation",
@@ -260,6 +255,27 @@ function updatePropertyError(name, newType, oldType, result) {
     }
   };
 }
+function updateUnionMemberError(name, newType, oldType, result) {
+  return (oldError) => {
+    const comparisonError = (0,
+    _ComparisonResult.typeAnnotationComparisonError)(
+      "has conflicting changes",
+      newType,
+      oldType,
+      oldError,
+    );
+    const memberLabel = getTypeAnnotationLabel(name);
+    const newFault = {
+      member: memberLabel,
+      fault: comparisonError,
+    };
+    if (result.errorMembers) {
+      result.errorMembers.push(newFault);
+    } else {
+      result.errorMembers = [newFault];
+    }
+  };
+}
 function updateEnumMemberError(name, newType, oldType, result) {
   return (oldError) => {
     const comparisonError = (0,
@@ -280,6 +296,20 @@ function updateEnumMemberError(name, newType, oldType, result) {
     }
   };
 }
+function getTypeAnnotationLabel(type) {
+  switch (type.type) {
+    case "StringLiteralTypeAnnotation":
+      return `"${type.value}"`;
+    case "NumberLiteralTypeAnnotation":
+      return String(type.value);
+    case "BooleanLiteralTypeAnnotation":
+      return String(type.value);
+    case "NullableTypeAnnotation":
+      return `?${getTypeAnnotationLabel(type.typeAnnotation)}`;
+    default:
+      return type.type;
+  }
+}
 function updateNestedProperties(name, propertyChange, result) {
   if (result.nestedPropertyChanges) {
     result.nestedPropertyChanges.push([name, propertyChange]);
@@ -387,6 +417,7 @@ function comparePropertyArrays(newerOriginal, olderOriginal) {
           result,
         );
       case "members":
+      case "unionMembers":
       case "properties":
       case "functionChange":
       case "positionalTypeChange":
@@ -536,11 +567,11 @@ function compareEnumDeclarationMemberArrays(newer, older) {
     return {};
   } else if (newer.length === 0) {
     return {
-      missingMembers: older,
+      missingMembers: [...older],
     };
   } else if (older.length === 0) {
     return {
-      addedMembers: newer,
+      addedMembers: [...newer],
     };
   }
   const newerHead = newer.pop();
@@ -577,6 +608,7 @@ function compareEnumDeclarationMemberArrays(newer, older) {
       case "functionChange":
       case "positionalTypeChange":
       case "members":
+      case "unionMembers":
         break;
       default:
         throw new Error("Unsupported status " + comparedTypes.status);
@@ -602,6 +634,77 @@ function compareEnumDeclarationMemberArrays(newer, older) {
   }
   throw new Error("Internal error: should not reach here");
 }
+function compareUnionMemberArrays(newer, older) {
+  if (newer.length === 0 && older.length === 0) {
+    return {};
+  } else if (newer.length === 0) {
+    return {
+      missingMembers: [...older],
+    };
+  } else if (older.length === 0) {
+    return {
+      addedMembers: [...newer],
+    };
+  }
+  const newerHead = newer.pop();
+  const olderHead = older.pop();
+  (0, _invariant.default)(
+    newerHead != null && olderHead != null,
+    "Array is empty",
+  );
+  const sortComparison = (0,
+  _SortTypeAnnotations.compareTypeAnnotationForSorting)(
+    [0, newerHead],
+    [0, olderHead],
+  );
+  if (sortComparison === 0) {
+    const headComparison = compareTypeAnnotation(newerHead, olderHead);
+    const restComparison = compareUnionMemberArrays(newer, older);
+    switch (headComparison.status) {
+      case "matching":
+        return restComparison;
+      case "error":
+        updateUnionMemberError(
+          newerHead,
+          newerHead,
+          olderHead,
+          restComparison,
+        )(headComparison.errorLog);
+        return restComparison;
+      case "skipped":
+        throw new Error(
+          "Internal error: returned 'skipped' for non-optional older type",
+        );
+      case "properties":
+        restComparison.missingMembers = restComparison.missingMembers || [];
+        restComparison.missingMembers.push(olderHead);
+        restComparison.addedMembers = restComparison.addedMembers || [];
+        restComparison.addedMembers.push(newerHead);
+        return restComparison;
+      case "nullableChange":
+      case "functionChange":
+      case "positionalTypeChange":
+      case "members":
+      case "unionMembers":
+        break;
+      default:
+        throw new Error("Unsupported status " + headComparison.status);
+    }
+  } else if (sortComparison > 0) {
+    older.push(olderHead);
+    const restComparison = compareUnionMemberArrays(newer, older);
+    restComparison.addedMembers = restComparison.addedMembers || [];
+    restComparison.addedMembers.push(newerHead);
+    return restComparison;
+  } else if (sortComparison < 0) {
+    newer.push(newerHead);
+    const restComparison = compareUnionMemberArrays(newer, older);
+    restComparison.missingMembers = restComparison.missingMembers || [];
+    restComparison.missingMembers.push(olderHead);
+    return restComparison;
+  }
+  throw new Error("Internal error: should not reach here");
+}
 function compareEnumDeclarationWithMembers(newerDeclaration, olderDeclaration) {
   const sortedNewerTypes = Array.from(newerDeclaration.members).sort(
     compareEnumMember,
@@ -718,17 +821,53 @@ function compareNullableChange(newerAnnotation, olderAnnotation) {
   }
 }
 function compareUnionTypes(newerType, olderType) {
-  if (newerType.memberType !== olderType.memberType) {
+  const sortedNewerTypes = (0, _SortTypeAnnotations.sortTypeAnnotations)(
+    newerType.types,
+  );
+  const sortedOlderTypes = (0, _SortTypeAnnotations.sortTypeAnnotations)(
+    olderType.types,
+  );
+  const result = compareUnionMemberArrays(
+    sortedNewerTypes.map(([_, type]) => type),
+    sortedOlderTypes.map(([_, type]) => type),
+  );
+  if ((0, _ComparisonResult.isUnionMemberLogEmpty)(result)) {
+    return {
+      status: "matching",
+    };
+  } else if (result.errorMembers) {
+    return (0, _ComparisonResult.makeError)(
+      (0, _ComparisonResult.typeAnnotationComparisonError)(
+        "Union types do not match",
+        newerType,
+        olderType,
+        (0, _ComparisonResult.memberComparisonError)(
+          result.errorMembers.length > 1
+            ? "Union contained members with type mismatches"
+            : "Union contained a member with a type mismatch",
+          result.errorMembers,
+        ),
+      ),
+    );
+  } else if (
+    (result.addedMembers &&
+      result.addedMembers.length > 0 &&
+      result.addedMembers.length === newerType.types.length) ||
+    (result.missingMembers &&
+      result.missingMembers.length > 0 &&
+      result.missingMembers.length === olderType.types.length)
+  ) {
     return (0, _ComparisonResult.makeError)(
       (0, _ComparisonResult.typeAnnotationComparisonError)(
-        "Union member type does not match",
+        "Union types do not match.",
         newerType,
         olderType,
       ),
     );
   }
   return {
-    status: "matching",
+    status: "unionMembers",
+    memberLog: result,
   };
 }
 function comparePromiseTypes(newerType, olderType) {
@@ -884,6 +1023,7 @@ function compareFunctionTypes(newerType, olderType) {
   if (
     returnTypeResult.status === "properties" ||
     returnTypeResult.status === "members" ||
+    returnTypeResult.status === "unionMembers" ||
     returnTypeResult.status === "functionChange" ||
     returnTypeResult.status === "positionalTypeChange" ||
     returnTypeResult.status === "nullableChange"
@@ -957,6 +1097,7 @@ function compareArrayOfTypes(fixedOrder, fixedLength, newerTypes, olderTypes) {
       if (
         result.status === "properties" ||
         result.status === "members" ||
+        result.status === "unionMembers" ||
         result.status === "functionChange" ||
         result.status === "positionalTypeChange" ||
         result.status === "nullableChange"

package/dist/TypeDiffing.js.flow

@@ -11,6 +11,7 @@
 import type {
   ComparisonResult,
   MembersComparisonResult,
+  UnionMembersComparisonResult,
 } from "./ComparisonResult";
 import type {
   BooleanLiteralTypeAnnotation,
@@ -59,6 +60,11 @@ declare export function compareEnumDeclarationMemberArrays(
   older: Array<NativeModuleEnumMember>,
 ): MembersComparisonResult;
 
+declare export function compareUnionMemberArrays(
+  newer: Array<CompleteTypeAnnotation>,
+  older: Array<CompleteTypeAnnotation>,
+): UnionMembersComparisonResult;
+
 declare export function compareEnumDeclarationWithMembers(
   newerDeclaration: NativeModuleEnumDeclarationWithMembers,
   olderDeclaration: NativeModuleEnumDeclarationWithMembers,

package/dist/VersionDiffing.d.ts

@@ -31,14 +31,15 @@ export declare type stricterPropertiesMessage =
 export declare const tooOptionalPropertiesMessage: "Property made optional, but native requires it";
 export declare type tooOptionalPropertiesMessage =
   typeof tooOptionalPropertiesMessage;
-export declare const removedUnionMessage: "Union removed items, but native may still provide them";
-export declare type removedUnionMessage = typeof removedUnionMessage;
-export declare const addedUnionMessage: "Union added items, but native will not expect/support them";
-export declare type addedUnionMessage = typeof addedUnionMessage;
 export declare const removedEnumMessage: "Enum removed items, but native may still provide them";
 export declare type removedEnumMessage = typeof removedEnumMessage;
 export declare const addedEnumMessage: "Enum added items, but native will not expect/support them";
 export declare type addedEnumMessage = typeof addedEnumMessage;
+export declare const removedUnionMemberMessage: "Union removed items, but native may still provide them";
+export declare type removedUnionMemberMessage =
+  typeof removedUnionMemberMessage;
+export declare const addedUnionMemberMessage: "Union added items, but native will not expect/support them";
+export declare type addedUnionMemberMessage = typeof addedUnionMemberMessage;
 export declare const removedIntersectionMessage: "Intersection removed items, but native may still require properties contained in them";
 export declare type removedIntersectionMessage =
   typeof removedIntersectionMessage;

package/dist/VersionDiffing.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true,
 });
-exports.addedUnionMessage =
+exports.addedUnionMemberMessage =
   exports.addedPropertiesMessage =
   exports.addedIntersectionMessage =
   exports.addedEnumMessage =
@@ -14,7 +14,7 @@ exports.fromNativeVoidChangeMessage = void 0;
 exports.hasCodegenUpdatesTypes = hasCodegenUpdatesTypes;
 exports.hasUpdatesTypes = hasUpdatesTypes;
 exports.stricterPropertiesMessage =
-  exports.removedUnionMessage =
+  exports.removedUnionMemberMessage =
   exports.removedPropertiesMessage =
   exports.removedIntersectionMessage =
   exports.removedEnumMessage =
@@ -78,7 +78,14 @@ function nestedPropertiesCheck(typeName, result, check, inverseCheck) {
         "Internal error: nested property change " + result.status,
       );
     case "properties":
-      let finalResult = check(result.propertyLog, null, null, null, typeName);
+      let finalResult = check(
+        result.propertyLog,
+        null,
+        null,
+        null,
+        null,
+        typeName,
+      );
       if (result.propertyLog.nestedPropertyChanges) {
         finalResult = combine(
           finalResult,
@@ -105,7 +112,9 @@ function nestedPropertiesCheck(typeName, result, check, inverseCheck) {
       }
       return finalResult;
     case "members":
-      return check(null, null, null, result.memberLog, typeName);
+      return check(null, null, null, result.memberLog, null, typeName);
+    case "unionMembers":
+      return check(null, null, null, null, result.memberLog, typeName);
     case "functionChange":
       let returnTypeResult = [];
       if (result.functionChangeLog.returnType) {
@@ -138,6 +147,7 @@ function nestedPropertiesCheck(typeName, result, check, inverseCheck) {
         changeLog,
         null,
         null,
+        null,
         typeName,
       );
       return combine(
@@ -155,6 +165,7 @@ function nestedPropertiesCheck(typeName, result, check, inverseCheck) {
         null,
         result.nullableLog,
         null,
+        null,
         typeName,
       );
       if (result.nullableLog.interiorLog) {
@@ -208,6 +219,7 @@ function checkForUnsafeRemovedProperties(
   _postionalChange,
   _nullableChange,
   _memberChange,
+  _unionMemberChange,
   typeName,
 ) {
   if (propertyChange && propertyChange.missingProperties) {
@@ -227,6 +239,7 @@ function checkForUnsafeAddedProperties(
   _positionalChange,
   _nullableChange,
   _memberChange,
+  _unionMemberChange,
   typeName,
 ) {
   if (propertyChange && propertyChange.addedProperties) {
@@ -246,6 +259,7 @@ function checkForUnSafeMadeStrictProperties(
   _positionalChange,
   _nullableChange,
   _memberChange,
+  _unionMemberChange,
   typeName,
 ) {
   if (
@@ -276,6 +290,7 @@ function checkForUnSafeMadeOptionalProperties(
   _positionalChange,
   _nullableChange,
   _memberChange,
+  _unionMemberChange,
   typeName,
 ) {
   if (
@@ -299,82 +314,105 @@ function checkForUnSafeMadeOptionalProperties(
   }
   return [];
 }
-const removedUnionMessage = (exports.removedUnionMessage =
-  "Union removed items, but native may still provide them");
-function checkForUnsafeRemovedUnionItems(
+const removedEnumMessage = (exports.removedEnumMessage =
+  "Enum removed items, but native may still provide them");
+function checkForUnsafeRemovedEnumItems(
   _propertyChange,
-  positionalChange,
+  _positionalChange,
   _nullableChange,
-  _memberChange,
+  memberChange,
+  _unionMemberChange,
   typeName,
 ) {
-  if (
-    positionalChange &&
-    (positionalChange.typeKind === "union" ||
-      positionalChange.typeKind === "stringUnion") &&
-    positionalChange.removedElements &&
-    positionalChange.removedElements.length > 0
-  ) {
+  if (memberChange?.missingMembers && memberChange?.missingMembers.length > 0) {
     return [
       {
         typeName,
-        errorCode: "removedUnionCases",
-        errorInformation: (0, _ComparisonResult.positionalComparisonError)(
-          removedUnionMessage,
-          positionalChange.removedElements,
+        errorCode: "removedEnumCases",
+        errorInformation: (0, _ComparisonResult.memberComparisonError)(
+          removedEnumMessage,
+          memberChange.missingMembers.map((member) => ({
+            member: member.name,
+          })),
         ),
       },
     ];
   }
   return [];
 }
-const addedUnionMessage = (exports.addedUnionMessage =
-  "Union added items, but native will not expect/support them");
-function checkForUnsafeAddedUnionItems(
+const addedEnumMessage = (exports.addedEnumMessage =
+  "Enum added items, but native will not expect/support them");
+function checkForUnsafeAddedEnumItems(
   _propertyChange,
-  positionalChange,
+  _positionalChange,
   _nullableChange,
-  _memberChange,
+  memberChange,
+  _unionMemberChange,
   typeName,
 ) {
-  if (
-    positionalChange &&
-    (positionalChange.typeKind === "union" ||
-      positionalChange.typeKind === "stringUnion") &&
-    positionalChange.addedElements &&
-    positionalChange.addedElements.length > 0
-  ) {
+  if (memberChange?.addedMembers && memberChange?.addedMembers.length > 0) {
     return [
       {
         typeName,
-        errorCode: "addedUnionCases",
-        errorInformation: (0, _ComparisonResult.positionalComparisonError)(
-          addedUnionMessage,
-          positionalChange.addedElements,
+        errorCode: "addedEnumCases",
+        errorInformation: (0, _ComparisonResult.memberComparisonError)(
+          addedEnumMessage,
+          memberChange.addedMembers.map((member) => ({
+            member: member.name,
+          })),
         ),
       },
     ];
   }
   return [];
 }
-const removedEnumMessage = (exports.removedEnumMessage =
-  "Enum removed items, but native may still provide them");
-function checkForUnsafeRemovedEnumItems(
+function getMemberLabel(member) {
+  if (
+    typeof member === "object" &&
+    member != null &&
+    "name" in member &&
+    "value" in member &&
+    typeof member.name === "string"
+  ) {
+    return member.name;
+  }
+  return getTypeAnnotationLabel(member);
+}
+function getTypeAnnotationLabel(type) {
+  if (type.type === "StringLiteralTypeAnnotation") {
+    return `"${type.value}"`;
+  } else if (type.type === "NumberLiteralTypeAnnotation") {
+    return String(type.value);
+  } else if (type.type === "BooleanLiteralTypeAnnotation") {
+    return String(type.value);
+  } else if (type.type === "NullableTypeAnnotation") {
+    return `?${getTypeAnnotationLabel(type.typeAnnotation)}`;
+  } else {
+    return type.type;
+  }
+}
+const removedUnionMemberMessage = (exports.removedUnionMemberMessage =
+  "Union removed items, but native may still provide them");
+function checkForUnsafeRemovedUnionItems(
   _propertyChange,
   _positionalChange,
   _nullableChange,
   memberChange,
+  unionMemberChange,
   typeName,
 ) {
-  if (memberChange?.missingMembers && memberChange?.missingMembers.length > 0) {
+  if (
+    unionMemberChange?.missingMembers &&
+    unionMemberChange?.missingMembers.length > 0
+  ) {
     return [
       {
         typeName,
-        errorCode: "removedEnumCases",
+        errorCode: "removedUnionCases",
         errorInformation: (0, _ComparisonResult.memberComparisonError)(
-          removedEnumMessage,
-          memberChange.missingMembers.map((member) => ({
-            member: member.name,
+          removedUnionMemberMessage,
+          unionMemberChange.missingMembers.map((member) => ({
+            member: getMemberLabel(member),
           })),
         ),
       },
@@ -382,24 +420,28 @@ function checkForUnsafeRemovedEnumItems(
   }
   return [];
 }
-const addedEnumMessage = (exports.addedEnumMessage =
-  "Enum added items, but native will not expect/support them");
-function checkForUnsafeAddedEnumItems(
+const addedUnionMemberMessage = (exports.addedUnionMemberMessage =
+  "Union added items, but native will not expect/support them");
+function checkForUnsafeAddedUnionItems(
   _propertyChange,
   _positionalChange,
   _nullableChange,
   memberChange,
+  unionMemberChange,
   typeName,
 ) {
-  if (memberChange?.addedMembers && memberChange?.addedMembers.length > 0) {
+  if (
+    unionMemberChange?.addedMembers &&
+    unionMemberChange?.addedMembers.length > 0
+  ) {
     return [
       {
         typeName,
-        errorCode: "addedEnumCases",
+        errorCode: "addedUnionCases",
         errorInformation: (0, _ComparisonResult.memberComparisonError)(
-          addedEnumMessage,
-          memberChange.addedMembers.map((member) => ({
-            member: member.name,
+          addedUnionMemberMessage,
+          unionMemberChange.addedMembers.map((member) => ({
+            member: getMemberLabel(member),
           })),
         ),
       },
@@ -414,6 +456,7 @@ function checkForUnsafeRemovedIntersectionItems(
   positionalChange,
   _nullableChange,
   _memberChange,
+  _unionMemberChange,
   typeName,
 ) {
   if (
@@ -442,6 +485,7 @@ function checkForUnsafeAddedIntersectionItems(
   positionalChange,
   _nullableChange,
   _memberChange,
+  _unionMemberChange,
   typeName,
 ) {
   if (
@@ -472,6 +516,7 @@ function checkForUnsafeNullableToNativeChange(
   _positionalChange,
   nullableChange,
   _memberChange,
+  _unionMemberChange,
   typeName,
 ) {
   if (
@@ -505,6 +550,7 @@ function checkForUnsafeNullableFromNativeChange(
   _positionalChange,
   nullableChange,
   _memberChange,
+  _unionMemberChange,
   typeName,
 ) {
   if (
@@ -535,6 +581,7 @@ function chainPropertiesChecks(checks) {
     positionalChange,
     nullableChange,
     memberChange,
+    unionMemberChange,
     typeName,
   ) =>
     checks.reduce(
@@ -545,6 +592,7 @@ function chainPropertiesChecks(checks) {
             positionalChange,
             nullableChange,
             memberChange,
+            unionMemberChange,
             typeName,
           ),
         ),
@@ -636,9 +684,52 @@ function assessComparisonResult(
             null,
             null,
             memberChange,
+            null,
             typeName,
           );
           const fromNativeErrorResult = checksForTypesFlowingFromNative(
+            null,
+            null,
+            null,
+            memberChange,
+            null,
+            typeName,
+          );
+          switch (oldDirection) {
+            case "toNative":
+              toNativeErrorResult.forEach((error) =>
+                incompatibleChanges.add(error),
+              );
+              break;
+            case "fromNative":
+              fromNativeErrorResult.forEach((error) =>
+                incompatibleChanges.add(error),
+              );
+              break;
+            case "both":
+              toNativeErrorResult.forEach((error) =>
+                incompatibleChanges.add(error),
+              );
+              fromNativeErrorResult.forEach((error) =>
+                incompatibleChanges.add(error),
+              );
+              break;
+          }
+        }
+        break;
+      case "unionMembers":
+        {
+          const memberChange = difference.memberLog;
+          const toNativeErrorResult = checksForTypesFlowingToNative(
+            null,
+            null,
+            null,
+            null,
+            memberChange,
+            typeName,
+          );
+          const fromNativeErrorResult = checksForTypesFlowingFromNative(
+            null,
             null,
             null,
             null,
@@ -776,6 +867,7 @@ function assessComparisonResult(
             changeLog,
             null,
             null,
+            null,
             typeName,
           );
           const toNativeResult = combine(
@@ -794,6 +886,7 @@ function assessComparisonResult(
             changeLog,
             null,
             null,
+            null,
             typeName,
           );
           const fromNativeResult = combine(
@@ -838,6 +931,7 @@ function assessComparisonResult(
               null,
               difference.nullableLog,
               null,
+              null,
               typeName,
             ).forEach((error) => incompatibleChanges.add(error));
             break;
@@ -847,6 +941,7 @@ function assessComparisonResult(
               null,
               difference.nullableLog,
               null,
+              null,
               typeName,
             ).forEach((error) => incompatibleChanges.add(error));
             break;

package/dist/VersionDiffing.js.flow

@@ -28,10 +28,10 @@ declare export const removedPropertiesMessage: "Object removed required properti
 declare export const addedPropertiesMessage: "Object added required properties, which native will not provide";
 declare export const stricterPropertiesMessage: "Property made strict, but native may not provide it";
 declare export const tooOptionalPropertiesMessage: "Property made optional, but native requires it";
-declare export const removedUnionMessage: "Union removed items, but native may still provide them";
-declare export const addedUnionMessage: "Union added items, but native will not expect/support them";
 declare export const removedEnumMessage: "Enum removed items, but native may still provide them";
 declare export const addedEnumMessage: "Enum added items, but native will not expect/support them";
+declare export const removedUnionMemberMessage: "Union removed items, but native may still provide them";
+declare export const addedUnionMemberMessage: "Union added items, but native will not expect/support them";
 declare export const removedIntersectionMessage: "Intersection removed items, but native may still require properties contained in them";
 declare export const addedIntersectionMessage: "Intersection added items, but native may not provide all required attributes";
 declare export const toNativeVoidChangeMessage: "Native may not be able to safely handle presence of type";

package/dist/convertPropToBasicTypes.js

@@ -34,7 +34,7 @@ function convertPropToBasicTypes(inputType) {
       break;
     case "StringEnumTypeAnnotation":
       resultingType = {
-        type: "StringLiteralUnionTypeAnnotation",
+        type: "UnionTypeAnnotation",
         types: inputType.options.map((option) => {
           return {
             type: "StringLiteralTypeAnnotation",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native/compatibility-check",
-  "version": "0.84.0-nightly-20251204-5bb3a6d68",
+  "version": "0.84.0-nightly-20251205-95cc1e767",
   "description": "Check a React Native app's boundary between JS and Native for incompatibilities",
   "license": "MIT",
   "repository": {
@@ -29,7 +29,7 @@
     "dist"
   ],
   "dependencies": {
-    "@react-native/codegen": "0.84.0-nightly-20251204-5bb3a6d68"
+    "@react-native/codegen": "0.84.0-nightly-20251205-95cc1e767"
   },
   "devDependencies": {
     "flow-remove-types": "^2.237.2",