@react-native-windows/codegen 0.0.0-canary.10 → 0.0.0-canary.101

package/src/Cli.ts

@@ -6,14 +6,7 @@
  */
 
 import yargs from 'yargs';
-import path from 'path';
-import fs from 'fs';
-import globby from 'globby';
-import {createNM2Generator} from './generators/GenerateNM2';
-// @ts-ignore
-import {parseFile} from 'react-native-tscodegen/lib/rncodegen/src/parsers/flow';
-// @ts-ignore
-import schemaValidator from 'react-native-tscodegen/lib/rncodegen/src/schemaValidator';
+import {CodeGenOptions, runCodeGen} from './index';
 
 const argv = yargs.options({
   file: {
@@ -21,12 +14,39 @@ const argv = yargs.options({
     describe: 'file which contains spec',
   },
   files: {
-    type: 'array',
+    type: 'string',
+    array: true,
     describe: 'glob patterns for files which contains specs',
   },
+  modulesTypeScriptTypes: {
+    type: 'boolean',
+    describe: 'generate turbo module definition files in TypeScript',
+    default: false,
+  },
+  modulesCxx: {
+    type: 'boolean',
+    describe: 'generate C++ JSI turbo module spec files',
+    default: false,
+  },
+  modulesWindows: {
+    type: 'boolean',
+    describe: 'generate turbo module spec files for REACT_MODULE',
+    default: false,
+  },
+  methodOnly: {
+    type: 'boolean',
+    describe: 'generate only method metadata in C++ turbo module spec',
+    default: false,
+  },
+  outputDirectory: {
+    type: 'string',
+    describe: 'output directory',
+    default: 'codegen',
+  },
   test: {
     type: 'boolean',
     describe: 'Verify that the generated output is unchanged',
+    default: false,
   },
   namespace: {
     type: 'string',
@@ -38,226 +58,51 @@ const argv = yargs.options({
     required: true,
     describe: 'Used for part of the path generated within the codegen dir',
   },
-}).argv;
-
-import {SchemaType} from 'react-native-tscodegen';
-
-interface Options {
-  libraryName: string;
-  schema: SchemaType;
-  outputDirectory: string;
-  moduleSpecName: string;
-}
-
-interface Config {
-  generators: any[] /*Generators[]*/;
-  test?: boolean;
-}
-
-/*
-const GENERATORS = {
-  descriptors: [generateComponentDescriptorH.generate],
-  events: [
-    generateEventEmitterCpp.generate,
-    generateEventEmitterH.generate,
-    generateModuleHObjCpp.generate,
-    generateModuleMm.generate,
-  ],
-  props: [
-    generateComponentHObjCpp.generate,
-    generatePropsCpp.generate,
-    generatePropsH.generate,
-    generatePropsJavaInterface.generate,
-    generatePropsJavaDelegate.generate,
-  ],
-  modules: [generateModuleCpp.generate, generateModuleH.generate],
-  tests: [generateTests.generate],
-  'shadow-nodes': [
-    generateShadowNodeCpp.generate,
-    generateShadowNodeH.generate,
-  ],
-};
-*/
-
-function normalizeFileMap(
-  map: Map<string, string>,
-  outputDir: string,
-  outMap: Map<string, string>,
-): void {
-  for (const [fileName, contents] of map) {
-    const location = path.join(outputDir, fileName);
-    outMap.set(path.normalize(location), contents);
-  }
-}
-
-function checkFilesForChanges(
-  map: Map<string, string>,
-  outputDir: string,
-): boolean {
-  let hasChanges = false;
-
-  const allExistingFiles = globby
-    .sync(`${outputDir}/**`)
-    .map(_ => path.normalize(_))
-    .sort();
-  const allGeneratedFiles = [...map.keys()].map(_ => path.normalize(_)).sort();
-
-  if (
-    allExistingFiles.length !== allGeneratedFiles.length ||
-    !allExistingFiles.every((val, index) => val === allGeneratedFiles[index])
-  )
-    return true;
-
-  for (const [fileName, contents] of map) {
-    if (!fs.existsSync(fileName)) {
-      hasChanges = true;
-      continue;
-    }
-
-    const currentContents = fs.readFileSync(fileName, 'utf8');
-    if (currentContents !== contents) {
-      console.error(`- ${fileName} has changed`);
-      hasChanges = true;
-      continue;
-    }
-  }
-
-  return hasChanges;
-}
-
-function writeMapToFiles(map: Map<string, string>, outputDir: string) {
-  let success = true;
-
-  // This ensures that we delete any generated files from modules that have been deleted
-  const allExistingFiles = globby.sync(`${outputDir}/**`);
-  allExistingFiles.forEach(existingFile => {
-    if (!map.has(path.normalize(existingFile))) {
-      fs.unlinkSync(existingFile);
-    }
-  });
-
-  for (const [fileName, contents] of map) {
-    try {
-      fs.mkdirSync(path.dirname(fileName), {recursive: true});
-
-      if (fs.existsSync(fileName)) {
-        const currentContents = fs.readFileSync(fileName, 'utf8');
-        // Don't update the files if there are no changes as this breaks incremental builds
-        if (currentContents === contents) {
-          continue;
-        }
-      }
-
-      fs.writeFileSync(fileName, contents);
-    } catch (error) {
-      success = false;
-      console.error(`Failed to write ${fileName} to ${fileName}`, error);
-    }
-  }
-
-  return success;
-}
-
-function combineSchemas(files: string[]): SchemaType {
-  return files.reduce(
-    (merged, filename) => {
-      const contents = fs.readFileSync(filename, 'utf8');
-      if (
-        contents &&
-        (/export\s+default\s+\(?codegenNativeComponent</.test(contents) ||
-          contents.includes('extends TurboModule'))
-      ) {
-        const schema = parseFile(filename);
-
-        if (schema && schema.modules) {
-          merged.modules = {...merged.modules, ...schema.modules};
-        }
-      }
-      return merged;
-    },
-    {modules: {}},
-  );
-}
-
-function generate(
-  {libraryName, schema, outputDirectory, moduleSpecName}: Options,
-  {/*generators,*/ test}: Config,
-): boolean {
-  schemaValidator.validate(schema);
-
-  const componentOutputdir = path.join(
-    outputDirectory,
-    'react/components',
-    libraryName,
-  );
-
-  const generatedFiles = new Map<string, string>();
-
-  generatedFiles.set(
-    path.join(outputDirectory, '.clang-format'),
-    'DisableFormat: true\nSortIncludes: false',
-  );
-
-  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;
-
-  normalizeFileMap(
-    generateNM2(libraryName, schema, moduleSpecName),
-    outputDirectory,
-    generatedFiles,
-  );
-
-  const componentGenerators = [
-    generatorPropsH,
-    generatorPropsCPP,
-    generatorShadowNodeH,
-    generatorShadowNodeCPP,
-    generatorComponentDescriptorH,
-    generatorEventEmitterH,
-  ];
-
-  componentGenerators.forEach(generator => {
-    normalizeFileMap(
-      generator(libraryName, schema, moduleSpecName),
-      componentOutputdir,
-      generatedFiles,
-    );
-  });
-
-  if (test === true) {
-    return checkFilesForChanges(generatedFiles, outputDirectory);
+  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,
+  },
+  componentsWindows: {
+    type: 'boolean',
+    describe: 'generate component cpp files for custom native components',
+    default: false,
+  },
+  internalComponents: {
+    type: 'boolean',
+    describe: 'generate non-ABI cpp/h for internal usage of built in native components [Only used within RNW itself]',
+    default: false,
+    hidden: true,
   }
-
-  return writeMapToFiles(generatedFiles, outputDirectory);
-}
+}).argv;
 
 if ((argv.file && argv.files) || (!argv.file && !argv.files)) {
   console.error('You must specify either --file or --files.');
   process.exit(1);
 }
 
-let schema: SchemaType;
-if (argv.file) {
-  schema = parseFile(argv.file);
-} else {
-  schema = combineSchemas(globby.sync(argv.files as string[]));
+if (
+  argv.cppStringType !== 'std::string' &&
+  argv.cppStringType !== 'std::wstring'
+) {
+  console.error('cppStringType should be "std::string" or "std::wstring".');
+  process.exit(1);
 }
 
-const libraryName = argv.libraryName;
-const moduleSpecName = 'moduleSpecName';
-const outputDirectory = 'codegen';
-generate(
-  {libraryName, schema, outputDirectory, moduleSpecName},
-  {generators: [], test: false},
-);
+// 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(
+    'There is a change in the output of codegen.  Rerun "npx @react-native-community/cli codegen-windows" to regenerate.',
+  );
+  process.exit(2);
+}

package/src/generators/AliasGen.ts

@@ -0,0 +1,186 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+'use strict';
+
+import type {
+  NativeModuleBaseTypeAnnotation,
+  NativeModuleObjectTypeAnnotation,
+  NamedShape,
+  Nullable,
+} from '@react-native/codegen/lib/CodegenSchema';
+import {AliasMap, getAliasCppName} from './AliasManaging';
+import {CppCodegenOptions, translateField} from './ObjectTypes';
+
+function translateObjectMembersDefinition(
+  type: NativeModuleObjectTypeAnnotation,
+  aliases: AliasMap,
+  baseAliasName: string,
+  prefix: string,
+  options: CppCodegenOptions,
+) {
+  return type.properties
+    .map((prop: NamedShape<Nullable<NativeModuleBaseTypeAnnotation>>) => {
+      let propType = prop.typeAnnotation;
+      if (prop.optional && propType.type !== 'NullableTypeAnnotation') {
+        propType = {type: 'NullableTypeAnnotation', typeAnnotation: propType};
+      }
+      return `${prefix}${translateField(
+        propType,
+        aliases,
+        `${baseAliasName}_${prop.name}`,
+        options,
+      )} ${prop.name};`;
+    })
+    .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');
+}
+
+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 AliasCode {
+  definition: string;
+  reflection: string;
+}
+
+interface AliasCodeMap {
+  [name: string]: AliasCode;
+}
+
+function getArrayTypeName(
+  type: Nullable<NativeModuleBaseTypeAnnotation>): string {
+    if (type.type === 'ArrayTypeAnnotation' && type.elementType?.type === 'TypeAliasTypeAnnotation') {
+      return  type.elementType.name;
+    }
+
+    return '';
+}
+
+function checkTypes(
+  aliases: AliasMap,
+  type: NativeModuleObjectTypeAnnotation,
+  aliasOrder: string[]): void {
+    for (const prop of type.properties) {
+      const propType = prop.typeAnnotation;
+      let propName = '';
+
+      if (propType.type === 'TypeAliasTypeAnnotation') {
+        propName = propType.name;
+      }
+
+      if (propType.type === 'ArrayTypeAnnotation') {
+        propName = getArrayTypeName(propType);
+      }
+
+      if (propName !== '' && !aliasOrder.includes(prop.name) && !aliases.jobs.includes(propName)) {
+        aliases.jobs.push(propName);
+      }
+    }
+}
+
+function generateSingleAlias(
+  aliases: AliasMap,
+  aliasName: string,
+  aliasCode: AliasCodeMap,
+  options: CppCodegenOptions,
+  aliasOrder: string[],
+): void {
+  const aliasCppName = getAliasCppName(aliasName);
+  const aliasType = <NativeModuleObjectTypeAnnotation>aliases.types[aliasName];
+
+  checkTypes(aliases, aliasType, aliasOrder);
+
+  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;
+  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, options, aliasOrder);
+    // 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,
+      options,
+    );
+    // all referenced C++ structs are generated
+    // put the current one following them
+    if (!aliasOrder.includes(aliasName)) {
+      aliasOrder.push(aliasName);
+    }
+  }
+}
+
+export function generateAliases(
+  aliases: AliasMap,
+  options: CppCodegenOptions,
+): [string, string] {
+  const aliasCode: AliasCodeMap = {};
+  const aliasOrder: string[] = [];
+  generateNestedAliasesInCorrectOrder(aliases, aliasCode, aliasOrder, options);
+
+  // aliasOrder now has the correct order of C++ struct code
+  let customTypes = '';
+  let customReflection = '';
+  for (const aliasName of aliasOrder) {
+    customTypes = `${customTypes}${aliasCode[aliasName].definition}`;
+    customReflection = `${customReflection}${aliasCode[aliasName].reflection}`;
+  }
+  return [customTypes, customReflection];
+}

package/src/generators/AliasManaging.ts

@@ -0,0 +1,75 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+'use strict';
+
+import type {NativeModuleObjectTypeAnnotation} from '@react-native/codegen/lib/CodegenSchema';
+
+let preferredModuleName: string = '';
+
+export function setPreferredModuleName(moduleName: string): void {
+  preferredModuleName = moduleName;
+}
+
+export function getAliasCppName(typeName: string): string {
+  return `${preferredModuleName}Spec_${typeName}`;
+}
+
+export interface AliasMap<T = NativeModuleObjectTypeAnnotation> {
+  types: {[name: string]: T | undefined};
+  jobs: string[];
+}
+
+const ExtendedObjectKey = '$RNW-TURBOMODULE-ALIAS';
+type ExtendedObject<T> = {
+  '$RNW-TURBOMODULE-ALIAS'?: string;
+} & T;
+
+function recordAnonymousAlias<T = NativeModuleObjectTypeAnnotation>(
+  aliases: AliasMap<T>,
+  baseAliasName: string,
+  extended: ExtendedObject<T>,
+): string {
+  extended[ExtendedObjectKey] = baseAliasName;
+  aliases.types[baseAliasName] = extended;
+  aliases.jobs.push(baseAliasName);
+  return baseAliasName;
+}
+
+export function getAnonymousAliasCppName<T = NativeModuleObjectTypeAnnotation>(
+  aliases: AliasMap<T>,
+  baseAliasName: string,
+  objectType: T,
+): 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<T>>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(
+      recordAnonymousAlias<T>(aliases, baseAliasName, extended),
+    );
+  }
+
+  // sometimes names could be anonymous
+  let index = 2;
+  while (aliases.types[`${baseAliasName}${index}`] !== undefined) {
+    index++;
+  }
+
+  return getAliasCppName(
+    recordAnonymousAlias(aliases, `${baseAliasName}${index}`, extended),
+  );
+}