@react-native-windows/codegen 0.0.0-canary.13 → 0.0.0-canary.130

package/src/generators/GenerateNM2.ts

@@ -6,23 +6,18 @@
 
 'use strict';
 
-import {
-  NativeModuleFunctionTypeAnnotation,
-  NativeModulePropertyShape,
-  SchemaType,
-} from 'react-native-tscodegen';
-import {
-  getAliasCppName,
-  setPreferredModuleName,
-  translateObjectBody,
-} from './ObjectTypes';
-import {translateArgs, translateSpecArgs} from './ParamTypes';
-import {translateImplReturnType, translateSpecReturnType} from './ReturnTypes';
+import type {SchemaType} from '@react-native/codegen/lib/CodegenSchema';
+import {AliasMap, setPreferredModuleName} from './AliasManaging';
+import {createAliasMap, generateAliases} from './AliasGen';
+import {generateValidateConstants} from './ValidateConstants';
+import {generateValidateMethods} from './ValidateMethods';
+import type {CppStringTypes} from './ObjectTypes';
+
+export type {CppStringTypes} from './ObjectTypes';
 
 type FilesOutput = Map<string, string>;
 
-const moduleTemplate = `
-/*
+const headerTemplate = `/*
  * This file is auto-generated from a NativeModule spec file in js.
  *
  * This is a C++ Spec class that should be used with MakeTurboModuleProvider to register native modules
@@ -30,117 +25,71 @@ const moduleTemplate = `
  * by the TurboModule JS spec.
  */
 #pragma once
+// clang-format off`;
 
-#include "NativeModules.h"
-#include <tuple>
-
-namespace ::_NAMESPACE_:: {
-::_MODULE_ALIASED_STRUCTS_::
+const specTemplate = `::_MODULE_CUSTOM_TYPES_REFLECTION_::
 struct ::_MODULE_NAME_::Spec : winrt::Microsoft::ReactNative::TurboModuleSpec {
-  static constexpr auto methods = std::tuple{
-::_MODULE_PROPERTIES_TUPLE_::
-  };
+::_MODULE_MEMBERS_TUPLES_::
 
   template <class TModule>
   static constexpr void ValidateModule() noexcept {
-    constexpr auto methodCheckResults = CheckMethods<TModule, ::_MODULE_NAME_::Spec>();
+::_MODULE_MEMBERS_CHECKS_::
 
-::_MODULE_PROPERTIES_SPEC_ERRORS_::
-  }
-};
+::_MODULE_MEMBERS_ERRORS_::
+  }`;
+
+const typeOnlyTemplate = `
+${headerTemplate}
 
+#include <string>
+#include <optional>
+#include <functional>
+#include <vector>
+
+namespace ::_NAMESPACE_:: {
+::_MODULE_CUSTOM_TYPES_::
 } // namespace ::_NAMESPACE_::
 `;
 
-function isMethodSync(funcType: NativeModuleFunctionTypeAnnotation) {
-  return (
-    funcType.returnTypeAnnotation.type !== 'VoidTypeAnnotation' &&
-    funcType.returnTypeAnnotation.type !== 'PromiseTypeAnnotation'
-  );
-}
+const moduleOnlyTemplate = `
+${headerTemplate}
 
-function isMethodReturnPromise(funcType: NativeModuleFunctionTypeAnnotation) {
-  return funcType.returnTypeAnnotation.type === 'PromiseTypeAnnotation';
-}
+::_TYPE_DEFINITION_INCLUDE_::
+#include <NativeModules.h>
+#include <tuple>
 
-function getPossibleMethodSignatures(
-  prop: NativeModulePropertyShape,
-  funcType: NativeModuleFunctionTypeAnnotation,
-): string[] {
-  const args = translateArgs(funcType.params);
-  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)} ${
-    prop.name
-  }(${args.join(', ')}) noexcept { /* implementation */ }}`;
-
-  const staticsig = `REACT_${isMethodSync(funcType) ? 'SYNC_' : ''}METHOD(${
-    prop.name
-  }) static ${translateImplReturnType(funcType.returnTypeAnnotation)} ${
-    prop.name
-  }(${args.join(', ')}) noexcept { /* implementation */ }}`;
-
-  return [sig, staticsig];
-}
+namespace ::_NAMESPACE_:: {
+${specTemplate}
+};
 
-function translatePossibleMethodSignatures(
-  prop: NativeModulePropertyShape,
-  funcType: NativeModuleFunctionTypeAnnotation,
-): string {
-  return getPossibleMethodSignatures(prop, funcType)
-    .map(sig => `"    ${sig}\\n"`)
-    .join('\n          ');
-}
+} // namespace ::_NAMESPACE_::
+`;
 
-function renderProperties(
-  properties: ReadonlyArray<NativeModulePropertyShape>,
-  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 funcType =
-        prop.typeAnnotation.type === 'NullableTypeAnnotation'
-          ? prop.typeAnnotation.typeAnnotation
-          : prop.typeAnnotation;
-
-      const traversedArgs = translateSpecArgs(funcType.params);
-
-      const translatedReturnParam = translateSpecReturnType(
-        funcType.returnTypeAnnotation,
-      );
-
-      if (isMethodReturnPromise(funcType)) {
-        // TODO: type of the promise could be provided in the future
-        traversedArgs.push('Promise<React::JSValue>');
-      }
+const allInOneTemplate = `
+${headerTemplate}
 
-      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)});`;
-      }
-    })
-    .join('\n');
-}
+#include <NativeModules.h>
+#include <tuple>
 
-export function createNM2Generator({namespace}: {namespace: string}) {
+namespace ::_NAMESPACE_:: {
+::_MODULE_CUSTOM_TYPES_::
+${specTemplate}
+};
+
+} // namespace ::_NAMESPACE_::
+`;
+
+export function createNM2Generator({
+  methodOnly,
+  namespace,
+  cppStringType,
+  separateDataTypes,
+}: {
+  methodOnly: boolean;
+  namespace: string;
+  cppStringType: CppStringTypes;
+  separateDataTypes: boolean;
+}) {
   return (
     _libraryName: string,
     schema: SchemaType,
@@ -161,33 +110,81 @@ export function createNM2Generator({namespace}: {namespace: string}) {
       if (nativeModule.type === 'NativeModule') {
         console.log(`Generating Native${preferredModuleName}Spec.g.h`);
 
-        let traversedAliasedStructs = '';
-        for (const aliasName of Object.keys(nativeModule.aliases)) {
-          const aliasType = nativeModule.aliases[aliasName];
-          traversedAliasedStructs = `${traversedAliasedStructs}
-REACT_STRUCT(${getAliasCppName(aliasName)})
-struct ${getAliasCppName(aliasName)} {
-${translateObjectBody(aliasType, '    ')}
-};
-`;
+        // copy all explicit to a map
+        const aliases: AliasMap = createAliasMap(nativeModule.aliasMap);
+
+        // prepare methods
+        const methods = generateValidateMethods(nativeModule, aliases, {
+          cppStringType,
+        });
+        let tuples = `
+  static constexpr auto methods = std::tuple{
+${methods.traversedPropertyTuples}${
+          methods.traversedEventEmitterTuples ? '\n' : ''
+        }${methods.traversedEventEmitterTuples}
+  };`;
+        let checks = `
+    constexpr auto methodCheckResults = CheckMethods<TModule, ::_MODULE_NAME_::Spec>();`;
+        let errors =
+          methods.traversedProperties +
+          (methods.traversedEventEmitters ? '\n' : '') +
+          methods.traversedEventEmitters;
+
+        // prepare constants
+        const constants = generateValidateConstants(nativeModule, aliases);
+        if (constants !== undefined && !methodOnly) {
+          tuples = `
+  static constexpr auto constants = std::tuple{
+${constants[0]}
+  };${tuples}`;
+          checks = `
+    constexpr auto constantCheckResults = CheckConstants<TModule, ::_MODULE_NAME_::Spec>();${checks}`;
+          errors = `${constants[1]}
+
+${errors}`;
         }
 
-        const properties = nativeModule.spec.properties;
-        const traversedProperties = renderProperties(properties, false);
-        const traversedPropertyTuples = renderProperties(properties, true);
+        // generate code for structs
+        const [customTypes, customReflection] = generateAliases(aliases, {
+          cppStringType,
+        });
 
-        files.set(
-          `Native${preferredModuleName}Spec.g.h`,
-          moduleTemplate
-            .replace(/::_MODULE_ALIASED_STRUCTS_::/g, traversedAliasedStructs)
-            .replace(/::_MODULE_PROPERTIES_TUPLE_::/g, traversedPropertyTuples)
+        const customTypesExist = customTypes !== '';
+
+        const replaceContent = function (template: string): string {
+          return template
+            .replace(/::_MODULE_CUSTOM_TYPES_::/g, customTypes)
+            .replace(/::_MODULE_CUSTOM_TYPES_REFLECTION_::/g, customReflection)
+            .replace(/::_MODULE_MEMBERS_TUPLES_::/g, tuples.substring(1))
+            .replace(/::_MODULE_MEMBERS_CHECKS_::/g, checks.substring(1))
+            .replace(/::_MODULE_MEMBERS_ERRORS_::/g, errors)
+            .replace(/::_MODULE_NAME_::/g, preferredModuleName)
             .replace(
-              /::_MODULE_PROPERTIES_SPEC_ERRORS_::/g,
-              traversedProperties,
+              /::_TYPE_DEFINITION_INCLUDE_::/g,
+              customTypesExist
+                ? `// #include "Native${preferredModuleName}DataTypes.g.h" before this file to use the generated type definition`
+                : '',
             )
-            .replace(/::_MODULE_NAME_::/g, preferredModuleName)
-            .replace(/::_NAMESPACE_::/g, namespace),
-        );
+            .replace(/::_NAMESPACE_::/g, namespace);
+        };
+
+        if (separateDataTypes) {
+          if (customTypesExist) {
+            files.set(
+              `Native${preferredModuleName}DataTypes.g.h`,
+              replaceContent(typeOnlyTemplate),
+            );
+          }
+          files.set(
+            `Native${preferredModuleName}Spec.g.h`,
+            replaceContent(moduleOnlyTemplate),
+          );
+        } else {
+          files.set(
+            `Native${preferredModuleName}Spec.g.h`,
+            replaceContent(allInOneTemplate),
+          );
+        }
       }
     }
 

package/src/generators/GenerateTypeScript.ts

@@ -0,0 +1,250 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+'use strict';
+
+import type {
+  NamedShape,
+  NativeModuleBaseTypeAnnotation,
+  NativeModuleFunctionTypeAnnotation,
+  NativeModuleObjectTypeAnnotation,
+  NativeModuleParamTypeAnnotation,
+  NativeModuleReturnTypeAnnotation,
+  NativeModuleSchema,
+  UnsafeAnyTypeAnnotation,
+  Nullable,
+  SchemaType,
+} from '@react-native/codegen/lib/CodegenSchema';
+
+interface CodegenNativeModuleSchema extends NativeModuleSchema {
+  optionalTurboModule?: boolean;
+}
+
+export function setOptionalTurboModule(
+  schema: NativeModuleSchema,
+  optional: boolean,
+): void {
+  const cs = <CodegenNativeModuleSchema>schema;
+  cs.optionalTurboModule = optional;
+}
+
+export function getOptionalTurboModule(schema: NativeModuleSchema): boolean {
+  return (<CodegenNativeModuleSchema>schema).optionalTurboModule ?? false;
+}
+
+type ObjectProp = NamedShape<Nullable<NativeModuleBaseTypeAnnotation>>;
+type FunctionParam = NamedShape<Nullable<NativeModuleParamTypeAnnotation>>;
+type FunctionDecl = NamedShape<Nullable<NativeModuleFunctionTypeAnnotation>>;
+type FilesOutput = Map<string, string>;
+
+const moduleTemplate = `
+/*
+ * This file is auto-generated from a NativeModule spec file in js.
+ *
+ * This is a TypeScript turbo module definition file.
+ */
+
+import {TurboModule, TurboModuleRegistry} from 'react-native';
+'use strict';
+::_MODULE_ALIASED_STRUCTS_::
+export interface Spec extends TurboModule {
+::_MODULE_MEMBERS_::
+}
+
+export default TurboModuleRegistry.::_MODULE_GETTER_::<Spec>('::_MODULE_NAME_::');
+`;
+
+function optionalSign<T>(obj: NamedShape<T>): string {
+  return obj.optional ? '?' : '';
+}
+
+function translateType(
+  type:
+    | Nullable<
+        | NativeModuleBaseTypeAnnotation
+        | NativeModuleParamTypeAnnotation
+        | NativeModuleReturnTypeAnnotation
+      >
+    | UnsafeAnyTypeAnnotation,
+): string {
+  // avoid: Property 'type' does not exist on type 'never'
+  const returnType = type.type;
+  switch (type.type) {
+    case 'StringTypeAnnotation':
+      return 'string';
+    case 'NumberTypeAnnotation':
+    case 'FloatTypeAnnotation':
+    case 'DoubleTypeAnnotation':
+    case 'Int32TypeAnnotation':
+      return 'number';
+    case 'BooleanTypeAnnotation':
+      return 'boolean';
+    case 'ArrayTypeAnnotation':
+      if (type.elementType.type !== 'AnyTypeAnnotation') {
+        return `${translateType(type.elementType)}[]`;
+      } else {
+        return `Array`;
+      }
+    case 'GenericObjectTypeAnnotation':
+      return 'object';
+    case 'ObjectTypeAnnotation':
+      return `{${type.properties
+        .map((prop: ObjectProp) => {
+          return `${prop.name}${optionalSign(prop)}: ${translateType(
+            prop.typeAnnotation,
+          )}`;
+        })
+        .join(', ')}}`;
+    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 'number';
+    }
+    case 'TypeAliasTypeAnnotation':
+      return type.name;
+    case 'NullableTypeAnnotation':
+      return `(${translateType(type.typeAnnotation)} | null | undefined)`;
+    case 'VoidTypeAnnotation':
+      return `void`;
+    case 'PromiseTypeAnnotation':
+      return `Promise`;
+    case `FunctionTypeAnnotation`:
+      return `((${type.params
+        .map((param: FunctionParam) => {
+          return `${param.name}${optionalSign(param)}: ${translateType(
+            param.typeAnnotation,
+          )}`;
+        })
+        .join(', ')}) => ${translateType(type.returnTypeAnnotation)})`;
+    default:
+      throw new Error(`Unhandled type in translateReturnType: ${returnType}`);
+  }
+}
+
+function translateAlias(
+  name: string,
+  type: NativeModuleObjectTypeAnnotation,
+): string {
+  return `
+export interface ${name} {
+${type.properties
+  .map((prop: ObjectProp) => {
+    return `  ${prop.name}${optionalSign(prop)}: ${translateType(
+      prop.typeAnnotation,
+    )};`;
+  })
+  .join('\n')}
+}
+`;
+}
+
+function tryGetConstantType(
+  nativeModule: NativeModuleSchema,
+): NativeModuleObjectTypeAnnotation | undefined {
+  const candidates = nativeModule.spec.methods.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;
+  }
+
+  return constantType;
+}
+
+function translateMethod(func: FunctionDecl): string {
+  const funcType =
+    func.typeAnnotation.type === 'NullableTypeAnnotation'
+      ? func.typeAnnotation.typeAnnotation
+      : func.typeAnnotation;
+
+  return `
+  ${func.name}(${funcType.params
+    .map((param: FunctionParam) => {
+      return `${param.name}${optionalSign(param)}: ${translateType(
+        param.typeAnnotation,
+      )}`;
+    })
+    .join(', ')})${optionalSign(func)}: ${translateType(
+    funcType.returnTypeAnnotation,
+  )}${
+    funcType.returnTypeAnnotation.type === 'ObjectTypeAnnotation' ? '' : ';'
+  }`;
+}
+
+export function generateTypeScript(
+  _libraryName: string,
+  schema: SchemaType,
+  _moduleSpecName: string,
+): FilesOutput {
+  const files = new Map<string, string>();
+
+  for (const moduleName of Object.keys(schema.modules)) {
+    const nativeModule = schema.modules[moduleName];
+    // from 0.65 facebook's react-native-codegen
+    // the module name has the Native prefix comparing to 0.63
+    // when reading files we provided
+    const nativePrefix = 'Native';
+    const preferredModuleName = moduleName.startsWith(nativePrefix)
+      ? moduleName.substr(nativePrefix.length)
+      : moduleName;
+
+    if (nativeModule.type === 'NativeModule') {
+      console.log(`Generating ${preferredModuleName}Spec.g.ts`);
+
+      const aliasCode = Object.keys(nativeModule.aliasMap)
+        .map(name => translateAlias(name, nativeModule.aliasMap[name]))
+        .join('');
+
+      const constantType = tryGetConstantType(nativeModule);
+      const constantCode =
+        constantType === undefined
+          ? ''
+          : `  getConstants(): ${translateType(constantType)}`;
+
+      const methods = nativeModule.spec.methods.filter(
+        prop => prop.name !== 'getConstants',
+      );
+      const membersCode = methods.map(translateMethod).join('');
+
+      files.set(
+        `${preferredModuleName}Spec.g.ts`,
+        moduleTemplate
+          .replace(/::_MODULE_ALIASED_STRUCTS_::/g, aliasCode)
+          .replace(/::_MODULE_MEMBERS_::/g, constantCode + membersCode)
+          .replace(/::_MODULE_NAME_::/g, preferredModuleName)
+          .replace(
+            /::_MODULE_GETTER_::/g,
+            getOptionalTurboModule(nativeModule) ? 'get' : 'getEnforcing',
+          ),
+      );
+    }
+  }
+
+  return files;
+}