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

package/lib/CodegenSchema.d.ts

@@ -318,10 +318,8 @@ export interface StringLiteralTypeAnnotation {
   readonly value: string;
 }
 
-export interface StringLiteralUnionTypeAnnotation {
-  readonly type: 'StringLiteralUnionTypeAnnotation';
-  readonly types: StringLiteralTypeAnnotation[];
-}
+export type StringLiteralUnionTypeAnnotation =
+  UnionTypeAnnotation<StringLiteralTypeAnnotation>;
 
 export interface NativeModuleNumberTypeAnnotation {
   readonly type: 'NumberTypeAnnotation';
@@ -383,11 +381,6 @@ export interface NativeModulePromiseTypeAnnotation {
   readonly elementType: Nullable<NativeModuleBaseTypeAnnotation> | VoidTypeAnnotation;
 }
 
-export type UnionTypeAnnotationMemberType =
-  | 'NumberTypeAnnotation'
-  | 'ObjectTypeAnnotation'
-  | 'StringTypeAnnotation';
-
 export type NativeModuleUnionTypeAnnotationMemberType =
   | NativeModuleObjectTypeAnnotation
   | StringLiteralTypeAnnotation
@@ -397,10 +390,8 @@ export type NativeModuleUnionTypeAnnotationMemberType =
   | StringTypeAnnotation
   | NumberTypeAnnotation;
 
-export interface NativeModuleUnionTypeAnnotation {
-  readonly type: 'UnionTypeAnnotation';
-  readonly memberType: UnionTypeAnnotationMemberType;
-}
+export type NativeModuleUnionTypeAnnotation =
+  UnionTypeAnnotation<NativeModuleUnionTypeAnnotationMemberType>;
 
 export interface NativeModuleMixedTypeAnnotation {
   readonly type: 'MixedTypeAnnotation';

package/lib/CodegenSchema.js.flow

@@ -61,10 +61,8 @@ export type BooleanLiteralTypeAnnotation = $ReadOnly<{
   value: boolean,
 }>;
 
-export type StringLiteralUnionTypeAnnotation = $ReadOnly<{
-  type: 'StringLiteralUnionTypeAnnotation',
-  types: $ReadOnlyArray<StringLiteralTypeAnnotation>,
-}>;
+export type StringLiteralUnionTypeAnnotation =
+  UnionTypeAnnotation<StringLiteralTypeAnnotation>;
 
 export type VoidTypeAnnotation = $ReadOnly<{
   type: 'VoidTypeAnnotation',
@@ -372,11 +370,6 @@ export type NativeModulePromiseTypeAnnotation = $ReadOnly<{
   elementType: VoidTypeAnnotation | Nullable<NativeModuleBaseTypeAnnotation>,
 }>;
 
-export type UnionTypeAnnotationMemberType =
-  | 'NumberTypeAnnotation'
-  | 'ObjectTypeAnnotation'
-  | 'StringTypeAnnotation';
-
 export type NativeModuleUnionTypeAnnotationMemberType =
   | NativeModuleObjectTypeAnnotation
   | StringLiteralTypeAnnotation
@@ -386,10 +379,8 @@ export type NativeModuleUnionTypeAnnotationMemberType =
   | StringTypeAnnotation
   | NumberTypeAnnotation;
 
-export type NativeModuleUnionTypeAnnotation = $ReadOnly<{
-  type: 'UnionTypeAnnotation',
-  memberType: UnionTypeAnnotationMemberType,
-}>;
+export type NativeModuleUnionTypeAnnotation =
+  UnionTypeAnnotation<NativeModuleUnionTypeAnnotationMemberType>;
 
 export type NativeModuleMixedTypeAnnotation = $ReadOnly<{
   type: 'MixedTypeAnnotation',
@@ -473,6 +464,7 @@ export type CompleteTypeAnnotation =
   | UnsafeAnyTypeAnnotation
   | ArrayTypeAnnotation<CompleteTypeAnnotation>
   | ObjectTypeAnnotation<CompleteTypeAnnotation>
+  | NativeModuleUnionTypeAnnotationMemberType
   // Components
   | CommandTypeAnnotation
   | CompleteReservedTypeAnnotation;

package/lib/cli/combine/combine-js-to-schema.js

@@ -14,8 +14,8 @@ const {FlowParser} = require('../../parsers/flow/parser');
 const {TypeScriptParser} = require('../../parsers/typescript/parser');
 const {filterJSFile} = require('./combine-utils');
 const fs = require('fs');
-const glob = require('glob');
 const path = require('path');
+const {globSync} = require('tinyglobby');
 const flowParser = new FlowParser();
 const typescriptParser = new TypeScriptParser();
 function combineSchemas(files, libraryName) {
@@ -55,13 +55,11 @@ function expandDirectoriesIntoFiles(fileList, platform, exclude) {
       if (!fs.lstatSync(file).isDirectory()) {
         return [file];
       }
-      const filePattern = path.sep === '\\' ? file.replace(/\\/g, '/') : file;
-      return glob.sync(`${filePattern}/**/*{,.fb}.{js,ts,tsx}`, {
-        nodir: true,
-        // TODO: This will remove the need of slash substitution above for Windows,
-        // but it requires glob@v9+; with the package currenlty relying on
-        // glob@7.1.1; and flow-typed repo not having definitions for glob@9+.
-        // windowsPathsNoEscape: true,
+      return globSync('**/*{,.fb}.{js,ts,tsx}', {
+        expandDirectories: false,
+        onlyFiles: true,
+        absolute: true,
+        cwd: file,
       });
     })
     .filter(element => filterJSFile(element, platform, exclude));

package/lib/cli/combine/combine-js-to-schema.js.flow

@@ -15,8 +15,8 @@ const {FlowParser} = require('../../parsers/flow/parser');
 const {TypeScriptParser} = require('../../parsers/typescript/parser');
 const {filterJSFile} = require('./combine-utils');
 const fs = require('fs');
-const glob = require('glob');
 const path = require('path');
+const {globSync} = require('tinyglobby');
 
 const flowParser = new FlowParser();
 const typescriptParser = new TypeScriptParser();
@@ -66,13 +66,11 @@ function expandDirectoriesIntoFiles(
       if (!fs.lstatSync(file).isDirectory()) {
         return [file];
       }
-      const filePattern = path.sep === '\\' ? file.replace(/\\/g, '/') : file;
-      return glob.sync(`${filePattern}/**/*{,.fb}.{js,ts,tsx}`, {
-        nodir: true,
-        // TODO: This will remove the need of slash substitution above for Windows,
-        // but it requires glob@v9+; with the package currenlty relying on
-        // glob@7.1.1; and flow-typed repo not having definitions for glob@9+.
-        // windowsPathsNoEscape: true,
+      return globSync('**/*{,.fb}.{js,ts,tsx}', {
+        expandDirectories: false,
+        onlyFiles: true,
+        absolute: true,
+        cwd: file,
       });
     })
     .filter(element => filterJSFile(element, platform, exclude));

package/lib/generators/Utils.js

@@ -38,10 +38,59 @@ function getEnumName(moduleName, origEnumName) {
   const uppercasedPropName = toSafeCppString(origEnumName);
   return `${moduleName}${uppercasedPropName}`;
 }
+const NumberTypes = ['NumberTypeAnnotation', 'NumberLiteralTypeAnnotation'];
+const StringTypes = ['StringTypeAnnotation', 'StringLiteralTypeAnnotation'];
+const ObjectTypes = ['ObjectTypeAnnotation'];
+const BooleanTypes = ['BooleanTypeAnnotation', 'BooleanLiteralTypeAnnotation'];
+const ValidUnionTypes = [
+  ...NumberTypes,
+  ...ObjectTypes,
+  ...StringTypes,
+  ...BooleanTypes,
+];
+class HeterogeneousUnionError extends Error {
+  constructor() {
+    super(`Non-homogenous union member types`);
+  }
+}
+function parseValidUnionType(annotation) {
+  const isUnionOfType = types => {
+    return annotation.types.every(memberTypeAnnotation =>
+      types.includes(memberTypeAnnotation.type),
+    );
+  };
+  if (isUnionOfType(BooleanTypes)) {
+    return 'boolean';
+  }
+  if (isUnionOfType(NumberTypes)) {
+    return 'number';
+  }
+  if (isUnionOfType(ObjectTypes)) {
+    return 'object';
+  }
+  if (isUnionOfType(StringTypes)) {
+    return 'string';
+  }
+  const invalidTypes = annotation.types.filter(member => {
+    return !ValidUnionTypes.includes(member.type);
+  });
+
+  // Check if union members are all supported but not homogeneous
+  // (e.g., mix of number and boolean)
+  if (invalidTypes.length === 0) {
+    throw new HeterogeneousUnionError();
+  } else {
+    throw new Error(
+      `Unsupported union member types: ${invalidTypes.join(', ')}"`,
+    );
+  }
+}
 module.exports = {
   capitalize,
   indent,
+  parseValidUnionType,
   toPascalCase,
   toSafeCppString,
   getEnumName,
+  HeterogeneousUnionError,
 };

package/lib/generators/Utils.js.flow

@@ -10,6 +10,8 @@
 
 'use strict';
 
+import type {NativeModuleUnionTypeAnnotation} from '../CodegenSchema';
+
 function capitalize(string: string): string {
   return string.charAt(0).toUpperCase() + string.slice(1);
 }
@@ -44,10 +46,66 @@ function getEnumName(moduleName: string, origEnumName: string): string {
   return `${moduleName}${uppercasedPropName}`;
 }
 
+type ValidUnionType = 'boolean' | 'number' | 'object' | 'string';
+const NumberTypes = ['NumberTypeAnnotation', 'NumberLiteralTypeAnnotation'];
+const StringTypes = ['StringTypeAnnotation', 'StringLiteralTypeAnnotation'];
+const ObjectTypes = ['ObjectTypeAnnotation'];
+const BooleanTypes = ['BooleanTypeAnnotation', 'BooleanLiteralTypeAnnotation'];
+const ValidUnionTypes = [
+  ...NumberTypes,
+  ...ObjectTypes,
+  ...StringTypes,
+  ...BooleanTypes,
+];
+
+class HeterogeneousUnionError extends Error {
+  constructor() {
+    super(`Non-homogenous union member types`);
+  }
+}
+
+function parseValidUnionType(
+  annotation: NativeModuleUnionTypeAnnotation,
+): ValidUnionType {
+  const isUnionOfType = (types: $ReadOnlyArray<string>): boolean => {
+    return annotation.types.every(memberTypeAnnotation =>
+      types.includes(memberTypeAnnotation.type),
+    );
+  };
+  if (isUnionOfType(BooleanTypes)) {
+    return 'boolean';
+  }
+  if (isUnionOfType(NumberTypes)) {
+    return 'number';
+  }
+  if (isUnionOfType(ObjectTypes)) {
+    return 'object';
+  }
+  if (isUnionOfType(StringTypes)) {
+    return 'string';
+  }
+
+  const invalidTypes = annotation.types.filter(member => {
+    return !ValidUnionTypes.includes(member.type);
+  });
+
+  // Check if union members are all supported but not homogeneous
+  // (e.g., mix of number and boolean)
+  if (invalidTypes.length === 0) {
+    throw new HeterogeneousUnionError();
+  } else {
+    throw new Error(
+      `Unsupported union member types: ${invalidTypes.join(', ')}"`,
+    );
+  }
+}
+
 module.exports = {
   capitalize,
   indent,
+  parseValidUnionType,
   toPascalCase,
   toSafeCppString,
   getEnumName,
+  HeterogeneousUnionError,
 };

package/lib/generators/components/CppHelpers.js

@@ -10,7 +10,7 @@
 
 'use strict';
 
-const {getEnumName, toSafeCppString} = require('../Utils');
+const {getEnumName, parseValidUnionType, toSafeCppString} = require('../Utils');
 function toIntEnumValueName(propName, value) {
   return `${toSafeCppString(propName)}${value}`;
 }
@@ -42,7 +42,40 @@ function getCppArrayTypeForAnnotation(typeElement, structParts) {
     case 'Int32TypeAnnotation':
     case 'MixedTypeAnnotation':
       return `std::vector<${getCppTypeForAnnotation(typeElement.type)}>`;
-    case 'StringLiteralUnionTypeAnnotation':
+    case 'UnionTypeAnnotation':
+      const validUnionType = parseValidUnionType(typeElement);
+      switch (validUnionType) {
+        case 'boolean':
+          return `std::vector<${getCppTypeForAnnotation('BooleanTypeAnnotation')}>`;
+        case 'number':
+          // Have type-upgraded Number to Double in this case to match the Int32TypeAnnotation, FloatTypeAnnotation & DoubleTypeAnnotation
+          return `std::vector<${getCppTypeForAnnotation('DoubleTypeAnnotation')}>`;
+        case 'object':
+          if (!structParts) {
+            throw new Error(
+              `Trying to generate the event emitter for an Array of ${typeElement.type} without informations to generate the generic type`,
+            );
+          }
+          return `std::vector<${generateEventStructName(structParts)}>`;
+        case 'string':
+          if (
+            typeElement.types.every(
+              ({type}) => type === 'StringLiteralTypeAnnotation',
+            )
+          ) {
+            if (!structParts) {
+              throw new Error(
+                `Trying to generate the event emitter for an Array of ${typeElement.type} without informations to generate the generic type`,
+              );
+            }
+            return `std::vector<${generateEventStructName(structParts)}>`;
+          }
+          // Unions of strings and string literals are treated as just strings
+          return `std::vector<${getCppTypeForAnnotation('StringTypeAnnotation')}>`;
+        default:
+          validUnionType;
+          throw new Error(`Unsupported union member type`);
+      }
     case 'ObjectTypeAnnotation':
       if (!structParts) {
         throw new Error(

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

@@ -15,7 +15,7 @@ import type {
   PropTypeAnnotation,
 } from '../../CodegenSchema';
 
-const {getEnumName, toSafeCppString} = require('../Utils');
+const {getEnumName, parseValidUnionType, toSafeCppString} = require('../Utils');
 
 function toIntEnumValueName(propName: string, value: number): string {
   return `${toSafeCppString(propName)}${value}`;
@@ -61,7 +61,40 @@ function getCppArrayTypeForAnnotation(
     case 'Int32TypeAnnotation':
     case 'MixedTypeAnnotation':
       return `std::vector<${getCppTypeForAnnotation(typeElement.type)}>`;
-    case 'StringLiteralUnionTypeAnnotation':
+    case 'UnionTypeAnnotation':
+      const validUnionType = parseValidUnionType(typeElement);
+      switch (validUnionType) {
+        case 'boolean':
+          return `std::vector<${getCppTypeForAnnotation('BooleanTypeAnnotation')}>`;
+        case 'number':
+          // Have type-upgraded Number to Double in this case to match the Int32TypeAnnotation, FloatTypeAnnotation & DoubleTypeAnnotation
+          return `std::vector<${getCppTypeForAnnotation('DoubleTypeAnnotation')}>`;
+        case 'object':
+          if (!structParts) {
+            throw new Error(
+              `Trying to generate the event emitter for an Array of ${typeElement.type} without informations to generate the generic type`,
+            );
+          }
+          return `std::vector<${generateEventStructName(structParts)}>`;
+        case 'string':
+          if (
+            typeElement.types.every(
+              ({type}) => type === 'StringLiteralTypeAnnotation',
+            )
+          ) {
+            if (!structParts) {
+              throw new Error(
+                `Trying to generate the event emitter for an Array of ${typeElement.type} without informations to generate the generic type`,
+              );
+            }
+            return `std::vector<${generateEventStructName(structParts)}>`;
+          }
+          // Unions of strings and string literals are treated as just strings
+          return `std::vector<${getCppTypeForAnnotation('StringTypeAnnotation')}>`;
+        default:
+          (validUnionType: empty);
+          throw new Error(`Unsupported union member type`);
+      }
     case 'ObjectTypeAnnotation':
       if (!structParts) {
         throw new Error(

package/lib/generators/components/GenerateEventEmitterCpp.js

@@ -11,6 +11,7 @@
 'use strict';
 
 const {indent} = require('../Utils');
+const {parseValidUnionType} = require('../Utils');
 const {IncludeTemplate, generateEventStructName} = require('./CppHelpers');
 
 // File path -> contents
@@ -146,7 +147,11 @@ function handleArrayElementType(
         loopLocalVariable,
         val => `jsi::valueFromDynamic(runtime, ${val})`,
       );
-    case 'StringLiteralUnionTypeAnnotation':
+    case 'UnionTypeAnnotation':
+      const validUnionType = parseValidUnionType(elementType);
+      if (validUnionType !== 'string') {
+        throw new Error('Invalid since it is a union of non strings');
+      }
       return setValueAtIndex(
         propertyName,
         indexVariable,
@@ -242,7 +247,11 @@ function generateSetters(
             usingEvent,
             prop => `jsi::valueFromDynamic(runtime, ${prop})`,
           );
-        case 'StringLiteralUnionTypeAnnotation':
+        case 'UnionTypeAnnotation':
+          const validUnionType = parseValidUnionType(typeAnnotation);
+          if (validUnionType !== 'string') {
+            throw new Error('Invalid since it is a union of non strings');
+          }
           return generateSetter(
             parentPropertyName,
             eventProperty.name,

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

@@ -19,6 +19,7 @@ import type {
 } from '../../CodegenSchema';
 
 const {indent} = require('../Utils');
+const {parseValidUnionType} = require('../Utils');
 const {IncludeTemplate, generateEventStructName} = require('./CppHelpers');
 
 // File path -> contents
@@ -207,7 +208,11 @@ function handleArrayElementType(
         loopLocalVariable,
         val => `jsi::valueFromDynamic(runtime, ${val})`,
       );
-    case 'StringLiteralUnionTypeAnnotation':
+    case 'UnionTypeAnnotation':
+      const validUnionType = parseValidUnionType(elementType);
+      if (validUnionType !== 'string') {
+        throw new Error('Invalid since it is a union of non strings');
+      }
       return setValueAtIndex(
         propertyName,
         indexVariable,
@@ -320,7 +325,11 @@ function generateSetters(
             usingEvent,
             prop => `jsi::valueFromDynamic(runtime, ${prop})`,
           );
-        case 'StringLiteralUnionTypeAnnotation':
+        case 'UnionTypeAnnotation':
+          const validUnionType = parseValidUnionType(typeAnnotation);
+          if (validUnionType !== 'string') {
+            throw new Error('Invalid since it is a union of non strings');
+          }
           return generateSetter(
             parentPropertyName,
             eventProperty.name,

package/lib/generators/components/GenerateEventEmitterH.js

@@ -10,7 +10,7 @@
 
 'use strict';
 
-const {indent, toSafeCppString} = require('../Utils');
+const {indent, parseValidUnionType, toSafeCppString} = require('../Utils');
 const {
   generateEventStructName,
   getCppArrayTypeForAnnotation,
@@ -67,16 +67,21 @@ static char const *toString(const ${enumName} value) {
 }
 `.trim();
 function getNativeTypeFromAnnotation(componentName, eventProperty, nameParts) {
-  const {type} = eventProperty.typeAnnotation;
-  switch (type) {
+  const {typeAnnotation} = eventProperty;
+  switch (typeAnnotation.type) {
     case 'BooleanTypeAnnotation':
     case 'StringTypeAnnotation':
     case 'Int32TypeAnnotation':
     case 'DoubleTypeAnnotation':
     case 'FloatTypeAnnotation':
     case 'MixedTypeAnnotation':
-      return getCppTypeForAnnotation(type);
-    case 'StringLiteralUnionTypeAnnotation':
+      return getCppTypeForAnnotation(typeAnnotation.type);
+    case 'UnionTypeAnnotation':
+      const validUnionType = parseValidUnionType(typeAnnotation);
+      if (validUnionType !== 'string') {
+        throw new Error('Invalid since it is a union of non strings');
+      }
+      return generateEventStructName([...nameParts, eventProperty.name]);
     case 'ObjectTypeAnnotation':
       return generateEventStructName([...nameParts, eventProperty.name]);
     case 'ArrayTypeAnnotation':
@@ -91,8 +96,10 @@ function getNativeTypeFromAnnotation(componentName, eventProperty, nameParts) {
         eventProperty.name,
       ]);
     default:
-      type;
-      throw new Error(`Received invalid event property type ${type}`);
+      typeAnnotation.type;
+      throw new Error(
+        `Received invalid event property type ${typeAnnotation.type}`,
+      );
   }
 }
 function generateEnum(structs, options, nameParts) {
@@ -129,7 +136,11 @@ function handleGenerateStructForArray(
       nameParts.concat([name]),
       nullthrows(elementType.properties),
     );
-  } else if (elementType.type === 'StringLiteralUnionTypeAnnotation') {
+  } else if (elementType.type === 'UnionTypeAnnotation') {
+    const validUnionType = parseValidUnionType(elementType);
+    if (validUnionType !== 'string') {
+      throw new Error('Invalid since it is a union of non strings');
+    }
     generateEnum(
       structs,
       elementType.types.map(literal => literal.value),
@@ -180,7 +191,11 @@ function generateStruct(structs, componentName, nameParts, properties) {
           nullthrows(typeAnnotation.properties),
         );
         return;
-      case 'StringLiteralUnionTypeAnnotation':
+      case 'UnionTypeAnnotation':
+        const validUnionType = parseValidUnionType(typeAnnotation);
+        if (validUnionType !== 'string') {
+          throw new Error('Invalid since it is a union of non strings');
+        }
         generateEnum(
           structs,
           typeAnnotation.types.map(literal => literal.value),

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

@@ -18,7 +18,7 @@ import type {
   SchemaType,
 } from '../../CodegenSchema';
 
-const {indent, toSafeCppString} = require('../Utils');
+const {indent, parseValidUnionType, toSafeCppString} = require('../Utils');
 const {
   generateEventStructName,
   getCppArrayTypeForAnnotation,
@@ -118,17 +118,21 @@ function getNativeTypeFromAnnotation(
   eventProperty: NamedShape<EventTypeAnnotation>,
   nameParts: $ReadOnlyArray<string>,
 ): string {
-  const {type} = eventProperty.typeAnnotation;
-
-  switch (type) {
+  const {typeAnnotation} = eventProperty;
+  switch (typeAnnotation.type) {
     case 'BooleanTypeAnnotation':
     case 'StringTypeAnnotation':
     case 'Int32TypeAnnotation':
     case 'DoubleTypeAnnotation':
     case 'FloatTypeAnnotation':
     case 'MixedTypeAnnotation':
-      return getCppTypeForAnnotation(type);
-    case 'StringLiteralUnionTypeAnnotation':
+      return getCppTypeForAnnotation(typeAnnotation.type);
+    case 'UnionTypeAnnotation':
+      const validUnionType = parseValidUnionType(typeAnnotation);
+      if (validUnionType !== 'string') {
+        throw new Error('Invalid since it is a union of non strings');
+      }
+      return generateEventStructName([...nameParts, eventProperty.name]);
     case 'ObjectTypeAnnotation':
       return generateEventStructName([...nameParts, eventProperty.name]);
     case 'ArrayTypeAnnotation':
@@ -143,8 +147,10 @@ function getNativeTypeFromAnnotation(
         eventProperty.name,
       ]);
     default:
-      (type: empty);
-      throw new Error(`Received invalid event property type ${type}`);
+      (typeAnnotation.type: empty);
+      throw new Error(
+        `Received invalid event property type ${typeAnnotation.type}`,
+      );
   }
 }
 function generateEnum(
@@ -188,7 +194,11 @@ function handleGenerateStructForArray(
       nameParts.concat([name]),
       nullthrows(elementType.properties),
     );
-  } else if (elementType.type === 'StringLiteralUnionTypeAnnotation') {
+  } else if (elementType.type === 'UnionTypeAnnotation') {
+    const validUnionType = parseValidUnionType(elementType);
+    if (validUnionType !== 'string') {
+      throw new Error('Invalid since it is a union of non strings');
+    }
     generateEnum(
       structs,
       elementType.types.map(literal => literal.value),
@@ -251,7 +261,11 @@ function generateStruct(
           nullthrows(typeAnnotation.properties),
         );
         return;
-      case 'StringLiteralUnionTypeAnnotation':
+      case 'UnionTypeAnnotation':
+        const validUnionType = parseValidUnionType(typeAnnotation);
+        if (validUnionType !== 'string') {
+          throw new Error('Invalid since it is a union of non strings');
+        }
         generateEnum(
           structs,
           typeAnnotation.types.map(literal => literal.value),