@react-native-windows/codegen 0.66.0 → 0.68.0-preview.1

package/src/Cli.ts

@@ -7,7 +7,7 @@
 
 import yargs from 'yargs';
 import path from 'path';
-import fs from 'fs';
+import fs from '@react-native-windows/fs';
 import globby from 'globby';
 import {createNM2Generator} from './generators/GenerateNM2';
 // @ts-ignore
@@ -98,9 +98,11 @@ function checkFilesForChanges(
 
   const allExistingFiles = globby
     .sync(`${outputDir}/**`)
-    .map(_ => path.normalize(_))
+    .map((_) => path.normalize(_))
+    .sort();
+  const allGeneratedFiles = [...map.keys()]
+    .map((_) => path.normalize(_))
     .sort();
-  const allGeneratedFiles = [...map.keys()].map(_ => path.normalize(_)).sort();
 
   if (
     allExistingFiles.length !== allGeneratedFiles.length ||
@@ -130,7 +132,7 @@ function writeMapToFiles(map: Map<string, string>, outputDir: string) {
 
   // This ensures that we delete any generated files from modules that have been deleted
   const allExistingFiles = globby.sync(`${outputDir}/**`);
-  allExistingFiles.forEach(existingFile => {
+  allExistingFiles.forEach((existingFile) => {
     if (!map.has(path.normalize(existingFile))) {
       fs.unlinkSync(existingFile);
     }
@@ -207,18 +209,18 @@ function generate(
   );
 
   const generateNM2 = createNM2Generator({namespace: argv.namespace});
-  const generatorPropsH = require('react-native-tscodegen/lib/rncodegen/src/generators/components/GeneratePropsH')
-    .generate;
-  const generatorPropsCPP = require('react-native-tscodegen/lib/rncodegen/src/generators/components/GeneratePropsCPP')
-    .generate;
-  const generatorShadowNodeH = require('react-native-tscodegen/lib/rncodegen/src/generators/components/GenerateShadowNodeH')
-    .generate;
-  const generatorShadowNodeCPP = require('react-native-tscodegen/lib/rncodegen/src/generators/components/GenerateShadowNodeCPP')
-    .generate;
-  const generatorComponentDescriptorH = require('react-native-tscodegen/lib/rncodegen/src/generators/components/GenerateComponentDescriptorH')
-    .generate;
-  const generatorEventEmitterH = require('react-native-tscodegen/lib/rncodegen/src/generators/components/GenerateEventEmitterH')
-    .generate;
+  const generatorPropsH =
+    require('react-native-tscodegen/lib/rncodegen/src/generators/components/GeneratePropsH').generate;
+  const generatorPropsCPP =
+    require('react-native-tscodegen/lib/rncodegen/src/generators/components/GeneratePropsCPP').generate;
+  const generatorShadowNodeH =
+    require('react-native-tscodegen/lib/rncodegen/src/generators/components/GenerateShadowNodeH').generate;
+  const generatorShadowNodeCPP =
+    require('react-native-tscodegen/lib/rncodegen/src/generators/components/GenerateShadowNodeCPP').generate;
+  const generatorComponentDescriptorH =
+    require('react-native-tscodegen/lib/rncodegen/src/generators/components/GenerateComponentDescriptorH').generate;
+  const generatorEventEmitterH =
+    require('react-native-tscodegen/lib/rncodegen/src/generators/components/GenerateEventEmitterH').generate;
 
   normalizeFileMap(
     generateNM2(libraryName, schema, moduleSpecName),
@@ -226,23 +228,29 @@ function generate(
     generatedFiles,
   );
 
-  const componentGenerators = [
-    generatorPropsH,
-    generatorPropsCPP,
-    generatorShadowNodeH,
-    generatorShadowNodeCPP,
-    generatorComponentDescriptorH,
-    generatorEventEmitterH,
-  ];
-
-  componentGenerators.forEach(generator => {
-    const generated: Map<string, string> = generator(
-      libraryName,
-      schema,
-      moduleSpecName,
-    );
-    normalizeFileMap(generated, componentOutputdir, generatedFiles);
-  });
+  if (
+    Object.keys(schema.modules).some(
+      (moduleName) => schema.modules[moduleName].type === 'Component',
+    )
+  ) {
+    const componentGenerators = [
+      generatorPropsH,
+      generatorPropsCPP,
+      generatorShadowNodeH,
+      generatorShadowNodeCPP,
+      generatorComponentDescriptorH,
+      generatorEventEmitterH,
+    ];
+
+    componentGenerators.forEach((generator) => {
+      const generated: Map<string, string> = generator(
+        libraryName,
+        schema,
+        moduleSpecName,
+      );
+      normalizeFileMap(generated, componentOutputdir, generatedFiles);
+    });
+  }
 
   if (test === true) {
     return checkFilesForChanges(generatedFiles, outputDirectory);

package/src/generators/AliasGen.ts

@@ -0,0 +1,105 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+'use strict';
+
+import {
+  NativeModuleBaseTypeAnnotation,
+  NativeModuleObjectTypeAnnotation,
+  NamedShape,
+  Nullable,
+} from 'react-native-tscodegen';
+import {AliasMap, getAliasCppName} from './AliasManaging';
+import {translateField} from './ObjectTypes';
+
+function translateObjectBody(
+  type: NativeModuleObjectTypeAnnotation,
+  aliases: AliasMap,
+  baseAliasName: string,
+  prefix: string,
+) {
+  return type.properties
+    .map((prop: NamedShape<Nullable<NativeModuleBaseTypeAnnotation>>) => {
+      let propType = prop.typeAnnotation;
+      if (prop.optional && propType.type !== 'NullableTypeAnnotation') {
+        propType = {type: 'NullableTypeAnnotation', typeAnnotation: propType};
+      }
+      const first = `${prefix}REACT_FIELD(${prop.name})`;
+      const second = `${prefix}${translateField(
+        propType,
+        aliases,
+        `${baseAliasName}_${prop.name}`,
+      )} ${prop.name};`;
+      return `${first}\n${second}`;
+    })
+    .join('\n');
+}
+
+export function createAliasMap(nativeModuleAliases: {
+  [name: string]: NativeModuleObjectTypeAnnotation;
+}): AliasMap {
+  const aliases: AliasMap = {types: {}, jobs: Object.keys(nativeModuleAliases)};
+  for (const aliasName of aliases.jobs) {
+    aliases.types[aliasName] = nativeModuleAliases[aliasName];
+  }
+  return aliases;
+}
+
+interface AliasCodeMap {
+  [name: string]: string;
+}
+
+function generateSingleAlias(
+  aliases: AliasMap,
+  aliasName: string,
+  aliasCode: AliasCodeMap,
+): void {
+  const aliasType = <NativeModuleObjectTypeAnnotation>aliases.types[aliasName];
+  aliasCode[aliasName] = `
+REACT_STRUCT(${getAliasCppName(aliasName)})
+struct ${getAliasCppName(aliasName)} {
+${translateObjectBody(aliasType, aliases, aliasName, '    ')}
+};
+`;
+}
+
+function generateNestedAliasesInCorrectOrder(
+  aliases: AliasMap,
+  aliasCode: AliasCodeMap,
+  aliasOrder: string[],
+): void {
+  // retrieve and clean all ungenerated aliases
+  const jobs = aliases.jobs;
+  aliases.jobs = [];
+
+  // generate each one in its found order
+  for (const aliasName of jobs) {
+    // 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);
+    // 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);
+    // all referenced C++ structs are generated
+    // put the current one following them
+    aliasOrder.push(aliasName);
+  }
+}
+
+export function generateAliases(aliases: AliasMap): string {
+  const aliasCode: AliasCodeMap = {};
+  const aliasOrder: string[] = [];
+  generateNestedAliasesInCorrectOrder(aliases, aliasCode, aliasOrder);
+
+  // aliasOrder now has the correct order of C++ struct code
+  let traversedAliasedStructs = '';
+  for (const aliasName of aliasOrder) {
+    traversedAliasedStructs = `${traversedAliasedStructs}${aliasCode[aliasName]}`;
+  }
+  return traversedAliasedStructs;
+}

package/src/generators/AliasManaging.ts

@@ -0,0 +1,75 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+'use strict';
+
+import {NativeModuleObjectTypeAnnotation} from 'react-native-tscodegen';
+
+let preferredModuleName: string = '';
+
+export function setPreferredModuleName(moduleName: string): void {
+  preferredModuleName = moduleName;
+}
+
+export function getAliasCppName(typeName: string): string {
+  return `${preferredModuleName}Spec_${typeName}`;
+}
+
+export interface AliasMap {
+  types: {[name: string]: NativeModuleObjectTypeAnnotation | undefined};
+  jobs: string[];
+}
+
+const ExtendedObjectKey = '$RNW-TURBOMODULE-ALIAS';
+interface ExtendedObject extends NativeModuleObjectTypeAnnotation {
+  '$RNW-TURBOMODULE-ALIAS'?: string;
+}
+
+function recordAnonymouseAlias(
+  aliases: AliasMap,
+  baseAliasName: string,
+  extended: ExtendedObject,
+): string {
+  extended[ExtendedObjectKey] = baseAliasName;
+  aliases.types[baseAliasName] = extended;
+  aliases.jobs.push(baseAliasName);
+  return baseAliasName;
+}
+
+export function getAnonymousAliasCppName(
+  aliases: AliasMap,
+  baseAliasName: string,
+  objectType: NativeModuleObjectTypeAnnotation,
+): string {
+  // someone found an anonymous object literal type
+  // if the ExtendedObjectKey flag has been set
+  // then it is a known one
+  // this happens because method signatures are generate twice in spec and error messages
+  const extended = <ExtendedObject>objectType;
+  const key = extended[ExtendedObjectKey];
+  if (key !== undefined) {
+    return getAliasCppName(key);
+  }
+
+  // if the ExtendedObjectKey flag has not been set
+  // it means it is a unknown one
+  // associate the name with this object literal type and return
+  if (aliases.types[baseAliasName] === undefined) {
+    return getAliasCppName(
+      recordAnonymouseAlias(aliases, baseAliasName, extended),
+    );
+  }
+
+  // sometimes names could be anonymous
+  let index = 2;
+  while (aliases.types[`${baseAliasName}${index}`] !== undefined) {
+    index++;
+  }
+
+  return getAliasCppName(
+    recordAnonymouseAlias(aliases, `${baseAliasName}${index}`, extended),
+  );
+}

package/src/generators/GenerateNM2.ts

@@ -6,18 +6,11 @@
 
 'use strict';
 
-import {
-  NativeModuleFunctionTypeAnnotation,
-  NativeModulePropertyShape,
-  SchemaType,
-} from 'react-native-tscodegen';
-import {
-  getAliasCppName,
-  setPreferredModuleName,
-  translateObjectBody,
-} from './ObjectTypes';
-import {translateArgs, translateSpecArgs} from './ParamTypes';
-import {translateImplReturnType, translateSpecReturnType} from './ReturnTypes';
+import {SchemaType} from 'react-native-tscodegen';
+import {AliasMap, setPreferredModuleName} from './AliasManaging';
+import {createAliasMap, generateAliases} from './AliasGen';
+import {generateValidateConstants} from './ValidateConstants';
+import {generateValidateMethods} from './ValidateMethods';
 
 type FilesOutput = Map<string, string>;
 
@@ -37,109 +30,19 @@ const moduleTemplate = `
 namespace ::_NAMESPACE_:: {
 ::_MODULE_ALIASED_STRUCTS_::
 struct ::_MODULE_NAME_::Spec : winrt::Microsoft::ReactNative::TurboModuleSpec {
-  static constexpr auto methods = std::tuple{
-::_MODULE_PROPERTIES_TUPLE_::
-  };
+::_MODULE_MEMBERS_TUPLES_::
 
   template <class TModule>
   static constexpr void ValidateModule() noexcept {
-    constexpr auto methodCheckResults = CheckMethods<TModule, ::_MODULE_NAME_::Spec>();
+::_MODULE_MEMBERS_CHECKS_::
 
-::_MODULE_PROPERTIES_SPEC_ERRORS_::
+::_MODULE_MEMBERS_ERRORS_::
   }
 };
 
 } // namespace ::_NAMESPACE_::
 `;
 
-function isMethodSync(funcType: NativeModuleFunctionTypeAnnotation) {
-  return (
-    funcType.returnTypeAnnotation.type !== 'VoidTypeAnnotation' &&
-    funcType.returnTypeAnnotation.type !== 'PromiseTypeAnnotation'
-  );
-}
-
-function isMethodReturnPromise(funcType: NativeModuleFunctionTypeAnnotation) {
-  return funcType.returnTypeAnnotation.type === 'PromiseTypeAnnotation';
-}
-
-function getPossibleMethodSignatures(
-  prop: NativeModulePropertyShape,
-  funcType: NativeModuleFunctionTypeAnnotation,
-): string[] {
-  const args = translateArgs(funcType.params);
-  if (isMethodReturnPromise(funcType)) {
-    // Sadly, currently, the schema doesn't currently provide us information on the type of the promise.
-    args.push('React::ReactPromise<React::JSValue> &&result');
-  }
-
-  // TODO: be much more exhastive on the possible method signatures that can be used..
-  const sig = `REACT_${isMethodSync(funcType) ? 'SYNC_' : ''}METHOD(${
-    prop.name
-  }) ${translateImplReturnType(funcType.returnTypeAnnotation)} ${
-    prop.name
-  }(${args.join(', ')}) noexcept { /* implementation */ }}`;
-
-  const staticsig = `REACT_${isMethodSync(funcType) ? 'SYNC_' : ''}METHOD(${
-    prop.name
-  }) static ${translateImplReturnType(funcType.returnTypeAnnotation)} ${
-    prop.name
-  }(${args.join(', ')}) noexcept { /* implementation */ }}`;
-
-  return [sig, staticsig];
-}
-
-function translatePossibleMethodSignatures(
-  prop: NativeModulePropertyShape,
-  funcType: NativeModuleFunctionTypeAnnotation,
-): string {
-  return getPossibleMethodSignatures(prop, funcType)
-    .map(sig => `"    ${sig}\\n"`)
-    .join('\n          ');
-}
-
-function renderProperties(
-  properties: ReadonlyArray<NativeModulePropertyShape>,
-  tuple: boolean,
-): string {
-  // We skip the constants for now, since we dont have Spec file validation of them.
-  return properties
-    .filter(prop => prop.name !== 'getConstants')
-    .map((prop, index) => {
-      // TODO: prop.optional === true
-      // TODO: prop.typeAnnotation.type === 'NullableTypeAnnotation'
-      const funcType =
-        prop.typeAnnotation.type === 'NullableTypeAnnotation'
-          ? prop.typeAnnotation.typeAnnotation
-          : prop.typeAnnotation;
-
-      const traversedArgs = translateSpecArgs(funcType.params);
-
-      const translatedReturnParam = translateSpecReturnType(
-        funcType.returnTypeAnnotation,
-      );
-
-      if (isMethodReturnPromise(funcType)) {
-        // Sadly, currently, the schema doesn't currently provide us information on the type of the promise.
-        traversedArgs.push('Promise<React::JSValue>');
-      }
-
-      if (tuple) {
-        return `      ${
-          isMethodSync(funcType) ? 'Sync' : ''
-        }Method<${translatedReturnParam}(${traversedArgs.join(
-          ', ',
-        )}) noexcept>{${index}, L"${prop.name}"},`;
-      } else {
-        return `    REACT_SHOW_METHOD_SPEC_ERRORS(
-          ${index},
-          "${prop.name}",
-          ${translatePossibleMethodSignatures(prop, funcType)});`;
-      }
-    })
-    .join('\n');
-}
-
 export function createNM2Generator({namespace}: {namespace: string}) {
   return (
     _libraryName: string,
@@ -161,30 +64,43 @@ export function createNM2Generator({namespace}: {namespace: string}) {
       if (nativeModule.type === 'NativeModule') {
         console.log(`Generating Native${preferredModuleName}Spec.g.h`);
 
-        let traversedAliasedStructs = '';
-        for (const aliasName of Object.keys(nativeModule.aliases)) {
-          const aliasType = nativeModule.aliases[aliasName];
-          traversedAliasedStructs = `${traversedAliasedStructs}
-REACT_STRUCT(${getAliasCppName(aliasName)})
-struct ${getAliasCppName(aliasName)} {
-${translateObjectBody(aliasType, '    ')}
-};
-`;
+        // copy all explicit to a map
+        const aliases: AliasMap = createAliasMap(nativeModule.aliases);
+
+        // prepare methods
+        const methods = generateValidateMethods(nativeModule, aliases);
+        let tuples = `
+  static constexpr auto methods = std::tuple{
+${methods[0]}
+  };`;
+        let checks = `
+    constexpr auto methodCheckResults = CheckMethods<TModule, ::_MODULE_NAME_::Spec>();`;
+        let errors = methods[1];
+
+        // prepare constants
+        const constants = generateValidateConstants(nativeModule, aliases);
+        if (constants !== undefined) {
+          tuples = `
+  static constexpr auto constants = std::tuple{
+${constants[0]}
+  };${tuples}`;
+          checks = `
+    constexpr auto constantCheckResults = CheckConstants<TModule, ::_MODULE_NAME_::Spec>();${checks}`;
+          errors = `${constants[1]}
+
+${errors}`;
         }
 
-        const properties = nativeModule.spec.properties;
-        const traversedProperties = renderProperties(properties, false);
-        const traversedPropertyTuples = renderProperties(properties, true);
+        // generate code for structs
+        const traversedAliasedStructs = generateAliases(aliases);
 
         files.set(
           `Native${preferredModuleName}Spec.g.h`,
           moduleTemplate
             .replace(/::_MODULE_ALIASED_STRUCTS_::/g, traversedAliasedStructs)
-            .replace(/::_MODULE_PROPERTIES_TUPLE_::/g, traversedPropertyTuples)
-            .replace(
-              /::_MODULE_PROPERTIES_SPEC_ERRORS_::/g,
-              traversedProperties,
-            )
+            .replace(/::_MODULE_MEMBERS_TUPLES_::/g, tuples.substr(1))
+            .replace(/::_MODULE_MEMBERS_CHECKS_::/g, checks.substr(1))
+            .replace(/::_MODULE_MEMBERS_ERRORS_::/g, errors)
             .replace(/::_MODULE_NAME_::/g, preferredModuleName)
             .replace(/::_NAMESPACE_::/g, namespace),
         );

package/src/generators/ObjectTypes.ts

@@ -6,25 +6,17 @@
 
 'use strict';
 
+import {NativeModuleBaseTypeAnnotation, Nullable} from 'react-native-tscodegen';
 import {
-  NativeModuleBaseTypeAnnotation,
-  NativeModuleObjectTypeAnnotation,
-  NamedShape,
-  Nullable,
-} from 'react-native-tscodegen';
+  AliasMap,
+  getAliasCppName,
+  getAnonymousAliasCppName,
+} from './AliasManaging';
 
-let preferredModuleName: string = '';
-
-export function setPreferredModuleName(moduleName: string): void {
-  preferredModuleName = moduleName;
-}
-
-export function getAliasCppName(typeName: string): string {
-  return `${preferredModuleName}Spec_${typeName}`;
-}
-
-function translateField(
+export function translateField(
   type: Nullable<NativeModuleBaseTypeAnnotation>,
+  aliases: AliasMap,
+  baseAliasName: string,
 ): string {
   // avoid: Property 'type' does not exist on type 'never'
   const returnType = type.type;
@@ -40,13 +32,19 @@ function translateField(
     case 'BooleanTypeAnnotation':
       return 'bool';
     case 'ArrayTypeAnnotation':
-      // TODO: type.elementType
-      return 'React::JSValueArray';
+      if (type.elementType) {
+        return `std::vector<${translateField(
+          type.elementType,
+          aliases,
+          `${baseAliasName}_element`,
+        )}>`;
+      } else {
+        return `::React::JSValueArray`;
+      }
     case 'GenericObjectTypeAnnotation':
-      return 'React::JSValueObject';
+      return '::React::JSValue';
     case 'ObjectTypeAnnotation':
-      // TODO: we have more information here, and could create a more specific type
-      return 'React::JSValueObject';
+      return getAnonymousAliasCppName(aliases, baseAliasName, type);
     case 'ReservedTypeAnnotation': {
       // avoid: Property 'name' does not exist on type 'never'
       const name = type.name;
@@ -61,25 +59,12 @@ function translateField(
     case 'TypeAliasTypeAnnotation':
       return getAliasCppName(type.name);
     case 'NullableTypeAnnotation':
-      return `std::optional<${translateField(type.typeAnnotation)}>`;
+      return `std::optional<${translateField(
+        type.typeAnnotation,
+        aliases,
+        baseAliasName,
+      )}>`;
     default:
       throw new Error(`Unhandled type in translateReturnType: ${returnType}`);
   }
 }
-
-export function translateObjectBody(
-  type: NativeModuleObjectTypeAnnotation,
-  prefix: string,
-) {
-  return type.properties
-    .map((prop: NamedShape<Nullable<NativeModuleBaseTypeAnnotation>>) => {
-      let propType = prop.typeAnnotation;
-      if (prop.optional && propType.type !== 'NullableTypeAnnotation') {
-        propType = {type: 'NullableTypeAnnotation', typeAnnotation: propType};
-      }
-      const first = `${prefix}REACT_FIELD(${prop.name})`;
-      const second = `${prefix}${translateField(propType)} ${prop.name};`;
-      return `${first}\n${second}`;
-    })
-    .join('\n');
-}