@react-native-windows/codegen 0.76.0-preview.1 → 0.76.0-preview.3

package/src/generators/GenerateComponentWindows.ts

@@ -6,9 +6,19 @@
 
 'use strict';
 
-import type {SchemaType, EventTypeAnnotation, PropTypeAnnotation, ObjectTypeAnnotation, CommandParamTypeAnnotation} from '@react-native/codegen/lib/CodegenSchema';
+import type {
+  SchemaType,
+  EventTypeAnnotation,
+  PropTypeAnnotation,
+  ObjectTypeAnnotation,
+  CommandParamTypeAnnotation,
+} from '@react-native/codegen/lib/CodegenSchema';
 import {getAliasCppName, setPreferredModuleName} from './AliasManaging';
-import {translateComponentPropsFieldType, translateComponentEventType, translateCommandParamType} from './PropObjectTypes';
+import {
+  translateComponentPropsFieldType,
+  translateComponentEventType,
+  translateCommandParamType,
+} from './PropObjectTypes';
 import type {CppStringTypes} from './ObjectTypes';
 import type {AliasMap} from './AliasManaging';
 
@@ -21,11 +31,14 @@ const headerTemplate = `/*
  */
 #pragma once
 
-#include <JSValueComposition.h>
 #include <NativeModules.h>
-#include <winrt/Microsoft.ReactNative.Composition.h>
-#include <winrt/Microsoft.UI.Composition.h>`
 
+#ifdef RNW_NEW_ARCH
+#include <JSValueComposition.h>
+
+#include <winrt/Microsoft.ReactNative.Composition.h>
+#include <winrt/Microsoft.UI.Composition.h>
+#endif // #ifdef RNW_NEW_ARCH`;
 
 const propsTemplate = `REACT_STRUCT(::_PROPS_NAME_::)
 struct ::_PROPS_NAME_:: : winrt::implements<::_PROPS_NAME_::, winrt::Microsoft::ReactNative::IComponentProps> {
@@ -37,16 +50,16 @@ struct ::_PROPS_NAME_:: : winrt::implements<::_PROPS_NAME_::, winrt::Microsoft::
 
 ::_PROPS_FIELDS_::
   const winrt::Microsoft::ReactNative::ViewProps ViewProps;
-};`
+};`;
 
 const propsObjectTemplate = `REACT_STRUCT(::_OBJECT_NAME_::)
 struct ::_OBJECT_NAME_:: {
 ::_OBJECT_FIELDS_::};
-`
+`;
 const eventsObjectTemplate = `REACT_STRUCT(::_OBJECT_NAME_::)
 struct ::_OBJECT_NAME_:: {
 ::_OBJECT_FIELDS_::};
-`
+`;
 
 const eventEmitterMethodTemplate = `  void ::_EVENT_NAME_::(::_EVENT_OBJECT_TYPE_:: &value) const {
     m_eventEmitter.DispatchEvent(L"::_EVENT_NAME_NO_ON_::", [value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
@@ -54,7 +67,6 @@ const eventEmitterMethodTemplate = `  void ::_EVENT_NAME_::(::_EVENT_OBJECT_TYPE
     });
   }`;
 
-
 const eventEmitterTemplate = `::_COMPONENT_EVENT_OBJECT_TYPES_::
 
 struct ::_EVENT_EMITTER_NAME_:: {
@@ -67,7 +79,7 @@ struct ::_EVENT_EMITTER_NAME_:: {
 
  private:
   winrt::Microsoft::ReactNative::EventEmitter m_eventEmitter{nullptr};
-};`
+};`;
 
 const baseStructTemplate = `
 template<typename TUserData>
@@ -212,6 +224,8 @@ void Register::_COMPONENT_NAME_::NativeComponent(
 const fileTemplate = `
 ${headerTemplate}
 
+#ifdef RNW_NEW_ARCH
+
 namespace ::_NAMESPACE_:: {
 
 ::_COMPONENT_PROP_OBJECT_TYPES_::
@@ -223,11 +237,13 @@ namespace ::_NAMESPACE_:: {
 
 ::_COMPONENT_REGISTRATION_::
 } // namespace ::_NAMESPACE_::
+
+#endif // #ifdef RNW_NEW_ARCH
 `;
 
 function capitalizeFirstLetter(s: string) {
   return s.charAt(0).toUpperCase() + s.slice(1);
-  }
+}
 
 export function createComponentGenerator({
   namespace,
@@ -255,114 +271,241 @@ export function createComponentGenerator({
         const componentShape = component.components[componentName];
 
         componentShape.extendsProps.forEach(propsBaseType => {
-          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-          if (propsBaseType.type !== 'ReactNativeBuiltInType' || propsBaseType.knownTypeName !== 'ReactNativeCoreViewProps') {
-            throw new Error('Currently only supports props extending from ViewProps');
+          if (
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            propsBaseType.type !== 'ReactNativeBuiltInType' ||
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            propsBaseType.knownTypeName !== 'ReactNativeCoreViewProps'
+          ) {
+            throw new Error(
+              'Currently only supports props extending from ViewProps',
+            );
           }
         });
 
         // Props
-        const propObjectAliases: AliasMap<ObjectTypeAnnotation<PropTypeAnnotation>> = {types:{}, jobs: []};
+        const propObjectAliases: AliasMap<
+          ObjectTypeAnnotation<PropTypeAnnotation>
+        > = {types: {}, jobs: []};
         const propsName = `${componentName}Props`;
-        const propsFields = componentShape.props.map(prop => {
-          const propType = translateComponentPropsFieldType(prop.typeAnnotation, propObjectAliases, `${propsName}_${prop.name}`, cppCodegenOptions);
-          return `  REACT_FIELD(${prop.name})\n  ${(prop.optional && !propType.alreadySupportsOptionalOrHasDefault) ? `std::optional<${propType.type}>` : propType.type} ${prop.name}${propType.initializer};\n`;
-        }).join('\n');
-
-        const propObjectTypes = propObjectAliases.jobs.map(propObjectTypeName => {
-          const propObjectType = propObjectAliases.types[propObjectTypeName]!;
-          const propsObjectFields = propObjectType.properties.map(property => {
-            const propType = translateComponentPropsFieldType(property.typeAnnotation, propObjectAliases, `${propsName}_${property.name}`, cppCodegenOptions);
-            return `  REACT_FIELD(${property.name})\n  ${(property.optional && !propType.alreadySupportsOptionalOrHasDefault) ? `std::optional<${propType.type}>` : propType.type} ${property.name}${propType.initializer};\n`;
-          }).join('\n');
-
-          return propsObjectTemplate.replace(/::_OBJECT_NAME_::/g, getAliasCppName(propObjectTypeName)).replace(/::_OBJECT_FIELDS_::/g, propsObjectFields);
-        }).join('\n');
-
+        const propsFields = componentShape.props
+          .map(prop => {
+            const propType = translateComponentPropsFieldType(
+              prop.typeAnnotation,
+              propObjectAliases,
+              `${propsName}_${prop.name}`,
+              cppCodegenOptions,
+            );
+            return `  REACT_FIELD(${prop.name})\n  ${
+              prop.optional && !propType.alreadySupportsOptionalOrHasDefault
+                ? `std::optional<${propType.type}>`
+                : propType.type
+            } ${prop.name}${propType.initializer};\n`;
+          })
+          .join('\n');
+
+        const propObjectTypes = propObjectAliases.jobs
+          .map(propObjectTypeName => {
+            const propObjectType = propObjectAliases.types[propObjectTypeName]!;
+            const propsObjectFields = propObjectType.properties
+              .map(property => {
+                const propType = translateComponentPropsFieldType(
+                  property.typeAnnotation,
+                  propObjectAliases,
+                  `${propsName}_${property.name}`,
+                  cppCodegenOptions,
+                );
+                return `  REACT_FIELD(${property.name})\n  ${
+                  property.optional &&
+                  !propType.alreadySupportsOptionalOrHasDefault
+                    ? `std::optional<${propType.type}>`
+                    : propType.type
+                } ${property.name}${propType.initializer};\n`;
+              })
+              .join('\n');
+
+            return propsObjectTemplate
+              .replace(
+                /::_OBJECT_NAME_::/g,
+                getAliasCppName(propObjectTypeName),
+              )
+              .replace(/::_OBJECT_FIELDS_::/g, propsObjectFields);
+          })
+          .join('\n');
 
         // Events
-        const eventObjectAliases: AliasMap<ObjectTypeAnnotation<EventTypeAnnotation>> = {types:{}, jobs: []};
+        const eventObjectAliases: AliasMap<
+          ObjectTypeAnnotation<EventTypeAnnotation>
+        > = {types: {}, jobs: []};
         const eventEmitterName = `${componentName}EventEmitter`;
-        const eventEmitterMethods = componentShape.events.filter(event => event.typeAnnotation.argument).map(event => {
-          if (event.typeAnnotation.argument?.baseTypes) {
-            throw new Error('Events with base type arguments not currently supported');
-          }
+        const eventEmitterMethods = componentShape.events
+          .filter(event => event.typeAnnotation.argument)
+          .map(event => {
+            if (event.typeAnnotation.argument?.baseTypes) {
+              throw new Error(
+                'Events with base type arguments not currently supported',
+              );
+            }
+
+            // Called to collect the eventObjectAliases
+            translateComponentEventType(
+              event.typeAnnotation.argument!,
+              eventObjectAliases,
+              `${event.name}`,
+              cppCodegenOptions,
+            );
+
+            // onSomething -> something
+            let eventNameLower = event.name.replace('on', '');
+            eventNameLower =
+              eventNameLower[0].toLowerCase() + eventNameLower.slice(1);
+
+            return eventEmitterMethodTemplate
+              .replace(/::_EVENT_NAME_::/g, event.name)
+              .replace(/::_EVENT_NAME_NO_ON_::/g, eventNameLower)
+              .replace(
+                /::_EVENT_OBJECT_TYPE_::/g,
+                event.name.replace('on', 'On'),
+              );
+          })
+          .join('\n\n');
+
+        const eventObjects = eventObjectAliases.jobs
+          .map(eventObjectTypeName => {
+            const eventObjectType =
+              eventObjectAliases.types[eventObjectTypeName]!;
+            const eventObjectFields = eventObjectType.properties
+              .map(property => {
+                const eventPropType = translateComponentEventType(
+                  property.typeAnnotation,
+                  eventObjectAliases,
+                  eventObjectTypeName,
+                  cppCodegenOptions,
+                );
+                return `  REACT_FIELD(${property.name})\n  ${
+                  property.optional &&
+                  !eventPropType.alreadySupportsOptionalOrHasDefault
+                    ? `std::optional<${eventPropType.type}>`
+                    : eventPropType.type
+                } ${property.name}${eventPropType.initializer};\n`;
+              })
+              .join('\n');
+            return eventsObjectTemplate
+              .replace(
+                /::_OBJECT_NAME_::/g,
+                `${componentName}_${eventObjectTypeName.replace('on', 'On')}`,
+              )
+              .replace(/::_OBJECT_FIELDS_::/g, eventObjectFields);
+          })
+          .join('\n');
+
+        const eventObjectUsings = eventObjectAliases.jobs
+          .map(eventObjectTypeName => {
+            return `  using ${eventObjectTypeName.replace(
+              'on',
+              'On',
+            )} = ${componentName}_${eventObjectTypeName.replace('on', 'On')};`;
+          })
+          .join('\n');
 
-          // Called to collect the eventObjectAliases
-          translateComponentEventType(event.typeAnnotation.argument!, eventObjectAliases, `${event.name}`, cppCodegenOptions);
-
-          // onSomething -> something
-          let eventNameLower = event.name.replace('on', '');
-          eventNameLower = eventNameLower[0].toLowerCase() + eventNameLower.slice(1);
-
-          return eventEmitterMethodTemplate
-                      .replace(/::_EVENT_NAME_::/g,event.name)
-                      .replace(/::_EVENT_NAME_NO_ON_::/g,eventNameLower)
-                      .replace(/::_EVENT_OBJECT_TYPE_::/g, event.name.replace('on', 'On'));
-        }).join('\n\n');
-        
-        const eventObjects = eventObjectAliases.jobs.map(eventObjectTypeName => {
-          const eventObjectType = eventObjectAliases.types[eventObjectTypeName]!;
-          const eventObjectFields = eventObjectType.properties.map(property => {
-            const eventPropType = translateComponentEventType(property.typeAnnotation, eventObjectAliases, eventObjectTypeName, cppCodegenOptions);
-            return `  REACT_FIELD(${property.name})\n  ${(property.optional && !eventPropType.alreadySupportsOptionalOrHasDefault) ? `std::optional<${eventPropType.type}>` : eventPropType.type} ${property.name}${eventPropType.initializer};\n`;
-          }).join('\n');
-          return eventsObjectTemplate.replace(/::_OBJECT_NAME_::/g, `${componentName}_${eventObjectTypeName.replace('on', 'On')}`).replace(/::_OBJECT_FIELDS_::/g, eventObjectFields);
-        }).join('\n');
-
-        const eventObjectUsings = eventObjectAliases.jobs.map(eventObjectTypeName => {
-          return `  using ${eventObjectTypeName.replace('on', 'On')} = ${componentName}_${eventObjectTypeName.replace('on', 'On')};`
-        }).join('\n');
-        
         const eventEmitter = eventEmitterTemplate
-                              .replace(/::_COMPONENT_EVENT_OBJECT_TYPES_::/g, eventObjects)
-                              .replace(/::_EVENT_EMITTER_METHODS_::/g, eventEmitterMethods)
-                              .replace(/::_EVENT_EMITTER_USINGS_::/g, eventObjectUsings);
-
+          .replace(/::_COMPONENT_EVENT_OBJECT_TYPES_::/g, eventObjects)
+          .replace(/::_EVENT_EMITTER_METHODS_::/g, eventEmitterMethods)
+          .replace(/::_EVENT_EMITTER_USINGS_::/g, eventObjectUsings);
 
         // Commands
-        const commandAliases: AliasMap<ObjectTypeAnnotation<CommandParamTypeAnnotation>> = {types:{}, jobs: []};
-        const hasAnyCommands = (componentShape.commands.length !== 0);
-        const commandHandlers = hasAnyCommands ? componentShape.commands.map(command => {
-          const commandArgs = command.typeAnnotation.params.map(param => {
-            const commandArgType = translateCommandParamType(param.typeAnnotation, commandAliases, `${componentName}_${command.name}`, cppCodegenOptions);
-            return `${(param.optional && !commandArgType.alreadySupportsOptionalOrHasDefault) ? `std::optional<${commandArgType.type}>` : commandArgType.type} ${param.name}`;
-          }).join(', ');
-
-          return `  // You must provide an implementation of this method to handle the "${command.name}" command
-  virtual void Handle${capitalizeFirstLetter(command.name)}Command(${commandArgs}) noexcept = 0;`;
-        }).join('\n\n') : '';
-
-
-        const commandHandler = hasAnyCommands ? `void HandleCommand(const winrt::Microsoft::ReactNative::ComponentView &view, const winrt::Microsoft::ReactNative::HandleCommandArgs& args) noexcept {
+        const commandAliases: AliasMap<
+          ObjectTypeAnnotation<CommandParamTypeAnnotation>
+        > = {types: {}, jobs: []};
+        const hasAnyCommands = componentShape.commands.length !== 0;
+        const commandHandlers = hasAnyCommands
+          ? componentShape.commands
+              .map(command => {
+                const commandArgs = command.typeAnnotation.params
+                  .map(param => {
+                    const commandArgType = translateCommandParamType(
+                      param.typeAnnotation,
+                      commandAliases,
+                      `${componentName}_${command.name}`,
+                      cppCodegenOptions,
+                    );
+                    return `${
+                      param.optional &&
+                      !commandArgType.alreadySupportsOptionalOrHasDefault
+                        ? `std::optional<${commandArgType.type}>`
+                        : commandArgType.type
+                    } ${param.name}`;
+                  })
+                  .join(', ');
+
+                return `  // You must provide an implementation of this method to handle the "${
+                  command.name
+                }" command
+  virtual void Handle${capitalizeFirstLetter(
+    command.name,
+  )}Command(${commandArgs}) noexcept = 0;`;
+              })
+              .join('\n\n')
+          : '';
+
+        const commandHandler = hasAnyCommands
+          ? `void HandleCommand(const winrt::Microsoft::ReactNative::ComponentView &view, const winrt::Microsoft::ReactNative::HandleCommandArgs& args) noexcept {
     auto userData = view.UserData().as<TUserData>();
     auto commandName = args.CommandName();
-${componentShape.commands.map(command => {
-      const commaSeparatedCommandArgs = command.typeAnnotation.params.map(param => param.name).join(', ');
-      return `    if (commandName == L"${command.name}") {
-${command.typeAnnotation.params.length !== 0 ? `      ${command.typeAnnotation.params.map(param => {
-            const commandArgType = translateCommandParamType(param.typeAnnotation, commandAliases, `${componentName}_${command.name}`, cppCodegenOptions);
-            return `${(param.optional && !commandArgType.alreadySupportsOptionalOrHasDefault) ? `std::optional<${commandArgType.type}>` : commandArgType.type} ${param.name};`;
-      }).join('\n')}
-      winrt::Microsoft::ReactNative::ReadArgs(args.CommandArgs(), ${commaSeparatedCommandArgs});` : ''}
-      userData->Handle${capitalizeFirstLetter(command.name)}Command(${commaSeparatedCommandArgs});
+${componentShape.commands
+  .map(command => {
+    const commaSeparatedCommandArgs = command.typeAnnotation.params
+      .map(param => param.name)
+      .join(', ');
+    return `    if (commandName == L"${command.name}") {
+${
+  command.typeAnnotation.params.length !== 0
+    ? `      ${command.typeAnnotation.params
+        .map(param => {
+          const commandArgType = translateCommandParamType(
+            param.typeAnnotation,
+            commandAliases,
+            `${componentName}_${command.name}`,
+            cppCodegenOptions,
+          );
+          return `${
+            param.optional &&
+            !commandArgType.alreadySupportsOptionalOrHasDefault
+              ? `std::optional<${commandArgType.type}>`
+              : commandArgType.type
+          } ${param.name};`;
+        })
+        .join('\n')}
+      winrt::Microsoft::ReactNative::ReadArgs(args.CommandArgs(), ${commaSeparatedCommandArgs});`
+    : ''
+}
+      userData->Handle${capitalizeFirstLetter(
+        command.name,
+      )}Command(${commaSeparatedCommandArgs});
       return;
-    }`
-    }).join('\n\n')}
-  }` : '';
-
-      const registerCommandHandler = hasAnyCommands ? `        builder.SetCustomCommandHandler([](const winrt::Microsoft::ReactNative::ComponentView &view,
+    }`;
+  })
+  .join('\n\n')}
+  }`
+          : '';
+
+        const registerCommandHandler = hasAnyCommands
+          ? `        builder.SetCustomCommandHandler([](const winrt::Microsoft::ReactNative::ComponentView &view,
                                           const winrt::Microsoft::ReactNative::HandleCommandArgs& args) noexcept {
           auto userData = view.UserData().as<TUserData>();
           userData->HandleCommand(view, args);
-        });` : '';
+        });`
+          : '';
 
         const baseType = baseStructTemplate
-        .replace(/::_COMPONENT_VIEW_COMMAND_HANDLERS_::/g, commandHandlers)
-        .replace(/::_COMPONENT_VIEW_COMMAND_HANDLER_::/g, commandHandler);
+          .replace(/::_COMPONENT_VIEW_COMMAND_HANDLERS_::/g, commandHandlers)
+          .replace(/::_COMPONENT_VIEW_COMMAND_HANDLER_::/g, commandHandler);
 
         // Registration
-        const componentRegistration = registerTemplate.replace(/::_REGISTER_CUSTOM_COMMAND_HANDLER_::/g, registerCommandHandler);
+        const componentRegistration = registerTemplate.replace(
+          /::_REGISTER_CUSTOM_COMMAND_HANDLER_::/g,
+          registerCommandHandler,
+        );
 
         // Final output
         const replaceContent = function (template: string): string {
@@ -380,10 +523,7 @@ ${command.typeAnnotation.params.length !== 0 ? `      ${command.typeAnnotation.p
             .replace(/\n\n\n+/g, '\n\n');
         };
 
-        files.set(
-          `${componentName}.g.h`,
-          replaceContent(fileTemplate),
-        );
+        files.set(`${componentName}.g.h`, replaceContent(fileTemplate));
       }
     }
 

package/src/generators/GenerateNM2.ts

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

package/src/generators/GenerateTypeScript.ts

@@ -62,11 +62,13 @@ function optionalSign<T>(obj: NamedShape<T>): string {
 }
 
 function translateType(
-  type: Nullable<
-    | NativeModuleBaseTypeAnnotation
-    | NativeModuleParamTypeAnnotation
-    | NativeModuleReturnTypeAnnotation
-  > | UnsafeAnyTypeAnnotation,
+  type:
+    | Nullable<
+        | NativeModuleBaseTypeAnnotation
+        | NativeModuleParamTypeAnnotation
+        | NativeModuleReturnTypeAnnotation
+      >
+    | UnsafeAnyTypeAnnotation,
 ): string {
   // avoid: Property 'type' does not exist on type 'never'
   const returnType = type.type;

package/src/generators/ObjectTypes.ts

@@ -47,11 +47,13 @@ function translateUnionReturnType(
 }
 
 export function translateFieldOrReturnType(
-  type: Nullable<
-    | NativeModuleBaseTypeAnnotation
-    | NativeModuleStringTypeAnnotation
-    | NativeModuleFunctionTypeAnnotation
-  > | UnsafeAnyTypeAnnotation,
+  type:
+    | Nullable<
+        | NativeModuleBaseTypeAnnotation
+        | NativeModuleStringTypeAnnotation
+        | NativeModuleFunctionTypeAnnotation
+      >
+    | UnsafeAnyTypeAnnotation,
   aliases: AliasMap,
   baseAliasName: string,
   callerName: 'translateField' | 'translateReturnType',

package/src/generators/ParamTypes.ts

@@ -149,7 +149,9 @@ function translateArray(
 function translateEventEmitterArray(
   param: {
     readonly type: 'ArrayTypeAnnotation';
-    readonly elementType: NativeModuleEventEmitterBaseTypeAnnotation | {type: string};
+    readonly elementType:
+      | NativeModuleEventEmitterBaseTypeAnnotation
+      | {type: string};
   },
   aliases: AliasMap,
   baseAliasName: string,
@@ -254,7 +256,13 @@ function translateEventEmitterParam(
     case 'BooleanTypeAnnotation':
       return 'bool';
     case 'ArrayTypeAnnotation':
-      return translateEventEmitterArray(param, aliases, baseAliasName, target, options);
+      return translateEventEmitterArray(
+        param,
+        aliases,
+        baseAliasName,
+        target,
+        options,
+      );
     case 'TypeAliasTypeAnnotation':
       return decorateType(getAliasCppName(param.name), target);
     case 'VoidTypeAnnotation':
@@ -265,7 +273,9 @@ function translateEventEmitterParam(
 }
 
 function translateNullableParamType(
-  paramType: Nullable<NativeModuleParamTypeAnnotation> | UnsafeAnyTypeAnnotation,
+  paramType:
+    | Nullable<NativeModuleParamTypeAnnotation>
+    | UnsafeAnyTypeAnnotation,
   aliases: AliasMap,
   baseAliasName: string,
   nullableTarget: ParamTarget,
@@ -357,14 +367,14 @@ export function translateEventEmitterArgs(
   baseAliasName: string,
   options: CppCodegenOptions,
 ) {
-    const translatedParam = translateEventEmitterParam(
-      params,
-      aliases,
-      baseAliasName,
-      'spec',
-      options,
-    );
-    return `${translatedParam}`;
+  const translatedParam = translateEventEmitterParam(
+    params,
+    aliases,
+    baseAliasName,
+    'spec',
+    options,
+  );
+  return `${translatedParam}`;
 }
 
 export function translateArgs(

package/src/generators/ValidateMethods.ts

@@ -14,7 +14,11 @@ import type {
 } from '@react-native/codegen/lib/CodegenSchema';
 import {AliasMap} from './AliasManaging';
 import type {CppCodegenOptions} from './ObjectTypes';
-import {translateArgs, translateSpecArgs, translateEventEmitterArgs} from './ParamTypes';
+import {
+  translateArgs,
+  translateSpecArgs,
+  translateEventEmitterArgs,
+} from './ParamTypes';
 import {translateImplReturnType, translateSpecReturnType} from './ReturnTypes';
 
 function isMethodSync(funcType: NativeModuleFunctionTypeAnnotation) {
@@ -92,7 +96,7 @@ function renderProperties(
   aliases: AliasMap,
   tuple: boolean,
   options: CppCodegenOptions,
-): { code: string, numberOfProperties: number } {
+): {code: string; numberOfProperties: number} {
   // TODO: generate code for constants
   const properties = methods
     .filter(prop => prop.name !== 'getConstants')
@@ -154,32 +158,31 @@ function renderProperties(
       }
     });
 
-    return {code: properties.join('\n'), numberOfProperties: properties.length};
+  return {code: properties.join('\n'), numberOfProperties: properties.length};
 }
 
 function getPossibleEventEmitterSignatures(
   eventEmitter: NativeModuleEventEmitterShape,
   aliases: AliasMap,
-  options: CppCodegenOptions): string[] {
-  
+  options: CppCodegenOptions,
+): string[] {
   const traversedArgs = translateEventEmitterArgs(
     eventEmitter.typeAnnotation.typeAnnotation,
     aliases,
     eventEmitter.name,
     options,
   );
-  return [`REACT_EVENT(${eventEmitter.name}) std::function<void(${traversedArgs})> ${eventEmitter.name};`]
+  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
-  )
+  options: CppCodegenOptions,
+): string {
+  return getPossibleEventEmitterSignatures(eventEmitter, aliases, options)
     .map(sig => `"    ${sig}\\n"`)
     .join('\n          ');
 }
@@ -201,7 +204,9 @@ function renderEventEmitters(
       );
 
       if (tuple) {
-        return `      EventEmitter<void(${traversedArgs})>{${index + indexOffset}, L"${eventEmitter.name}"},`;
+        return `      EventEmitter<void(${traversedArgs})>{${
+          index + indexOffset
+        }, L"${eventEmitter.name}"},`;
       } else {
         return `    REACT_SHOW_EVENTEMITTER_SPEC_ERRORS(
           ${index + indexOffset},
@@ -210,7 +215,7 @@ function renderEventEmitters(
             eventEmitter,
             aliases,
             options,
-      )});`;
+          )});`;
       }
     })
     .join('\n');
@@ -221,10 +226,10 @@ export function generateValidateMethods(
   aliases: AliasMap,
   options: CppCodegenOptions,
 ): {
-  traversedProperties: string,
-  traversedEventEmitters: string,
-  traversedPropertyTuples: string,
-  traversedEventEmitterTuples: string,
+  traversedProperties: string;
+  traversedEventEmitters: string;
+  traversedPropertyTuples: string;
+  traversedEventEmitterTuples: string;
 } {
   const methods = nativeModule.spec.methods;
   const eventEmitters = nativeModule.spec.eventEmitters;
@@ -254,5 +259,10 @@ export function generateValidateMethods(
     true,
     options,
   );
-  return {traversedPropertyTuples: traversedPropertyTuples.code, traversedEventEmitterTuples, traversedProperties: traversedProperties.code, traversedEventEmitters};
+  return {
+    traversedPropertyTuples: traversedPropertyTuples.code,
+    traversedEventEmitterTuples,
+    traversedProperties: traversedProperties.code,
+    traversedEventEmitters,
+  };
 }