@react-native/codegen 0.77.0-nightly-20241007-d0912ed06 → 0.77.0-nightly-20241009-e4814b0d6

package/lib/CodegenSchema.d.ts

@@ -290,6 +290,16 @@ export interface NativeModuleStringTypeAnnotation {
   readonly type: 'StringTypeAnnotation';
 }
 
+export interface NativeModuleStringLiteralTypeAnnotation {
+  readonly type: 'StringLiteralTypeAnnotation';
+  readonly value: string;
+}
+
+export interface NativeModuleStringLiteralUnionTypeAnnotation {
+  readonly type: 'StringLiteralUnionTypeAnnotation';
+  readonly types: NativeModuleStringLiteralTypeAnnotation[];
+}
+
 export interface NativeModuleNumberTypeAnnotation {
   readonly type: 'NumberTypeAnnotation';
 }
@@ -371,6 +381,8 @@ export type NativeModuleEventEmitterBaseTypeAnnotation =
   | NativeModuleInt32TypeAnnotation
   | NativeModuleNumberTypeAnnotation
   | NativeModuleStringTypeAnnotation
+  | NativeModuleStringLiteralTypeAnnotation
+  | NativeModuleStringLiteralUnionTypeAnnotation
   | NativeModuleTypeAliasTypeAnnotation
   | NativeModuleGenericObjectTypeAnnotation
   | VoidTypeAnnotation;
@@ -384,6 +396,8 @@ export type NativeModuleEventEmitterTypeAnnotation =
 
 export type NativeModuleBaseTypeAnnotation =
   | NativeModuleStringTypeAnnotation
+  | NativeModuleStringLiteralTypeAnnotation
+  | NativeModuleStringLiteralUnionTypeAnnotation
   | NativeModuleNumberTypeAnnotation
   | NativeModuleInt32TypeAnnotation
   | NativeModuleDoubleTypeAnnotation

package/lib/CodegenSchema.js.flow

@@ -41,6 +41,16 @@ export type StringTypeAnnotation = $ReadOnly<{
   type: 'StringTypeAnnotation',
 }>;
 
+export type StringLiteralTypeAnnotation = $ReadOnly<{
+  type: 'StringLiteralTypeAnnotation',
+  value: string,
+}>;
+
+export type StringLiteralUnionTypeAnnotation = $ReadOnly<{
+  type: 'StringLiteralUnionTypeAnnotation',
+  types: $ReadOnlyArray<StringLiteralTypeAnnotation>,
+}>;
+
 export type StringEnumTypeAnnotation = $ReadOnly<{
   type: 'StringEnumTypeAnnotation',
   options: $ReadOnlyArray<string>,
@@ -357,6 +367,8 @@ type NativeModuleEventEmitterBaseTypeAnnotation =
   | Int32TypeAnnotation
   | NativeModuleNumberTypeAnnotation
   | StringTypeAnnotation
+  | StringLiteralTypeAnnotation
+  | StringLiteralUnionTypeAnnotation
   | NativeModuleTypeAliasTypeAnnotation
   | NativeModuleGenericObjectTypeAnnotation
   | VoidTypeAnnotation;
@@ -370,6 +382,8 @@ export type NativeModuleEventEmitterTypeAnnotation =
 
 export type NativeModuleBaseTypeAnnotation =
   | StringTypeAnnotation
+  | StringLiteralTypeAnnotation
+  | StringLiteralUnionTypeAnnotation
   | NativeModuleNumberTypeAnnotation
   | Int32TypeAnnotation
   | DoubleTypeAnnotation

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

@@ -59,11 +59,17 @@ const _require = require('./combine-js-to-schema'),
     _require.combineSchemasInFileListAndWriteToFile;
 const yargs = require('yargs');
 const argv = yargs
+  .usage('Usage: $0 <outfile> <file1> [<file2> ...]')
   .option('p', {
+    describe:
+      'Platforms to generate schema for, this works on filenames: <filename>[.<platform>].(js|tsx?)',
     alias: 'platform',
+    default: null,
   })
   .option('e', {
+    describe: 'Regular expression to exclude files from schema generation',
     alias: 'exclude',
+    default: null,
   })
   .parseSync();
 const _argv$_ = _toArray(argv._),

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

@@ -17,11 +17,17 @@ const {
 const yargs = require('yargs');
 
 const argv = yargs
+  .usage('Usage: $0 <outfile> <file1> [<file2> ...]')
   .option('p', {
+    describe:
+      'Platforms to generate schema for, this works on filenames: <filename>[.<platform>].(js|tsx?)',
     alias: 'platform',
+    default: null,
   })
   .option('e', {
+    describe: 'Regular expression to exclude files from schema generation',
     alias: 'exclude',
+    default: null,
   })
   .parseSync();
 

package/lib/generators/components/JavaHelpers.js

@@ -77,6 +77,7 @@ function getImports(component, type) {
   component.props.forEach(prop => {
     const typeAnnotation = prop.typeAnnotation;
     if (typeAnnotation.type === 'ReservedPropTypeAnnotation') {
+      // $FlowFixMe[incompatible-call]
       addImportsForNativeName(typeAnnotation.name);
     }
     if (typeAnnotation.type === 'ArrayTypeAnnotation') {

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

@@ -66,12 +66,7 @@ function getImports(
       | 'EdgeInsetsPrimitive'
       | 'ImageSourcePrimitive'
       | 'PointPrimitive'
-      | 'DimensionPrimitive'
-      | $TEMPORARY$string<'ColorPrimitive'>
-      | $TEMPORARY$string<'EdgeInsetsPrimitive'>
-      | $TEMPORARY$string<'ImageSourcePrimitive'>
-      | $TEMPORARY$string<'PointPrimitive'>
-      | $TEMPORARY$string<'DimensionPrimitive'>,
+      | 'DimensionPrimitive',
   ) {
     switch (name) {
       case 'ColorPrimitive':
@@ -107,6 +102,7 @@ function getImports(
     const typeAnnotation = prop.typeAnnotation;
 
     if (typeAnnotation.type === 'ReservedPropTypeAnnotation') {
+      // $FlowFixMe[incompatible-call]
       addImportsForNativeName(typeAnnotation.name);
     }
 

package/lib/generators/modules/GenerateModuleCpp.js

@@ -193,6 +193,10 @@ function serializeArg(moduleName, arg, index, resolveAlias, enumMap) {
       }
     case 'StringTypeAnnotation':
       return wrap(val => `${val}.asString(rt)`);
+    case 'StringLiteralTypeAnnotation':
+      return wrap(val => `${val}.asString(rt)`);
+    case 'StringLiteralUnionTypeAnnotation':
+      return wrap(val => `${val}.asString(rt)`);
     case 'BooleanTypeAnnotation':
       return wrap(val => `${val}.asBool()`);
     case 'EnumDeclaration':

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

@@ -161,6 +161,10 @@ function serializeArg(
       }
     case 'StringTypeAnnotation':
       return wrap(val => `${val}.asString(rt)`);
+    case 'StringLiteralTypeAnnotation':
+      return wrap(val => `${val}.asString(rt)`);
+    case 'StringLiteralUnionTypeAnnotation':
+      return wrap(val => `${val}.asString(rt)`);
     case 'BooleanTypeAnnotation':
       return wrap(val => `${val}.asBool()`);
     case 'EnumDeclaration':

package/lib/generators/modules/GenerateModuleH.js

@@ -213,6 +213,10 @@ function translatePrimitiveJSTypeToCpp(
       return 'void';
     case 'StringTypeAnnotation':
       return wrapOptional('jsi::String', isRequired);
+    case 'StringLiteralTypeAnnotation':
+      return wrapOptional('jsi::String', isRequired);
+    case 'StringLiteralUnionTypeAnnotation':
+      return wrapOptional('jsi::String', isRequired);
     case 'NumberTypeAnnotation':
       return wrapOptional('double', isRequired);
     case 'DoubleTypeAnnotation':

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

@@ -173,6 +173,10 @@ function translatePrimitiveJSTypeToCpp(
       return 'void';
     case 'StringTypeAnnotation':
       return wrapOptional('jsi::String', isRequired);
+    case 'StringLiteralTypeAnnotation':
+      return wrapOptional('jsi::String', isRequired);
+    case 'StringLiteralUnionTypeAnnotation':
+      return wrapOptional('jsi::String', isRequired);
     case 'NumberTypeAnnotation':
       return wrapOptional('double', isRequired);
     case 'DoubleTypeAnnotation':

package/lib/generators/modules/GenerateModuleJavaSpec.js

@@ -162,9 +162,14 @@ function MethodTemplate(config) {
   )})${methodClosing}`;
 }
 function translateEventEmitterTypeToJavaType(eventEmitter, imports) {
-  switch (eventEmitter.typeAnnotation.typeAnnotation.type) {
+  const type = eventEmitter.typeAnnotation.typeAnnotation.type;
+  switch (type) {
     case 'StringTypeAnnotation':
       return 'String';
+    case 'StringLiteralTypeAnnotation':
+      return 'String';
+    case 'StringLiteralUnionTypeAnnotation':
+      return 'String';
     case 'NumberTypeAnnotation':
     case 'FloatTypeAnnotation':
     case 'DoubleTypeAnnotation':
@@ -180,7 +185,16 @@ function translateEventEmitterTypeToJavaType(eventEmitter, imports) {
     case 'ArrayTypeAnnotation':
       imports.add('com.facebook.react.bridge.ReadableArray');
       return 'ReadableArray';
+    case 'DoubleTypeAnnotation':
+    case 'FloatTypeAnnotation':
+    case 'Int32TypeAnnotation':
+    case 'VoidTypeAnnotation':
+      // TODO: Add support for these types
+      throw new Error(
+        `Unsupported eventType for ${eventEmitter.name}. Found: ${eventEmitter.typeAnnotation.typeAnnotation.type}`,
+      );
     default:
+      type;
       throw new Error(
         `Unsupported eventType for ${eventEmitter.name}. Found: ${eventEmitter.typeAnnotation.typeAnnotation.type}`,
       );
@@ -219,6 +233,10 @@ function translateFunctionParamToJavaType(
       }
     case 'StringTypeAnnotation':
       return wrapOptional('String', isRequired);
+    case 'StringLiteralTypeAnnotation':
+      return wrapOptional('String', isRequired);
+    case 'StringLiteralUnionTypeAnnotation':
+      return wrapOptional('String', isRequired);
     case 'NumberTypeAnnotation':
       return wrapOptional('double', isRequired);
     case 'FloatTypeAnnotation':
@@ -305,6 +323,10 @@ function translateFunctionReturnTypeToJavaType(
       return 'void';
     case 'StringTypeAnnotation':
       return wrapOptional('String', isRequired);
+    case 'StringLiteralTypeAnnotation':
+      return wrapOptional('String', isRequired);
+    case 'StringLiteralUnionTypeAnnotation':
+      return wrapOptional('String', isRequired);
     case 'NumberTypeAnnotation':
       return wrapOptional('double', isRequired);
     case 'FloatTypeAnnotation':
@@ -412,6 +434,10 @@ function getFalsyReturnStatementFromReturnType(
       }
     case 'StringTypeAnnotation':
       return nullable ? 'return null;' : 'return "";';
+    case 'StringLiteralTypeAnnotation':
+      return nullable ? 'return null;' : 'return "";';
+    case 'StringLiteralUnionTypeAnnotation':
+      return nullable ? 'return null;' : 'return "";';
     case 'ObjectTypeAnnotation':
       return 'return null;';
     case 'GenericObjectTypeAnnotation':

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

@@ -127,9 +127,14 @@ function translateEventEmitterTypeToJavaType(
   eventEmitter: NativeModuleEventEmitterShape,
   imports: Set<string>,
 ): string {
-  switch (eventEmitter.typeAnnotation.typeAnnotation.type) {
+  const type = eventEmitter.typeAnnotation.typeAnnotation.type;
+  switch (type) {
     case 'StringTypeAnnotation':
       return 'String';
+    case 'StringLiteralTypeAnnotation':
+      return 'String';
+    case 'StringLiteralUnionTypeAnnotation':
+      return 'String';
     case 'NumberTypeAnnotation':
     case 'FloatTypeAnnotation':
     case 'DoubleTypeAnnotation':
@@ -145,7 +150,16 @@ function translateEventEmitterTypeToJavaType(
     case 'ArrayTypeAnnotation':
       imports.add('com.facebook.react.bridge.ReadableArray');
       return 'ReadableArray';
+    case 'DoubleTypeAnnotation':
+    case 'FloatTypeAnnotation':
+    case 'Int32TypeAnnotation':
+    case 'VoidTypeAnnotation':
+      // TODO: Add support for these types
+      throw new Error(
+        `Unsupported eventType for ${eventEmitter.name}. Found: ${eventEmitter.typeAnnotation.typeAnnotation.type}`,
+      );
     default:
+      (type: empty);
       throw new Error(
         `Unsupported eventType for ${eventEmitter.name}. Found: ${eventEmitter.typeAnnotation.typeAnnotation.type}`,
       );
@@ -183,6 +197,10 @@ function translateFunctionParamToJavaType(
       }
     case 'StringTypeAnnotation':
       return wrapOptional('String', isRequired);
+    case 'StringLiteralTypeAnnotation':
+      return wrapOptional('String', isRequired);
+    case 'StringLiteralUnionTypeAnnotation':
+      return wrapOptional('String', isRequired);
     case 'NumberTypeAnnotation':
       return wrapOptional('double', isRequired);
     case 'FloatTypeAnnotation':
@@ -273,6 +291,10 @@ function translateFunctionReturnTypeToJavaType(
       return 'void';
     case 'StringTypeAnnotation':
       return wrapOptional('String', isRequired);
+    case 'StringLiteralTypeAnnotation':
+      return wrapOptional('String', isRequired);
+    case 'StringLiteralUnionTypeAnnotation':
+      return wrapOptional('String', isRequired);
     case 'NumberTypeAnnotation':
       return wrapOptional('double', isRequired);
     case 'FloatTypeAnnotation':
@@ -383,6 +405,10 @@ function getFalsyReturnStatementFromReturnType(
       }
     case 'StringTypeAnnotation':
       return nullable ? 'return null;' : 'return "";';
+    case 'StringLiteralTypeAnnotation':
+      return nullable ? 'return null;' : 'return "";';
+    case 'StringLiteralUnionTypeAnnotation':
+      return nullable ? 'return null;' : 'return "";';
     case 'ObjectTypeAnnotation':
       return 'return null;';
     case 'GenericObjectTypeAnnotation':

package/lib/generators/modules/GenerateModuleJniCpp.js

@@ -180,6 +180,10 @@ function translateReturnTypeToKind(nullableTypeAnnotation, resolveAlias) {
       return 'VoidKind';
     case 'StringTypeAnnotation':
       return 'StringKind';
+    case 'StringLiteralTypeAnnotation':
+      return 'StringKind';
+    case 'StringLiteralUnionTypeAnnotation':
+      return 'StringKind';
     case 'BooleanTypeAnnotation':
       return 'BooleanKind';
     case 'EnumDeclaration':
@@ -254,6 +258,10 @@ function translateParamTypeToJniType(param, resolveAlias) {
       }
     case 'StringTypeAnnotation':
       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 'EnumDeclaration':
@@ -327,6 +335,10 @@ function translateReturnTypeToJniType(nullableTypeAnnotation, resolveAlias) {
       return 'V';
     case 'StringTypeAnnotation':
       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 'EnumDeclaration':

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

@@ -165,6 +165,10 @@ function translateReturnTypeToKind(
       return 'VoidKind';
     case 'StringTypeAnnotation':
       return 'StringKind';
+    case 'StringLiteralTypeAnnotation':
+      return 'StringKind';
+    case 'StringLiteralUnionTypeAnnotation':
+      return 'StringKind';
     case 'BooleanTypeAnnotation':
       return 'BooleanKind';
     case 'EnumDeclaration':
@@ -244,6 +248,10 @@ function translateParamTypeToJniType(
       }
     case 'StringTypeAnnotation':
       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 'EnumDeclaration':
@@ -320,6 +328,10 @@ function translateReturnTypeToJniType(
       return 'V';
     case 'StringTypeAnnotation':
       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 'EnumDeclaration':

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

@@ -22,6 +22,8 @@ import type {
   NativeModuleNumberTypeAnnotation,
   NativeModuleObjectTypeAnnotation,
   StringTypeAnnotation,
+  StringLiteralTypeAnnotation,
+  StringLiteralUnionTypeAnnotation,
   NativeModuleTypeAliasTypeAnnotation,
   Nullable,
   ReservedTypeAnnotation,
@@ -58,6 +60,8 @@ export type StructProperty = $ReadOnly<{
 
 export type StructTypeAnnotation =
   | StringTypeAnnotation
+  | StringLiteralTypeAnnotation
+  | StringLiteralUnionTypeAnnotation
   | NativeModuleNumberTypeAnnotation
   | Int32TypeAnnotation
   | DoubleTypeAnnotation

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

@@ -157,6 +157,10 @@ function toObjCType(
       }
     case 'StringTypeAnnotation':
       return 'NSString *';
+    case 'StringLiteralTypeAnnotation':
+      return 'NSString *';
+    case 'StringLiteralUnionTypeAnnotation':
+      return 'NSString *';
     case 'NumberTypeAnnotation':
       return wrapCxxOptional('double', isRequired);
     case 'FloatTypeAnnotation':
@@ -235,6 +239,10 @@ function toObjCValue(
       }
     case 'StringTypeAnnotation':
       return value;
+    case 'StringLiteralTypeAnnotation':
+      return value;
+    case 'StringLiteralUnionTypeAnnotation':
+      return value;
     case 'NumberTypeAnnotation':
       return wrapPrimitive('double');
     case 'FloatTypeAnnotation':

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

@@ -94,6 +94,10 @@ function toObjCType(
       }
     case 'StringTypeAnnotation':
       return 'NSString *';
+    case 'StringLiteralTypeAnnotation':
+      return 'NSString *';
+    case 'StringLiteralUnionTypeAnnotation':
+      return 'NSString *';
     case 'NumberTypeAnnotation':
       return wrapCxxOptional('double', isRequired);
     case 'FloatTypeAnnotation':
@@ -173,6 +177,10 @@ function toObjCValue(
       }
     case 'StringTypeAnnotation':
       return value;
+    case 'StringLiteralTypeAnnotation':
+      return value;
+    case 'StringLiteralUnionTypeAnnotation':
+      return value;
     case 'NumberTypeAnnotation':
       return wrapPrimitive('double');
     case 'FloatTypeAnnotation':

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

@@ -145,6 +145,10 @@ function toObjCType(
       }
     case 'StringTypeAnnotation':
       return 'NSString *';
+    case 'StringLiteralTypeAnnotation':
+      return 'NSString *';
+    case 'StringLiteralUnionTypeAnnotation':
+      return 'NSString *';
     case 'NumberTypeAnnotation':
       return wrapCxxOptional('double', isRequired);
     case 'FloatTypeAnnotation':
@@ -224,6 +228,10 @@ function toObjCValue(
       }
     case 'StringTypeAnnotation':
       return RCTBridgingTo('String');
+    case 'StringLiteralTypeAnnotation':
+      return RCTBridgingTo('String');
+    case 'StringLiteralUnionTypeAnnotation':
+      return RCTBridgingTo('String');
     case 'NumberTypeAnnotation':
       return RCTBridgingTo('Double');
     case 'FloatTypeAnnotation':

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

@@ -85,6 +85,10 @@ function toObjCType(
       }
     case 'StringTypeAnnotation':
       return 'NSString *';
+    case 'StringLiteralTypeAnnotation':
+      return 'NSString *';
+    case 'StringLiteralUnionTypeAnnotation':
+      return 'NSString *';
     case 'NumberTypeAnnotation':
       return wrapCxxOptional('double', isRequired);
     case 'FloatTypeAnnotation':
@@ -163,6 +167,10 @@ function toObjCValue(
       }
     case 'StringTypeAnnotation':
       return RCTBridgingTo('String');
+    case 'StringLiteralTypeAnnotation':
+      return RCTBridgingTo('String');
+    case 'StringLiteralUnionTypeAnnotation':
+      return RCTBridgingTo('String');
     case 'NumberTypeAnnotation':
       return RCTBridgingTo('Double');
     case 'FloatTypeAnnotation':

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

@@ -11,9 +11,14 @@
 const _require = require('../../Utils'),
   toPascalCase = _require.toPascalCase;
 function getEventEmitterTypeObjCType(eventEmitter) {
-  switch (eventEmitter.typeAnnotation.typeAnnotation.type) {
+  const type = eventEmitter.typeAnnotation.typeAnnotation.type;
+  switch (type) {
     case 'StringTypeAnnotation':
       return 'NSString *_Nonnull';
+    case 'StringLiteralTypeAnnotation':
+      return 'NSString *_Nonnull';
+    case 'StringLiteralUnionTypeAnnotation':
+      return 'NSString *_Nonnull';
     case 'NumberTypeAnnotation':
       return 'NSNumber *_Nonnull';
     case 'BooleanTypeAnnotation':
@@ -24,7 +29,16 @@ function getEventEmitterTypeObjCType(eventEmitter) {
       return 'NSDictionary *';
     case 'ArrayTypeAnnotation':
       return 'NSArray<id<NSObject>> *';
+    case 'DoubleTypeAnnotation':
+    case 'FloatTypeAnnotation':
+    case 'Int32TypeAnnotation':
+    case 'VoidTypeAnnotation':
+      // TODO: Add support for these types
+      throw new Error(
+        `Unsupported eventType for ${eventEmitter.name}. Found: ${eventEmitter.typeAnnotation.typeAnnotation.type}`,
+      );
     default:
+      type;
       throw new Error(
         `Unsupported eventType for ${eventEmitter.name}. Found: ${eventEmitter.typeAnnotation.typeAnnotation.type}`,
       );

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

@@ -15,9 +15,15 @@ const {toPascalCase} = require('../../Utils');
 function getEventEmitterTypeObjCType(
   eventEmitter: NativeModuleEventEmitterShape,
 ): string {
-  switch (eventEmitter.typeAnnotation.typeAnnotation.type) {
+  const type = eventEmitter.typeAnnotation.typeAnnotation.type;
+
+  switch (type) {
     case 'StringTypeAnnotation':
       return 'NSString *_Nonnull';
+    case 'StringLiteralTypeAnnotation':
+      return 'NSString *_Nonnull';
+    case 'StringLiteralUnionTypeAnnotation':
+      return 'NSString *_Nonnull';
     case 'NumberTypeAnnotation':
       return 'NSNumber *_Nonnull';
     case 'BooleanTypeAnnotation':
@@ -28,7 +34,16 @@ function getEventEmitterTypeObjCType(
       return 'NSDictionary *';
     case 'ArrayTypeAnnotation':
       return 'NSArray<id<NSObject>> *';
+    case 'DoubleTypeAnnotation':
+    case 'FloatTypeAnnotation':
+    case 'Int32TypeAnnotation':
+    case 'VoidTypeAnnotation':
+      // TODO: Add support for these types
+      throw new Error(
+        `Unsupported eventType for ${eventEmitter.name}. Found: ${eventEmitter.typeAnnotation.typeAnnotation.type}`,
+      );
     default:
+      (type: empty);
       throw new Error(
         `Unsupported eventType for ${eventEmitter.name}. Found: ${eventEmitter.typeAnnotation.typeAnnotation.type}`,
       );

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

@@ -297,6 +297,10 @@ function getParamObjCType(
       }
     case 'StringTypeAnnotation':
       return notStruct(wrapOptional('NSString *', !nullable));
+    case 'StringLiteralTypeAnnotation':
+      return notStruct(wrapOptional('NSString *', !nullable));
+    case 'StringLiteralUnionTypeAnnotation':
+      return notStruct(wrapOptional('NSString *', !nullable));
     case 'NumberTypeAnnotation':
       return notStruct(isRequired ? 'double' : 'NSNumber *');
     case 'FloatTypeAnnotation':
@@ -367,6 +371,14 @@ 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 'StringLiteralTypeAnnotation':
+      // 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 'FloatTypeAnnotation':
@@ -431,6 +443,10 @@ function getReturnJSType(methodName, nullableTypeAnnotation) {
       return 'NumberKind';
     case 'StringTypeAnnotation':
       return 'StringKind';
+    case 'StringLiteralTypeAnnotation':
+      return 'StringKind';
+    case 'StringLiteralUnionTypeAnnotation':
+      return 'StringKind';
     case 'NumberTypeAnnotation':
       return 'NumberKind';
     case 'FloatTypeAnnotation':

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

@@ -257,6 +257,10 @@ function getParamObjCType(
       }
     case 'StringTypeAnnotation':
       return notStruct(wrapOptional('NSString *', !nullable));
+    case 'StringLiteralTypeAnnotation':
+      return notStruct(wrapOptional('NSString *', !nullable));
+    case 'StringLiteralUnionTypeAnnotation':
+      return notStruct(wrapOptional('NSString *', !nullable));
     case 'NumberTypeAnnotation':
       return notStruct(isRequired ? 'double' : 'NSNumber *');
     case 'FloatTypeAnnotation':
@@ -330,6 +334,14 @@ function getReturnObjCType(
       // TODO: Can NSString * returns not be _Nullable?
       // In the legacy codegen, we don't surround NSSTring * with _Nullable
       return wrapOptional('NSString *', isRequired);
+    case 'StringLiteralTypeAnnotation':
+      // 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 'FloatTypeAnnotation':
@@ -396,6 +408,10 @@ function getReturnJSType(
       return 'NumberKind';
     case 'StringTypeAnnotation':
       return 'StringKind';
+    case 'StringLiteralTypeAnnotation':
+      return 'StringKind';
+    case 'StringLiteralUnionTypeAnnotation':
+      return 'StringKind';
     case 'NumberTypeAnnotation':
       return 'NumberKind';
     case 'FloatTypeAnnotation':

package/lib/generators/modules/__test_fixtures__/fixtures.js

@@ -2306,6 +2306,23 @@ const CXX_ONLY_NATIVE_MODULES = {
                     memberType: 'StringTypeAnnotation',
                   },
                 },
+                {
+                  name: 'y-literal',
+                  optional: false,
+                  typeAnnotation: {
+                    type: 'StringLiteralUnionTypeAnnotation',
+                    types: [
+                      {
+                        type: 'StringLiteralTypeAnnotation',
+                        value: 'foo',
+                      },
+                      {
+                        type: 'StringLiteralTypeAnnotation',
+                        value: 'bar',
+                      },
+                    ],
+                  },
+                },
                 {
                   name: 'z',
                   optional: false,
@@ -2613,6 +2630,71 @@ const UNION_MODULE = {
                     memberType: 'StringTypeAnnotation',
                   },
                 },
+                {
+                  name: 'chooseStringLiteral',
+                  optional: false,
+                  typeAnnotation: {
+                    type: 'StringLiteralUnionTypeAnnotation',
+                    types: [
+                      {
+                        type: 'StringLiteralTypeAnnotation',
+                        value: 'foo',
+                      },
+                      {
+                        type: 'StringLiteralTypeAnnotation',
+                        value: 'bar',
+                      },
+                    ],
+                  },
+                },
+              ],
+            },
+          },
+        ],
+      },
+      moduleName: 'SampleTurboModule',
+    },
+  },
+};
+const STRING_LITERALS = {
+  modules: {
+    NativeSampleTurboModule: {
+      type: 'NativeModule',
+      aliasMap: {},
+      enumMap: {},
+      spec: {
+        eventEmitters: [
+          {
+            name: 'literalEvent',
+            optional: false,
+            typeAnnotation: {
+              type: 'EventEmitterTypeAnnotation',
+              typeAnnotation: {
+                type: 'StringLiteralTypeAnnotation',
+                value: 'A String Literal Event',
+              },
+            },
+          },
+        ],
+        methods: [
+          {
+            name: 'getStringLiteral',
+            optional: false,
+            typeAnnotation: {
+              type: 'FunctionTypeAnnotation',
+              returnTypeAnnotation: {
+                type: 'StringLiteralTypeAnnotation',
+                value: 'A String Literal Return',
+              },
+              params: [
+                {
+                  name: 'literalParam',
+                  optional: false,
+                  typeAnnotation: {
+                    type: 'StringLiteralTypeAnnotation',
+                    value: 'A String Literal Param',
+                  },
+                },
               ],
             },
           },
@@ -2633,4 +2715,5 @@ module.exports = {
   cxx_only_native_modules: CXX_ONLY_NATIVE_MODULES,
   SampleWithUppercaseName: SAMPLE_WITH_UPPERCASE_NAME,
   union_module: UNION_MODULE,
+  string_literals: STRING_LITERALS,
 };

package/lib/generators/modules/__test_fixtures__/fixtures.js.flow

@@ -2316,6 +2316,23 @@ const CXX_ONLY_NATIVE_MODULES: SchemaType = {
                     memberType: 'StringTypeAnnotation',
                   },
                 },
+                {
+                  name: 'y-literal',
+                  optional: false,
+                  typeAnnotation: {
+                    type: 'StringLiteralUnionTypeAnnotation',
+                    types: [
+                      {
+                        type: 'StringLiteralTypeAnnotation',
+                        value: 'foo',
+                      },
+                      {
+                        type: 'StringLiteralTypeAnnotation',
+                        value: 'bar',
+                      },
+                    ],
+                  },
+                },
                 {
                   name: 'z',
                   optional: false,
@@ -2626,6 +2643,72 @@ const UNION_MODULE: SchemaType = {
                     memberType: 'StringTypeAnnotation',
                   },
                 },
+                {
+                  name: 'chooseStringLiteral',
+                  optional: false,
+                  typeAnnotation: {
+                    type: 'StringLiteralUnionTypeAnnotation',
+                    types: [
+                      {
+                        type: 'StringLiteralTypeAnnotation',
+                        value: 'foo',
+                      },
+                      {
+                        type: 'StringLiteralTypeAnnotation',
+                        value: 'bar',
+                      },
+                    ],
+                  },
+                },
+              ],
+            },
+          },
+        ],
+      },
+      moduleName: 'SampleTurboModule',
+    },
+  },
+};
+
+const STRING_LITERALS = {
+  modules: {
+    NativeSampleTurboModule: {
+      type: 'NativeModule',
+      aliasMap: {},
+      enumMap: {},
+      spec: {
+        eventEmitters: [
+          {
+            name: 'literalEvent',
+            optional: false,
+            typeAnnotation: {
+              type: 'EventEmitterTypeAnnotation',
+              typeAnnotation: {
+                type: 'StringLiteralTypeAnnotation',
+                value: 'A String Literal Event',
+              },
+            },
+          },
+        ],
+        methods: [
+          {
+            name: 'getStringLiteral',
+            optional: false,
+            typeAnnotation: {
+              type: 'FunctionTypeAnnotation',
+              returnTypeAnnotation: {
+                type: 'StringLiteralTypeAnnotation',
+                value: 'A String Literal Return',
+              },
+              params: [
+                {
+                  name: 'literalParam',
+                  optional: false,
+                  typeAnnotation: {
+                    type: 'StringLiteralTypeAnnotation',
+                    value: 'A String Literal Param',
+                  },
+                },
               ],
             },
           },
@@ -2647,4 +2730,5 @@ module.exports = {
   cxx_only_native_modules: CXX_ONLY_NATIVE_MODULES,
   SampleWithUppercaseName: SAMPLE_WITH_UPPERCASE_NAME,
   union_module: UNION_MODULE,
+  string_literals: STRING_LITERALS,
 };

package/lib/parsers/flow/modules/__test_fixtures__/fixtures.js

@@ -125,6 +125,7 @@ export interface Spec extends TurboModule {
   +passNumber: (arg: number) => void;
   +passString: (arg: string) => void;
   +passStringish: (arg: Stringish) => void;
+  +passStringLiteral: (arg: 'A String Literal') => void;
 }
 
 export default TurboModuleRegistry.getEnforcing<Spec>('SampleTurboModule');

package/lib/parsers/flow/modules/__test_fixtures__/fixtures.js.flow

@@ -128,6 +128,7 @@ export interface Spec extends TurboModule {
   +passNumber: (arg: number) => void;
   +passString: (arg: string) => void;
   +passStringish: (arg: Stringish) => void;
+  +passStringLiteral: (arg: 'A String Literal') => void;
 }
 
 export default TurboModuleRegistry.getEnforcing<Spec>('SampleTurboModule');

package/lib/parsers/flow/modules/index.js

@@ -301,10 +301,9 @@ function translateTypeAnnotation(
       return emitUnion(nullable, hasteModuleName, typeAnnotation, parser);
     }
     case 'StringLiteralTypeAnnotation': {
-      // 'a' is a special case for 'a' | 'b' but the type name is different
       return wrapNullable(nullable, {
-        type: 'UnionTypeAnnotation',
-        memberType: 'StringTypeAnnotation',
+        type: 'StringLiteralTypeAnnotation',
+        value: typeAnnotation.value,
       });
     }
     case 'EnumStringBody':

package/lib/parsers/flow/modules/index.js.flow

@@ -244,10 +244,9 @@ function translateTypeAnnotation(
       return emitUnion(nullable, hasteModuleName, typeAnnotation, parser);
     }
     case 'StringLiteralTypeAnnotation': {
-      // 'a' is a special case for 'a' | 'b' but the type name is different
       return wrapNullable(nullable, {
-        type: 'UnionTypeAnnotation',
-        memberType: 'StringTypeAnnotation',
+        type: 'StringLiteralTypeAnnotation',
+        value: typeAnnotation.value,
       });
     }
     case 'EnumStringBody':

package/lib/parsers/flow/parser.js

@@ -124,6 +124,9 @@ class FlowParser {
     };
     return [...new Set(membersTypes.map(remapLiteral))];
   }
+  getStringLiteralUnionTypeAnnotationStringLiterals(membersTypes) {
+    return membersTypes.map(item => item.value);
+  }
   parseFile(filename) {
     const contents = fs.readFileSync(filename, 'utf8');
     return this.parseString(contents, filename);

package/lib/parsers/flow/parser.js.flow

@@ -117,6 +117,12 @@ class FlowParser implements Parser {
     return [...new Set(membersTypes.map(remapLiteral))];
   }
 
+  getStringLiteralUnionTypeAnnotationStringLiterals(
+    membersTypes: $FlowFixMe[],
+  ): string[] {
+    return membersTypes.map((item: $FlowFixMe) => item.value);
+  }
+
   parseFile(filename: string): SchemaType {
     const contents = fs.readFileSync(filename, 'utf8');
 

package/lib/parsers/parser.js.flow

@@ -146,6 +146,14 @@ export interface Parser {
   remapUnionTypeAnnotationMemberNames(
     types: $FlowFixMe,
   ): UnionTypeAnnotationMemberType[];
+  /**
+   * Given a union annotation members types, it returns an array of string literals.
+   * @parameter membersTypes: union annotation members types
+   * @returns: an array of string literals.
+   */
+  getStringLiteralUnionTypeAnnotationStringLiterals(
+    types: $FlowFixMe,
+  ): string[];
   /**
    * Given the name of a file, it returns a Schema.
    * @parameter filename: the name of the file.

package/lib/parsers/parserMock.js

@@ -115,6 +115,9 @@ export class MockedParser {
   remapUnionTypeAnnotationMemberNames(membersTypes) {
     return [];
   }
+  getStringLiteralUnionTypeAnnotationStringLiterals(membersTypes) {
+    return [];
+  }
   parseFile(filename) {
     return schemaMock;
   }

package/lib/parsers/parserMock.js.flow

@@ -109,6 +109,12 @@ export class MockedParser implements Parser {
     return [];
   }
 
+  getStringLiteralUnionTypeAnnotationStringLiterals(
+    membersTypes: $FlowFixMe[],
+  ): string[] {
+    return [];
+  }
+
   parseFile(filename: string): SchemaType {
     return schemaMock;
   }

package/lib/parsers/parsers-primitives.js

@@ -193,6 +193,12 @@ function emitString(nullable) {
     type: 'StringTypeAnnotation',
   });
 }
+function emitStringLiteral(nullable, value) {
+  return wrapNullable(nullable, {
+    type: 'StringLiteralTypeAnnotation',
+    value,
+  });
+}
 function emitStringProp(name, optional) {
   return {
     name,
@@ -379,6 +385,11 @@ function emitFloatProp(name, optional) {
   };
 }
 function emitUnion(nullable, hasteModuleName, typeAnnotation, parser) {
+  // Get all the literals by type
+  // Verify they are all the same
+  // If string, persist as StringLiteralUnionType
+  // If number, persist as NumberTypeAnnotation (TODO: Number literal)
+
   const unionTypes = parser.remapUnionTypeAnnotationMemberNames(
     typeAnnotation.types,
   );
@@ -391,11 +402,38 @@ function emitUnion(nullable, hasteModuleName, typeAnnotation, parser) {
       unionTypes,
     );
   }
+  if (unionTypes[0] === 'StringTypeAnnotation') {
+    // Reprocess as a string literal union
+    return emitStringLiteralUnion(
+      nullable,
+      hasteModuleName,
+      typeAnnotation,
+      parser,
+    );
+  }
   return wrapNullable(nullable, {
     type: 'UnionTypeAnnotation',
     memberType: unionTypes[0],
   });
 }
+function emitStringLiteralUnion(
+  nullable,
+  hasteModuleName,
+  typeAnnotation,
+  parser,
+) {
+  const stringLiterals =
+    parser.getStringLiteralUnionTypeAnnotationStringLiterals(
+      typeAnnotation.types,
+    );
+  return wrapNullable(nullable, {
+    type: 'StringLiteralUnionTypeAnnotation',
+    types: stringLiterals.map(stringLiteral => ({
+      type: 'StringLiteralTypeAnnotation',
+      value: stringLiteral,
+    })),
+  });
+}
 function translateArrayTypeAnnotation(
   hasteModuleName,
   types,
@@ -666,6 +704,7 @@ module.exports = {
   emitString,
   emitStringish,
   emitStringProp,
+  emitStringLiteral,
   emitMixed,
   emitUnion,
   emitPartial,

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

@@ -34,6 +34,8 @@ import type {
   ObjectTypeAnnotation,
   ReservedTypeAnnotation,
   StringTypeAnnotation,
+  StringLiteralTypeAnnotation,
+  StringLiteralUnionTypeAnnotation,
   VoidTypeAnnotation,
 } from '../CodegenSchema';
 import type {Parser} from './parser';
@@ -174,6 +176,16 @@ function emitString(nullable: boolean): Nullable<StringTypeAnnotation> {
   });
 }
 
+function emitStringLiteral(
+  nullable: boolean,
+  value: string,
+): Nullable<StringLiteralTypeAnnotation> {
+  return wrapNullable(nullable, {
+    type: 'StringLiteralTypeAnnotation',
+    value,
+  });
+}
+
 function emitStringProp(
   name: string,
   optional: boolean,
@@ -398,7 +410,14 @@ function emitUnion(
   hasteModuleName: string,
   typeAnnotation: $FlowFixMe,
   parser: Parser,
-): Nullable<NativeModuleUnionTypeAnnotation> {
+): Nullable<
+  NativeModuleUnionTypeAnnotation | StringLiteralUnionTypeAnnotation,
+> {
+  // Get all the literals by type
+  // Verify they are all the same
+  // If string, persist as StringLiteralUnionType
+  // If number, persist as NumberTypeAnnotation (TODO: Number literal)
+
   const unionTypes = parser.remapUnionTypeAnnotationMemberNames(
     typeAnnotation.types,
   );
@@ -412,12 +431,42 @@ function emitUnion(
     );
   }
 
+  if (unionTypes[0] === 'StringTypeAnnotation') {
+    // Reprocess as a string literal union
+    return emitStringLiteralUnion(
+      nullable,
+      hasteModuleName,
+      typeAnnotation,
+      parser,
+    );
+  }
+
   return wrapNullable(nullable, {
     type: 'UnionTypeAnnotation',
     memberType: unionTypes[0],
   });
 }
 
+function emitStringLiteralUnion(
+  nullable: boolean,
+  hasteModuleName: string,
+  typeAnnotation: $FlowFixMe,
+  parser: Parser,
+): Nullable<StringLiteralUnionTypeAnnotation> {
+  const stringLiterals =
+    parser.getStringLiteralUnionTypeAnnotationStringLiterals(
+      typeAnnotation.types,
+    );
+
+  return wrapNullable(nullable, {
+    type: 'StringLiteralUnionTypeAnnotation',
+    types: stringLiterals.map(stringLiteral => ({
+      type: 'StringLiteralTypeAnnotation',
+      value: stringLiteral,
+    })),
+  });
+}
+
 function translateArrayTypeAnnotation(
   hasteModuleName: string,
   types: TypeDeclarationMap,
@@ -722,6 +771,7 @@ module.exports = {
   emitString,
   emitStringish,
   emitStringProp,
+  emitStringLiteral,
   emitMixed,
   emitUnion,
   emitPartial,

package/lib/parsers/typescript/modules/__test_fixtures__/fixtures.js

@@ -112,6 +112,7 @@ export interface Spec extends TurboModule {
   readonly passNumber: (arg: number) => void;
   readonly passString: (arg: string) => void;
   readonly passStringish: (arg: Stringish) => void;
+  readonly passStringLiteral: (arg: 'A String Literal') => void;
 }
 
 export default TurboModuleRegistry.getEnforcing<Spec>('SampleTurboModule');

package/lib/parsers/typescript/modules/__test_fixtures__/fixtures.js.flow

@@ -115,6 +115,7 @@ export interface Spec extends TurboModule {
   readonly passNumber: (arg: number) => void;
   readonly passString: (arg: string) => void;
   readonly passStringish: (arg: Stringish) => void;
+  readonly passStringLiteral: (arg: 'A String Literal') => void;
 }
 
 export default TurboModuleRegistry.getEnforcing<Spec>('SampleTurboModule');

package/lib/parsers/typescript/modules/index.js

@@ -28,6 +28,7 @@ const _require3 = require('../../parsers-primitives'),
   emitPromise = _require3.emitPromise,
   emitRootTag = _require3.emitRootTag,
   emitUnion = _require3.emitUnion,
+  emitStringLiteral = _require3.emitStringLiteral,
   translateArrayTypeAnnotation = _require3.translateArrayTypeAnnotation,
   typeAliasResolution = _require3.typeAliasResolution,
   typeEnumResolution = _require3.typeEnumResolution;
@@ -387,6 +388,21 @@ function translateTypeAnnotation(
     case 'TSUnionType': {
       return emitUnion(nullable, hasteModuleName, typeAnnotation, parser);
     }
+    case 'TSLiteralType': {
+      const literal = typeAnnotation.literal;
+      switch (literal.type) {
+        case 'StringLiteral': {
+          return emitStringLiteral(nullable, literal.value);
+        }
+        default: {
+          throw new UnsupportedTypeAnnotationParserError(
+            hasteModuleName,
+            typeAnnotation,
+            parser.language(),
+          );
+        }
+      }
+    }
     default: {
       const commonType = emitCommonTypes(
         hasteModuleName,

package/lib/parsers/typescript/modules/index.js.flow

@@ -40,6 +40,7 @@ const {
   emitPromise,
   emitRootTag,
   emitUnion,
+  emitStringLiteral,
   translateArrayTypeAnnotation,
   typeAliasResolution,
   typeEnumResolution,
@@ -396,6 +397,21 @@ function translateTypeAnnotation(
     case 'TSUnionType': {
       return emitUnion(nullable, hasteModuleName, typeAnnotation, parser);
     }
+    case 'TSLiteralType': {
+      const literal = typeAnnotation.literal;
+      switch (literal.type) {
+        case 'StringLiteral': {
+          return emitStringLiteral(nullable, literal.value);
+        }
+        default: {
+          throw new UnsupportedTypeAnnotationParserError(
+            hasteModuleName,
+            typeAnnotation,
+            parser.language(),
+          );
+        }
+      }
+    }
     default: {
       const commonType = emitCommonTypes(
         hasteModuleName,

package/lib/parsers/typescript/parser.js

@@ -126,6 +126,9 @@ class TypeScriptParser {
     };
     return [...new Set(membersTypes.map(remapLiteral))];
   }
+  getStringLiteralUnionTypeAnnotationStringLiterals(membersTypes) {
+    return membersTypes.map(item => item.literal.value);
+  }
   parseFile(filename) {
     const contents = fs.readFileSync(filename, 'utf8');
     return this.parseString(contents, filename);

package/lib/parsers/typescript/parser.js.flow

@@ -117,6 +117,12 @@ class TypeScriptParser implements Parser {
     return [...new Set(membersTypes.map(remapLiteral))];
   }
 
+  getStringLiteralUnionTypeAnnotationStringLiterals(
+    membersTypes: $FlowFixMe[],
+  ): string[] {
+    return membersTypes.map((item: $FlowFixMe) => item.literal.value);
+  }
+
   parseFile(filename: string): SchemaType {
     const contents = fs.readFileSync(filename, 'utf8');
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native/codegen",
-  "version": "0.77.0-nightly-20241007-d0912ed06",
+  "version": "0.77.0-nightly-20241009-e4814b0d6",
   "description": "Code generation tools for React Native",
   "license": "MIT",
   "repository": {