@react-native-windows/codegen 0.0.0-canary.9 → 0.0.1-0

package/src/generators/GenerateTypeScript.ts

@@ -0,0 +1,247 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+'use strict';
+
+import type {
+  NamedShape,
+  NativeModuleBaseTypeAnnotation,
+  NativeModuleFunctionTypeAnnotation,
+  NativeModuleObjectTypeAnnotation,
+  NativeModuleParamTypeAnnotation,
+  NativeModuleReturnTypeAnnotation,
+  NativeModuleSchema,
+  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
+  >,
+): 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) {
+        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.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;
+  }
+
+  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.properties.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;
+}

package/src/generators/ObjectTypes.ts

@@ -0,0 +1,130 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+'use strict';
+
+import type {
+  NativeModuleEnumDeclaration,
+  NativeModuleBaseTypeAnnotation,
+  NativeModuleUnionTypeAnnotation,
+  NativeModuleStringTypeAnnotation,
+  NativeModuleFunctionTypeAnnotation,
+  Nullable,
+} from '@react-native/codegen/lib/CodegenSchema';
+import {
+  AliasMap,
+  getAliasCppName,
+  getAnonymousAliasCppName,
+} from './AliasManaging';
+
+export type CppStringTypes = 'std::string' | 'std::wstring';
+
+export interface CppCodegenOptions {
+  cppStringType: CppStringTypes;
+}
+
+function translateUnionReturnType(
+  type: NativeModuleEnumDeclaration | NativeModuleUnionTypeAnnotation,
+  options: CppCodegenOptions,
+): string {
+  const memberType = type.memberType;
+  switch (type.memberType) {
+    case 'StringTypeAnnotation':
+      return options.cppStringType;
+    case 'NumberTypeAnnotation':
+      return 'double';
+    case 'ObjectTypeAnnotation':
+      return '::React::JSValue';
+    default:
+      throw new Error(
+        `Unknown enum/union member type in translateReturnType: ${memberType}`,
+      );
+  }
+}
+
+export function translateFieldOrReturnType(
+  type: Nullable<
+    | NativeModuleBaseTypeAnnotation
+    | NativeModuleStringTypeAnnotation
+    | NativeModuleFunctionTypeAnnotation
+  >,
+  aliases: AliasMap,
+  baseAliasName: string,
+  callerName: 'translateField' | 'translateReturnType',
+  options: CppCodegenOptions,
+): string {
+  // avoid: Property 'type' does not exist on type 'never'
+  const returnType = type.type;
+  switch (type.type) {
+    case 'StringTypeAnnotation':
+      return options.cppStringType;
+    case 'NumberTypeAnnotation':
+    case 'FloatTypeAnnotation':
+    case 'DoubleTypeAnnotation':
+      return 'double';
+    case 'Int32TypeAnnotation':
+      return 'int';
+    case 'BooleanTypeAnnotation':
+      return 'bool';
+    case 'ArrayTypeAnnotation':
+      if (type.elementType) {
+        return `std::vector<${translateFieldOrReturnType(
+          type.elementType,
+          aliases,
+          `${baseAliasName}_element`,
+          callerName,
+          options,
+        )}>`;
+      } 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 ${callerName}`);
+      return 'double';
+    }
+    case 'TypeAliasTypeAnnotation':
+      return getAliasCppName(type.name);
+    case 'NullableTypeAnnotation':
+      return `std::optional<${translateFieldOrReturnType(
+        type.typeAnnotation,
+        aliases,
+        baseAliasName,
+        callerName,
+        options,
+      )}>`;
+    case 'MixedTypeAnnotation':
+      return '';
+    case 'EnumDeclaration':
+    case 'UnionTypeAnnotation':
+      return translateUnionReturnType(type, options);
+    default:
+      throw new Error(`Unhandled type in ${callerName}: ${returnType}`);
+  }
+}
+
+export function translateField(
+  type: Nullable<NativeModuleBaseTypeAnnotation>,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
+): string {
+  return translateFieldOrReturnType(
+    type,
+    aliases,
+    baseAliasName,
+    'translateField',
+    options,
+  );
+}

package/src/generators/ParamTypes.ts

@@ -0,0 +1,298 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+'use strict';
+
+import type {
+  NamedShape,
+  NativeModuleArrayTypeAnnotation,
+  NativeModuleBaseTypeAnnotation,
+  NativeModuleEnumDeclaration,
+  NativeModuleFunctionTypeAnnotation,
+  NativeModuleParamTypeAnnotation,
+  NativeModuleUnionTypeAnnotation,
+  Nullable,
+} from '@react-native/codegen/lib/CodegenSchema';
+import {
+  AliasMap,
+  getAliasCppName,
+  getAnonymousAliasCppName,
+} from './AliasManaging';
+import type {CppCodegenOptions} from './ObjectTypes';
+
+type NativeModuleParamShape = NamedShape<
+  Nullable<NativeModuleParamTypeAnnotation>
+>;
+
+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 translateUnionReturnType(
+  type: NativeModuleEnumDeclaration | NativeModuleUnionTypeAnnotation,
+  target: ParamTarget,
+  options: CppCodegenOptions,
+): string {
+  const memberType = type.memberType;
+  switch (type.memberType) {
+    case 'StringTypeAnnotation':
+      return options.cppStringType;
+    case 'NumberTypeAnnotation':
+      return 'double';
+    case 'ObjectTypeAnnotation':
+      return decorateType('::React::JSValue', target);
+    default:
+      throw new Error(
+        `Unknown enum/union member type in translateReturnType: ${memberType}`,
+      );
+  }
+}
+
+function translateFunction(
+  param: NativeModuleFunctionTypeAnnotation,
+  aliases: AliasMap,
+  baseAliasName: string,
+  target: ParamTarget,
+  options: CppCodegenOptions,
+): string {
+  // TODO: type.returnTypeAnnotation
+  switch (target) {
+    case 'spec':
+      return `Callback<${param.params
+        .map((p: NativeModuleParamShape) =>
+          translateSpecFunctionParam(
+            p,
+            aliases,
+            `${baseAliasName}_${p.name}`,
+            options,
+          ),
+        )
+        .join(', ')}>`;
+    case 'template':
+      return `std::function<void(${param.params
+        .map((p: NativeModuleParamShape) =>
+          translateCallbackParam(
+            p,
+            aliases,
+            `${baseAliasName}_${p.name}`,
+            options,
+          ),
+        )
+        .join(', ')})>`;
+    default:
+      return `std::function<void(${param.params
+        .map((p: NativeModuleParamShape) =>
+          translateCallbackParam(
+            p,
+            aliases,
+            `${baseAliasName}_${p.name}`,
+            options,
+          ),
+        )
+        .join(', ')})> const &`;
+  }
+}
+
+function translateArray(
+  param: NativeModuleArrayTypeAnnotation<
+    Nullable<NativeModuleBaseTypeAnnotation>
+  >,
+  aliases: AliasMap,
+  baseAliasName: string,
+  target: ParamTarget,
+  options: CppCodegenOptions,
+): string {
+  if (param.elementType) {
+    switch (target) {
+      case 'spec':
+      case 'template':
+        return `std::vector<${translateNullableParamType(
+          param.elementType,
+          aliases,
+          `${baseAliasName}_element`,
+          'template',
+          'template',
+          options,
+        )}>`;
+      default:
+        return `std::vector<${translateNullableParamType(
+          param.elementType,
+          aliases,
+          `${baseAliasName}_element`,
+          'template',
+          'template',
+          options,
+        )}> const &`;
+    }
+  } else {
+    return decorateType('::React::JSValueArray', target);
+  }
+}
+
+function translateParam(
+  param: NativeModuleParamTypeAnnotation,
+  aliases: AliasMap,
+  baseAliasName: string,
+  target: ParamTarget,
+  options: CppCodegenOptions,
+): string {
+  // avoid: Property 'type' does not exist on type 'never'
+  const paramType = param.type;
+  switch (param.type) {
+    case 'StringTypeAnnotation':
+      return options.cppStringType;
+    case 'NumberTypeAnnotation':
+    case 'FloatTypeAnnotation':
+    case 'DoubleTypeAnnotation':
+      return 'double';
+    case 'Int32TypeAnnotation':
+      return 'int';
+    case 'BooleanTypeAnnotation':
+      return 'bool';
+    case 'FunctionTypeAnnotation':
+      return translateFunction(param, aliases, baseAliasName, target, options);
+    case 'ArrayTypeAnnotation':
+      return translateArray(param, aliases, baseAliasName, target, options);
+    case 'GenericObjectTypeAnnotation':
+      return decorateType('::React::JSValue', target);
+    case 'ObjectTypeAnnotation':
+      return decorateType(
+        getAnonymousAliasCppName(aliases, baseAliasName, param),
+        target,
+      );
+    case 'ReservedTypeAnnotation': {
+      // avoid: Property 'name' does not exist on type 'never'
+      const name = param.name;
+      // (#6597)
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      if (name !== 'RootTag')
+        throw new Error(`Unknown reserved function: ${name} in translateParam`);
+      return 'double';
+    }
+    case 'TypeAliasTypeAnnotation':
+      return decorateType(getAliasCppName(param.name), target);
+    case 'MixedTypeAnnotation':
+      return '';
+    case 'EnumDeclaration':
+    case 'UnionTypeAnnotation':
+      return translateUnionReturnType(param, target, options);
+    default:
+      throw new Error(`Unhandled type in translateParam: ${paramType}`);
+  }
+}
+
+function translateNullableParamType(
+  paramType: Nullable<NativeModuleParamTypeAnnotation>,
+  aliases: AliasMap,
+  baseAliasName: string,
+  nullableTarget: ParamTarget,
+  target: ParamTarget,
+  options: CppCodegenOptions,
+): string {
+  switch (paramType.type) {
+    case 'NullableTypeAnnotation':
+      return `std::optional<${translateParam(
+        paramType.typeAnnotation,
+        aliases,
+        baseAliasName,
+        nullableTarget,
+        options,
+      )}>`;
+    default:
+      return translateParam(paramType, aliases, baseAliasName, target, options);
+  }
+}
+
+function translateSpecFunctionParam(
+  param: NativeModuleParamShape,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
+): string {
+  return translateNullableParamType(
+    param.typeAnnotation,
+    aliases,
+    baseAliasName,
+    'spec',
+    'spec',
+    options,
+  );
+}
+
+function translateCallbackParam(
+  param: NativeModuleParamShape,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
+): string {
+  return translateNullableParamType(
+    param.typeAnnotation,
+    aliases,
+    baseAliasName,
+    'template',
+    'callback-arg',
+    options,
+  );
+}
+
+function translateFunctionParam(
+  param: NativeModuleParamShape,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
+): string {
+  return translateNullableParamType(
+    param.typeAnnotation,
+    aliases,
+    baseAliasName,
+    'template',
+    'method-arg',
+    options,
+  );
+}
+
+export function translateSpecArgs(
+  params: ReadonlyArray<NativeModuleParamShape>,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
+) {
+  return params.map(param => {
+    const translatedParam = translateSpecFunctionParam(
+      param,
+      aliases,
+      `${baseAliasName}_${param.name}`,
+      options,
+    );
+    return `${translatedParam}`;
+  });
+}
+
+export function translateArgs(
+  params: ReadonlyArray<NativeModuleParamShape>,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
+) {
+  return params.map(param => {
+    const translatedParam = translateFunctionParam(
+      param,
+      aliases,
+      `${baseAliasName}_${param.name}`,
+      options,
+    );
+    return `${translatedParam} ${param.name}`;
+  });
+}