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

package/src/generators/ReturnTypes.ts

@@ -0,0 +1,92 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+'use strict';
+
+import {
+  NativeModuleReturnTypeAnnotation,
+  Nullable,
+} from 'react-native-tscodegen';
+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;
+  switch (type.type) {
+    case 'VoidTypeAnnotation':
+    case 'PromiseTypeAnnotation':
+      return 'void';
+    case 'StringTypeAnnotation':
+      return 'std::string';
+    case 'NumberTypeAnnotation':
+    case 'FloatTypeAnnotation':
+    case 'DoubleTypeAnnotation':
+      return 'double';
+    case 'Int32TypeAnnotation':
+      return 'int';
+    case 'BooleanTypeAnnotation':
+      return 'bool';
+    case 'ArrayTypeAnnotation':
+      if (type.elementType) {
+        return `std::vector<${translateReturnType(
+          type.elementType,
+          aliases,
+          `${baseAliasName}_element`,
+        )}>`;
+      } else {
+        return 'React::JSValueArray';
+      }
+    case 'GenericObjectTypeAnnotation':
+      return 'React::JSValue';
+    case 'ObjectTypeAnnotation':
+      return getAnonymousAliasCppName(aliases, baseAliasName, type);
+    case 'ReservedTypeAnnotation': {
+      // avoid: Property 'name' does not exist on type 'never'
+      const name = type.name;
+      // (#6597)
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      if (name !== 'RootTag')
+        throw new Error(
+          `Unknown reserved function: ${name} in translateReturnType`,
+        );
+      return 'double';
+    }
+    case 'TypeAliasTypeAnnotation':
+      return getAliasCppName(type.name);
+    case 'NullableTypeAnnotation':
+      return `std::optional<${translateReturnType(
+        type.typeAnnotation,
+        aliases,
+        baseAliasName,
+      )}>`;
+    default:
+      throw new Error(`Unhandled type in translateReturnType: ${returnType}`);
+  }
+}
+
+export function translateSpecReturnType(
+  type: Nullable<NativeModuleReturnTypeAnnotation>,
+  aliases: AliasMap,
+  baseAliasName: string,
+) {
+  return translateReturnType(type, aliases, `${baseAliasName}_returnType`);
+}
+
+export function translateImplReturnType(
+  type: Nullable<NativeModuleReturnTypeAnnotation>,
+  aliases: AliasMap,
+  baseAliasName: string,
+) {
+  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"]
-}