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

package/src/generators/ParamTypes.ts

@@ -10,10 +10,13 @@ import type {
   NamedShape,
   NativeModuleArrayTypeAnnotation,
   NativeModuleBaseTypeAnnotation,
+  NativeModuleEventEmitterBaseTypeAnnotation,
+  NativeModuleEventEmitterTypeAnnotation,
   NativeModuleEnumDeclaration,
   NativeModuleFunctionTypeAnnotation,
   NativeModuleParamTypeAnnotation,
   NativeModuleUnionTypeAnnotation,
+  UnsafeAnyTypeAnnotation,
   Nullable,
 } from '@react-native/codegen/lib/CodegenSchema';
 import {
@@ -114,7 +117,7 @@ function translateArray(
   target: ParamTarget,
   options: CppCodegenOptions,
 ): string {
-  if (param.elementType) {
+  if (param.elementType.type !== 'AnyTypeAnnotation') {
     switch (target) {
       case 'spec':
       case 'template':
@@ -141,8 +144,41 @@ 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,
+  param: NativeModuleParamTypeAnnotation | UnsafeAnyTypeAnnotation,
   aliases: AliasMap,
   baseAliasName: string,
   target: ParamTarget,
@@ -188,13 +224,48 @@ function translateParam(
     case 'EnumDeclaration':
     case 'UnionTypeAnnotation':
       return translateUnionReturnType(param, target, options);
+    case 'AnyTypeAnnotation':
+      return decorateType('::React::JSValue', target);
+    default:
+      throw new Error(`Unhandled type in translateParam: ${paramType}`);
+  }
+}
+
+// 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>,
+  paramType: Nullable<NativeModuleParamTypeAnnotation> | UnsafeAnyTypeAnnotation,
   aliases: AliasMap,
   baseAliasName: string,
   nullableTarget: ParamTarget,
@@ -280,6 +351,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,

package/src/generators/PropObjectTypes.ts

@@ -0,0 +1,233 @@
+import type { PropTypeAnnotation, ObjectTypeAnnotation, EventTypeAnnotation, CommandParamTypeAnnotation } from '@react-native/codegen/lib/CodegenSchema';
+import type { CppCodegenOptions } from './ObjectTypes';
+import {
+  AliasMap,
+  getAnonymousAliasCppName,
+} from './AliasManaging';
+
+
+// eslint-disable-next-line complexity
+export function translateComponentPropsFieldType(type: PropTypeAnnotation,
+  aliases: AliasMap<ObjectTypeAnnotation<PropTypeAnnotation>>,
+  baseAliasName: string,
+  options: CppCodegenOptions): { type: string, initializer: string, alreadySupportsOptionalOrHasDefault?: boolean } {
+  switch (type.type) {
+    case 'StringTypeAnnotation':
+      return { type: options.cppStringType, initializer: type.default ? `{${type.default}}` : '', alreadySupportsOptionalOrHasDefault: !!type.default };
+    case 'FloatTypeAnnotation':
+      return { type: 'float', initializer: type.default ? `{${type.default}}` : '{}', alreadySupportsOptionalOrHasDefault: !!type.default };
+    case 'DoubleTypeAnnotation':
+      return { type: 'double', initializer: type.default ? `{${type.default}}` : '{}', alreadySupportsOptionalOrHasDefault: !!type.default };
+    case 'Int32TypeAnnotation':
+      return { type: 'int32_t', initializer: type.default ? `{${type.default}}` : '{}', alreadySupportsOptionalOrHasDefault: !!type.default };
+    case 'BooleanTypeAnnotation':
+      return { type: 'bool', initializer: type.default ? `{${type.default}}` : '{}', alreadySupportsOptionalOrHasDefault: !!type.default };
+    case 'ArrayTypeAnnotation':
+
+      let arrayTemplateArg = '';
+      switch (type.elementType.type) {
+        case 'BooleanTypeAnnotation':
+          arrayTemplateArg = 'bool';
+          break;
+        case 'DoubleTypeAnnotation':
+          arrayTemplateArg = 'double';
+          break;
+        case 'FloatTypeAnnotation':
+          arrayTemplateArg = 'float';
+          break;
+        case 'Int32TypeAnnotation':
+          arrayTemplateArg = 'int32_t';
+          break;
+        case 'StringTypeAnnotation':
+          arrayTemplateArg = options.cppStringType;
+          break;
+        case 'ArrayTypeAnnotation':
+          const innerType = translateComponentPropsFieldType(type.elementType, aliases, baseAliasName, options);
+          arrayTemplateArg = `std::vector<${innerType.type}>`;
+          break;
+        case 'ObjectTypeAnnotation':
+          arrayTemplateArg = translateComponentPropsFieldType(type.elementType, aliases, baseAliasName, options).type;
+          break;
+        case 'ReservedPropTypeAnnotation':
+          switch (type.elementType.name) {
+            case 'ColorPrimitive':
+              arrayTemplateArg = 'winrt::Microsoft::ReactNative::Color';
+              break;
+            case 'DimensionPrimitive':
+            case 'EdgeInsetsPrimitive':
+            case 'ImageRequestPrimitive':
+            case 'ImageSourcePrimitive':
+            case 'PointPrimitive':
+              arrayTemplateArg = 'winrt::Microsoft::ReactNative::JSValue'; // TODO - better handling for these types than JSValue
+              break;
+            default:
+              throw new Error(`Unhandled ReservedPropTypeAnnotation type: ${type.elementType.name}`);
+          }
+          break;
+        case 'StringEnumTypeAnnotation':
+          arrayTemplateArg = options.cppStringType; // TODO - better enum type handling than just passing a string
+          break;
+        default:
+          throw new Error(`Unhandled type: ${type.type}`);
+      }
+
+      return { type: `std::vector<${arrayTemplateArg}>`, initializer: '' };
+    case 'ReservedPropTypeAnnotation':
+      switch (type.name) {
+        case 'ColorPrimitive':
+          return { type: 'winrt::Microsoft::ReactNative::Color', initializer: '{nullptr}', alreadySupportsOptionalOrHasDefault: true };
+        case 'DimensionPrimitive':
+        case 'EdgeInsetsPrimitive':
+        case 'ImageRequestPrimitive':
+        case 'ImageSourcePrimitive':
+        case 'PointPrimitive':
+          return { type: 'winrt::Microsoft::ReactNative::JSValue', initializer: '{nullptr}', alreadySupportsOptionalOrHasDefault: true }; // TODO - better handling for these types than JSValue
+        default:
+          throw new Error(`Unhandled ReservedPropTypeAnnotation type: ${type.name}`);
+      }
+    case 'ObjectTypeAnnotation': {
+      return { type: getAnonymousAliasCppName<ObjectTypeAnnotation<PropTypeAnnotation>>(aliases, baseAliasName, type), initializer: '' };
+    }
+    case 'MixedTypeAnnotation':
+      return { type: 'winrt::Microsoft::ReactNative::JSValue', initializer: '{nullptr}', alreadySupportsOptionalOrHasDefault: true };
+    case 'Int32EnumTypeAnnotation':
+      return { type: 'int32_t', initializer: '' }; // TODO - better enum type handling than just passing a string
+    case 'StringEnumTypeAnnotation':
+      return { type: options.cppStringType, initializer: '' }; // TODO - better enum type handling than just passing an int
+    default:
+      throw new Error(`Unhandled type: ${(type as any).type}`);
+  }
+}
+
+export function translateComponentEventType(type: EventTypeAnnotation,
+  aliases: AliasMap<ObjectTypeAnnotation<EventTypeAnnotation>>,
+  baseAliasName: string,
+  options: CppCodegenOptions): { type: string, initializer: string, alreadySupportsOptionalOrHasDefault?: boolean } {
+  switch (type.type) {
+    case 'StringTypeAnnotation':
+      return { type: options.cppStringType, initializer: '' };
+    case 'FloatTypeAnnotation':
+      return { type: 'float', initializer: '{}' };
+    case 'DoubleTypeAnnotation':
+      return { type: 'double', initializer: '{}' };
+    case 'Int32TypeAnnotation':
+      return { type: 'int32_t', initializer: '{}' };
+    case 'BooleanTypeAnnotation':
+      return { type: 'bool', initializer: '{}' };
+    case 'ArrayTypeAnnotation':
+      {
+        let arrayTemplateArg = '';
+        switch (type.elementType.type) {
+          case 'BooleanTypeAnnotation':
+            arrayTemplateArg = 'bool';
+            break;
+          case 'DoubleTypeAnnotation':
+            arrayTemplateArg = 'double';
+            break;
+          case 'FloatTypeAnnotation':
+            arrayTemplateArg = 'float';
+            break;
+          case 'Int32TypeAnnotation':
+            arrayTemplateArg = 'int32_t';
+            break;
+          case 'StringTypeAnnotation':
+            arrayTemplateArg = options.cppStringType;
+            break;
+          case 'ArrayTypeAnnotation':
+            const innerType = translateComponentEventType(type.elementType, aliases, baseAliasName, options);
+            arrayTemplateArg = `std::vector<${innerType.type}>`;
+            break;
+          case 'MixedTypeAnnotation':
+            arrayTemplateArg = 'winrt::Microsoft::ReactNative::JSValue';
+            break;
+          case 'ObjectTypeAnnotation':
+            arrayTemplateArg = translateComponentEventType(type.elementType, aliases, baseAliasName, options).type;
+            break;
+          case 'StringEnumTypeAnnotation':
+            arrayTemplateArg = options.cppStringType; // TODO - better enum type handling than just passing a string
+            break;
+          default:
+            throw new Error(`Unhandled type: ${type.type}`);
+        }
+
+        return { type: `std::vector<${arrayTemplateArg}>`, initializer: '{}' };
+      }
+    case 'ObjectTypeAnnotation': {
+      return { type: getAnonymousAliasCppName<ObjectTypeAnnotation<EventTypeAnnotation>>(aliases, baseAliasName, type), initializer: '' };
+    }
+    case 'MixedTypeAnnotation': {
+      return { type: 'winrt::Microsoft::ReactNative::JSValue', initializer: '{nullptr}', alreadySupportsOptionalOrHasDefault: true };
+    }
+    case 'StringEnumTypeAnnotation':
+      return { type: options.cppStringType, initializer: '' };  // TODO - better enum type handling than just passing a string
+    default:
+      throw new Error(`Unhandled type: ${(type as any).type}`);
+  }
+}
+
+
+export function translateCommandParamType(type: CommandParamTypeAnnotation,
+  aliases: AliasMap<ObjectTypeAnnotation<CommandParamTypeAnnotation>>,
+  baseAliasName: string,
+  options: CppCodegenOptions): { type: string, initializer: string, alreadySupportsOptionalOrHasDefault?: boolean } {
+  switch (type.type) {
+    case 'StringTypeAnnotation':
+      return { type: options.cppStringType, initializer: '' };
+    case 'FloatTypeAnnotation':
+      return { type: 'float', initializer: '{}' };
+    case 'DoubleTypeAnnotation':
+      return { type: 'double', initializer: '{}' };
+    case 'Int32TypeAnnotation':
+      return { type: 'int32_t', initializer: '{}' };
+    case 'BooleanTypeAnnotation':
+      return { type: 'bool', initializer: '{}' };
+    case 'ArrayTypeAnnotation':
+      {
+        let arrayTemplateArg = '';
+        switch (type.elementType.type) {
+          case 'BooleanTypeAnnotation':
+            arrayTemplateArg = 'bool';
+            break;
+          case 'DoubleTypeAnnotation':
+            arrayTemplateArg = 'double';
+            break;
+          case 'FloatTypeAnnotation':
+            arrayTemplateArg = 'float';
+            break;
+          case 'Int32TypeAnnotation':
+            arrayTemplateArg = 'int32_t';
+            break;
+          case 'StringTypeAnnotation':
+            arrayTemplateArg = options.cppStringType;
+            break;
+          case 'ArrayTypeAnnotation':
+            const innerType = translateCommandParamType(type.elementType, aliases, baseAliasName, options);
+            arrayTemplateArg = `std::vector<${innerType.type}>`;
+            break;
+          case 'ReservedPropTypeAnnotation':
+            arrayTemplateArg = 'winrt::Microsoft::ReactNative::JSValue';
+            break;
+          case 'ObjectTypeAnnotation':
+            arrayTemplateArg = 'winrt::Microsoft::ReactNative::JSValueObject'; // TODO - better typing
+            break;
+          case 'StringEnumTypeAnnotation':
+            arrayTemplateArg = options.cppStringType; // TODO - better enum type handling than just passing a string
+            break;
+          case 'GenericTypeAnnotation' as any: // TODO verify schema - Getting this type when running codegen on all the built in types
+            arrayTemplateArg = 'winrt::Microsoft::ReactNative::JSValue';
+            break;
+          default:
+            throw new Error(`Unhandled type: ${(type.elementType as any).type} - ${JSON.stringify(type.elementType, null, 2)}`);
+        }
+
+        return { type: `std::vector<${arrayTemplateArg}>`, initializer: '{}' };
+      }
+    case 'ReservedTypeAnnotation': 
+      if ((type.name as any) !== 'RootTag') {
+        throw new Error(`Unhandled ReservedTypeAnnotation: ${type.name}`)
+      }
+      return { type: 'bool', initializer: '{-1}' };
+    default:
+      throw new Error(`Unhandled type: ${(type as any).type}`);
+  }
+}

package/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};
 }

package/src/index.ts

@@ -10,6 +10,7 @@ import fs from '@react-native-windows/fs';
 import globby from 'globby';
 import type {CppStringTypes} from './generators/GenerateNM2';
 import {createNM2Generator} from './generators/GenerateNM2';
+import {createComponentGenerator} from './generators/GenerateComponentWindows';
 import {
   generateTypeScript,
   setOptionalTurboModule,
@@ -49,6 +50,8 @@ export interface SharedOptions {
   modulesCxx: boolean;
   modulesTypeScriptTypes: boolean;
   modulesWindows: boolean;
+  componentsWindows: boolean,
+  internalComponents: boolean,
   namespace: string;
   outputDirectory: string;
   cppStringType: CppStringTypes;
@@ -214,6 +217,8 @@ export function generate(
     modulesCxx,
     modulesTypeScriptTypes,
     modulesWindows,
+    internalComponents,
+    componentsWindows,
     namespace,
     outputDirectory,
     cppStringType,
@@ -320,6 +325,10 @@ export function generate(
     )
   ) {
     const componentGenerators = [
+    ];
+
+    if (internalComponents) {
+      componentGenerators.push(
       generatorComponentDescriptorH,
       generatorEventEmitterCPP,
       generatorEventEmitterH,
@@ -328,8 +337,18 @@ export function generate(
       generatorShadowNodeCPP,
       generatorShadowNodeH,
       generatorStateCPP,
-      generatorStateH,
-    ];
+      generatorStateH
+      );
+    }
+
+    if (componentsWindows) {
+    const generateComponentWindows = createComponentGenerator({
+        namespace,
+        cppStringType,
+      });
+
+      componentGenerators.push(generateComponentWindows);
+    }
 
     componentGenerators.forEach(generator => {
       const generated: Map<string, string> = generator(
@@ -369,6 +388,8 @@ export function runCodeGen(options: CodeGenOptions): boolean {
     modulesCxx,
     modulesTypeScriptTypes,
     modulesWindows,
+    componentsWindows,
+    internalComponents,
     namespace,
     outputDirectory,
     cppStringType,
@@ -381,6 +402,8 @@ export function runCodeGen(options: CodeGenOptions): boolean {
       modulesCxx,
       modulesTypeScriptTypes,
       modulesWindows,
+      componentsWindows,
+      internalComponents,
       namespace,
       outputDirectory,
       cppStringType,