@react-native-windows/codegen 0.0.0-canary.9 → 0.0.1-0

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,193 +58,40 @@ 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;
 
-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 checkFilesForChanges(
-  map: Map<string, string>,
-  outputDir: string,
-): boolean {
-  let hasChanges = false;
-
-  for (const [contents, fileName] of map) {
-    const location = path.join(outputDir, fileName);
-    if (!fs.existsSync(location)) {
-      hasChanges = true;
-      continue;
-    }
-
-    const currentContents = fs.readFileSync(location, '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;
-  map.forEach((contents: string, fileName: string) => {
-    try {
-      const location = path.join(outputDir, fileName);
-      fs.mkdirSync(path.dirname(location), {recursive: true});
-      fs.writeFileSync(location, contents);
-    } catch (error) {
-      success = false;
-      console.error(`Failed to write ${fileName} to ${outputDir}`, 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 generatedModuleFiles = [];
-  const generatedComponentFiles = [];
-  /*
-  for (const name of generators) {
-    for (const generator of GENERATORS[name]) {
-      generatedFiles.push(...generator(libraryName, schema, moduleSpecName));
-    }
-  }
-*/
-
-  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;
-
-  generatedModuleFiles.push(
-    ...generateNM2(libraryName, schema, moduleSpecName),
-  );
-
-  generatedComponentFiles.push(
-    ...generatorPropsH(libraryName, schema, moduleSpecName),
-    ...generatorPropsCPP(libraryName, schema, moduleSpecName),
-    ...generatorShadowNodeH(libraryName, schema, moduleSpecName),
-    ...generatorShadowNodeCPP(libraryName, schema, moduleSpecName),
-    ...generatorComponentDescriptorH(libraryName, schema, moduleSpecName),
-    ...generatorEventEmitterH(libraryName, schema, moduleSpecName),
-  );
-
-  const moduleFilesToUpdate = new Map<string, string>([
-    ...generatedModuleFiles,
-  ]);
-  const componentFilesToUpdate = new Map<string, string>([
-    ...generatedComponentFiles,
-  ]);
-
-  if (test === true) {
-    return (
-      checkFilesForChanges(moduleFilesToUpdate, outputDirectory) &&
-      checkFilesForChanges(componentFilesToUpdate, componentOutputdir)
-    );
-  }
-
-  return (
-    writeMapToFiles(moduleFilesToUpdate, outputDirectory) &&
-    writeMapToFiles(componentFilesToUpdate, componentOutputdir)
-  );
-}
-
 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 "react-native codegen-windows" to regenerate.',
+  );
+  process.exit(2);
+}

package/src/generators/AliasGen.ts

@@ -0,0 +1,149 @@
+/**
+ * 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 generateSingleAlias(
+  aliases: AliasMap,
+  aliasName: string,
+  aliasCode: AliasCodeMap,
+  options: CppCodegenOptions,
+): void {
+  const aliasCppName = getAliasCppName(aliasName);
+  const aliasType = <NativeModuleObjectTypeAnnotation>aliases.types[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;
+  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);
+    // 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
+    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 {
+  types: {[name: string]: NativeModuleObjectTypeAnnotation | undefined};
+  jobs: string[];
+}
+
+const ExtendedObjectKey = '$RNW-TURBOMODULE-ALIAS';
+interface ExtendedObject extends NativeModuleObjectTypeAnnotation {
+  '$RNW-TURBOMODULE-ALIAS'?: string;
+}
+
+function recordAnonymousAlias(
+  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(
+      recordAnonymousAlias(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),
+  );
+}