@react-native/codegen 0.75.0-nightly-20240611-5b3a32142 → 0.75.0-nightly-20240612-fd618819c

package/lib/CodegenSchema.d.ts

@@ -58,6 +58,11 @@ export interface MixedTypeAnnotation {
   readonly type: 'MixedTypeAnnotation';
 }
 
+export interface EventEmitterTypeAnnotation {
+  readonly type: 'EventEmitterTypeAnnotation';
+  readonly typeAnnotation: NativeModuleBaseTypeAnnotation;
+}
+
 export interface FunctionTypeAnnotation<P, R> {
   readonly type: 'FunctionTypeAnnotation';
   readonly params: readonly NamedShape<P>[];
@@ -241,6 +246,7 @@ export interface NativeModuleSchema {
 }
 
 export interface NativeModuleSpec {
+  readonly eventEmitters: readonly NativeModuleEventEmitterShape[];
   readonly properties: readonly NativeModulePropertyShape[];
 }
 
@@ -248,6 +254,8 @@ export type NativeModulePropertyShape = NamedShape<
   Nullable<NativeModuleFunctionTypeAnnotation>
 >;
 
+export type NativeModuleEventEmitterShape = NamedShape<EventEmitterTypeAnnotation>;
+
 export interface NativeModuleEnumMap {
   readonly [enumName: string]: NativeModuleEnumDeclarationWithMembers;
 }

package/lib/CodegenSchema.js.flow

@@ -61,6 +61,11 @@ export type MixedTypeAnnotation = $ReadOnly<{
   type: 'MixedTypeAnnotation',
 }>;
 
+type EventEmitterTypeAnnotation = $ReadOnly<{
+  type: 'EventEmitterTypeAnnotation',
+  typeAnnotation: NativeModuleBaseTypeAnnotation,
+}>;
+
 type FunctionTypeAnnotation<+P, +R> = $ReadOnly<{
   type: 'FunctionTypeAnnotation',
   params: $ReadOnlyArray<NamedShape<P>>,
@@ -242,9 +247,13 @@ export type NativeModuleSchema = $ReadOnly<{
 }>;
 
 type NativeModuleSpec = $ReadOnly<{
+  eventEmitters: $ReadOnlyArray<NativeModuleEventEmitterShape>,
   properties: $ReadOnlyArray<NativeModulePropertyShape>,
 }>;
 
+export type NativeModuleEventEmitterShape =
+  NamedShape<EventEmitterTypeAnnotation>;
+
 export type NativeModulePropertyShape = NamedShape<
   Nullable<NativeModuleFunctionTypeAnnotation>,
 >;

package/lib/generators/__test_fixtures__/fixtures.js

@@ -42,6 +42,7 @@ const SCHEMA_WITH_TM_AND_FC = {
       aliasMap: {},
       enumMap: {},
       spec: {
+        eventEmitters: [],
         properties: [
           {
             name: 'add',

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

@@ -44,6 +44,7 @@ const SCHEMA_WITH_TM_AND_FC: SchemaType = {
       aliasMap: {},
       enumMap: {},
       spec: {
+        eventEmitters: [],
         properties: [
           {
             name: 'add',

package/lib/generators/modules/GenerateModuleH.js

@@ -84,6 +84,7 @@ const _require2 = require('../TypeUtils/Cxx'),
   wrapOptional = _require2.wrapOptional;
 const _require3 = require('../Utils'),
   getEnumName = _require3.getEnumName,
+  toPascalCase = _require3.toPascalCase,
   toSafeCppString = _require3.toSafeCppString;
 const _require4 = require('../Utils'),
   indent = _require4.indent;
@@ -111,6 +112,7 @@ public:
 const ModuleSpecClassDeclarationTemplate = ({
   hasteModuleName,
   moduleName,
+  moduleEventEmitters,
   moduleProperties,
 }) => {
   return `template <typename T>
@@ -126,16 +128,20 @@ protected:
   ${hasteModuleName}CxxSpec(std::shared_ptr<CallInvoker> jsInvoker)
     : TurboModule(std::string{${hasteModuleName}CxxSpec::kModuleName}, jsInvoker),
       delegate_(reinterpret_cast<T*>(this), jsInvoker) {}
+${moduleEventEmitters.map(e => e.emitFunction).join('\n')}
 
 private:
   class Delegate : public ${hasteModuleName}CxxSpecJSI {
   public:
     Delegate(T *instance, std::shared_ptr<CallInvoker> jsInvoker) :
-      ${hasteModuleName}CxxSpecJSI(std::move(jsInvoker)), instance_(instance) {}
+      ${hasteModuleName}CxxSpecJSI(std::move(jsInvoker)), instance_(instance) {
+${moduleEventEmitters.map(e => e.registerEventEmitter).join('\n')}
+    }
 
     ${indent(moduleProperties.join('\n'), 4)}
 
   private:
+    friend class ${hasteModuleName}CxxSpec;
     T *instance_;
   };
 
@@ -509,6 +515,61 @@ function translatePropertyToCpp(
       rt, &T::${prop.name}, jsInvoker_, ${['instance_', ...params].join(', ')});
 }`;
 }
+function translateEventEmitterToCpp(
+  moduleName,
+  eventEmitter,
+  resolveAlias,
+  enumMap,
+) {
+  const isVoidTypeAnnotation =
+    eventEmitter.typeAnnotation.typeAnnotation.type === 'VoidTypeAnnotation';
+  const templateName = `${toPascalCase(eventEmitter.name)}Type`;
+  const jsiType = translatePrimitiveJSTypeToCpp(
+    moduleName,
+    null,
+    eventEmitter.typeAnnotation.typeAnnotation,
+    false,
+    typeName =>
+      `Unsupported type for eventEmitter "${eventEmitter.name}" in ${moduleName}. Found: ${typeName}`,
+    resolveAlias,
+    enumMap,
+  );
+  const isArray = jsiType === 'jsi::Array';
+  return {
+    isVoidTypeAnnotation: isVoidTypeAnnotation,
+    templateName: isVoidTypeAnnotation ? `/*${templateName}*/` : templateName,
+    registerEventEmitter: `      eventEmitterMap_["${
+      eventEmitter.name
+    }"] = std::make_shared<AsyncEventEmitter<${
+      isVoidTypeAnnotation ? '' : 'jsi::Value'
+    }>>();`,
+    emitFunction: `
+  ${
+    isVoidTypeAnnotation ? '' : `template <typename ${templateName}> `
+  }void emit${toPascalCase(eventEmitter.name)}(${
+      isVoidTypeAnnotation
+        ? ''
+        : `${isArray ? `std::vector<${templateName}>` : templateName} value`
+    }) {${
+      isVoidTypeAnnotation
+        ? ''
+        : `
+    static_assert(bridging::supportsFromJs<${
+      isArray ? `std::vector<${templateName}>` : templateName
+    }, ${jsiType}>, "value cannnot be converted to ${jsiType}");`
+    }
+    std::static_pointer_cast<AsyncEventEmitter<${
+      isVoidTypeAnnotation ? '' : 'jsi::Value'
+    }>>(delegate_.eventEmitterMap_["${eventEmitter.name}"])->emit(${
+      isVoidTypeAnnotation
+        ? ''
+        : `[jsInvoker = jsInvoker_, eventValue = value](jsi::Runtime& rt) -> jsi::Value {
+      return bridging::toJs(rt, eventValue, jsInvoker);
+    }`
+    });
+  }`,
+  };
+}
 module.exports = {
   generate(
     libraryName,
@@ -522,7 +583,7 @@ module.exports = {
       const _nativeModules$hasteM = nativeModules[hasteModuleName],
         aliasMap = _nativeModules$hasteM.aliasMap,
         enumMap = _nativeModules$hasteM.enumMap,
-        properties = _nativeModules$hasteM.spec.properties,
+        spec = _nativeModules$hasteM.spec,
         moduleName = _nativeModules$hasteM.moduleName;
       const resolveAlias = createAliasResolver(aliasMap);
       const structs = createStructsString(
@@ -535,7 +596,7 @@ module.exports = {
       return [
         ModuleClassDeclarationTemplate({
           hasteModuleName,
-          moduleProperties: properties.map(prop =>
+          moduleProperties: spec.properties.map(prop =>
             translatePropertyToCpp(
               hasteModuleName,
               prop,
@@ -550,7 +611,15 @@ module.exports = {
         ModuleSpecClassDeclarationTemplate({
           hasteModuleName,
           moduleName,
-          moduleProperties: properties.map(prop =>
+          moduleEventEmitters: spec.eventEmitters.map(eventEmitter =>
+            translateEventEmitterToCpp(
+              moduleName,
+              eventEmitter,
+              resolveAlias,
+              enumMap,
+            ),
+          ),
+          moduleProperties: spec.properties.map(prop =>
             translatePropertyToCpp(
               hasteModuleName,
               prop,

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

@@ -18,6 +18,7 @@ import type {
   NativeModuleEnumMap,
   NativeModuleEnumMembers,
   NativeModuleEnumMemberType,
+  NativeModuleEventEmitterShape,
   NativeModuleFunctionTypeAnnotation,
   NativeModulePropertyShape,
   NativeModuleTypeAnnotation,
@@ -28,7 +29,7 @@ import type {AliasResolver} from './Utils';
 
 const {unwrapNullable} = require('../../parsers/parsers-commons');
 const {wrapOptional} = require('../TypeUtils/Cxx');
-const {getEnumName, toSafeCppString} = require('../Utils');
+const {getEnumName, toPascalCase, toSafeCppString} = require('../Utils');
 const {indent} = require('../Utils');
 const {
   createAliasResolver,
@@ -64,10 +65,12 @@ public:
 const ModuleSpecClassDeclarationTemplate = ({
   hasteModuleName,
   moduleName,
+  moduleEventEmitters,
   moduleProperties,
 }: $ReadOnly<{
   hasteModuleName: string,
   moduleName: string,
+  moduleEventEmitters: EventEmitterCpp[],
   moduleProperties: string[],
 }>) => {
   return `template <typename T>
@@ -83,16 +86,20 @@ protected:
   ${hasteModuleName}CxxSpec(std::shared_ptr<CallInvoker> jsInvoker)
     : TurboModule(std::string{${hasteModuleName}CxxSpec::kModuleName}, jsInvoker),
       delegate_(reinterpret_cast<T*>(this), jsInvoker) {}
+${moduleEventEmitters.map(e => e.emitFunction).join('\n')}
 
 private:
   class Delegate : public ${hasteModuleName}CxxSpecJSI {
   public:
     Delegate(T *instance, std::shared_ptr<CallInvoker> jsInvoker) :
-      ${hasteModuleName}CxxSpecJSI(std::move(jsInvoker)), instance_(instance) {}
+      ${hasteModuleName}CxxSpecJSI(std::move(jsInvoker)), instance_(instance) {
+${moduleEventEmitters.map(e => e.registerEventEmitter).join('\n')}
+    }
 
     ${indent(moduleProperties.join('\n'), 4)}
 
   private:
+    friend class ${hasteModuleName}CxxSpec;
     T *instance_;
   };
 
@@ -460,7 +467,7 @@ function translatePropertyToCpp(
   resolveAlias: AliasResolver,
   enumMap: NativeModuleEnumMap,
   abstract: boolean = false,
-) {
+): string {
   const [propTypeAnnotation] =
     unwrapNullable<NativeModuleFunctionTypeAnnotation>(prop.typeAnnotation);
 
@@ -511,6 +518,69 @@ function translatePropertyToCpp(
 }`;
 }
 
+type EventEmitterCpp = {
+  isVoidTypeAnnotation: boolean,
+  templateName: string,
+  registerEventEmitter: string,
+  emitFunction: string,
+};
+
+function translateEventEmitterToCpp(
+  moduleName: string,
+  eventEmitter: NativeModuleEventEmitterShape,
+  resolveAlias: AliasResolver,
+  enumMap: NativeModuleEnumMap,
+): EventEmitterCpp {
+  const isVoidTypeAnnotation =
+    eventEmitter.typeAnnotation.typeAnnotation.type === 'VoidTypeAnnotation';
+  const templateName = `${toPascalCase(eventEmitter.name)}Type`;
+  const jsiType = translatePrimitiveJSTypeToCpp(
+    moduleName,
+    null,
+    eventEmitter.typeAnnotation.typeAnnotation,
+    false,
+    typeName =>
+      `Unsupported type for eventEmitter "${eventEmitter.name}" in ${moduleName}. Found: ${typeName}`,
+    resolveAlias,
+    enumMap,
+  );
+  const isArray = jsiType === 'jsi::Array';
+  return {
+    isVoidTypeAnnotation: isVoidTypeAnnotation,
+    templateName: isVoidTypeAnnotation ? `/*${templateName}*/` : templateName,
+    registerEventEmitter: `      eventEmitterMap_["${
+      eventEmitter.name
+    }"] = std::make_shared<AsyncEventEmitter<${
+      isVoidTypeAnnotation ? '' : 'jsi::Value'
+    }>>();`,
+    emitFunction: `
+  ${
+    isVoidTypeAnnotation ? '' : `template <typename ${templateName}> `
+  }void emit${toPascalCase(eventEmitter.name)}(${
+      isVoidTypeAnnotation
+        ? ''
+        : `${isArray ? `std::vector<${templateName}>` : templateName} value`
+    }) {${
+      isVoidTypeAnnotation
+        ? ''
+        : `
+    static_assert(bridging::supportsFromJs<${
+      isArray ? `std::vector<${templateName}>` : templateName
+    }, ${jsiType}>, "value cannnot be converted to ${jsiType}");`
+    }
+    std::static_pointer_cast<AsyncEventEmitter<${
+      isVoidTypeAnnotation ? '' : 'jsi::Value'
+    }>>(delegate_.eventEmitterMap_["${eventEmitter.name}"])->emit(${
+      isVoidTypeAnnotation
+        ? ''
+        : `[jsInvoker = jsInvoker_, eventValue = value](jsi::Runtime& rt) -> jsi::Value {
+      return bridging::toJs(rt, eventValue, jsInvoker);
+    }`
+    });
+  }`,
+  };
+}
+
 module.exports = {
   generate(
     libraryName: string,
@@ -522,12 +592,8 @@ module.exports = {
     const nativeModules = getModules(schema);
 
     const modules = Object.keys(nativeModules).flatMap(hasteModuleName => {
-      const {
-        aliasMap,
-        enumMap,
-        spec: {properties},
-        moduleName,
-      } = nativeModules[hasteModuleName];
+      const {aliasMap, enumMap, spec, moduleName} =
+        nativeModules[hasteModuleName];
       const resolveAlias = createAliasResolver(aliasMap);
       const structs = createStructsString(
         hasteModuleName,
@@ -540,7 +606,7 @@ module.exports = {
       return [
         ModuleClassDeclarationTemplate({
           hasteModuleName,
-          moduleProperties: properties.map(prop =>
+          moduleProperties: spec.properties.map(prop =>
             translatePropertyToCpp(
               hasteModuleName,
               prop,
@@ -555,7 +621,15 @@ module.exports = {
         ModuleSpecClassDeclarationTemplate({
           hasteModuleName,
           moduleName,
-          moduleProperties: properties.map(prop =>
+          moduleEventEmitters: spec.eventEmitters.map(eventEmitter =>
+            translateEventEmitterToCpp(
+              moduleName,
+              eventEmitter,
+              resolveAlias,
+              enumMap,
+            ),
+          ),
+          moduleProperties: spec.properties.map(prop =>
             translatePropertyToCpp(
               hasteModuleName,
               prop,

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

@@ -17,6 +17,7 @@ const EMPTY_NATIVE_MODULES = {
       aliasMap: {},
       enumMap: {},
       spec: {
+        eventEmitters: [],
         properties: [],
       },
       moduleName: 'SampleTurboModule',
@@ -80,6 +81,7 @@ const SIMPLE_NATIVE_MODULES = {
         },
       },
       spec: {
+        eventEmitters: [],
         properties: [
           {
             name: 'getConstants',
@@ -407,6 +409,7 @@ const TWO_MODULES_DIFFERENT_FILES = {
       aliasMap: {},
       enumMap: {},
       spec: {
+        eventEmitters: [],
         properties: [
           {
             name: 'voidFunc',
@@ -428,6 +431,7 @@ const TWO_MODULES_DIFFERENT_FILES = {
       aliasMap: {},
       enumMap: {},
       spec: {
+        eventEmitters: [],
         properties: [
           {
             name: 'getConstants',
@@ -465,6 +469,7 @@ const COMPLEX_OBJECTS = {
       aliasMap: {},
       enumMap: {},
       spec: {
+        eventEmitters: [],
         properties: [
           {
             name: 'difficult',
@@ -920,6 +925,7 @@ const NATIVE_MODULES_WITH_TYPE_ALIASES = {
       },
       enumMap: {},
       spec: {
+        eventEmitters: [],
         properties: [
           {
             name: 'getConstants',
@@ -1204,6 +1210,7 @@ const REAL_MODULE_EXAMPLE = {
       },
       enumMap: {},
       spec: {
+        eventEmitters: [],
         properties: [
           {
             name: 'getConstants',
@@ -1400,6 +1407,7 @@ const REAL_MODULE_EXAMPLE = {
       },
       enumMap: {},
       spec: {
+        eventEmitters: [],
         properties: [
           {
             name: 'reportFatalException',
@@ -1820,6 +1828,7 @@ const CXX_ONLY_NATIVE_MODULES = {
         },
       },
       spec: {
+        eventEmitters: [],
         properties: [
           {
             name: 'getArray',
@@ -2403,6 +2412,7 @@ const SAMPLE_WITH_UPPERCASE_NAME = {
       enumMap: {},
       aliasMap: {},
       spec: {
+        eventEmitters: [],
         properties: [],
       },
       moduleName: 'SampleTurboModule',

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

@@ -19,6 +19,7 @@ const EMPTY_NATIVE_MODULES: SchemaType = {
       aliasMap: {},
       enumMap: {},
       spec: {
+        eventEmitters: [],
         properties: [],
       },
       moduleName: 'SampleTurboModule',
@@ -83,6 +84,7 @@ const SIMPLE_NATIVE_MODULES: SchemaType = {
         },
       },
       spec: {
+        eventEmitters: [],
         properties: [
           {
             name: 'getConstants',
@@ -412,6 +414,7 @@ const TWO_MODULES_DIFFERENT_FILES: SchemaType = {
       aliasMap: {},
       enumMap: {},
       spec: {
+        eventEmitters: [],
         properties: [
           {
             name: 'voidFunc',
@@ -433,6 +436,7 @@ const TWO_MODULES_DIFFERENT_FILES: SchemaType = {
       aliasMap: {},
       enumMap: {},
       spec: {
+        eventEmitters: [],
         properties: [
           {
             name: 'getConstants',
@@ -471,6 +475,7 @@ const COMPLEX_OBJECTS: SchemaType = {
       aliasMap: {},
       enumMap: {},
       spec: {
+        eventEmitters: [],
         properties: [
           {
             name: 'difficult',
@@ -927,6 +932,7 @@ const NATIVE_MODULES_WITH_TYPE_ALIASES: SchemaType = {
       },
       enumMap: {},
       spec: {
+        eventEmitters: [],
         properties: [
           {
             name: 'getConstants',
@@ -1212,6 +1218,7 @@ const REAL_MODULE_EXAMPLE: SchemaType = {
       },
       enumMap: {},
       spec: {
+        eventEmitters: [],
         properties: [
           {
             name: 'getConstants',
@@ -1408,6 +1415,7 @@ const REAL_MODULE_EXAMPLE: SchemaType = {
       },
       enumMap: {},
       spec: {
+        eventEmitters: [],
         properties: [
           {
             name: 'reportFatalException',
@@ -1829,6 +1837,7 @@ const CXX_ONLY_NATIVE_MODULES: SchemaType = {
         },
       },
       spec: {
+        eventEmitters: [],
         properties: [
           {
             name: 'getArray',
@@ -2414,6 +2423,7 @@ const SAMPLE_WITH_UPPERCASE_NAME: SchemaType = {
       enumMap: {},
       aliasMap: {},
       spec: {
+        eventEmitters: [],
         properties: [],
       },
       moduleName: 'SampleTurboModule',

package/lib/parsers/error-utils.js

@@ -31,6 +31,10 @@ const _require = require('./errors'),
     _require.UnsupportedFunctionParamTypeAnnotationParserError,
   UnsupportedFunctionReturnTypeAnnotationParserError =
     _require.UnsupportedFunctionReturnTypeAnnotationParserError,
+  UnsupportedModuleEventEmitterPropertyParserError =
+    _require.UnsupportedModuleEventEmitterPropertyParserError,
+  UnsupportedModuleEventEmitterTypePropertyParserError =
+    _require.UnsupportedModuleEventEmitterTypePropertyParserError,
   UnsupportedModulePropertyParserError =
     _require.UnsupportedModulePropertyParserError,
   UnsupportedObjectPropertyValueTypeAnnotationParserError =
@@ -152,6 +156,44 @@ function throwIfUntypedModule(
     );
   }
 }
+function throwIfEventEmitterTypeIsUnsupported(
+  nativeModuleName,
+  propertyName,
+  propertyValueType,
+  parser,
+  nullable,
+  untyped,
+  cxxOnly,
+) {
+  if (nullable || untyped || !cxxOnly) {
+    throw new UnsupportedModuleEventEmitterPropertyParserError(
+      nativeModuleName,
+      propertyName,
+      propertyValueType,
+      parser.language(),
+      nullable,
+      untyped,
+      cxxOnly,
+    );
+  }
+}
+function throwIfEventEmitterEventTypeIsUnsupported(
+  nativeModuleName,
+  propertyName,
+  propertyValueType,
+  parser,
+  nullable,
+) {
+  if (nullable) {
+    throw new UnsupportedModuleEventEmitterTypePropertyParserError(
+      nativeModuleName,
+      propertyName,
+      propertyValueType,
+      parser.language(),
+      nullable,
+    );
+  }
+}
 function throwIfModuleTypeIsUnsupported(
   nativeModuleName,
   propertyValue,
@@ -330,6 +372,8 @@ module.exports = {
   throwIfWrongNumberOfCallExpressionArgs,
   throwIfIncorrectModuleRegistryCallTypeParameterParserError,
   throwIfUntypedModule,
+  throwIfEventEmitterTypeIsUnsupported,
+  throwIfEventEmitterEventTypeIsUnsupported,
   throwIfModuleTypeIsUnsupported,
   throwIfMoreThanOneModuleInterfaceParserError,
   throwIfUnsupportedFunctionParamTypeAnnotationParserError,

package/lib/parsers/error-utils.js.flow

@@ -26,6 +26,8 @@ const {
   UnsupportedArrayElementTypeAnnotationParserError,
   UnsupportedFunctionParamTypeAnnotationParserError,
   UnsupportedFunctionReturnTypeAnnotationParserError,
+  UnsupportedModuleEventEmitterPropertyParserError,
+  UnsupportedModuleEventEmitterTypePropertyParserError,
   UnsupportedModulePropertyParserError,
   UnsupportedObjectPropertyValueTypeAnnotationParserError,
   UntypedModuleRegistryCallParserError,
@@ -155,6 +157,46 @@ function throwIfUntypedModule(
   }
 }
 
+function throwIfEventEmitterTypeIsUnsupported(
+  nativeModuleName: string,
+  propertyName: string,
+  propertyValueType: string,
+  parser: Parser,
+  nullable: boolean,
+  untyped: boolean,
+  cxxOnly: boolean,
+) {
+  if (nullable || untyped || !cxxOnly) {
+    throw new UnsupportedModuleEventEmitterPropertyParserError(
+      nativeModuleName,
+      propertyName,
+      propertyValueType,
+      parser.language(),
+      nullable,
+      untyped,
+      cxxOnly,
+    );
+  }
+}
+
+function throwIfEventEmitterEventTypeIsUnsupported(
+  nativeModuleName: string,
+  propertyName: string,
+  propertyValueType: string,
+  parser: Parser,
+  nullable: boolean,
+) {
+  if (nullable) {
+    throw new UnsupportedModuleEventEmitterTypePropertyParserError(
+      nativeModuleName,
+      propertyName,
+      propertyValueType,
+      parser.language(),
+      nullable,
+    );
+  }
+}
+
 function throwIfModuleTypeIsUnsupported(
   nativeModuleName: string,
   propertyValue: $FlowFixMe,
@@ -363,6 +405,8 @@ module.exports = {
   throwIfWrongNumberOfCallExpressionArgs,
   throwIfIncorrectModuleRegistryCallTypeParameterParserError,
   throwIfUntypedModule,
+  throwIfEventEmitterTypeIsUnsupported,
+  throwIfEventEmitterEventTypeIsUnsupported,
   throwIfModuleTypeIsUnsupported,
   throwIfMoreThanOneModuleInterfaceParserError,
   throwIfUnsupportedFunctionParamTypeAnnotationParserError,

package/lib/parsers/errors.js

@@ -56,6 +56,42 @@ class MoreThanOneModuleInterfaceParserError extends ParserError {
     );
   }
 }
+class UnsupportedModuleEventEmitterTypePropertyParserError extends ParserError {
+  constructor(
+    nativeModuleName,
+    propertyValue,
+    propertyName,
+    language,
+    nullable,
+  ) {
+    super(
+      nativeModuleName,
+      propertyValue,
+      `Property '${propertyName}' is an EventEmitter and must have a non nullable eventType`,
+    );
+  }
+}
+class UnsupportedModuleEventEmitterPropertyParserError extends ParserError {
+  constructor(
+    nativeModuleName,
+    propertyValue,
+    propertyName,
+    language,
+    nullable,
+    untyped,
+    cxxOnly,
+  ) {
+    let message = `${language} interfaces extending TurboModule must only contain 'FunctionTypeAnnotation's or non nullable 'EventEmitter's. Further the EventEmitter property `;
+    if (nullable) {
+      message += `'${propertyValue}' must non nullable.`;
+    } else if (untyped) {
+      message += `'${propertyValue}' must have a concrete or void eventType.`;
+    } else if (cxxOnly) {
+      message += `'${propertyValue}' is only supported in C++ Turbo Modules.`;
+    }
+    super(nativeModuleName, propertyValue, message);
+  }
+}
 class UnsupportedModulePropertyParserError extends ParserError {
   constructor(
     nativeModuleName,
@@ -67,7 +103,7 @@ class UnsupportedModulePropertyParserError extends ParserError {
     super(
       nativeModuleName,
       propertyValue,
-      `${language} interfaces extending TurboModule must only contain 'FunctionTypeAnnotation's. Property '${propertyName}' refers to a '${invalidPropertyValueType}'.`,
+      `${language} interfaces extending TurboModule must only contain 'FunctionTypeAnnotation's or non nullable 'EventEmitter's. Property '${propertyName}' refers to a '${invalidPropertyValueType}'.`,
     );
   }
 }
@@ -321,6 +357,8 @@ module.exports = {
   UnsupportedFunctionReturnTypeAnnotationParserError,
   UnsupportedEnumDeclarationParserError,
   UnsupportedUnionTypeAnnotationParserError,
+  UnsupportedModuleEventEmitterTypePropertyParserError,
+  UnsupportedModuleEventEmitterPropertyParserError,
   UnsupportedModulePropertyParserError,
   UnsupportedObjectPropertyTypeAnnotationParserError,
   UnsupportedObjectPropertyValueTypeAnnotationParserError,

package/lib/parsers/errors.js.flow

@@ -76,6 +76,44 @@ class MoreThanOneModuleInterfaceParserError extends ParserError {
   }
 }
 
+class UnsupportedModuleEventEmitterTypePropertyParserError extends ParserError {
+  constructor(
+    nativeModuleName: string,
+    propertyValue: $FlowFixMe,
+    propertyName: string,
+    language: ParserType,
+    nullable: boolean,
+  ) {
+    super(
+      nativeModuleName,
+      propertyValue,
+      `Property '${propertyName}' is an EventEmitter and must have a non nullable eventType`,
+    );
+  }
+}
+
+class UnsupportedModuleEventEmitterPropertyParserError extends ParserError {
+  constructor(
+    nativeModuleName: string,
+    propertyValue: $FlowFixMe,
+    propertyName: string,
+    language: ParserType,
+    nullable: boolean,
+    untyped: boolean,
+    cxxOnly: boolean,
+  ) {
+    let message = `${language} interfaces extending TurboModule must only contain 'FunctionTypeAnnotation's or non nullable 'EventEmitter's. Further the EventEmitter property `;
+    if (nullable) {
+      message += `'${propertyValue}' must non nullable.`;
+    } else if (untyped) {
+      message += `'${propertyValue}' must have a concrete or void eventType.`;
+    } else if (cxxOnly) {
+      message += `'${propertyValue}' is only supported in C++ Turbo Modules.`;
+    }
+    super(nativeModuleName, propertyValue, message);
+  }
+}
+
 class UnsupportedModulePropertyParserError extends ParserError {
   constructor(
     nativeModuleName: string,
@@ -87,7 +125,7 @@ class UnsupportedModulePropertyParserError extends ParserError {
     super(
       nativeModuleName,
       propertyValue,
-      `${language} interfaces extending TurboModule must only contain 'FunctionTypeAnnotation's. Property '${propertyName}' refers to a '${invalidPropertyValueType}'.`,
+      `${language} interfaces extending TurboModule must only contain 'FunctionTypeAnnotation's or non nullable 'EventEmitter's. Property '${propertyName}' refers to a '${invalidPropertyValueType}'.`,
     );
   }
 }
@@ -416,6 +454,8 @@ module.exports = {
   UnsupportedFunctionReturnTypeAnnotationParserError,
   UnsupportedEnumDeclarationParserError,
   UnsupportedUnionTypeAnnotationParserError,
+  UnsupportedModuleEventEmitterTypePropertyParserError,
+  UnsupportedModuleEventEmitterPropertyParserError,
   UnsupportedModulePropertyParserError,
   UnsupportedObjectPropertyTypeAnnotationParserError,
   UnsupportedObjectPropertyValueTypeAnnotationParserError,

package/lib/parsers/parsers-commons.js

@@ -142,6 +142,10 @@ function _arrayWithHoles(arr) {
 }
 const _require = require('./error-utils'),
   throwIfConfigNotfound = _require.throwIfConfigNotfound,
+  throwIfEventEmitterEventTypeIsUnsupported =
+    _require.throwIfEventEmitterEventTypeIsUnsupported,
+  throwIfEventEmitterTypeIsUnsupported =
+    _require.throwIfEventEmitterTypeIsUnsupported,
   throwIfIncorrectModuleRegistryCallArgument =
     _require.throwIfIncorrectModuleRegistryCallArgument,
   throwIfIncorrectModuleRegistryCallTypeParameterParserError =
@@ -543,6 +547,66 @@ function buildPropertySchema(
     ),
   };
 }
+function buildEventEmitterSchema(
+  hasteModuleName,
+  // TODO(T108222691): [TS] Use flow-types for @babel/parser
+  // TODO(T71778680): [Flow] This is an ObjectTypeProperty containing either:
+  // - a FunctionTypeAnnotation or GenericTypeAnnotation
+  // - a NullableTypeAnnoation containing a FunctionTypeAnnotation or GenericTypeAnnotation
+  // Flow type this node
+  property,
+  types,
+  aliasMap,
+  enumMap,
+  tryParse,
+  cxxOnly,
+  translateTypeAnnotation,
+  parser,
+) {
+  let key = property.key,
+    value = property.value;
+  const eventemitterName = key.name;
+  const resolveTypeAnnotationFN = parser.getResolveTypeAnnotationFN();
+  const _unwrapNullable7 = unwrapNullable(value),
+    _unwrapNullable8 = _slicedToArray(_unwrapNullable7, 2),
+    typeAnnotation = _unwrapNullable8[0],
+    typeAnnotationNullable = _unwrapNullable8[1];
+  const typeAnnotationUntyped =
+    value.typeParameters.params.length === 1 &&
+    value.typeParameters.params[0].type === 'ObjectTypeAnnotation' &&
+    value.typeParameters.params[0].properties.length === 0;
+  throwIfEventEmitterTypeIsUnsupported(
+    hasteModuleName,
+    key.name,
+    typeAnnotation.type,
+    parser,
+    typeAnnotationNullable,
+    typeAnnotationUntyped,
+    cxxOnly,
+  );
+  const eventTypeResolutionStatus = resolveTypeAnnotationFN(
+    typeAnnotation.typeParameters.params[0],
+    types,
+    parser,
+  );
+  throwIfEventEmitterEventTypeIsUnsupported(
+    hasteModuleName,
+    key.name,
+    eventTypeResolutionStatus.typeAnnotation,
+    parser,
+    eventTypeResolutionStatus.nullable,
+  );
+  return {
+    name: eventemitterName,
+    optional: false,
+    typeAnnotation: {
+      type: 'EventEmitterTypeAnnotation',
+      typeAnnotation: {
+        type: eventTypeResolutionStatus.typeAnnotation.type,
+      },
+    },
+  };
+}
 function buildSchemaFromConfigType(
   configType,
   filename,
@@ -744,7 +808,6 @@ const buildModuleSchema = (
     : {};
   const properties =
     language === 'Flow' ? moduleSpec.body.properties : moduleSpec.body.body;
-
   // $FlowFixMe[missing-type-arg]
   const nativeModuleSchema = properties
     .filter(
@@ -754,21 +817,55 @@ const buildModuleSchema = (
         property.type === 'TSMethodSignature',
     )
     .map(property => {
+      var _property$value, _property$value2;
       const enumMap = {};
+      const isEventEmitter =
+        (property === null ||
+        property === void 0 ||
+        (_property$value = property.value) === null ||
+        _property$value === void 0
+          ? void 0
+          : _property$value.type) === 'GenericTypeAnnotation' &&
+        (property === null ||
+        property === void 0 ||
+        (_property$value2 = property.value) === null ||
+        _property$value2 === void 0 ||
+        (_property$value2 = _property$value2.id) === null ||
+        _property$value2 === void 0
+          ? void 0
+          : _property$value2.name) === 'EventEmitter';
       return tryParse(() => ({
         aliasMap,
         enumMap,
-        propertyShape: buildPropertySchema(
-          hasteModuleName,
-          property,
-          types,
-          aliasMap,
-          enumMap,
-          tryParse,
-          cxxOnly,
-          translateTypeAnnotation,
-          parser,
-        ),
+        propertyShape: isEventEmitter
+          ? {
+              type: 'eventEmitter',
+              value: buildEventEmitterSchema(
+                hasteModuleName,
+                property,
+                types,
+                aliasMap,
+                enumMap,
+                tryParse,
+                cxxOnly,
+                translateTypeAnnotation,
+                parser,
+              ),
+            }
+          : {
+              type: 'method',
+              value: buildPropertySchema(
+                hasteModuleName,
+                property,
+                types,
+                aliasMap,
+                enumMap,
+                tryParse,
+                cxxOnly,
+                translateTypeAnnotation,
+                parser,
+              ),
+            },
       }));
     })
     .filter(Boolean)
@@ -784,7 +881,12 @@ const buildModuleSchema = (
           enumMap,
         ),
         spec: {
-          properties: [...moduleSchema.spec.properties, propertyShape],
+          eventEmitters: [...moduleSchema.spec.eventEmitters].concat(
+            propertyShape.type === 'eventEmitter' ? [propertyShape.value] : [],
+          ),
+          properties: [...moduleSchema.spec.properties].concat(
+            propertyShape.type === 'method' ? [propertyShape.value] : [],
+          ),
         },
         moduleName: moduleSchema.moduleName,
         excludedPlatforms: moduleSchema.excludedPlatforms,
@@ -794,6 +896,7 @@ const buildModuleSchema = (
         aliasMap: {},
         enumMap: {},
         spec: {
+          eventEmitters: [],
           properties: [],
         },
         moduleName,
@@ -806,6 +909,7 @@ const buildModuleSchema = (
     aliasMap: getSortedObject(nativeModuleSchema.aliasMap),
     enumMap: getSortedObject(nativeModuleSchema.enumMap),
     spec: {
+      eventEmitters: nativeModuleSchema.spec.eventEmitters.sort(),
       properties: nativeModuleSchema.spec.properties.sort(),
     },
     moduleName,

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

@@ -17,6 +17,7 @@ import type {
   NativeModuleAliasMap,
   NativeModuleBaseTypeAnnotation,
   NativeModuleEnumMap,
+  NativeModuleEventEmitterShape,
   NativeModuleFunctionTypeAnnotation,
   NativeModuleParamTypeAnnotation,
   NativeModulePropertyShape,
@@ -40,6 +41,8 @@ import type {
 
 const {
   throwIfConfigNotfound,
+  throwIfEventEmitterEventTypeIsUnsupported,
+  throwIfEventEmitterTypeIsUnsupported,
   throwIfIncorrectModuleRegistryCallArgument,
   throwIfIncorrectModuleRegistryCallTypeParameterParserError,
   throwIfModuleInterfaceIsMisnamed,
@@ -470,6 +473,63 @@ function buildPropertySchema(
   };
 }
 
+function buildEventEmitterSchema(
+  hasteModuleName: string,
+  // TODO(T108222691): [TS] Use flow-types for @babel/parser
+  // TODO(T71778680): [Flow] This is an ObjectTypeProperty containing either:
+  // - a FunctionTypeAnnotation or GenericTypeAnnotation
+  // - a NullableTypeAnnoation containing a FunctionTypeAnnotation or GenericTypeAnnotation
+  // Flow type this node
+  property: $FlowFixMe,
+  types: TypeDeclarationMap,
+  aliasMap: {...NativeModuleAliasMap},
+  enumMap: {...NativeModuleEnumMap},
+  tryParse: ParserErrorCapturer,
+  cxxOnly: boolean,
+  translateTypeAnnotation: $FlowFixMe,
+  parser: Parser,
+): NativeModuleEventEmitterShape {
+  let {key, value} = property;
+  const eventemitterName: string = key.name;
+
+  const resolveTypeAnnotationFN = parser.getResolveTypeAnnotationFN();
+  const [typeAnnotation, typeAnnotationNullable] = unwrapNullable(value);
+  const typeAnnotationUntyped =
+    value.typeParameters.params.length === 1 &&
+    value.typeParameters.params[0].type === 'ObjectTypeAnnotation' &&
+    value.typeParameters.params[0].properties.length === 0;
+
+  throwIfEventEmitterTypeIsUnsupported(
+    hasteModuleName,
+    key.name,
+    typeAnnotation.type,
+    parser,
+    typeAnnotationNullable,
+    typeAnnotationUntyped,
+    cxxOnly,
+  );
+  const eventTypeResolutionStatus = resolveTypeAnnotationFN(
+    typeAnnotation.typeParameters.params[0],
+    types,
+    parser,
+  );
+  throwIfEventEmitterEventTypeIsUnsupported(
+    hasteModuleName,
+    key.name,
+    eventTypeResolutionStatus.typeAnnotation,
+    parser,
+    eventTypeResolutionStatus.nullable,
+  );
+  return {
+    name: eventemitterName,
+    optional: false,
+    typeAnnotation: {
+      type: 'EventEmitterTypeAnnotation',
+      typeAnnotation: {type: eventTypeResolutionStatus.typeAnnotation.type},
+    },
+  };
+}
+
 function buildSchemaFromConfigType(
   configType: 'module' | 'component' | 'none',
   filename: ?string,
@@ -719,6 +779,10 @@ const buildModuleSchema = (
   const properties: $ReadOnlyArray<$FlowFixMe> =
     language === 'Flow' ? moduleSpec.body.properties : moduleSpec.body.body;
 
+  type PropertyShape =
+    | {type: 'eventEmitter', value: NativeModuleEventEmitterShape}
+    | {type: 'method', value: NativeModulePropertyShape};
+
   // $FlowFixMe[missing-type-arg]
   const nativeModuleSchema = properties
     .filter(
@@ -730,23 +794,44 @@ const buildModuleSchema = (
     .map<?{
       aliasMap: NativeModuleAliasMap,
       enumMap: NativeModuleEnumMap,
-      propertyShape: NativeModulePropertyShape,
+      propertyShape: PropertyShape,
     }>(property => {
       const enumMap: {...NativeModuleEnumMap} = {};
+      const isEventEmitter =
+        property?.value?.type === 'GenericTypeAnnotation' &&
+        property?.value?.id?.name === 'EventEmitter';
       return tryParse(() => ({
         aliasMap,
         enumMap,
-        propertyShape: buildPropertySchema(
-          hasteModuleName,
-          property,
-          types,
-          aliasMap,
-          enumMap,
-          tryParse,
-          cxxOnly,
-          translateTypeAnnotation,
-          parser,
-        ),
+        propertyShape: isEventEmitter
+          ? {
+              type: 'eventEmitter',
+              value: buildEventEmitterSchema(
+                hasteModuleName,
+                property,
+                types,
+                aliasMap,
+                enumMap,
+                tryParse,
+                cxxOnly,
+                translateTypeAnnotation,
+                parser,
+              ),
+            }
+          : {
+              type: 'method',
+              value: buildPropertySchema(
+                hasteModuleName,
+                property,
+                types,
+                aliasMap,
+                enumMap,
+                tryParse,
+                cxxOnly,
+                translateTypeAnnotation,
+                parser,
+              ),
+            },
       }));
     })
     .filter(Boolean)
@@ -756,7 +841,12 @@ const buildModuleSchema = (
         aliasMap: {...moduleSchema.aliasMap, ...aliasMap},
         enumMap: {...moduleSchema.enumMap, ...enumMap},
         spec: {
-          properties: [...moduleSchema.spec.properties, propertyShape],
+          eventEmitters: [...moduleSchema.spec.eventEmitters].concat(
+            propertyShape.type === 'eventEmitter' ? [propertyShape.value] : [],
+          ),
+          properties: [...moduleSchema.spec.properties].concat(
+            propertyShape.type === 'method' ? [propertyShape.value] : [],
+          ),
         },
         moduleName: moduleSchema.moduleName,
         excludedPlatforms: moduleSchema.excludedPlatforms,
@@ -765,7 +855,7 @@ const buildModuleSchema = (
         type: 'NativeModule',
         aliasMap: {},
         enumMap: {},
-        spec: {properties: []},
+        spec: {eventEmitters: [], properties: []},
         moduleName,
         excludedPlatforms:
           excludedPlatforms.length !== 0 ? [...excludedPlatforms] : undefined,
@@ -776,7 +866,10 @@ const buildModuleSchema = (
     type: 'NativeModule',
     aliasMap: getSortedObject(nativeModuleSchema.aliasMap),
     enumMap: getSortedObject(nativeModuleSchema.enumMap),
-    spec: {properties: nativeModuleSchema.spec.properties.sort()},
+    spec: {
+      eventEmitters: nativeModuleSchema.spec.eventEmitters.sort(),
+      properties: nativeModuleSchema.spec.properties.sort(),
+    },
     moduleName,
     excludedPlatforms: nativeModuleSchema.excludedPlatforms,
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native/codegen",
-  "version": "0.75.0-nightly-20240611-5b3a32142",
+  "version": "0.75.0-nightly-20240612-fd618819c",
   "description": "Code generation tools for React Native",
   "license": "MIT",
   "repository": {