Add support for turbomodule eventemitters, and codegen (#13555)

* Add support for turbomodule eventemitters, and codegen

* Change files

* fix

* fix

* fix

* Minor review feedback

* format

Author: acoates-ms

change/@react-native-windows-codegen-ae4b2a67-9881-42db-ab82-02d7d2374e43.json

@@ -0,0 +1,7 @@
+{
+  "type": "prerelease",
+  "comment": "Add support for turbomodule eventemitters, and codegen",
+  "packageName": "@react-native-windows/codegen",
+  "email": "30809111+acoates-ms@users.noreply.github.com",
+  "dependentChangeType": "patch"
+}

change/react-native-windows-69671805-a682-4e35-8999-c68f20b14b74.json

@@ -0,0 +1,7 @@
+{
+  "type": "prerelease",
+  "comment": "Add support for turbomodule eventemitters, and codegen",
+  "packageName": "react-native-windows",
+  "email": "30809111+acoates-ms@users.noreply.github.com",
+  "dependentChangeType": "patch"
+}

packages/@react-native-windows/codegen/src/generators/GenerateNM2.ts

@@ -118,11 +118,11 @@ export function createNM2Generator({
         });
         let tuples = `
   static constexpr auto methods = std::tuple{
-${methods[0]}
+${methods.traversedPropertyTuples}${methods.traversedEventEmitterTuples ? '\n' : ''}${methods.traversedEventEmitterTuples}
   };`;
         let checks = `
     constexpr auto methodCheckResults = CheckMethods<TModule, ::_MODULE_NAME_::Spec>();`;
-        let errors = methods[1];
+        let errors = methods.traversedProperties + (methods.traversedEventEmitters ? '\n' : '') + methods.traversedEventEmitters;
 
         // prepare constants
         const constants = generateValidateConstants(nativeModule, aliases);

packages/@react-native-windows/codegen/src/generators/ParamTypes.ts

@@ -10,6 +10,8 @@ import type {
   NamedShape,
   NativeModuleArrayTypeAnnotation,
   NativeModuleBaseTypeAnnotation,
+  NativeModuleEventEmitterBaseTypeAnnotation,
+  NativeModuleEventEmitterTypeAnnotation,
   NativeModuleEnumDeclaration,
   NativeModuleFunctionTypeAnnotation,
   NativeModuleParamTypeAnnotation,
@@ -141,6 +143,39 @@ function translateArray(
   }
 }
 
+// Hopefully eventually NativeModuleEventEmitterTypeAnnotation will align better with NativeModuleParamTypeAnnotation
+// and this method can be merged / replaced with translateArray
+function translateEventEmitterArray(
+  param: {
+    readonly type: 'ArrayTypeAnnotation';
+    readonly elementType: NativeModuleEventEmitterBaseTypeAnnotation | {type: string};
+  },
+  aliases: AliasMap,
+  baseAliasName: string,
+  target: ParamTarget,
+  options: CppCodegenOptions,
+): string {
+  switch (target) {
+    case 'spec':
+    case 'template':
+      return `std::vector<${translateEventEmitterParam(
+        param.elementType as NativeModuleEventEmitterBaseTypeAnnotation,
+        aliases,
+        `${baseAliasName}_element`,
+        'template',
+        options,
+      )}>`;
+    default:
+      return `std::vector<${translateEventEmitterParam(
+        param.elementType as NativeModuleEventEmitterBaseTypeAnnotation,
+        aliases,
+        `${baseAliasName}_element`,
+        'template',
+        options,
+      )}> const &`;
+  }
+}
+
 function translateParam(
   param: NativeModuleParamTypeAnnotation,
   aliases: AliasMap,
@@ -193,6 +228,39 @@ function translateParam(
   }
 }
 
+// Hopefully eventually NativeModuleEventEmitterTypeAnnotation will align better with NativeModuleParamTypeAnnotation
+// and this method can be merged / replaced with translateParam
+function translateEventEmitterParam(
+  param: NativeModuleEventEmitterTypeAnnotation,
+  aliases: AliasMap,
+  baseAliasName: string,
+  target: ParamTarget,
+  options: CppCodegenOptions,
+): string {
+  // avoid: Property 'type' does not exist on type 'never'
+  const paramType = param.type;
+  switch (param.type) {
+    case 'StringTypeAnnotation':
+      return options.cppStringType;
+    case 'NumberTypeAnnotation':
+    case 'FloatTypeAnnotation':
+    case 'DoubleTypeAnnotation':
+      return 'double';
+    case 'Int32TypeAnnotation':
+      return 'int';
+    case 'BooleanTypeAnnotation':
+      return 'bool';
+    case 'ArrayTypeAnnotation':
+      return translateEventEmitterArray(param, aliases, baseAliasName, target, options);
+    case 'TypeAliasTypeAnnotation':
+      return decorateType(getAliasCppName(param.name), target);
+    case 'VoidTypeAnnotation':
+      return 'void';
+    default:
+      throw new Error(`Unhandled type in translateParam: ${paramType}`);
+  }
+}
+
 function translateNullableParamType(
   paramType: Nullable<NativeModuleParamTypeAnnotation>,
   aliases: AliasMap,
@@ -280,6 +348,22 @@ export function translateSpecArgs(
   });
 }
 
+export function translateEventEmitterArgs(
+  params: NativeModuleEventEmitterTypeAnnotation,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
+) {
+    const translatedParam = translateEventEmitterParam(
+      params,
+      aliases,
+      baseAliasName,
+      'spec',
+      options,
+    );
+    return `${translatedParam}`;
+}
+
 export function translateArgs(
   params: ReadonlyArray<NativeModuleParamShape>,
   aliases: AliasMap,

packages/@react-native-windows/codegen/src/generators/ValidateMethods.ts

@@ -7,13 +7,14 @@
 'use strict';
 
 import type {
+  NativeModuleEventEmitterShape,
   NativeModuleFunctionTypeAnnotation,
   NativeModulePropertyShape,
   NativeModuleSchema,
 } from '@react-native/codegen/lib/CodegenSchema';
 import {AliasMap} from './AliasManaging';
 import type {CppCodegenOptions} from './ObjectTypes';
-import {translateArgs, translateSpecArgs} from './ParamTypes';
+import {translateArgs, translateSpecArgs, translateEventEmitterArgs} from './ParamTypes';
 import {translateImplReturnType, translateSpecReturnType} from './ReturnTypes';
 
 function isMethodSync(funcType: NativeModuleFunctionTypeAnnotation) {
@@ -91,9 +92,9 @@ function renderProperties(
   aliases: AliasMap,
   tuple: boolean,
   options: CppCodegenOptions,
-): string {
+): { code: string, numberOfProperties: number } {
   // TODO: generate code for constants
-  return methods
+  const properties = methods
     .filter(prop => prop.name !== 'getConstants')
     .map((prop, index) => {
       // TODO: prop.optional === true
@@ -151,6 +152,66 @@ function renderProperties(
             options,
           )});`;
       }
+    });
+
+    return {code: properties.join('\n'), numberOfProperties: properties.length};
+}
+
+function getPossibleEventEmitterSignatures(
+  eventEmitter: NativeModuleEventEmitterShape,
+  aliases: AliasMap,
+  options: CppCodegenOptions): string[] {
+  
+  const traversedArgs = translateEventEmitterArgs(
+    eventEmitter.typeAnnotation.typeAnnotation,
+    aliases,
+    eventEmitter.name,
+    options,
+  );
+  return [`REACT_EVENT(${eventEmitter.name}) std::function<void(${traversedArgs})> ${eventEmitter.name};`]
+}
+
+function translatePossibleEventSignatures(
+  eventEmitter: NativeModuleEventEmitterShape,
+  aliases: AliasMap,
+  options: CppCodegenOptions): string {
+  return getPossibleEventEmitterSignatures(
+    eventEmitter,
+    aliases,
+    options
+  )
+    .map(sig => `"    ${sig}\\n"`)
+    .join('\n          ');
+}
+
+function renderEventEmitters(
+  eventEmitters: ReadonlyArray<NativeModuleEventEmitterShape>,
+  indexOffset: number,
+  aliases: AliasMap,
+  tuple: boolean,
+  options: CppCodegenOptions,
+): string {
+  return eventEmitters
+    .map((eventEmitter, index) => {
+      const traversedArgs = translateEventEmitterArgs(
+        eventEmitter.typeAnnotation.typeAnnotation,
+        aliases,
+        eventEmitter.name,
+        options,
+      );
+
+      if (tuple) {
+        return `      EventEmitter<void(${traversedArgs})>{${index + indexOffset}, L"${eventEmitter.name}"},`;
+      } else {
+        return `    REACT_SHOW_EVENTEMITTER_SPEC_ERRORS(
+          ${index + indexOffset},
+          "${eventEmitter.name}",
+          ${translatePossibleEventSignatures(
+            eventEmitter,
+            aliases,
+            options,
+      )});`;
+      }
     })
     .join('\n');
 }
@@ -159,19 +220,39 @@ export function generateValidateMethods(
   nativeModule: NativeModuleSchema,
   aliases: AliasMap,
   options: CppCodegenOptions,
-): [string, string] {
+): {
+  traversedProperties: string,
+  traversedEventEmitters: string,
+  traversedPropertyTuples: string,
+  traversedEventEmitterTuples: string,
+} {
   const methods = nativeModule.spec.methods;
+  const eventEmitters = nativeModule.spec.eventEmitters;
   const traversedProperties = renderProperties(
     methods,
     aliases,
     false,
     options,
   );
+  const traversedEventEmitters = renderEventEmitters(
+    eventEmitters,
+    traversedProperties.numberOfProperties,
+    aliases,
+    false,
+    options,
+  );
   const traversedPropertyTuples = renderProperties(
     methods,
     aliases,
     true,
     options,
   );
-  return [traversedPropertyTuples, traversedProperties];
+  const traversedEventEmitterTuples = renderEventEmitters(
+    eventEmitters,
+    traversedProperties.numberOfProperties,
+    aliases,
+    true,
+    options,
+  );
+  return {traversedPropertyTuples: traversedPropertyTuples.code, traversedEventEmitterTuples, traversedProperties: traversedProperties.code, traversedEventEmitters};
 }

packages/@react-native-windows/tester/src/js/examples/TurboModule/SampleTurboModuleExample.windows.js

@@ -225,8 +225,6 @@ class SampleTurboModuleExample extends React.Component<{||}, State> {
     Windows]
     */
 
-    /*
-    [Windows Wee need to implement both a proper SampleTurboModule (issue #13531) and add EventEmitter support (issue #13532)
     this.eventSubscriptions.push(
       NativeSampleTurboModule.onPress(value => console.log('onPress: ()')),
     );
@@ -245,8 +243,6 @@ class SampleTurboModuleExample extends React.Component<{||}, State> {
         console.log(`onSubmit: (${JSON.stringify(value)})`),
       ),
     );
-    Windows]
-    */
   }
 
   componentWillUnmount() {

vnext/Microsoft.ReactNative.Cxx.UnitTests/ReactModuleBuilderMock.cpp

@@ -84,6 +84,8 @@ void ReactModuleBuilderMock::AddSyncMethod(hstring const &name, SyncMethodDelega
   m_syncMethods.emplace(name, method);
 }
 
+void ReactModuleBuilderMock::AddEventEmitter(hstring const &, EventEmitterInitializerDelegate const &) noexcept {}
+
 JSValueObject ReactModuleBuilderMock::GetConstants() noexcept {
   auto constantWriter = MakeJSValueTreeWriter();
   constantWriter.WriteObjectBegin();

vnext/Microsoft.ReactNative.Cxx.UnitTests/ReactModuleBuilderMock.h

@@ -73,6 +73,7 @@ struct ReactModuleBuilderMock {
   void AddConstantProvider(ConstantProviderDelegate const &constantProvider) noexcept;
   void AddMethod(hstring const &name, MethodReturnType returnType, MethodDelegate const &method) noexcept;
   void AddSyncMethod(hstring const &name, SyncMethodDelegate const &method) noexcept;
+  void AddEventEmitter(hstring const &name, EventEmitterInitializerDelegate const &emitter) noexcept;
 
  private:
   MethodDelegate GetMethod0(std::wstring const &methodName) const noexcept;
@@ -218,6 +219,7 @@ struct ReactModuleBuilderImpl : implements<ReactModuleBuilderImpl, IReactModuleB
   void AddConstantProvider(ConstantProviderDelegate const &constantProvider) noexcept;
   void AddMethod(hstring const &name, MethodReturnType returnType, MethodDelegate const &method) noexcept;
   void AddSyncMethod(hstring const &name, SyncMethodDelegate const &method) noexcept;
+  void AddEventEmitter(hstring const &name, EventEmitterInitializerDelegate const &emitter) noexcept;
 
  private:
   ReactModuleBuilderMock &m_mock;
@@ -352,4 +354,10 @@ inline void ReactModuleBuilderImpl::AddSyncMethod(hstring const &name, SyncMetho
   m_mock.AddSyncMethod(name, method);
 }
 
+inline void ReactModuleBuilderImpl::AddEventEmitter(
+    hstring const &name,
+    EventEmitterInitializerDelegate const &emitter) noexcept {
+  m_mock.AddEventEmitter(name, emitter);
+}
+
 } // namespace winrt::Microsoft::ReactNative

vnext/Microsoft.ReactNative.Cxx/ModuleRegistration.cpp

@@ -17,7 +17,7 @@ ModuleRegistration::ModuleRegistration(wchar_t const *moduleName) noexcept : m_m
 
 void AddAttributedModules(IReactPackageBuilder const &packageBuilder, bool useTurboModules) noexcept {
   for (auto const *reg = ModuleRegistration::Head(); reg != nullptr; reg = reg->Next()) {
-    if (useTurboModules)
+    if (useTurboModules || reg->ShouldRegisterAsTurboModule())
       packageBuilder.AddTurboModule(reg->ModuleName(), reg->MakeModuleProvider());
     else
       packageBuilder.AddModule(reg->ModuleName(), reg->MakeModuleProvider());
@@ -30,7 +30,7 @@ bool TryAddAttributedModule(
     bool useTurboModule) noexcept {
   for (auto const *reg = ModuleRegistration::Head(); reg != nullptr; reg = reg->Next()) {
     if (moduleName == reg->ModuleName()) {
-      if (useTurboModule) {
+      if (useTurboModule || reg->ShouldRegisterAsTurboModule()) {
         packageBuilder.AddTurboModule(moduleName, reg->MakeModuleProvider());
       } else {
         packageBuilder.AddModule(moduleName, reg->MakeModuleProvider());