@react-native-windows/codegen 0.65.0 → 0.67.0-preview.1

package/lib-commonjs/generators/ReturnTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReturnTypes.js","sourceRoot":"","sources":["../../src/generators/ReturnTypes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,CAAC;;;AAMb,mDAIyB;AAEzB,SAAS,mBAAmB,CAC1B,IAAgD,EAChD,OAAiB,EACjB,aAAqB;IAErB,wDAAwD;IACxD,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC;IAC7B,QAAQ,IAAI,CAAC,IAAI,EAAE;QACjB,KAAK,oBAAoB,CAAC;QAC1B,KAAK,uBAAuB;YAC1B,OAAO,MAAM,CAAC;QAChB,KAAK,sBAAsB;YACzB,OAAO,aAAa,CAAC;QACvB,KAAK,sBAAsB,CAAC;QAC5B,KAAK,qBAAqB,CAAC;QAC3B,KAAK,sBAAsB;YACzB,OAAO,QAAQ,CAAC;QAClB,KAAK,qBAAqB;YACxB,OAAO,KAAK,CAAC;QACf,KAAK,uBAAuB;YAC1B,OAAO,MAAM,CAAC;QAChB,KAAK,qBAAqB;YACxB,IAAI,IAAI,CAAC,WAAW,EAAE;gBACpB,OAAO,eAAe,mBAAmB,CACvC,IAAI,CAAC,WAAW,EAChB,OAAO,EACP,GAAG,aAAa,UAAU,CAC3B,GAAG,CAAC;aACN;iBAAM;gBACL,OAAO,qBAAqB,CAAC;aAC9B;QACH,KAAK,6BAA6B;YAChC,OAAO,gBAAgB,CAAC;QAC1B,KAAK,sBAAsB;YACzB,OAAO,IAAA,wCAAwB,EAAC,OAAO,EAAE,aAAa,EAAE,IAAI,CAAC,CAAC;QAChE,KAAK,wBAAwB,CAAC,CAAC;YAC7B,wDAAwD;YACxD,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;YACvB,UAAU;YACV,uEAAuE;YACvE,IAAI,IAAI,KAAK,SAAS;gBACpB,MAAM,IAAI,KAAK,CACb,8BAA8B,IAAI,yBAAyB,CAC5D,CAAC;YACJ,OAAO,QAAQ,CAAC;SACjB;QACD,KAAK,yBAAyB;YAC5B,OAAO,IAAA,+BAAe,EAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpC,KAAK,wBAAwB;YAC3B,OAAO,iBAAiB,mBAAmB,CACzC,IAAI,CAAC,cAAc,EACnB,OAAO,EACP,aAAa,CACd,GAAG,CAAC;QACP;YACE,MAAM,IAAI,KAAK,CAAC,0CAA0C,UAAU,EAAE,CAAC,CAAC;KAC3E;AACH,CAAC;AAED,SAAgB,uBAAuB,CACrC,IAAgD,EAChD,OAAiB,EACjB,aAAqB;IAErB,OAAO,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,aAAa,aAAa,CAAC,CAAC;AAC3E,CAAC;AAND,0DAMC;AAED,SAAgB,uBAAuB,CACrC,IAAgD,EAChD,OAAiB,EACjB,aAAqB;IAErB,OAAO,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,aAAa,aAAa,CAAC,CAAC;AAC3E,CAAC;AAND,0DAMC","sourcesContent":["/**\n * Copyright (c) Microsoft Corporation.\n * Licensed under the MIT License.\n * @format\n */\n\n'use strict';\n\nimport {\n  NativeModuleReturnTypeAnnotation,\n  Nullable,\n} from 'react-native-tscodegen';\nimport {\n  AliasMap,\n  getAliasCppName,\n  getAnonymousAliasCppName,\n} from './AliasManaging';\n\nfunction translateReturnType(\n  type: Nullable<NativeModuleReturnTypeAnnotation>,\n  aliases: AliasMap,\n  baseAliasName: string,\n): string {\n  // avoid: Property 'type' does not exist on type 'never'\n  const returnType = type.type;\n  switch (type.type) {\n    case 'VoidTypeAnnotation':\n    case 'PromiseTypeAnnotation':\n      return 'void';\n    case 'StringTypeAnnotation':\n      return 'std::string';\n    case 'NumberTypeAnnotation':\n    case 'FloatTypeAnnotation':\n    case 'DoubleTypeAnnotation':\n      return 'double';\n    case 'Int32TypeAnnotation':\n      return 'int';\n    case 'BooleanTypeAnnotation':\n      return 'bool';\n    case 'ArrayTypeAnnotation':\n      if (type.elementType) {\n        return `std::vector<${translateReturnType(\n          type.elementType,\n          aliases,\n          `${baseAliasName}_element`,\n        )}>`;\n      } else {\n        return 'React::JSValueArray';\n      }\n    case 'GenericObjectTypeAnnotation':\n      return 'React::JSValue';\n    case 'ObjectTypeAnnotation':\n      return getAnonymousAliasCppName(aliases, baseAliasName, type);\n    case 'ReservedTypeAnnotation': {\n      // avoid: Property 'name' does not exist on type 'never'\n      const name = type.name;\n      // (#6597)\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n      if (name !== 'RootTag')\n        throw new Error(\n          `Unknown reserved function: ${name} in translateReturnType`,\n        );\n      return 'double';\n    }\n    case 'TypeAliasTypeAnnotation':\n      return getAliasCppName(type.name);\n    case 'NullableTypeAnnotation':\n      return `std::optional<${translateReturnType(\n        type.typeAnnotation,\n        aliases,\n        baseAliasName,\n      )}>`;\n    default:\n      throw new Error(`Unhandled type in translateReturnType: ${returnType}`);\n  }\n}\n\nexport function translateSpecReturnType(\n  type: Nullable<NativeModuleReturnTypeAnnotation>,\n  aliases: AliasMap,\n  baseAliasName: string,\n) {\n  return translateReturnType(type, aliases, `${baseAliasName}_returnType`);\n}\n\nexport function translateImplReturnType(\n  type: Nullable<NativeModuleReturnTypeAnnotation>,\n  aliases: AliasMap,\n  baseAliasName: string,\n) {\n  return translateReturnType(type, aliases, `${baseAliasName}_returnType`);\n}\n"]}

package/lib-commonjs/generators/ValidateConstants.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+import { NativeModuleSchema } from 'react-native-tscodegen';
+import { AliasMap } from './AliasManaging';
+export declare function generateValidateConstants(nativeModule: NativeModuleSchema, aliases: AliasMap): [string, string] | undefined;

package/lib-commonjs/generators/ValidateConstants.js

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateValidateConstants = void 0;
+const AliasManaging_1 = require("./AliasManaging");
+function generateValidateConstants(nativeModule, aliases) {
+    const candidates = nativeModule.spec.properties.filter(prop => prop.name === 'getConstants');
+    if (candidates.length === 0) {
+        return undefined;
+    }
+    const getConstant = candidates[0];
+    const funcType = getConstant.typeAnnotation.type === 'NullableTypeAnnotation'
+        ? getConstant.typeAnnotation.typeAnnotation
+        : getConstant.typeAnnotation;
+    if (funcType.params.length > 0 ||
+        funcType.returnTypeAnnotation.type !== 'ObjectTypeAnnotation') {
+        return undefined;
+    }
+    const constantType = funcType.returnTypeAnnotation;
+    if (constantType.properties.length === 0) {
+        return undefined;
+    }
+    const cppName = (0, AliasManaging_1.getAnonymousAliasCppName)(aliases, 'Constants', constantType);
+    return [
+        `      TypedConstant<${cppName}>{0},`,
+        `    REACT_SHOW_CONSTANT_SPEC_ERRORS(
+          0,
+          "${cppName}",
+          "    REACT_GET_CONSTANTS(GetConstants) ${cppName} GetConstants() noexcept {/*implementation*/}\\n"
+          "    REACT_GET_CONSTANTS(GetConstants) static ${cppName} GetConstants() noexcept {/*implementation*/}\\n");`,
+    ];
+}
+exports.generateValidateConstants = generateValidateConstants;
+//# sourceMappingURL=ValidateConstants.js.map

package/lib-commonjs/generators/ValidateConstants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidateConstants.js","sourceRoot":"","sources":["../../src/generators/ValidateConstants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,CAAC;;;AAGb,mDAAmE;AAEnE,SAAgB,yBAAyB,CACvC,YAAgC,EAChC,OAAiB;IAEjB,MAAM,UAAU,GAAG,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CACpD,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,cAAc,CACrC,CAAC;IACF,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE;QAC3B,OAAO,SAAS,CAAC;KAClB;IAED,MAAM,WAAW,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;IAClC,MAAM,QAAQ,GACZ,WAAW,CAAC,cAAc,CAAC,IAAI,KAAK,wBAAwB;QAC1D,CAAC,CAAC,WAAW,CAAC,cAAc,CAAC,cAAc;QAC3C,CAAC,CAAC,WAAW,CAAC,cAAc,CAAC;IACjC,IACE,QAAQ,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC;QAC1B,QAAQ,CAAC,oBAAoB,CAAC,IAAI,KAAK,sBAAsB,EAC7D;QACA,OAAO,SAAS,CAAC;KAClB;IAED,MAAM,YAAY,GAAG,QAAQ,CAAC,oBAAoB,CAAC;IACnD,IAAI,YAAY,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE;QACxC,OAAO,SAAS,CAAC;KAClB;IAED,MAAM,OAAO,GAAG,IAAA,wCAAwB,EAAC,OAAO,EAAE,WAAW,EAAE,YAAY,CAAC,CAAC;IAE7E,OAAO;QACL,uBAAuB,OAAO,OAAO;QACrC;;aAES,OAAO;mDAC+B,OAAO;0DACA,OAAO,qDAAqD;KACnH,CAAC;AACJ,CAAC;AAtCD,8DAsCC","sourcesContent":["/**\n * Copyright (c) Microsoft Corporation.\n * Licensed under the MIT License.\n * @format\n */\n\n'use strict';\n\nimport {NativeModuleSchema} from 'react-native-tscodegen';\nimport {AliasMap, getAnonymousAliasCppName} from './AliasManaging';\n\nexport function generateValidateConstants(\n  nativeModule: NativeModuleSchema,\n  aliases: AliasMap,\n): [string, string] | undefined {\n  const candidates = nativeModule.spec.properties.filter(\n    prop => prop.name === 'getConstants',\n  );\n  if (candidates.length === 0) {\n    return undefined;\n  }\n\n  const getConstant = candidates[0];\n  const funcType =\n    getConstant.typeAnnotation.type === 'NullableTypeAnnotation'\n      ? getConstant.typeAnnotation.typeAnnotation\n      : getConstant.typeAnnotation;\n  if (\n    funcType.params.length > 0 ||\n    funcType.returnTypeAnnotation.type !== 'ObjectTypeAnnotation'\n  ) {\n    return undefined;\n  }\n\n  const constantType = funcType.returnTypeAnnotation;\n  if (constantType.properties.length === 0) {\n    return undefined;\n  }\n\n  const cppName = getAnonymousAliasCppName(aliases, 'Constants', constantType);\n\n  return [\n    `      TypedConstant<${cppName}>{0},`,\n    `    REACT_SHOW_CONSTANT_SPEC_ERRORS(\n          0,\n          \"${cppName}\",\n          \"    REACT_GET_CONSTANTS(GetConstants) ${cppName} GetConstants() noexcept {/*implementation*/}\\\\n\"\n          \"    REACT_GET_CONSTANTS(GetConstants) static ${cppName} GetConstants() noexcept {/*implementation*/}\\\\n\");`,\n  ];\n}\n"]}

package/lib-commonjs/generators/ValidateMethods.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+import { NativeModuleSchema } from 'react-native-tscodegen';
+import { AliasMap } from './AliasManaging';
+export declare function generateValidateMethods(nativeModule: NativeModuleSchema, aliases: AliasMap): [string, string];

package/lib-commonjs/generators/ValidateMethods.js

@@ -0,0 +1,70 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateValidateMethods = void 0;
+const ParamTypes_1 = require("./ParamTypes");
+const ReturnTypes_1 = require("./ReturnTypes");
+function isMethodSync(funcType) {
+    return (funcType.returnTypeAnnotation.type !== 'VoidTypeAnnotation' &&
+        funcType.returnTypeAnnotation.type !== 'PromiseTypeAnnotation');
+}
+function isMethodReturnPromise(funcType) {
+    return funcType.returnTypeAnnotation.type === 'PromiseTypeAnnotation';
+}
+function getPossibleMethodSignatures(prop, funcType, aliases, baseAliasName) {
+    const args = (0, ParamTypes_1.translateArgs)(funcType.params, aliases, baseAliasName);
+    if (isMethodReturnPromise(funcType)) {
+        // TODO: type of the promise could be provided in the future
+        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}) ${(0, ReturnTypes_1.translateImplReturnType)(funcType.returnTypeAnnotation, aliases, baseAliasName)} ${prop.name}(${args.join(', ')}) noexcept { /* implementation */ }}`;
+    const staticsig = `REACT_${isMethodSync(funcType) ? 'SYNC_' : ''}METHOD(${prop.name}) static ${(0, ReturnTypes_1.translateImplReturnType)(funcType.returnTypeAnnotation, aliases, baseAliasName)} ${prop.name}(${args.join(', ')}) noexcept { /* implementation */ }}`;
+    return [sig, staticsig];
+}
+function translatePossibleMethodSignatures(prop, funcType, aliases, baseAliasName) {
+    return getPossibleMethodSignatures(prop, funcType, aliases, baseAliasName)
+        .map(sig => `"    ${sig}\\n"`)
+        .join('\n          ');
+}
+function renderProperties(properties, aliases, tuple) {
+    // TODO: generate code for constants
+    return properties
+        .filter(prop => prop.name !== 'getConstants')
+        .map((prop, index) => {
+        // TODO: prop.optional === true
+        // TODO: prop.typeAnnotation.type === 'NullableTypeAnnotation'
+        const propAliasName = prop.name;
+        const funcType = prop.typeAnnotation.type === 'NullableTypeAnnotation'
+            ? prop.typeAnnotation.typeAnnotation
+            : prop.typeAnnotation;
+        const traversedArgs = (0, ParamTypes_1.translateSpecArgs)(funcType.params, aliases, propAliasName);
+        const translatedReturnParam = (0, ReturnTypes_1.translateSpecReturnType)(funcType.returnTypeAnnotation, aliases, propAliasName);
+        if (isMethodReturnPromise(funcType)) {
+            // TODO: type of the promise could be provided in the future
+            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, aliases, propAliasName)});`;
+        }
+    })
+        .join('\n');
+}
+function generateValidateMethods(nativeModule, aliases) {
+    const properties = nativeModule.spec.properties;
+    const traversedProperties = renderProperties(properties, aliases, false);
+    const traversedPropertyTuples = renderProperties(properties, aliases, true);
+    return [traversedPropertyTuples, traversedProperties];
+}
+exports.generateValidateMethods = generateValidateMethods;
+//# sourceMappingURL=ValidateMethods.js.map

package/lib-commonjs/generators/ValidateMethods.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidateMethods.js","sourceRoot":"","sources":["../../src/generators/ValidateMethods.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Copyright (c) Microsoft Corporation.\n * Licensed under the MIT License.\n * @format\n */\n\n'use strict';\n\nimport {\n  NativeModuleFunctionTypeAnnotation,\n  NativeModulePropertyShape,\n  NativeModuleSchema,\n} from 'react-native-tscodegen';\nimport {AliasMap} from './AliasManaging';\nimport {translateArgs, translateSpecArgs} from './ParamTypes';\nimport {translateImplReturnType, translateSpecReturnType} from './ReturnTypes';\n\nfunction isMethodSync(funcType: NativeModuleFunctionTypeAnnotation) {\n  return (\n    funcType.returnTypeAnnotation.type !== 'VoidTypeAnnotation' &&\n    funcType.returnTypeAnnotation.type !== 'PromiseTypeAnnotation'\n  );\n}\n\nfunction isMethodReturnPromise(funcType: NativeModuleFunctionTypeAnnotation) {\n  return funcType.returnTypeAnnotation.type === 'PromiseTypeAnnotation';\n}\n\nfunction getPossibleMethodSignatures(\n  prop: NativeModulePropertyShape,\n  funcType: NativeModuleFunctionTypeAnnotation,\n  aliases: AliasMap,\n  baseAliasName: string,\n): string[] {\n  const args = translateArgs(funcType.params, aliases, baseAliasName);\n  if (isMethodReturnPromise(funcType)) {\n    // TODO: type of the promise could be provided in the future\n    args.push('React::ReactPromise<React::JSValue> &&result');\n  }\n\n  // TODO: be much more exhastive on the possible method signatures that can be used..\n  const sig = `REACT_${isMethodSync(funcType) ? 'SYNC_' : ''}METHOD(${\n    prop.name\n  }) ${translateImplReturnType(\n    funcType.returnTypeAnnotation,\n    aliases,\n    baseAliasName,\n  )} ${prop.name}(${args.join(', ')}) noexcept { /* implementation */ }}`;\n\n  const staticsig = `REACT_${isMethodSync(funcType) ? 'SYNC_' : ''}METHOD(${\n    prop.name\n  }) static ${translateImplReturnType(\n    funcType.returnTypeAnnotation,\n    aliases,\n    baseAliasName,\n  )} ${prop.name}(${args.join(', ')}) noexcept { /* implementation */ }}`;\n\n  return [sig, staticsig];\n}\n\nfunction translatePossibleMethodSignatures(\n  prop: NativeModulePropertyShape,\n  funcType: NativeModuleFunctionTypeAnnotation,\n  aliases: AliasMap,\n  baseAliasName: string,\n): string {\n  return getPossibleMethodSignatures(prop, funcType, aliases, baseAliasName)\n    .map(sig => `\"    ${sig}\\\\n\"`)\n    .join('\\n          ');\n}\n\nfunction renderProperties(\n  properties: ReadonlyArray<NativeModulePropertyShape>,\n  aliases: AliasMap,\n  tuple: boolean,\n): string {\n  // TODO: generate code for constants\n  return properties\n    .filter(prop => prop.name !== 'getConstants')\n    .map((prop, index) => {\n      // TODO: prop.optional === true\n      // TODO: prop.typeAnnotation.type === 'NullableTypeAnnotation'\n      const propAliasName = prop.name;\n      const funcType =\n        prop.typeAnnotation.type === 'NullableTypeAnnotation'\n          ? prop.typeAnnotation.typeAnnotation\n          : prop.typeAnnotation;\n\n      const traversedArgs = translateSpecArgs(\n        funcType.params,\n        aliases,\n        propAliasName,\n      );\n\n      const translatedReturnParam = translateSpecReturnType(\n        funcType.returnTypeAnnotation,\n        aliases,\n        propAliasName,\n      );\n\n      if (isMethodReturnPromise(funcType)) {\n        // TODO: type of the promise could be provided in the future\n        traversedArgs.push('Promise<React::JSValue>');\n      }\n\n      if (tuple) {\n        return `      ${\n          isMethodSync(funcType) ? 'Sync' : ''\n        }Method<${translatedReturnParam}(${traversedArgs.join(\n          ', ',\n        )}) noexcept>{${index}, L\"${prop.name}\"},`;\n      } else {\n        return `    REACT_SHOW_METHOD_SPEC_ERRORS(\n          ${index},\n          \"${prop.name}\",\n          ${translatePossibleMethodSignatures(\n            prop,\n            funcType,\n            aliases,\n            propAliasName,\n          )});`;\n      }\n    })\n    .join('\\n');\n}\n\nexport function generateValidateMethods(\n  nativeModule: NativeModuleSchema,\n  aliases: AliasMap,\n): [string, string] {\n  const properties = nativeModule.spec.properties;\n  const traversedProperties = renderProperties(properties, aliases, false);\n  const traversedPropertyTuples = renderProperties(properties, aliases, true);\n  return [traversedPropertyTuples, traversedProperties];\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native-windows/codegen",
-  "version": "0.65.0",
+  "version": "0.67.0-preview.1",
   "description": "Generators for react-native-codegen targeting react-native-windows",
   "main": "index.js",
   "repository": "https://github.com/microsoft/react-native-windows",
@@ -15,21 +15,21 @@
     "watch": "rnw-scripts watch"
   },
   "bin": {
-    "codegen": "./bin.js"
+    "react-native-windows-codegen": "./bin.js"
   },
   "dependencies": {
     "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": "^16.2.0"
   },
   "devDependencies": {
-    "@rnw-scripts/eslint-config": "1.1.6",
-    "@rnw-scripts/jest-unittest-config": "1.2.1",
-    "@rnw-scripts/just-task": "2.1.1",
-    "@rnw-scripts/ts-config": "1.1.0",
+    "@rnw-scripts/eslint-config": "1.1.8",
+    "@rnw-scripts/jest-unittest-config": "1.2.4",
+    "@rnw-scripts/just-task": "2.2.1",
+    "@rnw-scripts/ts-config": "2.0.1",
     "@types/chalk": "^2.2.0",
     "@types/globby": "^9.1.0",
     "@types/jest": "^26.0.20",
@@ -40,15 +40,25 @@
     "jest": "^26.6.3",
     "just-scripts": "^1.3.3",
     "prettier": "1.19.1",
-    "typescript": "^3.8.3"
+    "typescript": "^4.4.4"
   },
+  "files": [
+    "bin.js",
+    "CHANGELOG.md",
+    "README.md",
+    "lib-commonjs",
+    "src"
+  ],
   "beachball": {
-    "defaultNpmTag": "latest",
+    "defaultNpmTag": "preview",
     "disallowedChangeTypes": [
       "major",
       "minor",
-      "prerelease"
+      "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 '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: {
@@ -79,20 +79,42 @@ 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;
@@ -105,20 +127,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) => {
@@ -128,11 +178,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;
     },
@@ -152,15 +199,12 @@ function generate(
     libraryName,
   );
 
-  const generatedModuleFiles = [];
-  const generatedComponentFiles = [];
-  /*
-  for (const name of generators) {
-    for (const generator of GENERATORS[name]) {
-      generatedFiles.push(...generator(libraryName, schema, moduleSpecName));
-    }
-  }
-*/
+  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')
@@ -176,37 +220,41 @@ function generate(
   const generatorEventEmitterH = require('react-native-tscodegen/lib/rncodegen/src/generators/components/GenerateEventEmitterH')
     .generate;
 
-  generatedModuleFiles.push(
-    ...generateNM2(libraryName, schema, moduleSpecName),
+  normalizeFileMap(
+    generateNM2(libraryName, schema, moduleSpecName),
+    outputDirectory,
+    generatedFiles,
   );
 
-  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),
-  );
+  if (
+    Object.keys(schema.modules).some(
+      moduleName => schema.modules[moduleName].type === 'Component',
+    )
+  ) {
+    const componentGenerators = [
+      generatorPropsH,
+      generatorPropsCPP,
+      generatorShadowNodeH,
+      generatorShadowNodeCPP,
+      generatorComponentDescriptorH,
+      generatorEventEmitterH,
+    ];
 
-  const moduleFilesToUpdate = new Map<string, string>([
-    ...generatedModuleFiles,
-  ]);
-  const componentFilesToUpdate = new Map<string, string>([
-    ...generatedComponentFiles,
-  ]);
+    componentGenerators.forEach(generator => {
+      const generated: Map<string, string> = generator(
+        libraryName,
+        schema,
+        moduleSpecName,
+      );
+      normalizeFileMap(generated, componentOutputdir, generatedFiles);
+    });
+  }
 
   if (test === true) {
-    return (
-      checkFilesForChanges(moduleFilesToUpdate, outputDirectory) &&
-      checkFilesForChanges(componentFilesToUpdate, componentOutputdir)
-    );
+    return checkFilesForChanges(generatedFiles, outputDirectory);
   }
 
-  return (
-    writeMapToFiles(moduleFilesToUpdate, outputDirectory) &&
-    writeMapToFiles(componentFilesToUpdate, componentOutputdir)
-  );
+  return writeMapToFiles(generatedFiles, outputDirectory);
 }
 
 if ((argv.file && argv.files) || (!argv.file && !argv.files)) {
@@ -216,7 +264,7 @@ 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[]));
 }

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