@react-native-windows/codegen 0.0.0-canary.4 → 0.0.0-canary.41

package/src/Cli.ts

@@ -5,15 +5,8 @@
  * @format
  */
 
-import * as yargs from 'yargs';
-import * as path from 'path';
-import * as fs from 'fs';
-import * as globby from 'globby';
-import {createNM2Generator} from './generators/GenerateNM2';
-// @ts-ignore
-import {parseFile} from 'react-native-tscodegen/lib/rncodegen/src/parsers/flow';
-// @ts-ignore
-import * as schemaValidator from 'react-native-tscodegen/lib/rncodegen/src/schemaValidator';
+import yargs from 'yargs';
+import {runCodeGen} from './index';
 
 const argv = yargs.options({
   file: {
@@ -21,164 +14,45 @@ const argv = yargs.options({
     describe: 'file which contains spec',
   },
   files: {
-    type: 'array',
+    type: 'string',
+    array: true,
     describe: 'glob patterns for files which contains specs',
   },
+  ts: {
+    type: 'boolean',
+    describe: 'generate turbo module definition files in TypeScript',
+    default: false,
+  },
+  methodonly: {
+    type: 'boolean',
+    describe: 'generate only method metadata in C++ turbo module spec',
+    default: false,
+  },
+  outdir: {
+    type: 'string',
+    describe: 'output directory',
+    default: 'codegen',
+  },
   test: {
     type: 'boolean',
     describe: 'Verify that the generated output is unchanged',
+    default: false,
   },
   namespace: {
     type: 'string',
     describe: 'C++/C# Namespace to put generated native modules in',
     default: 'MyNamespace',
   },
+  libraryName: {
+    type: 'string',
+    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 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 generatedFiles = [];
-  /*
-  for (const name of generators) {
-    for (const generator of GENERATORS[name]) {
-      generatedFiles.push(...generator(libraryName, schema, moduleSpecName));
-    }
-  }
-*/
-
-  const generateNM2 = createNM2Generator({namespace: argv.namespace});
-
-  generatedFiles.push(...generateNM2(libraryName, schema, moduleSpecName));
-
-  const filesToUpdate = new Map<string, string>([...generatedFiles]);
-
-  if (test === true) {
-    return checkFilesForChanges(filesToUpdate, outputDirectory);
-  }
-
-  return writeMapToFiles(filesToUpdate, outputDirectory);
-}
-
 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[]));
-}
-
-const libraryName = 'libraryName';
-const moduleSpecName = 'moduleSpecName';
-const outputDirectory = 'codegen';
-generate(
-  {libraryName, schema, outputDirectory, moduleSpecName},
-  {generators: [], test: false},
-);
+runCodeGen(argv);

package/src/generators/AliasGen.ts

@@ -0,0 +1,105 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+'use strict';
+
+import type {
+  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 type {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),
+  );
+}