@react-native-windows/codegen 0.72.0 → 0.72.1

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,
+  );
 }

package/src/generators/ValidateMethods.ts

@@ -12,6 +12,7 @@ import type {
   NativeModuleSchema,
 } from '@react-native/codegen/lib/CodegenSchema';
 import {AliasMap} from './AliasManaging';
+import type {CppCodegenOptions} from './ObjectTypes';
 import {translateArgs, translateSpecArgs} from './ParamTypes';
 import {translateImplReturnType, translateSpecReturnType} from './ReturnTypes';
 
@@ -27,8 +28,9 @@ function getPossibleMethodSignatures(
   funcType: NativeModuleFunctionTypeAnnotation,
   aliases: AliasMap,
   baseAliasName: string,
+  options: CppCodegenOptions,
 ): string[] {
-  const args = translateArgs(funcType.params, aliases, baseAliasName);
+  const args = translateArgs(funcType.params, aliases, baseAliasName, options);
   if (funcType.returnTypeAnnotation.type === 'PromiseTypeAnnotation') {
     if (funcType.returnTypeAnnotation.elementType) {
       args.push(
@@ -36,6 +38,7 @@ function getPossibleMethodSignatures(
           funcType.returnTypeAnnotation.elementType,
           aliases,
           baseAliasName,
+          options,
         )}> &&result`,
       );
     } else {
@@ -50,6 +53,7 @@ function getPossibleMethodSignatures(
     funcType.returnTypeAnnotation,
     aliases,
     baseAliasName,
+    options,
   )} ${prop.name}(${args.join(', ')}) noexcept { /* implementation */ }`;
 
   const staticsig = `REACT_${isMethodSync(funcType) ? 'SYNC_' : ''}METHOD(${
@@ -58,6 +62,7 @@ function getPossibleMethodSignatures(
     funcType.returnTypeAnnotation,
     aliases,
     baseAliasName,
+    options,
   )} ${prop.name}(${args.join(', ')}) noexcept { /* implementation */ }`;
 
   return [sig, staticsig];
@@ -68,8 +73,15 @@ function translatePossibleMethodSignatures(
   funcType: NativeModuleFunctionTypeAnnotation,
   aliases: AliasMap,
   baseAliasName: string,
+  options: CppCodegenOptions,
 ): string {
-  return getPossibleMethodSignatures(prop, funcType, aliases, baseAliasName)
+  return getPossibleMethodSignatures(
+    prop,
+    funcType,
+    aliases,
+    baseAliasName,
+    options,
+  )
     .map(sig => `"    ${sig}\\n"`)
     .join('\n          ');
 }
@@ -78,6 +90,7 @@ function renderProperties(
   properties: ReadonlyArray<NativeModulePropertyShape>,
   aliases: AliasMap,
   tuple: boolean,
+  options: CppCodegenOptions,
 ): string {
   // TODO: generate code for constants
   return properties
@@ -95,12 +108,14 @@ function renderProperties(
         funcType.params,
         aliases,
         propAliasName,
+        options,
       );
 
       const translatedReturnParam = translateSpecReturnType(
         funcType.returnTypeAnnotation,
         aliases,
         propAliasName,
+        options,
       );
 
       if (funcType.returnTypeAnnotation.type === 'PromiseTypeAnnotation') {
@@ -110,6 +125,7 @@ function renderProperties(
               funcType.returnTypeAnnotation.elementType,
               aliases,
               propAliasName,
+              options,
             )}>`,
           );
         } else {
@@ -132,6 +148,7 @@ function renderProperties(
             funcType,
             aliases,
             propAliasName,
+            options,
           )});`;
       }
     })
@@ -141,9 +158,20 @@ function renderProperties(
 export function generateValidateMethods(
   nativeModule: NativeModuleSchema,
   aliases: AliasMap,
+  options: CppCodegenOptions,
 ): [string, string] {
   const properties = nativeModule.spec.properties;
-  const traversedProperties = renderProperties(properties, aliases, false);
-  const traversedPropertyTuples = renderProperties(properties, aliases, true);
+  const traversedProperties = renderProperties(
+    properties,
+    aliases,
+    false,
+    options,
+  );
+  const traversedPropertyTuples = renderProperties(
+    properties,
+    aliases,
+    true,
+    options,
+  );
   return [traversedPropertyTuples, traversedProperties];
 }

package/src/index.ts

@@ -8,6 +8,7 @@
 import path from 'path';
 import fs from '@react-native-windows/fs';
 import globby from 'globby';
+import type {CppStringTypes} from './generators/GenerateNM2';
 import {createNM2Generator} from './generators/GenerateNM2';
 import {
   generateTypeScript,
@@ -16,6 +17,8 @@ import {
 import type {SchemaType} from '@react-native/codegen/lib/CodegenSchema';
 import type {Parser} from '@react-native/codegen/lib/parsers/parser';
 
+export type {CppStringTypes} from './generators/GenerateNM2';
+
 // Load @react-native/codegen from react-native
 const rnPath = path.dirname(require.resolve('react-native/package.json'));
 const rncodegenPath = path.dirname(
@@ -37,18 +40,22 @@ function getParser(isTypeScript: boolean): Parser {
 
 const schemaValidator = require(path.resolve(
   rncodegenPath,
-  'lib/schemaValidator',
+  'lib/SchemaValidator',
 ));
 
-interface Options {
+export interface SharedOptions {
   libraryName: string;
   methodOnly: boolean;
   modulesCxx: boolean;
-  moduleSpecName: string;
   modulesTypeScriptTypes: boolean;
   modulesWindows: boolean;
   namespace: string;
   outputDirectory: string;
+  cppStringType: CppStringTypes;
+}
+
+interface Options extends SharedOptions {
+  moduleSpecName: string;
   schema: SchemaType;
 }
 
@@ -204,11 +211,12 @@ export function generate(
     libraryName,
     methodOnly,
     modulesCxx,
-    moduleSpecName,
     modulesTypeScriptTypes,
     modulesWindows,
     namespace,
     outputDirectory,
+    cppStringType,
+    moduleSpecName,
     schema,
   }: Options,
   {/*generators,*/ test}: Config,
@@ -231,6 +239,7 @@ export function generate(
   const generateNM2 = createNM2Generator({
     methodOnly,
     namespace,
+    cppStringType,
   });
 
   const generateJsiModuleH = require(path.resolve(
@@ -336,18 +345,11 @@ export function generate(
   return writeMapToFiles(generatedFiles, outputDirectory);
 }
 
-export type CodeGenOptions = {
+export interface CodeGenOptions extends SharedOptions {
   file?: string;
   files?: string[];
-  libraryName: string;
-  methodOnly: boolean;
-  modulesCxx: boolean;
-  modulesTypeScriptTypes: boolean;
-  modulesWindows: boolean;
-  namespace: string;
-  outputDirectory: string;
   test: boolean;
-};
+}
 
 export function runCodeGen(options: CodeGenOptions): boolean {
   if (!options.file && !options.files)
@@ -366,17 +368,19 @@ export function runCodeGen(options: CodeGenOptions): boolean {
     modulesWindows,
     namespace,
     outputDirectory,
+    cppStringType,
   } = options;
   return generate(
     {
       libraryName,
       methodOnly,
       modulesCxx,
-      moduleSpecName,
       modulesTypeScriptTypes,
       modulesWindows,
       namespace,
       outputDirectory,
+      cppStringType,
+      moduleSpecName,
       schema,
     },
     {generators: [], test: options.test},