@react-native-windows/codegen 0.72.0 → 0.72.2

package/src/Cli.ts

@@ -6,7 +6,7 @@
  */
 
 import yargs from 'yargs';
-import {runCodeGen} from './index';
+import {CodeGenOptions, runCodeGen} from './index';
 
 const argv = yargs.options({
   file: {
@@ -58,6 +58,17 @@ const argv = yargs.options({
     required: true,
     describe: 'Used for part of the path generated within the codegen dir',
   },
+  cppStringType: {
+    choices: ['std::string', 'std::wstring'],
+    describe:
+      'C++ string type in generated code, should be "std::string" or "std::wstring"',
+    default: 'std::string',
+  },
+  separateDataTypes: {
+    type: 'boolean',
+    describe: 'generate data types in a separate file',
+    default: false,
+  },
 }).argv;
 
 if ((argv.file && argv.files) || (!argv.file && !argv.files)) {
@@ -65,7 +76,18 @@ if ((argv.file && argv.files) || (!argv.file && !argv.files)) {
   process.exit(1);
 }
 
-const changesNecessary = runCodeGen(argv);
+if (
+  argv.cppStringType !== 'std::string' &&
+  argv.cppStringType !== 'std::wstring'
+) {
+  console.error('cppStringType should be "std::string" or "std::wstring".');
+  process.exit(1);
+}
+
+// type casting is necessary here because
+// cppStringType does not become union of string literals
+// until yargs.options get improved in the future
+const changesNecessary = runCodeGen(<CodeGenOptions>argv);
 
 if (argv.test && changesNecessary) {
   console.error(

package/src/generators/AliasGen.ts

@@ -13,13 +13,14 @@ import type {
   Nullable,
 } from '@react-native/codegen/lib/CodegenSchema';
 import {AliasMap, getAliasCppName} from './AliasManaging';
-import {translateField} from './ObjectTypes';
+import {CppCodegenOptions, translateField} from './ObjectTypes';
 
-function translateObjectBody(
+function translateObjectMembersDefinition(
   type: NativeModuleObjectTypeAnnotation,
   aliases: AliasMap,
   baseAliasName: string,
   prefix: string,
+  options: CppCodegenOptions,
 ) {
   return type.properties
     .map((prop: NamedShape<Nullable<NativeModuleBaseTypeAnnotation>>) => {
@@ -27,13 +28,24 @@ function translateObjectBody(
       if (prop.optional && propType.type !== 'NullableTypeAnnotation') {
         propType = {type: 'NullableTypeAnnotation', typeAnnotation: propType};
       }
-      const first = `${prefix}REACT_FIELD(${prop.name})`;
-      const second = `${prefix}${translateField(
+      return `${prefix}${translateField(
         propType,
         aliases,
         `${baseAliasName}_${prop.name}`,
+        options,
       )} ${prop.name};`;
-      return `${first}\n${second}`;
+    })
+    .join('\n');
+}
+
+function translateObjectMembersReflection(
+  type: NativeModuleObjectTypeAnnotation,
+  aliasCppName: string,
+  prefix: string,
+) {
+  return type.properties
+    .map((prop: NamedShape<Nullable<NativeModuleBaseTypeAnnotation>>) => {
+      return `${prefix}{L"${prop.name}", &${aliasCppName}::${prop.name}},`;
     })
     .join('\n');
 }
@@ -48,28 +60,50 @@ export function createAliasMap(nativeModuleAliases: {
   return aliases;
 }
 
+interface AliasCode {
+  definition: string;
+  reflection: string;
+}
+
 interface AliasCodeMap {
-  [name: string]: string;
+  [name: string]: AliasCode;
 }
 
 function generateSingleAlias(
   aliases: AliasMap,
   aliasName: string,
   aliasCode: AliasCodeMap,
+  options: CppCodegenOptions,
 ): void {
+  const aliasCppName = getAliasCppName(aliasName);
   const aliasType = <NativeModuleObjectTypeAnnotation>aliases.types[aliasName];
-  aliasCode[aliasName] = `
-REACT_STRUCT(${getAliasCppName(aliasName)})
-struct ${getAliasCppName(aliasName)} {
-${translateObjectBody(aliasType, aliases, aliasName, '    ')}
+  const definition = `
+struct ${aliasCppName} {
+${translateObjectMembersDefinition(
+  aliasType,
+  aliases,
+  aliasName,
+  '    ',
+  options,
+)}
 };
 `;
+  const reflection = `
+inline winrt::Microsoft::ReactNative::FieldMap GetStructInfo(${aliasCppName}*) noexcept {
+    winrt::Microsoft::ReactNative::FieldMap fieldMap {
+${translateObjectMembersReflection(aliasType, aliasCppName, '        ')}
+    };
+    return fieldMap;
+}
+`;
+  aliasCode[aliasName] = {definition, reflection};
 }
 
 function generateNestedAliasesInCorrectOrder(
   aliases: AliasMap,
   aliasCode: AliasCodeMap,
   aliasOrder: string[],
+  options: CppCodegenOptions,
 ): void {
   // retrieve and clean all ungenerated aliases
   const jobs = aliases.jobs;
@@ -80,26 +114,36 @@ function generateNestedAliasesInCorrectOrder(
     // generate a new struct and all fields will be examined
     // new anonymous objects could be found
     // they will be stored in aliases.jobs
-    generateSingleAlias(aliases, aliasName, aliasCode);
+    generateSingleAlias(aliases, aliasName, aliasCode, options);
     // nested C++ structs must be put before the current C++ struct
     // as they will be used in the current C++ struct
     // the order will be perfectly and easily ensured by doing this recursively
-    generateNestedAliasesInCorrectOrder(aliases, aliasCode, aliasOrder);
+    generateNestedAliasesInCorrectOrder(
+      aliases,
+      aliasCode,
+      aliasOrder,
+      options,
+    );
     // all referenced C++ structs are generated
     // put the current one following them
     aliasOrder.push(aliasName);
   }
 }
 
-export function generateAliases(aliases: AliasMap): string {
+export function generateAliases(
+  aliases: AliasMap,
+  options: CppCodegenOptions,
+): [string, string] {
   const aliasCode: AliasCodeMap = {};
   const aliasOrder: string[] = [];
-  generateNestedAliasesInCorrectOrder(aliases, aliasCode, aliasOrder);
+  generateNestedAliasesInCorrectOrder(aliases, aliasCode, aliasOrder, options);
 
   // aliasOrder now has the correct order of C++ struct code
-  let traversedAliasedStructs = '';
+  let customTypes = '';
+  let customReflection = '';
   for (const aliasName of aliasOrder) {
-    traversedAliasedStructs = `${traversedAliasedStructs}${aliasCode[aliasName]}`;
+    customTypes = `${customTypes}${aliasCode[aliasName].definition}`;
+    customReflection = `${customReflection}${aliasCode[aliasName].reflection}`;
   }
-  return traversedAliasedStructs;
+  return [customTypes, customReflection];
 }

package/src/generators/GenerateNM2.ts

@@ -11,24 +11,22 @@ import {AliasMap, setPreferredModuleName} from './AliasManaging';
 import {createAliasMap, generateAliases} from './AliasGen';
 import {generateValidateConstants} from './ValidateConstants';
 import {generateValidateMethods} from './ValidateMethods';
+import type {CppStringTypes} from './ObjectTypes';
+
+export type {CppStringTypes} from './ObjectTypes';
 
 type FilesOutput = Map<string, string>;
 
-const moduleTemplate = `
-/*
+const headerTemplate = `/*
  * This file is auto-generated from a NativeModule spec file in js.
  *
  * This is a C++ Spec class that should be used with MakeTurboModuleProvider to register native modules
  * in a way that also verifies at compile time that the native module matches the interface required
  * by the TurboModule JS spec.
  */
-#pragma once
-
-#include "NativeModules.h"
-#include <tuple>
+#pragma once`;
 
-namespace ::_NAMESPACE_:: {
-::_MODULE_ALIASED_STRUCTS_::
+const specTemplate = `::_MODULE_CUSTPM_TYPES_REFLECTION_::
 struct ::_MODULE_NAME_::Spec : winrt::Microsoft::ReactNative::TurboModuleSpec {
 ::_MODULE_MEMBERS_TUPLES_::
 
@@ -37,7 +35,44 @@ struct ::_MODULE_NAME_::Spec : winrt::Microsoft::ReactNative::TurboModuleSpec {
 ::_MODULE_MEMBERS_CHECKS_::
 
 ::_MODULE_MEMBERS_ERRORS_::
-  }
+  }`;
+
+const typeOnlyTemplate = `
+${headerTemplate}
+
+#include <string>
+#include <optional>
+#include <functional>
+#include <vector>
+
+namespace ::_NAMESPACE_:: {
+::_MODULE_CUSTPM_TYPES_::
+} // namespace ::_NAMESPACE_::
+`;
+
+const moduleOnlyTemplate = `
+${headerTemplate}
+
+::_TYPE_DEFINITION_INCLUDE_::
+#include <NativeModules.h>
+#include <tuple>
+
+namespace ::_NAMESPACE_:: {
+${specTemplate}
+};
+
+} // namespace ::_NAMESPACE_::
+`;
+
+const allInOneTemplate = `
+${headerTemplate}
+
+#include <NativeModules.h>
+#include <tuple>
+
+namespace ::_NAMESPACE_:: {
+::_MODULE_CUSTPM_TYPES_::
+${specTemplate}
 };
 
 } // namespace ::_NAMESPACE_::
@@ -46,9 +81,13 @@ struct ::_MODULE_NAME_::Spec : winrt::Microsoft::ReactNative::TurboModuleSpec {
 export function createNM2Generator({
   methodOnly,
   namespace,
+  cppStringType,
+  separateDataTypes,
 }: {
   methodOnly: boolean;
   namespace: string;
+  cppStringType: CppStringTypes;
+  separateDataTypes: boolean;
 }) {
   return (
     _libraryName: string,
@@ -74,7 +113,9 @@ export function createNM2Generator({
         const aliases: AliasMap = createAliasMap(nativeModule.aliasMap);
 
         // prepare methods
-        const methods = generateValidateMethods(nativeModule, aliases);
+        const methods = generateValidateMethods(nativeModule, aliases, {
+          cppStringType,
+        });
         let tuples = `
   static constexpr auto methods = std::tuple{
 ${methods[0]}
@@ -98,18 +139,46 @@ ${errors}`;
         }
 
         // generate code for structs
-        const traversedAliasedStructs = generateAliases(aliases);
+        const [customTypes, customReflection] = generateAliases(aliases, {
+          cppStringType,
+        });
+
+        const customTypesExist = customTypes !== '';
 
-        files.set(
-          `Native${preferredModuleName}Spec.g.h`,
-          moduleTemplate
-            .replace(/::_MODULE_ALIASED_STRUCTS_::/g, traversedAliasedStructs)
+        const replaceContent = function (template: string): string {
+          return template
+            .replace(/::_MODULE_CUSTPM_TYPES_::/g, customTypes)
+            .replace(/::_MODULE_CUSTPM_TYPES_REFLECTION_::/g, customReflection)
             .replace(/::_MODULE_MEMBERS_TUPLES_::/g, tuples.substring(1))
             .replace(/::_MODULE_MEMBERS_CHECKS_::/g, checks.substring(1))
             .replace(/::_MODULE_MEMBERS_ERRORS_::/g, errors)
             .replace(/::_MODULE_NAME_::/g, preferredModuleName)
-            .replace(/::_NAMESPACE_::/g, namespace),
-        );
+            .replace(
+              /::_TYPE_DEFINITION_INCLUDE_::/g,
+              customTypesExist
+                ? `// #include "Native${preferredModuleName}DataTypes.g.h" before this file to use the generated type definition`
+                : '',
+            )
+            .replace(/::_NAMESPACE_::/g, namespace);
+        };
+
+        if (separateDataTypes) {
+          if (customTypesExist) {
+            files.set(
+              `Native${preferredModuleName}DataTypes.g.h`,
+              replaceContent(typeOnlyTemplate),
+            );
+          }
+          files.set(
+            `Native${preferredModuleName}Spec.g.h`,
+            replaceContent(moduleOnlyTemplate),
+          );
+        } else {
+          files.set(
+            `Native${preferredModuleName}Spec.g.h`,
+            replaceContent(allInOneTemplate),
+          );
+        }
       }
     }
 

package/src/generators/ObjectTypes.ts

@@ -18,13 +18,20 @@ import {
   getAnonymousAliasCppName,
 } from './AliasManaging';
 
+export type CppStringTypes = 'std::string' | 'std::wstring';
+
+export interface CppCodegenOptions {
+  cppStringType: CppStringTypes;
+}
+
 function translateUnionReturnType(
   type: NativeModuleEnumDeclaration | NativeModuleUnionTypeAnnotation,
+  options: CppCodegenOptions,
 ): string {
   const memberType = type.memberType;
   switch (type.memberType) {
     case 'StringTypeAnnotation':
-      return 'std::string';
+      return options.cppStringType;
     case 'NumberTypeAnnotation':
       return 'double';
     case 'ObjectTypeAnnotation':
@@ -41,12 +48,13 @@ export function translateFieldOrReturnType(
   aliases: AliasMap,
   baseAliasName: string,
   callerName: 'translateField' | 'translateReturnType',
+  options: CppCodegenOptions,
 ): string {
   // avoid: Property 'type' does not exist on type 'never'
   const returnType = type.type;
   switch (type.type) {
     case 'StringTypeAnnotation':
-      return 'std::string';
+      return options.cppStringType;
     case 'NumberTypeAnnotation':
     case 'FloatTypeAnnotation':
     case 'DoubleTypeAnnotation':
@@ -62,6 +70,7 @@ export function translateFieldOrReturnType(
           aliases,
           `${baseAliasName}_element`,
           callerName,
+          options,
         )}>`;
       } else {
         return `::React::JSValueArray`;
@@ -87,10 +96,11 @@ export function translateFieldOrReturnType(
         aliases,
         baseAliasName,
         callerName,
+        options,
       )}>`;
     case 'EnumDeclaration':
     case 'UnionTypeAnnotation':
-      return translateUnionReturnType(type);
+      return translateUnionReturnType(type, options);
     default:
       throw new Error(`Unhandled type in ${callerName}: ${returnType}`);
   }
@@ -100,11 +110,13 @@ export function translateField(
   type: Nullable<NativeModuleBaseTypeAnnotation>,
   aliases: AliasMap,
   baseAliasName: string,
+  options: CppCodegenOptions,
 ): string {
   return translateFieldOrReturnType(
     type,
     aliases,
     baseAliasName,
     'translateField',
+    options,
   );
 }

package/src/generators/ParamTypes.ts

@@ -21,6 +21,7 @@ import {
   getAliasCppName,
   getAnonymousAliasCppName,
 } from './AliasManaging';
+import type {CppCodegenOptions} from './ObjectTypes';
 
 type NativeModuleParamShape = NamedShape<
   Nullable<NativeModuleParamTypeAnnotation>
@@ -42,11 +43,12 @@ function decorateType(type: string, target: ParamTarget): string {
 function translateUnionReturnType(
   type: NativeModuleEnumDeclaration | NativeModuleUnionTypeAnnotation,
   target: ParamTarget,
+  options: CppCodegenOptions,
 ): string {
   const memberType = type.memberType;
   switch (type.memberType) {
     case 'StringTypeAnnotation':
-      return 'std::string';
+      return options.cppStringType;
     case 'NumberTypeAnnotation':
       return 'double';
     case 'ObjectTypeAnnotation':
@@ -63,25 +65,41 @@ function translateFunction(
   aliases: AliasMap,
   baseAliasName: string,
   target: ParamTarget,
+  options: CppCodegenOptions,
 ): string {
   // TODO: type.returnTypeAnnotation
   switch (target) {
     case 'spec':
       return `Callback<${param.params
         .map((p: NativeModuleParamShape) =>
-          translateSpecFunctionParam(p, aliases, `${baseAliasName}_${p.name}`),
+          translateSpecFunctionParam(
+            p,
+            aliases,
+            `${baseAliasName}_${p.name}`,
+            options,
+          ),
         )
         .join(', ')}>`;
     case 'template':
       return `std::function<void(${param.params
         .map((p: NativeModuleParamShape) =>
-          translateCallbackParam(p, aliases, `${baseAliasName}_${p.name}`),
+          translateCallbackParam(
+            p,
+            aliases,
+            `${baseAliasName}_${p.name}`,
+            options,
+          ),
         )
         .join(', ')})>`;
     default:
       return `std::function<void(${param.params
         .map((p: NativeModuleParamShape) =>
-          translateCallbackParam(p, aliases, `${baseAliasName}_${p.name}`),
+          translateCallbackParam(
+            p,
+            aliases,
+            `${baseAliasName}_${p.name}`,
+            options,
+          ),
         )
         .join(', ')})> const &`;
   }
@@ -94,6 +112,7 @@ function translateArray(
   aliases: AliasMap,
   baseAliasName: string,
   target: ParamTarget,
+  options: CppCodegenOptions,
 ): string {
   if (param.elementType) {
     switch (target) {
@@ -105,6 +124,7 @@ function translateArray(
           `${baseAliasName}_element`,
           'template',
           'template',
+          options,
         )}>`;
       default:
         return `std::vector<${translateNullableParamType(
@@ -113,6 +133,7 @@ function translateArray(
           `${baseAliasName}_element`,
           'template',
           'template',
+          options,
         )}> const &`;
     }
   } else {
@@ -125,12 +146,13 @@ function translateParam(
   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 'std::string';
+      return options.cppStringType;
     case 'NumberTypeAnnotation':
     case 'FloatTypeAnnotation':
     case 'DoubleTypeAnnotation':
@@ -140,9 +162,9 @@ function translateParam(
     case 'BooleanTypeAnnotation':
       return 'bool';
     case 'FunctionTypeAnnotation':
-      return translateFunction(param, aliases, baseAliasName, target);
+      return translateFunction(param, aliases, baseAliasName, target, options);
     case 'ArrayTypeAnnotation':
-      return translateArray(param, aliases, baseAliasName, target);
+      return translateArray(param, aliases, baseAliasName, target, options);
     case 'GenericObjectTypeAnnotation':
       return decorateType('::React::JSValue', target);
     case 'ObjectTypeAnnotation':
@@ -163,7 +185,7 @@ function translateParam(
       return decorateType(getAliasCppName(param.name), target);
     case 'EnumDeclaration':
     case 'UnionTypeAnnotation':
-      return translateUnionReturnType(param, target);
+      return translateUnionReturnType(param, target, options);
     default:
       throw new Error(`Unhandled type in translateParam: ${paramType}`);
   }
@@ -175,6 +197,7 @@ function translateNullableParamType(
   baseAliasName: string,
   nullableTarget: ParamTarget,
   target: ParamTarget,
+  options: CppCodegenOptions,
 ): string {
   switch (paramType.type) {
     case 'NullableTypeAnnotation':
@@ -183,9 +206,10 @@ function translateNullableParamType(
         aliases,
         baseAliasName,
         nullableTarget,
+        options,
       )}>`;
     default:
-      return translateParam(paramType, aliases, baseAliasName, target);
+      return translateParam(paramType, aliases, baseAliasName, target, options);
   }
 }
 
@@ -193,6 +217,7 @@ function translateSpecFunctionParam(
   param: NativeModuleParamShape,
   aliases: AliasMap,
   baseAliasName: string,
+  options: CppCodegenOptions,
 ): string {
   return translateNullableParamType(
     param.typeAnnotation,
@@ -200,6 +225,7 @@ function translateSpecFunctionParam(
     baseAliasName,
     'spec',
     'spec',
+    options,
   );
 }
 
@@ -207,6 +233,7 @@ function translateCallbackParam(
   param: NativeModuleParamShape,
   aliases: AliasMap,
   baseAliasName: string,
+  options: CppCodegenOptions,
 ): string {
   return translateNullableParamType(
     param.typeAnnotation,
@@ -214,6 +241,7 @@ function translateCallbackParam(
     baseAliasName,
     'template',
     'callback-arg',
+    options,
   );
 }
 
@@ -221,6 +249,7 @@ function translateFunctionParam(
   param: NativeModuleParamShape,
   aliases: AliasMap,
   baseAliasName: string,
+  options: CppCodegenOptions,
 ): string {
   return translateNullableParamType(
     param.typeAnnotation,
@@ -228,6 +257,7 @@ function translateFunctionParam(
     baseAliasName,
     'template',
     'method-arg',
+    options,
   );
 }
 
@@ -235,12 +265,14 @@ export function translateSpecArgs(
   params: ReadonlyArray<NativeModuleParamShape>,
   aliases: AliasMap,
   baseAliasName: string,
+  options: CppCodegenOptions,
 ) {
   return params.map(param => {
     const translatedParam = translateSpecFunctionParam(
       param,
       aliases,
       `${baseAliasName}_${param.name}`,
+      options,
     );
     return `${translatedParam}`;
   });
@@ -250,12 +282,14 @@ export function translateArgs(
   params: ReadonlyArray<NativeModuleParamShape>,
   aliases: AliasMap,
   baseAliasName: string,
+  options: CppCodegenOptions,
 ) {
   return params.map(param => {
     const translatedParam = translateFunctionParam(
       param,
       aliases,
       `${baseAliasName}_${param.name}`,
+      options,
     );
     return `${translatedParam} ${param.name}`;
   });

package/src/generators/ReturnTypes.ts

@@ -11,12 +11,13 @@ import type {
   Nullable,
 } from '@react-native/codegen/lib/CodegenSchema';
 import {AliasMap} from './AliasManaging';
-import {translateFieldOrReturnType} from './ObjectTypes';
+import {CppCodegenOptions, translateFieldOrReturnType} from './ObjectTypes';
 
 function translateReturnType(
   type: Nullable<NativeModuleReturnTypeAnnotation>,
   aliases: AliasMap,
   baseAliasName: string,
+  options: CppCodegenOptions,
 ): string {
   switch (type.type) {
     case 'VoidTypeAnnotation':
@@ -27,6 +28,7 @@ function translateReturnType(
         type.typeAnnotation,
         aliases,
         baseAliasName,
+        options,
       )}>`;
     default:
       return translateFieldOrReturnType(
@@ -34,6 +36,7 @@ function translateReturnType(
         aliases,
         baseAliasName,
         'translateReturnType',
+        options,
       );
   }
 }
@@ -42,14 +45,26 @@ export function translateSpecReturnType(
   type: Nullable<NativeModuleReturnTypeAnnotation>,
   aliases: AliasMap,
   baseAliasName: string,
+  options: CppCodegenOptions,
 ) {
-  return translateReturnType(type, aliases, `${baseAliasName}_returnType`);
+  return translateReturnType(
+    type,
+    aliases,
+    `${baseAliasName}_returnType`,
+    options,
+  );
 }
 
 export function translateImplReturnType(
   type: Nullable<NativeModuleReturnTypeAnnotation>,
   aliases: AliasMap,
   baseAliasName: string,
+  options: CppCodegenOptions,
 ) {
-  return translateReturnType(type, aliases, `${baseAliasName}_returnType`);
+  return translateReturnType(
+    type,
+    aliases,
+    `${baseAliasName}_returnType`,
+    options,
+  );
 }