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

package/src/generators/PropObjectTypes.ts

@@ -0,0 +1,223 @@
+import type { PropTypeAnnotation, ObjectTypeAnnotation, EventTypeAnnotation, CommandParamTypeAnnotation } from '@react-native/codegen/lib/CodegenSchema';
+import type { CppCodegenOptions } from './ObjectTypes';
+import {
+  AliasMap,
+  getAnonymousAliasCppName,
+} from './AliasManaging';
+
+
+// eslint-disable-next-line complexity
+export function translateComponentPropsFieldType(type: PropTypeAnnotation,
+  aliases: AliasMap<ObjectTypeAnnotation<PropTypeAnnotation>>,
+  baseAliasName: string,
+  options: CppCodegenOptions): { type: string, initializer: string, alreadySupportsOptionalOrHasDefault?: boolean } {
+  switch (type.type) {
+    case 'StringTypeAnnotation':
+      return { type: options.cppStringType, initializer: type.default ? `{${type.default}}` : '', alreadySupportsOptionalOrHasDefault: !!type.default };
+    case 'FloatTypeAnnotation':
+      return { type: 'float', initializer: type.default ? `{${type.default}}` : '{}', alreadySupportsOptionalOrHasDefault: !!type.default };
+    case 'DoubleTypeAnnotation':
+      return { type: 'double', initializer: type.default ? `{${type.default}}` : '{}', alreadySupportsOptionalOrHasDefault: !!type.default };
+    case 'Int32TypeAnnotation':
+      return { type: 'int32_t', initializer: type.default ? `{${type.default}}` : '{}', alreadySupportsOptionalOrHasDefault: !!type.default };
+    case 'BooleanTypeAnnotation':
+      return { type: 'bool', initializer: type.default ? `{${type.default}}` : '{}', alreadySupportsOptionalOrHasDefault: !!type.default };
+    case 'ArrayTypeAnnotation':
+      let arrayTemplateArg = '';
+      switch (type.elementType.type) {
+        case 'BooleanTypeAnnotation':
+          arrayTemplateArg = 'bool';
+          break;
+        case 'DoubleTypeAnnotation':
+          arrayTemplateArg = 'double';
+          break;
+        case 'FloatTypeAnnotation':
+          arrayTemplateArg = 'float';
+          break;
+        case 'Int32TypeAnnotation':
+          arrayTemplateArg = 'int32_t';
+          break;
+        case 'StringTypeAnnotation':
+          arrayTemplateArg = options.cppStringType;
+          break;
+        case 'ArrayTypeAnnotation':
+          const innerType = translateComponentPropsFieldType(type.elementType, aliases, baseAliasName, options);
+          arrayTemplateArg = `std::vector<${innerType.type}>`;
+          break;
+        case 'ObjectTypeAnnotation':
+          arrayTemplateArg = translateComponentPropsFieldType(type.elementType, aliases, baseAliasName, options).type;
+          break;
+        case 'ReservedPropTypeAnnotation':
+          switch (type.elementType.name) {
+            case 'ColorPrimitive':
+              arrayTemplateArg = 'winrt::Microsoft::ReactNative::Color';
+              break;
+            case 'DimensionPrimitive':
+            case 'EdgeInsetsPrimitive':
+            case 'ImageRequestPrimitive':
+            case 'ImageSourcePrimitive':
+            case 'PointPrimitive':
+              arrayTemplateArg = 'winrt::Microsoft::ReactNative::JSValue'; // TODO - better handling for these types than JSValue
+              break;
+            default:
+              throw new Error(`Unhandled ReservedPropTypeAnnotation type: ${type.elementType.name}`);
+          }
+          break;
+        case 'StringEnumTypeAnnotation':
+          arrayTemplateArg = options.cppStringType; // TODO - better enum type handling than just passing a string
+          break;
+        default:
+          throw new Error(`Unhandled type: ${type.type}`);
+      }
+
+      return { type: `std::vector<${arrayTemplateArg}>`, initializer: '' };
+    case 'ReservedPropTypeAnnotation':
+      switch (type.name) {
+        case 'ColorPrimitive':
+          return { type: 'winrt::Microsoft::ReactNative::Color', initializer: '{nullptr}', alreadySupportsOptionalOrHasDefault: true };
+        case 'DimensionPrimitive':
+        case 'EdgeInsetsPrimitive':
+        case 'ImageRequestPrimitive':
+        case 'ImageSourcePrimitive':
+        case 'PointPrimitive':
+          return { type: 'winrt::Microsoft::ReactNative::JSValue', initializer: '{nullptr}', alreadySupportsOptionalOrHasDefault: true }; // TODO - better handling for these types than JSValue
+        default:
+          throw new Error(`Unhandled ReservedPropTypeAnnotation type: ${type.name}`);
+      }
+    case 'ObjectTypeAnnotation': {
+      return { type: getAnonymousAliasCppName<ObjectTypeAnnotation<PropTypeAnnotation>>(aliases, baseAliasName, type), initializer: '' };
+    }
+    case 'MixedTypeAnnotation':
+      return { type: 'winrt::Microsoft::ReactNative::JSValue', initializer: '{nullptr}', alreadySupportsOptionalOrHasDefault: true };
+    case 'Int32EnumTypeAnnotation':
+      return { type: 'int32_t', initializer: '' }; // TODO - better enum type handling than just passing a string
+    case 'StringEnumTypeAnnotation':
+      return { type: options.cppStringType, initializer: '' }; // TODO - better enum type handling than just passing an int
+    default:
+      throw new Error(`Unhandled type: ${(type as any).type}`);
+  }
+}
+
+export function translateComponentEventType(type: EventTypeAnnotation,
+  aliases: AliasMap<ObjectTypeAnnotation<EventTypeAnnotation>>,
+  baseAliasName: string,
+  options: CppCodegenOptions): { type: string, initializer: string, alreadySupportsOptionalOrHasDefault?: boolean } {
+  switch (type.type) {
+    case 'StringTypeAnnotation':
+      return { type: options.cppStringType, initializer: '' };
+    case 'FloatTypeAnnotation':
+      return { type: 'float', initializer: '{}' };
+    case 'DoubleTypeAnnotation':
+      return { type: 'double', initializer: '{}' };
+    case 'Int32TypeAnnotation':
+      return { type: 'int32_t', initializer: '{}' };
+    case 'BooleanTypeAnnotation':
+      return { type: 'bool', initializer: '{}' };
+    case 'ArrayTypeAnnotation':
+      {
+        let arrayTemplateArg = '';
+        switch (type.elementType.type) {
+          case 'BooleanTypeAnnotation':
+            arrayTemplateArg = 'bool';
+            break;
+          case 'DoubleTypeAnnotation':
+            arrayTemplateArg = 'double';
+            break;
+          case 'FloatTypeAnnotation':
+            arrayTemplateArg = 'float';
+            break;
+          case 'Int32TypeAnnotation':
+            arrayTemplateArg = 'int32_t';
+            break;
+          case 'StringTypeAnnotation':
+            arrayTemplateArg = options.cppStringType;
+            break;
+          case 'ArrayTypeAnnotation':
+            const innerType = translateComponentEventType(type.elementType, aliases, baseAliasName, options);
+            arrayTemplateArg = `std::vector<${innerType.type}>`;
+            break;
+          case 'MixedTypeAnnotation':
+            arrayTemplateArg = 'winrt::Microsoft::ReactNative::JSValue';
+            break;
+          case 'ObjectTypeAnnotation':
+            arrayTemplateArg = translateComponentEventType(type.elementType, aliases, baseAliasName, options).type;
+            break;
+          case 'StringLiteralUnionTypeAnnotation':
+            arrayTemplateArg = options.cppStringType; // TODO - better enum type handling than just passing a string
+            break;
+          default:
+            throw new Error(`Unhandled type: ${type.type}`);
+        }
+
+        return { type: `std::vector<${arrayTemplateArg}>`, initializer: '{}' };
+      }
+    case 'ObjectTypeAnnotation': {
+      return { type: getAnonymousAliasCppName<ObjectTypeAnnotation<EventTypeAnnotation>>(aliases, baseAliasName, type), initializer: '' };
+    }
+    case 'MixedTypeAnnotation': {
+      return { type: 'winrt::Microsoft::ReactNative::JSValue', initializer: '{nullptr}', alreadySupportsOptionalOrHasDefault: true };
+    }
+    case 'StringLiteralUnionTypeAnnotation':
+      return { type: options.cppStringType, initializer: '' };  // TODO - better enum type handling than just passing a string
+    default:
+      throw new Error(`Unhandled type: ${(type as any).type}`);
+  }
+}
+
+
+export function translateCommandParamType(type: CommandParamTypeAnnotation,
+  aliases: AliasMap<ObjectTypeAnnotation<CommandParamTypeAnnotation>>,
+  baseAliasName: string,
+  options: CppCodegenOptions): { type: string, initializer: string, alreadySupportsOptionalOrHasDefault?: boolean } {
+  switch (type.type) {
+    case 'StringTypeAnnotation':
+      return { type: options.cppStringType, initializer: '' };
+    case 'FloatTypeAnnotation':
+      return { type: 'float', initializer: '{}' };
+    case 'DoubleTypeAnnotation':
+      return { type: 'double', initializer: '{}' };
+    case 'Int32TypeAnnotation':
+      return { type: 'int32_t', initializer: '{}' };
+    case 'BooleanTypeAnnotation':
+      return { type: 'bool', initializer: '{}' };
+    case 'ArrayTypeAnnotation':
+      {
+        let arrayTemplateArg = '';
+        switch (type.elementType.type) {
+          case 'BooleanTypeAnnotation':
+            arrayTemplateArg = 'bool';
+            break;
+          case 'DoubleTypeAnnotation':
+            arrayTemplateArg = 'double';
+            break;
+          case 'FloatTypeAnnotation':
+            arrayTemplateArg = 'float';
+            break;
+          case 'Int32TypeAnnotation':
+            arrayTemplateArg = 'int32_t';
+            break;
+          case 'StringTypeAnnotation':
+            arrayTemplateArg = options.cppStringType;
+            break;
+          case 'MixedTypeAnnotation':
+            // TODO - not sure what exact value to be used here
+            arrayTemplateArg = 'winrt::Microsoft::ReactNative::JSValue';
+            break;
+          case 'GenericTypeAnnotation' as any: // TODO verify schema - Getting this type when running codegen on all the built in types
+            arrayTemplateArg = 'winrt::Microsoft::ReactNative::JSValue';
+            break;
+          default:
+            throw new Error(`Unhandled type: ${(type.elementType as any).type} - ${JSON.stringify(type.elementType, null, 2)}`);
+        }
+
+        return { type: `std::vector<${arrayTemplateArg}>`, initializer: '{}' };
+      }
+    case 'ReservedTypeAnnotation': 
+      if ((type.name as any) !== 'RootTag') {
+        throw new Error(`Unhandled ReservedTypeAnnotation: ${type.name}`)
+      }
+      return { type: 'bool', initializer: '{-1}' };
+    default:
+      throw new Error(`Unhandled type: ${(type as any).type}`);
+  }
+}

package/src/generators/ReturnTypes.ts

@@ -6,67 +6,65 @@
 
 'use strict';
 
-import {
+import type {
   NativeModuleReturnTypeAnnotation,
   Nullable,
-} from 'react-native-tscodegen';
-import {getAliasCppName} from './ObjectTypes';
+} from '@react-native/codegen/lib/CodegenSchema';
+import {AliasMap} from './AliasManaging';
+import {CppCodegenOptions, translateFieldOrReturnType} from './ObjectTypes';
 
 function translateReturnType(
   type: Nullable<NativeModuleReturnTypeAnnotation>,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
 ): 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':
-      // TODO: type.elementType
-      return 'React::JSValueArray';
-    case 'GenericObjectTypeAnnotation':
-      return 'React::JSValue';
-    case 'ObjectTypeAnnotation':
-      // TODO: we have more information here, and could create a more specific type
-      return 'React::JSValueObject';
-    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)}>`;
+      return `std::optional<${translateReturnType(
+        type.typeAnnotation,
+        aliases,
+        baseAliasName,
+        options,
+      )}>`;
     default:
-      throw new Error(`Unhandled type in translateReturnType: ${returnType}`);
+      return translateFieldOrReturnType(
+        type,
+        aliases,
+        baseAliasName,
+        'translateReturnType',
+        options,
+      );
   }
 }
 
 export function translateSpecReturnType(
   type: Nullable<NativeModuleReturnTypeAnnotation>,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
 ) {
-  return translateReturnType(type);
+  return translateReturnType(
+    type,
+    aliases,
+    `${baseAliasName}_returnType`,
+    options,
+  );
 }
 
 export function translateImplReturnType(
   type: Nullable<NativeModuleReturnTypeAnnotation>,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
 ) {
-  return translateReturnType(type);
+  return translateReturnType(
+    type,
+    aliases,
+    `${baseAliasName}_returnType`,
+    options,
+  );
 }

package/src/generators/ValidateConstants.ts

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+'use strict';
+
+import type {NativeModuleSchema} from '@react-native/codegen/lib/CodegenSchema';
+import {AliasMap, getAnonymousAliasCppName} from './AliasManaging';
+
+export function generateValidateConstants(
+  nativeModule: NativeModuleSchema,
+  aliases: AliasMap,
+): [string, string] | 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;
+  }
+
+  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,270 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+'use strict';
+
+import type {
+  NativeModuleEventEmitterShape,
+  NativeModuleFunctionTypeAnnotation,
+  NativeModulePropertyShape,
+  NativeModuleSchema,
+} from '@react-native/codegen/lib/CodegenSchema';
+import {AliasMap} from './AliasManaging';
+import type {CppCodegenOptions} from './ObjectTypes';
+import {
+  translateArgs,
+  translateSpecArgs,
+  translateEventEmitterArgs,
+} from './ParamTypes';
+import {translateImplReturnType, translateSpecReturnType} from './ReturnTypes';
+
+function isMethodSync(funcType: NativeModuleFunctionTypeAnnotation) {
+  return (
+    funcType.returnTypeAnnotation.type !== 'VoidTypeAnnotation' &&
+    funcType.returnTypeAnnotation.type !== 'PromiseTypeAnnotation'
+  );
+}
+
+function getPossibleMethodSignatures(
+  prop: NativeModulePropertyShape,
+  funcType: NativeModuleFunctionTypeAnnotation,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
+): string[] {
+  const args = translateArgs(funcType.params, aliases, baseAliasName, options);
+  if (funcType.returnTypeAnnotation.type === 'PromiseTypeAnnotation') {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (funcType.returnTypeAnnotation.elementType) {
+      args.push(
+        `::React::ReactPromise<${translateImplReturnType(
+          funcType.returnTypeAnnotation.elementType,
+          aliases,
+          baseAliasName,
+          options,
+        )}> &&result`,
+      );
+    } else {
+      args.push('::React::ReactPromise<::React::JSValue> &&result');
+    }
+  }
+
+  // TODO: be much more exhaustive on the possible method signatures that can be used..
+  const sig = `REACT_${isMethodSync(funcType) ? 'SYNC_' : ''}METHOD(${
+    prop.name
+  }) ${translateImplReturnType(
+    funcType.returnTypeAnnotation,
+    aliases,
+    baseAliasName,
+    options,
+  )} ${prop.name}(${args.join(', ')}) noexcept { /* implementation */ }`;
+
+  const staticsig = `REACT_${isMethodSync(funcType) ? 'SYNC_' : ''}METHOD(${
+    prop.name
+  }) static ${translateImplReturnType(
+    funcType.returnTypeAnnotation,
+    aliases,
+    baseAliasName,
+    options,
+  )} ${prop.name}(${args.join(', ')}) noexcept { /* implementation */ }`;
+
+  return [sig, staticsig];
+}
+
+function translatePossibleMethodSignatures(
+  prop: NativeModulePropertyShape,
+  funcType: NativeModuleFunctionTypeAnnotation,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
+): string {
+  return getPossibleMethodSignatures(
+    prop,
+    funcType,
+    aliases,
+    baseAliasName,
+    options,
+  )
+    .map(sig => `"    ${sig}\\n"`)
+    .join('\n          ');
+}
+
+function renderProperties(
+  methods: ReadonlyArray<NativeModulePropertyShape>,
+  aliases: AliasMap,
+  tuple: boolean,
+  options: CppCodegenOptions,
+): {code: string; numberOfProperties: number} {
+  // TODO: generate code for constants
+  const properties = methods
+    .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,
+        options,
+      );
+
+      const translatedReturnParam = translateSpecReturnType(
+        funcType.returnTypeAnnotation,
+        aliases,
+        propAliasName,
+        options,
+      );
+
+      if (funcType.returnTypeAnnotation.type === 'PromiseTypeAnnotation') {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (funcType.returnTypeAnnotation.elementType) {
+          traversedArgs.push(
+            `Promise<${translateSpecReturnType(
+              funcType.returnTypeAnnotation.elementType,
+              aliases,
+              propAliasName,
+              options,
+            )}>`,
+          );
+        } else {
+          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,
+            options,
+          )});`;
+      }
+    });
+
+  return {code: properties.join('\n'), numberOfProperties: properties.length};
+}
+
+function getPossibleEventEmitterSignatures(
+  eventEmitter: NativeModuleEventEmitterShape,
+  aliases: AliasMap,
+  options: CppCodegenOptions,
+): string[] {
+  const traversedArgs = translateEventEmitterArgs(
+    eventEmitter.typeAnnotation.typeAnnotation,
+    aliases,
+    eventEmitter.name,
+    options,
+  );
+  return [
+    `REACT_EVENT(${eventEmitter.name}) std::function<void(${traversedArgs})> ${eventEmitter.name};`,
+  ];
+}
+
+function translatePossibleEventSignatures(
+  eventEmitter: NativeModuleEventEmitterShape,
+  aliases: AliasMap,
+  options: CppCodegenOptions,
+): string {
+  return getPossibleEventEmitterSignatures(eventEmitter, aliases, options)
+    .map(sig => `"    ${sig}\\n"`)
+    .join('\n          ');
+}
+
+function renderEventEmitters(
+  eventEmitters: ReadonlyArray<NativeModuleEventEmitterShape>,
+  indexOffset: number,
+  aliases: AliasMap,
+  tuple: boolean,
+  options: CppCodegenOptions,
+): string {
+  return eventEmitters
+    .map((eventEmitter, index) => {
+      const traversedArgs = translateEventEmitterArgs(
+        eventEmitter.typeAnnotation.typeAnnotation,
+        aliases,
+        eventEmitter.name,
+        options,
+      );
+
+      if (tuple) {
+        return `      EventEmitter<void(${traversedArgs})>{${
+          index + indexOffset
+        }, L"${eventEmitter.name}"},`;
+      } else {
+        return `    REACT_SHOW_EVENTEMITTER_SPEC_ERRORS(
+          ${index + indexOffset},
+          "${eventEmitter.name}",
+          ${translatePossibleEventSignatures(
+            eventEmitter,
+            aliases,
+            options,
+          )});`;
+      }
+    })
+    .join('\n');
+}
+
+export function generateValidateMethods(
+  nativeModule: NativeModuleSchema,
+  aliases: AliasMap,
+  options: CppCodegenOptions,
+): {
+  traversedProperties: string;
+  traversedEventEmitters: string;
+  traversedPropertyTuples: string;
+  traversedEventEmitterTuples: string;
+} {
+  const methods = nativeModule.spec.methods;
+  const eventEmitters = nativeModule.spec.eventEmitters;
+  const traversedProperties = renderProperties(
+    methods,
+    aliases,
+    false,
+    options,
+  );
+  const traversedEventEmitters = renderEventEmitters(
+    eventEmitters,
+    traversedProperties.numberOfProperties,
+    aliases,
+    false,
+    options,
+  );
+  const traversedPropertyTuples = renderProperties(
+    methods,
+    aliases,
+    true,
+    options,
+  );
+  const traversedEventEmitterTuples = renderEventEmitters(
+    eventEmitters,
+    traversedProperties.numberOfProperties,
+    aliases,
+    true,
+    options,
+  );
+  return {
+    traversedPropertyTuples: traversedPropertyTuples.code,
+    traversedEventEmitterTuples,
+    traversedProperties: traversedProperties.code,
+    traversedEventEmitters,
+  };
+}