@react-native-windows/codegen 0.0.0-canary.2 → 0.0.0-canary.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native-windows/codegen",
-  "version": "0.0.0-canary.2",
+  "version": "0.0.0-canary.23",
   "description": "Generators for react-native-codegen targeting react-native-windows",
   "main": "index.js",
   "repository": "https://github.com/microsoft/react-native-windows",
@@ -15,33 +15,41 @@
     "watch": "rnw-scripts watch"
   },
   "bin": {
-    "codegen": "./bin.js"
+    "react-native-windows-codegen": "./bin.js"
   },
   "dependencies": {
+    "@react-native-windows/fs": "^1.0.1",
     "chalk": "^4.1.0",
     "globby": "^9.2.0",
     "mustache": "^4.0.1",
-    "react-native-tscodegen": "0.66.1",
+    "react-native-tscodegen": "0.68.4",
     "source-map-support": "^0.5.19",
-    "yargs": "^15.4.1"
+    "yargs": "^16.2.0"
   },
   "devDependencies": {
-    "@rnw-scripts/eslint-config": "1.1.6",
-    "@rnw-scripts/jest-unittest-config": "1.1.1",
-    "@rnw-scripts/just-task": "2.0.2",
-    "@rnw-scripts/ts-config": "1.1.0",
+    "@rnw-scripts/eslint-config": "1.1.10",
+    "@rnw-scripts/jest-unittest-config": "1.2.5",
+    "@rnw-scripts/just-task": "2.2.2",
+    "@rnw-scripts/ts-config": "2.0.1",
     "@types/chalk": "^2.2.0",
     "@types/globby": "^9.1.0",
     "@types/jest": "^26.0.20",
     "@types/node": "^14.14.22",
-    "@types/yargs": "15.0.5",
+    "@types/yargs": "16.0.0",
     "babel-jest": "^26.3.0",
-    "eslint": "7.12.0",
-    "jest": "^26.5.2",
+    "eslint": "^7.32.0",
+    "jest": "^26.6.3",
     "just-scripts": "^1.3.3",
-    "prettier": "1.19.1",
-    "typescript": "^3.8.3"
+    "prettier": "^2.4.1",
+    "typescript": "^4.4.4"
   },
+  "files": [
+    "bin.js",
+    "CHANGELOG.md",
+    "README.md",
+    "lib-commonjs",
+    "src"
+  ],
   "beachball": {
     "defaultNpmTag": "canary",
     "disallowedChangeTypes": [
@@ -50,5 +58,8 @@
       "patch"
     ]
   },
-  "promoteRelease": true
+  "promoteRelease": true,
+  "engines": {
+    "node": ">= 12.0.0"
+  }
 }

package/src/Cli.ts

@@ -5,15 +5,15 @@
  * @format
  */
 
-import * as yargs from 'yargs';
-import * as path from 'path';
-import * as fs from 'fs';
-import * as globby from 'globby';
+import yargs from 'yargs';
+import path from 'path';
+import fs from '@react-native-windows/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 * as schemaValidator from 'react-native-tscodegen/lib/rncodegen/src/schemaValidator';
+import schemaValidator from 'react-native-tscodegen/lib/rncodegen/src/schemaValidator';
 
 const argv = yargs.options({
   file: {
@@ -33,6 +33,11 @@ const argv = yargs.options({
     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';
@@ -74,20 +79,44 @@ const GENERATORS = {
 };
 */
 
+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;
 
-  for (const [contents, fileName] of map) {
-    const location = path.join(outputDir, fileName);
-    if (!fs.existsSync(location)) {
+  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(location, 'utf8');
+    const currentContents = fs.readFileSync(fileName, 'utf8');
     if (currentContents !== contents) {
       console.error(`- ${fileName} has changed`);
       hasChanges = true;
@@ -100,20 +129,48 @@ function checkFilesForChanges(
 
 function writeMapToFiles(map: Map<string, string>, outputDir: string) {
   let success = true;
-  map.forEach((contents: string, fileName: string) => {
+
+  // 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 {
-      const location = path.join(outputDir, fileName);
-      fs.mkdirSync(path.dirname(location), {recursive: true});
-      fs.writeFileSync(location, contents);
+      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 ${outputDir}`, error);
+      console.error(`Failed to write ${fileName} to ${fileName}`, error);
     }
-  });
+  }
 
   return success;
 }
 
+function parseFlowFile(filename: string): SchemaType {
+  try {
+    return parseFile(filename);
+  } catch (e) {
+    if (e instanceof Error) {
+      e.message = `(${filename}): ${e.message}`;
+    }
+    throw e;
+  }
+}
+
 function combineSchemas(files: string[]): SchemaType {
   return files.reduce(
     (merged, filename) => {
@@ -123,11 +180,8 @@ function combineSchemas(files: string[]): SchemaType {
         (/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};
-        }
+        const schema = parseFlowFile(filename);
+        merged.modules = {...merged.modules, ...schema.modules};
       }
       return merged;
     },
@@ -141,26 +195,68 @@ function generate(
 ): boolean {
   schemaValidator.validate(schema);
 
-  const generatedFiles = [];
-  /*
-  for (const name of generators) {
-    for (const generator of GENERATORS[name]) {
-      generatedFiles.push(...generator(libraryName, schema, moduleSpecName));
-    }
-  }
-*/
+  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,
+  );
 
-  generatedFiles.push(...generateNM2(libraryName, schema, moduleSpecName));
+  if (
+    Object.keys(schema.modules).some(
+      (moduleName) => schema.modules[moduleName].type === 'Component',
+    )
+  ) {
+    const componentGenerators = [
+      generatorPropsH,
+      generatorPropsCPP,
+      generatorShadowNodeH,
+      generatorShadowNodeCPP,
+      generatorComponentDescriptorH,
+      generatorEventEmitterH,
+    ];
 
-  const filesToUpdate = new Map<string, string>([...generatedFiles]);
+    componentGenerators.forEach((generator) => {
+      const generated: Map<string, string> = generator(
+        libraryName,
+        schema,
+        moduleSpecName,
+      );
+      normalizeFileMap(generated, componentOutputdir, generatedFiles);
+    });
+  }
 
   if (test === true) {
-    return checkFilesForChanges(filesToUpdate, outputDirectory);
+    return checkFilesForChanges(generatedFiles, outputDirectory);
   }
 
-  return writeMapToFiles(filesToUpdate, outputDirectory);
+  return writeMapToFiles(generatedFiles, outputDirectory);
 }
 
 if ((argv.file && argv.files) || (!argv.file && !argv.files)) {
@@ -170,12 +266,12 @@ if ((argv.file && argv.files) || (!argv.file && !argv.files)) {
 
 let schema: SchemaType;
 if (argv.file) {
-  schema = parseFile(argv.file);
+  schema = parseFlowFile(argv.file);
 } else {
   schema = combineSchemas(globby.sync(argv.files as string[]));
 }
 
-const libraryName = 'libraryName';
+const libraryName = argv.libraryName;
 const moduleSpecName = 'moduleSpecName';
 const outputDirectory = 'codegen';
 generate(

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