@react-native-windows/codegen 0.66.1 → 0.67.1

package/src/generators/ObjectTypes.ts

@@ -6,25 +6,17 @@
 
 'use strict';
 
+import {NativeModuleBaseTypeAnnotation, Nullable} from 'react-native-tscodegen';
 import {
-  NativeModuleBaseTypeAnnotation,
-  NativeModuleObjectTypeAnnotation,
-  NamedShape,
-  Nullable,
-} from 'react-native-tscodegen';
+  AliasMap,
+  getAliasCppName,
+  getAnonymousAliasCppName,
+} from './AliasManaging';
 
-let preferredModuleName: string = '';
-
-export function setPreferredModuleName(moduleName: string): void {
-  preferredModuleName = moduleName;
-}
-
-export function getAliasCppName(typeName: string): string {
-  return `${preferredModuleName}Spec_${typeName}`;
-}
-
-function translateField(
+export function translateField(
   type: Nullable<NativeModuleBaseTypeAnnotation>,
+  aliases: AliasMap,
+  baseAliasName: string,
 ): string {
   // avoid: Property 'type' does not exist on type 'never'
   const returnType = type.type;
@@ -40,13 +32,19 @@ function translateField(
     case 'BooleanTypeAnnotation':
       return 'bool';
     case 'ArrayTypeAnnotation':
-      // TODO: type.elementType
-      return 'React::JSValueArray';
+      if (type.elementType) {
+        return `std::vector<${translateField(
+          type.elementType,
+          aliases,
+          `${baseAliasName}_element`,
+        )}>`;
+      } else {
+        return `React::JSValueArray`;
+      }
     case 'GenericObjectTypeAnnotation':
-      return 'React::JSValueObject';
+      return 'React::JSValue';
     case 'ObjectTypeAnnotation':
-      // TODO: we have more information here, and could create a more specific type
-      return 'React::JSValueObject';
+      return getAnonymousAliasCppName(aliases, baseAliasName, type);
     case 'ReservedTypeAnnotation': {
       // avoid: Property 'name' does not exist on type 'never'
       const name = type.name;
@@ -61,25 +59,12 @@ function translateField(
     case 'TypeAliasTypeAnnotation':
       return getAliasCppName(type.name);
     case 'NullableTypeAnnotation':
-      return `std::optional<${translateField(type.typeAnnotation)}>`;
+      return `std::optional<${translateField(
+        type.typeAnnotation,
+        aliases,
+        baseAliasName,
+      )}>`;
     default:
       throw new Error(`Unhandled type in translateReturnType: ${returnType}`);
   }
 }
-
-export function translateObjectBody(
-  type: NativeModuleObjectTypeAnnotation,
-  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)} ${prop.name};`;
-      return `${first}\n${second}`;
-    })
-    .join('\n');
-}

package/src/generators/ParamTypes.ts

@@ -11,19 +11,34 @@ import {
   NativeModuleParamTypeAnnotation,
   Nullable,
 } from 'react-native-tscodegen';
-import {getAliasCppName} from './ObjectTypes';
+import {
+  AliasMap,
+  getAliasCppName,
+  getAnonymousAliasCppName,
+} from './AliasManaging';
 
 type NativeModuleParamShape = NamedShape<
   Nullable<NativeModuleParamTypeAnnotation>
 >;
 
-function decorateType(type: string, forSpec: boolean): string {
-  return forSpec ? type : `${type} &&`;
+type ParamTarget = 'spec' | 'template' | 'callback-arg' | 'method-arg';
+
+function decorateType(type: string, target: ParamTarget): string {
+  switch (target) {
+    case 'method-arg':
+      return `${type} &&`;
+    case 'callback-arg':
+      return `${type} const &`;
+    default:
+      return type;
+  }
 }
 
 function translateParam(
   param: NativeModuleParamTypeAnnotation,
-  forSpec: boolean,
+  aliases: AliasMap,
+  baseAliasName: string,
+  target: ParamTarget,
 ): string {
   // avoid: Property 'type' does not exist on type 'never'
   const paramType = param.type;
@@ -39,21 +54,63 @@ function translateParam(
     case 'BooleanTypeAnnotation':
       return 'bool';
     case 'FunctionTypeAnnotation': {
-      // TODO: type.params && type.returnTypeAnnotation
-      if (forSpec) {
-        return 'Callback<React::JSValue>';
-      } else {
-        return 'std::function<void(React::JSValue const &)> const &';
+      // TODO: type.returnTypeAnnotation
+      switch (target) {
+        case 'spec':
+          return `Callback<${param.params
+            .map((p: NativeModuleParamShape) =>
+              translateSpecFunctionParam(
+                p,
+                aliases,
+                `${baseAliasName}_${p.name}`,
+              ),
+            )
+            .join(', ')}>`;
+        case 'template':
+          return `std::function<void(${param.params
+            .map((p: NativeModuleParamShape) =>
+              translateCallbackParam(p, aliases, `${baseAliasName}_${p.name}`),
+            )
+            .join(', ')})>`;
+        default:
+          return `std::function<void(${param.params
+            .map((p: NativeModuleParamShape) =>
+              translateCallbackParam(p, aliases, `${baseAliasName}_${p.name}`),
+            )
+            .join(', ')})> const &`;
       }
     }
     case 'ArrayTypeAnnotation':
-      // TODO: type.elementType
-      return decorateType('React::JSValueArray', forSpec);
+      if (param.elementType) {
+        switch (target) {
+          case 'spec':
+          case 'template':
+            return `std::vector<${translateNullableParamType(
+              param.elementType,
+              aliases,
+              `${baseAliasName}_element`,
+              'template',
+              'template',
+            )}>`;
+          default:
+            return `std::vector<${translateNullableParamType(
+              param.elementType,
+              aliases,
+              `${baseAliasName}_element`,
+              'template',
+              'template',
+            )}> const &`;
+        }
+      } else {
+        return decorateType('React::JSValueArray', target);
+      }
     case 'GenericObjectTypeAnnotation':
-      return decorateType('React::JSValueObject', forSpec);
+      return decorateType('React::JSValue', target);
     case 'ObjectTypeAnnotation':
-      // TODO: we have more information here, and could create a more specific type
-      return decorateType('React::JSValueObject', forSpec);
+      return decorateType(
+        getAnonymousAliasCppName(aliases, baseAliasName, param),
+        target,
+      );
     case 'ReservedTypeAnnotation': {
       // avoid: Property 'name' does not exist on type 'never'
       const name = param.name;
@@ -64,52 +121,100 @@ function translateParam(
       return 'double';
     }
     case 'TypeAliasTypeAnnotation':
-      return decorateType(getAliasCppName(param.name), forSpec);
+      return decorateType(getAliasCppName(param.name), target);
     default:
       throw new Error(`Unhandled type in translateParam: ${paramType}`);
   }
 }
 
-function translateSpecFunctionParam(param: NativeModuleParamShape): string {
-  switch (param.typeAnnotation.type) {
+function translateNullableParamType(
+  paramType: Nullable<NativeModuleParamTypeAnnotation>,
+  aliases: AliasMap,
+  baseAliasName: string,
+  nullableTarget: ParamTarget,
+  target: ParamTarget,
+): string {
+  switch (paramType.type) {
     case 'NullableTypeAnnotation':
-      // TODO: should be
-      // return `std::optional<${translateParam(
-      //   param.typeAnnotation.typeAnnotation,
-      //   true,
-      // )}>`;
-      return translateParam(param.typeAnnotation.typeAnnotation, true);
+      return `std::optional<${translateParam(
+        paramType.typeAnnotation,
+        aliases,
+        baseAliasName,
+        nullableTarget,
+      )}>`;
     default:
-      return translateParam(param.typeAnnotation, true);
+      return translateParam(paramType, aliases, baseAliasName, target);
   }
 }
 
-function translateFunctionParam(param: NativeModuleParamShape): string {
-  switch (param.typeAnnotation.type) {
-    case 'NullableTypeAnnotation':
-      // TODO: should be
-      // return `std::optional<${translateParam(
-      //   param.typeAnnotation.typeAnnotation,
-      //   false,
-      // )}>`;
-      return translateParam(param.typeAnnotation.typeAnnotation, false);
-    default:
-      return translateParam(param.typeAnnotation, false);
-  }
+function translateSpecFunctionParam(
+  param: NativeModuleParamShape,
+  aliases: AliasMap,
+  baseAliasName: string,
+): string {
+  return translateNullableParamType(
+    param.typeAnnotation,
+    aliases,
+    baseAliasName,
+    'spec',
+    'spec',
+  );
+}
+
+function translateCallbackParam(
+  param: NativeModuleParamShape,
+  aliases: AliasMap,
+  baseAliasName: string,
+): string {
+  return translateNullableParamType(
+    param.typeAnnotation,
+    aliases,
+    baseAliasName,
+    'template',
+    'callback-arg',
+  );
+}
+
+function translateFunctionParam(
+  param: NativeModuleParamShape,
+  aliases: AliasMap,
+  baseAliasName: string,
+): string {
+  return translateNullableParamType(
+    param.typeAnnotation,
+    aliases,
+    baseAliasName,
+    'template',
+    'method-arg',
+  );
 }
 
 export function translateSpecArgs(
   params: ReadonlyArray<NativeModuleParamShape>,
+  aliases: AliasMap,
+  baseAliasName: string,
 ) {
   return params.map(param => {
-    const translatedParam = translateSpecFunctionParam(param);
+    const translatedParam = translateSpecFunctionParam(
+      param,
+      aliases,
+      `${baseAliasName}_${param.name}`,
+    );
     return `${translatedParam}`;
   });
 }
 
-export function translateArgs(params: ReadonlyArray<NativeModuleParamShape>) {
+export function translateArgs(
+  params: ReadonlyArray<NativeModuleParamShape>,
+  aliases: AliasMap,
+  baseAliasName: string,
+) {
   return params.map(param => {
-    const translatedParam = translateFunctionParam(param);
+    const translatedParam = translateFunctionParam(
+      param,
+      aliases,
+      `${baseAliasName}_${param.name}`,
+    );
     return `${translatedParam} ${param.name}`;
   });
 }

package/src/generators/ReturnTypes.ts

@@ -10,10 +10,16 @@ import {
   NativeModuleReturnTypeAnnotation,
   Nullable,
 } from 'react-native-tscodegen';
-import {getAliasCppName} from './ObjectTypes';
+import {
+  AliasMap,
+  getAliasCppName,
+  getAnonymousAliasCppName,
+} from './AliasManaging';
 
 function translateReturnType(
   type: Nullable<NativeModuleReturnTypeAnnotation>,
+  aliases: AliasMap,
+  baseAliasName: string,
 ): string {
   // avoid: Property 'type' does not exist on type 'never'
   const returnType = type.type;
@@ -32,13 +38,19 @@ function translateReturnType(
     case 'BooleanTypeAnnotation':
       return 'bool';
     case 'ArrayTypeAnnotation':
-      // TODO: type.elementType
-      return 'React::JSValueArray';
+      if (type.elementType) {
+        return `std::vector<${translateReturnType(
+          type.elementType,
+          aliases,
+          `${baseAliasName}_element`,
+        )}>`;
+      } else {
+        return 'React::JSValueArray';
+      }
     case 'GenericObjectTypeAnnotation':
-      return 'React::JSValueObject';
+      return 'React::JSValue';
     case 'ObjectTypeAnnotation':
-      // TODO: we have more information here, and could create a more specific type
-      return 'React::JSValueObject';
+      return getAnonymousAliasCppName(aliases, baseAliasName, type);
     case 'ReservedTypeAnnotation': {
       // avoid: Property 'name' does not exist on type 'never'
       const name = type.name;
@@ -53,8 +65,11 @@ function translateReturnType(
     case 'TypeAliasTypeAnnotation':
       return getAliasCppName(type.name);
     case 'NullableTypeAnnotation':
-      // TODO: should be `std::optional<${translateReturnType(type.typeAnnotation)}>`;
-      return translateReturnType(type.typeAnnotation);
+      return `std::optional<${translateReturnType(
+        type.typeAnnotation,
+        aliases,
+        baseAliasName,
+      )}>`;
     default:
       throw new Error(`Unhandled type in translateReturnType: ${returnType}`);
   }
@@ -62,12 +77,16 @@ function translateReturnType(
 
 export function translateSpecReturnType(
   type: Nullable<NativeModuleReturnTypeAnnotation>,
+  aliases: AliasMap,
+  baseAliasName: string,
 ) {
-  return translateReturnType(type);
+  return translateReturnType(type, aliases, `${baseAliasName}_returnType`);
 }
 
 export function translateImplReturnType(
   type: Nullable<NativeModuleReturnTypeAnnotation>,
+  aliases: AliasMap,
+  baseAliasName: string,
 ) {
-  return translateReturnType(type);
+  return translateReturnType(type, aliases, `${baseAliasName}_returnType`);
 }

package/src/generators/ValidateConstants.ts

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+'use strict';
+
+import {NativeModuleSchema} from 'react-native-tscodegen';
+import {AliasMap, getAnonymousAliasCppName} from './AliasManaging';
+
+export function generateValidateConstants(
+  nativeModule: NativeModuleSchema,
+  aliases: AliasMap,
+): [string, string] | undefined {
+  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 = 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");`,
+  ];
+}

package/src/generators/ValidateMethods.ts

@@ -0,0 +1,135 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+'use strict';
+
+import {
+  NativeModuleFunctionTypeAnnotation,
+  NativeModulePropertyShape,
+  NativeModuleSchema,
+} from 'react-native-tscodegen';
+import {AliasMap} from './AliasManaging';
+import {translateArgs, translateSpecArgs} from './ParamTypes';
+import {translateImplReturnType, translateSpecReturnType} from './ReturnTypes';
+
+function isMethodSync(funcType: NativeModuleFunctionTypeAnnotation) {
+  return (
+    funcType.returnTypeAnnotation.type !== 'VoidTypeAnnotation' &&
+    funcType.returnTypeAnnotation.type !== 'PromiseTypeAnnotation'
+  );
+}
+
+function isMethodReturnPromise(funcType: NativeModuleFunctionTypeAnnotation) {
+  return funcType.returnTypeAnnotation.type === 'PromiseTypeAnnotation';
+}
+
+function getPossibleMethodSignatures(
+  prop: NativeModulePropertyShape,
+  funcType: NativeModuleFunctionTypeAnnotation,
+  aliases: AliasMap,
+  baseAliasName: string,
+): string[] {
+  const args = 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
+  }) ${translateImplReturnType(
+    funcType.returnTypeAnnotation,
+    aliases,
+    baseAliasName,
+  )} ${prop.name}(${args.join(', ')}) noexcept { /* implementation */ }}`;
+
+  const staticsig = `REACT_${isMethodSync(funcType) ? 'SYNC_' : ''}METHOD(${
+    prop.name
+  }) static ${translateImplReturnType(
+    funcType.returnTypeAnnotation,
+    aliases,
+    baseAliasName,
+  )} ${prop.name}(${args.join(', ')}) noexcept { /* implementation */ }}`;
+
+  return [sig, staticsig];
+}
+
+function translatePossibleMethodSignatures(
+  prop: NativeModulePropertyShape,
+  funcType: NativeModuleFunctionTypeAnnotation,
+  aliases: AliasMap,
+  baseAliasName: string,
+): string {
+  return getPossibleMethodSignatures(prop, funcType, aliases, baseAliasName)
+    .map(sig => `"    ${sig}\\n"`)
+    .join('\n          ');
+}
+
+function renderProperties(
+  properties: ReadonlyArray<NativeModulePropertyShape>,
+  aliases: AliasMap,
+  tuple: boolean,
+): string {
+  // 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 = translateSpecArgs(
+        funcType.params,
+        aliases,
+        propAliasName,
+      );
+
+      const translatedReturnParam = 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');
+}
+
+export function generateValidateMethods(
+  nativeModule: NativeModuleSchema,
+  aliases: AliasMap,
+): [string, string] {
+  const properties = nativeModule.spec.properties;
+  const traversedProperties = renderProperties(properties, aliases, false);
+  const traversedPropertyTuples = renderProperties(properties, aliases, true);
+  return [traversedPropertyTuples, traversedProperties];
+}

package/.eslintrc.js

@@ -1,4 +0,0 @@
-module.exports = {
-  extends: ['@rnw-scripts'],
-  parserOptions: {tsconfigRootDir : __dirname},
-};

package/.vscode/launch.json

@@ -1,23 +0,0 @@
-{
-  // Use IntelliSense to learn about possible attributes.
-  // Hover to view descriptions of existing attributes.
-  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-  "version": "0.2.0",
-  "configurations": [
-    {
-      "name": "vscode-jest-tests",
-      "type": "node",
-      "request": "launch",
-      "runtimeArgs": [
-        "--inspect-brk",
-        "../../node_modules/jest/bin/jest.js",
-        "--runInBand",
-        "--config",
-        "../@rnw-scripts/jest-debug-config/jest.debug.config.js",
-      ],
-      "console": "integratedTerminal",
-      "internalConsoleOptions": "neverOpen",
-      "port": 9229,
-    },
-  ]
-}

package/jest.config.js

@@ -1 +0,0 @@
-module.exports = require('@rnw-scripts/jest-unittest-config');

package/tsconfig.json

@@ -1,5 +0,0 @@
-{
-  "extends": "@rnw-scripts/ts-config",
-  "include": ["src"],
-  "exclude": ["node_modules"]
-}