@react-native-windows/codegen 0.75.0 → 0.75.1

package/src/generators/GenerateComponentWindows.ts

@@ -0,0 +1,393 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+'use strict';
+
+import type {SchemaType, EventTypeAnnotation, PropTypeAnnotation, ObjectTypeAnnotation, CommandParamTypeAnnotation} from '@react-native/codegen/lib/CodegenSchema';
+import {getAliasCppName, setPreferredModuleName} from './AliasManaging';
+import {translateComponentPropsFieldType, translateComponentEventType, translateCommandParamType} from './PropObjectTypes';
+import type {CppStringTypes} from './ObjectTypes';
+import type {AliasMap} from './AliasManaging';
+
+export type {CppStringTypes} from './ObjectTypes';
+
+type FilesOutput = Map<string, string>;
+
+const headerTemplate = `/*
+ * This file is auto-generated from ::_COMPONENT_NAME_::NativeComponent spec file in flow / TypeScript.
+ */
+#pragma once
+
+#include <JSValueComposition.h>
+#include <NativeModules.h>
+#include <winrt/Microsoft.ReactNative.Composition.h>
+#include <winrt/Microsoft.UI.Composition.h>`
+
+
+const propsTemplate = `REACT_STRUCT(::_PROPS_NAME_::)
+struct ::_PROPS_NAME_:: : winrt::implements<::_PROPS_NAME_::, winrt::Microsoft::ReactNative::IComponentProps> {
+  ::_PROPS_NAME_::(winrt::Microsoft::ReactNative::ViewProps props) : ViewProps(props) {}
+
+  void SetProp(uint32_t hash, winrt::hstring propName, winrt::Microsoft::ReactNative::IJSValueReader value) noexcept {
+    winrt::Microsoft::ReactNative::ReadProp(hash, propName, value, *this);
+  }
+
+::_PROPS_FIELDS_::
+  const winrt::Microsoft::ReactNative::ViewProps ViewProps;
+};`
+
+const propsObjectTemplate = `REACT_STRUCT(::_OBJECT_NAME_::)
+struct ::_OBJECT_NAME_:: {
+::_OBJECT_FIELDS_::};
+`
+const eventsObjectTemplate = `REACT_STRUCT(::_OBJECT_NAME_::)
+struct ::_OBJECT_NAME_:: {
+::_OBJECT_FIELDS_::};
+`
+
+const eventEmitterMethodTemplate = `  void ::_EVENT_NAME_::(::_EVENT_OBJECT_TYPE_:: &value) const {
+    m_eventEmitter.DispatchEvent(L"::_EVENT_NAME_NO_ON_::", [value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
+      winrt::Microsoft::ReactNative::WriteValue(writer, value);
+    });
+  }`;
+
+
+const eventEmitterTemplate = `::_COMPONENT_EVENT_OBJECT_TYPES_::
+
+struct ::_EVENT_EMITTER_NAME_:: {
+  ::_EVENT_EMITTER_NAME_::(const winrt::Microsoft::ReactNative::EventEmitter &eventEmitter)
+      : m_eventEmitter(eventEmitter) {}
+
+::_EVENT_EMITTER_USINGS_::
+
+::_EVENT_EMITTER_METHODS_::
+
+ private:
+  winrt::Microsoft::ReactNative::EventEmitter m_eventEmitter{nullptr};
+};`
+
+const baseStructTemplate = `
+template<typename TUserData>
+struct Base::_COMPONENT_NAME_:: {
+
+  virtual void UpdateProps(
+    const winrt::Microsoft::ReactNative::ComponentView &/*view*/,
+    const winrt::com_ptr<::_COMPONENT_NAME_::Props> &newProps,
+    const winrt::com_ptr<::_COMPONENT_NAME_::Props> &/*oldProps*/) noexcept {
+    m_props = newProps;
+  }
+
+  // UpdateState will only be called if this method is overridden
+  virtual void UpdateState(
+    const winrt::Microsoft::ReactNative::ComponentView &/*view*/,
+    const winrt::Microsoft::ReactNative::IComponentState &/*newState*/) noexcept {
+  }
+
+  virtual void UpdateEventEmitter(const std::shared_ptr<::_COMPONENT_NAME_::EventEmitter> &eventEmitter) noexcept {
+    m_eventEmitter = eventEmitter;
+  }
+
+  // MountChildComponentView will only be called if this method is overridden
+  virtual void MountChildComponentView(const winrt::Microsoft::ReactNative::ComponentView &/*view*/,
+           const winrt::Microsoft::ReactNative::MountChildComponentViewArgs &/*args*/) noexcept {
+  }
+
+  // UnmountChildComponentView will only be called if this method is overridden
+  virtual void UnmountChildComponentView(const winrt::Microsoft::ReactNative::ComponentView &/*view*/,
+           const winrt::Microsoft::ReactNative::UnmountChildComponentViewArgs &/*args*/) noexcept {
+  }
+
+  // Initialize will only be called if this method is overridden
+  virtual void Initialize(const winrt::Microsoft::ReactNative::ComponentView &/*view*/) noexcept {
+  }
+
+  // CreateVisual will only be called if this method is overridden
+  virtual winrt::Microsoft::UI::Composition::Visual CreateVisual(const winrt::Microsoft::ReactNative::ComponentView &view) noexcept {
+    return view.as<winrt::Microsoft::ReactNative::Composition::ComponentView>().Compositor().CreateSpriteVisual();
+  }
+
+  // FinalizeUpdate will only be called if this method is overridden
+  virtual void FinalizeUpdate(const winrt::Microsoft::ReactNative::ComponentView &/*view*/,
+                                        winrt::Microsoft::ReactNative::ComponentViewUpdateMask /*mask*/) noexcept {
+  }
+
+::_COMPONENT_VIEW_COMMAND_HANDLERS_::
+
+  ::_COMPONENT_VIEW_COMMAND_HANDLER_::
+
+  const std::shared_ptr<::_COMPONENT_NAME_::EventEmitter>& EventEmitter() const { return m_eventEmitter; }
+  const winrt::com_ptr<::_COMPONENT_NAME_::Props>& Props() const { return m_props; }
+
+private:
+  winrt::com_ptr<::_COMPONENT_NAME_::Props> m_props;
+  std::shared_ptr<::_COMPONENT_NAME_::EventEmitter> m_eventEmitter;
+};
+`;
+
+const registerTemplate = `
+template <typename TUserData>
+void Register::_COMPONENT_NAME_::NativeComponent(
+    winrt::Microsoft::ReactNative::IReactPackageBuilder const &packageBuilder,
+    std::function<void(const winrt::Microsoft::ReactNative::Composition::IReactCompositionViewComponentBuilder&)> builderCallback) noexcept {
+  packageBuilder.as<winrt::Microsoft::ReactNative::IReactPackageBuilderFabric>().AddViewComponent(
+      L"::_COMPONENT_NAME_::", [builderCallback](winrt::Microsoft::ReactNative::IReactViewComponentBuilder const &builder) noexcept {
+        auto compBuilder = builder.as<winrt::Microsoft::ReactNative::Composition::IReactCompositionViewComponentBuilder>();
+
+        builder.SetCreateProps(
+            [](winrt::Microsoft::ReactNative::ViewProps props) noexcept { return winrt::make<::_COMPONENT_NAME_::Props>(props); });
+
+        builder.SetUpdatePropsHandler([](const winrt::Microsoft::ReactNative::ComponentView &view,
+                                     const winrt::Microsoft::ReactNative::IComponentProps &newProps,
+                                     const winrt::Microsoft::ReactNative::IComponentProps &oldProps) noexcept {
+            auto userData = view.UserData().as<TUserData>();
+            userData->UpdateProps(view, newProps ? newProps.as<::_COMPONENT_NAME_::Props>() : nullptr, oldProps ? oldProps.as<::_COMPONENT_NAME_::Props>() : nullptr);
+        });
+
+        builder.SetUpdateEventEmitterHandler([](const winrt::Microsoft::ReactNative::ComponentView &view,
+                                     const winrt::Microsoft::ReactNative::EventEmitter &eventEmitter) noexcept {
+          auto userData = view.UserData().as<TUserData>();
+          userData->UpdateEventEmitter(std::make_shared<::_COMPONENT_NAME_::EventEmitter>(eventEmitter));
+        });
+
+        if constexpr (&TUserData::FinalizeUpdate != &Base::_COMPONENT_NAME_::<TUserData>::FinalizeUpdate) {
+            builder.SetFinalizeUpdateHandler([](const winrt::Microsoft::ReactNative::ComponentView &view,
+                                     winrt::Microsoft::ReactNative::ComponentViewUpdateMask mask) noexcept {
+            auto userData = view.UserData().as<TUserData>();
+            userData->FinalizeUpdate(view, mask);
+          });
+        } 
+
+        if constexpr (&TUserData::UpdateState != &Base::_COMPONENT_NAME_::<TUserData>::UpdateState) {
+          builder.SetUpdateStateHandler([](const winrt::Microsoft::ReactNative::ComponentView &view,
+                                     const winrt::Microsoft::ReactNative::IComponentState &newState) noexcept {
+            auto userData = view.UserData().as<TUserData>();
+            userData->member(view, newState);
+          });
+        }
+
+::_REGISTER_CUSTOM_COMMAND_HANDLER_::
+
+        if constexpr (&TUserData::MountChildComponentView != &Base::_COMPONENT_NAME_::<TUserData>::MountChildComponentView) {
+          builder.SetMountChildComponentViewHandler([](const winrt::Microsoft::ReactNative::ComponentView &view,
+                                      const winrt::Microsoft::ReactNative::MountChildComponentViewArgs &args) noexcept {
+            auto userData = view.UserData().as<TUserData>();
+            return userData->MountChildComponentView(view, args);
+          });
+        }
+
+        if constexpr (&TUserData::UnmountChildComponentView != &Base::_COMPONENT_NAME_::<TUserData>::UnmountChildComponentView) {
+          builder.SetUnmountChildComponentViewHandler([](const winrt::Microsoft::ReactNative::ComponentView &view,
+                                      const winrt::Microsoft::ReactNative::UnmountChildComponentViewArgs &args) noexcept {
+            auto userData = view.UserData().as<TUserData>();
+            return userData->UnmountChildComponentView(view, args);
+          });
+        }
+
+        compBuilder.SetViewComponentViewInitializer([](const winrt::Microsoft::ReactNative::ComponentView &view) noexcept {
+          auto userData = winrt::make_self<TUserData>();
+          if constexpr (&TUserData::Initialize != &Base::_COMPONENT_NAME_::<TUserData>::Initialize) {
+            userData->Initialize(view);
+          }
+          view.UserData(*userData);
+        });
+
+        if constexpr (&TUserData::CreateVisual != &Base::_COMPONENT_NAME_::<TUserData>::CreateVisual) {
+          compBuilder.SetCreateVisualHandler([](const winrt::Microsoft::ReactNative::ComponentView &view) noexcept {
+            auto userData = view.UserData().as<TUserData>();
+            return userData->CreateVisual(view);
+          });
+        }
+
+        // Allow app to further customize the builder
+        if (builderCallback) {
+          builderCallback(compBuilder);
+        }
+      });
+}
+`;
+
+const fileTemplate = `
+${headerTemplate}
+
+namespace ::_NAMESPACE_:: {
+
+::_COMPONENT_PROP_OBJECT_TYPES_::
+::_COMPONENT_PROP_TYPES_::
+
+::_COMPONENT_EVENT_EMITTER_::
+
+::_BASE_COMPONENT_STRUCT_::
+
+::_COMPONENT_REGISTRATION_::
+} // namespace ::_NAMESPACE_::
+`;
+
+function capitalizeFirstLetter(s: string) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+  }
+
+export function createComponentGenerator({
+  namespace,
+  cppStringType,
+}: {
+  namespace: string;
+  cppStringType: CppStringTypes;
+}) {
+  return (
+    _libraryName: string,
+    schema: SchemaType,
+    _moduleSpecName: string,
+  ): FilesOutput => {
+    const files = new Map<string, string>();
+
+    const cppCodegenOptions = {cppStringType};
+
+    for (const componentName of Object.keys(schema.modules)) {
+      const component = schema.modules[componentName];
+      setPreferredModuleName(componentName);
+
+      if (component.type === 'Component') {
+        console.log(`Generating ${componentName}.g.h`);
+
+        const componentShape = component.components[componentName];
+
+        componentShape.extendsProps.forEach(propsBaseType => {
+          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+          if (propsBaseType.type !== 'ReactNativeBuiltInType' || propsBaseType.knownTypeName !== 'ReactNativeCoreViewProps') {
+            throw new Error('Currently only supports props extending from ViewProps');
+          }
+        });
+
+        // Props
+        const propObjectAliases: AliasMap<ObjectTypeAnnotation<PropTypeAnnotation>> = {types:{}, jobs: []};
+        const propsName = `${componentName}Props`;
+        const propsFields = componentShape.props.map(prop => {
+          const propType = translateComponentPropsFieldType(prop.typeAnnotation, propObjectAliases, `${propsName}_${prop.name}`, cppCodegenOptions);
+          return `  REACT_FIELD(${prop.name})\n  ${(prop.optional && !propType.alreadySupportsOptionalOrHasDefault) ? `std::optional<${propType.type}>` : propType.type} ${prop.name}${propType.initializer};\n`;
+        }).join('\n');
+
+        const propObjectTypes = propObjectAliases.jobs.map(propObjectTypeName => {
+          const propObjectType = propObjectAliases.types[propObjectTypeName]!;
+          const propsObjectFields = propObjectType.properties.map(property => {
+            const propType = translateComponentPropsFieldType(property.typeAnnotation, propObjectAliases, `${propsName}_${property.name}`, cppCodegenOptions);
+            return `  REACT_FIELD(${property.name})\n  ${(property.optional && !propType.alreadySupportsOptionalOrHasDefault) ? `std::optional<${propType.type}>` : propType.type} ${property.name}${propType.initializer};\n`;
+          }).join('\n');
+
+          return propsObjectTemplate.replace(/::_OBJECT_NAME_::/g, getAliasCppName(propObjectTypeName)).replace(/::_OBJECT_FIELDS_::/g, propsObjectFields);
+        }).join('\n');
+
+
+        // Events
+        const eventObjectAliases: AliasMap<ObjectTypeAnnotation<EventTypeAnnotation>> = {types:{}, jobs: []};
+        const eventEmitterName = `${componentName}EventEmitter`;
+        const eventEmitterMethods = componentShape.events.filter(event => event.typeAnnotation.argument).map(event => {
+          if (event.typeAnnotation.argument?.baseTypes) {
+            throw new Error('Events with base type arguments not currently supported');
+          }
+
+          // Called to collect the eventObjectAliases
+          translateComponentEventType(event.typeAnnotation.argument!, eventObjectAliases, `${event.name}`, cppCodegenOptions);
+
+          // onSomething -> something
+          let eventNameLower = event.name.replace('on', '');
+          eventNameLower = eventNameLower[0].toLowerCase() + eventNameLower.slice(1);
+
+          return eventEmitterMethodTemplate
+                      .replace(/::_EVENT_NAME_::/g,event.name)
+                      .replace(/::_EVENT_NAME_NO_ON_::/g,eventNameLower)
+                      .replace(/::_EVENT_OBJECT_TYPE_::/g, event.name.replace('on', 'On'));
+        }).join('\n\n');
+        
+        const eventObjects = eventObjectAliases.jobs.map(eventObjectTypeName => {
+          const eventObjectType = eventObjectAliases.types[eventObjectTypeName]!;
+          const eventObjectFields = eventObjectType.properties.map(property => {
+            const eventPropType = translateComponentEventType(property.typeAnnotation, eventObjectAliases, eventObjectTypeName, cppCodegenOptions);
+            return `  REACT_FIELD(${property.name})\n  ${(property.optional && !eventPropType.alreadySupportsOptionalOrHasDefault) ? `std::optional<${eventPropType.type}>` : eventPropType.type} ${property.name}${eventPropType.initializer};\n`;
+          }).join('\n');
+          return eventsObjectTemplate.replace(/::_OBJECT_NAME_::/g, `${componentName}_${eventObjectTypeName.replace('on', 'On')}`).replace(/::_OBJECT_FIELDS_::/g, eventObjectFields);
+        }).join('\n');
+
+        const eventObjectUsings = eventObjectAliases.jobs.map(eventObjectTypeName => {
+          return `  using ${eventObjectTypeName.replace('on', 'On')} = ${componentName}_${eventObjectTypeName.replace('on', 'On')};`
+        }).join('\n');
+        
+        const eventEmitter = eventEmitterTemplate
+                              .replace(/::_COMPONENT_EVENT_OBJECT_TYPES_::/g, eventObjects)
+                              .replace(/::_EVENT_EMITTER_METHODS_::/g, eventEmitterMethods)
+                              .replace(/::_EVENT_EMITTER_USINGS_::/g, eventObjectUsings);
+
+
+        // Commands
+        const commandAliases: AliasMap<ObjectTypeAnnotation<CommandParamTypeAnnotation>> = {types:{}, jobs: []};
+        const hasAnyCommands = (componentShape.commands.length !== 0);
+        const commandHandlers = hasAnyCommands ? componentShape.commands.map(command => {
+          const commandArgs = command.typeAnnotation.params.map(param => {
+            const commandArgType = translateCommandParamType(param.typeAnnotation, commandAliases, `${componentName}_${command.name}`, cppCodegenOptions);
+            return `${(param.optional && !commandArgType.alreadySupportsOptionalOrHasDefault) ? `std::optional<${commandArgType.type}>` : commandArgType.type} ${param.name}`;
+          }).join(', ');
+
+          return `  // You must provide an implementation of this method to handle the "${command.name}" command
+  virtual void Handle${capitalizeFirstLetter(command.name)}Command(${commandArgs}) noexcept = 0;`;
+        }).join('\n\n') : '';
+
+
+        const commandHandler = hasAnyCommands ? `void HandleCommand(const winrt::Microsoft::ReactNative::ComponentView &view, winrt::hstring commandName, const winrt::Microsoft::ReactNative::IJSValueReader &args) noexcept {
+    args;
+    auto userData = view.UserData().as<TUserData>();
+${componentShape.commands.map(command => {
+      const commaSeparatedCommandArgs = command.typeAnnotation.params.map(param => param.name).join(', ');
+      return `    if (commandName == L"${command.name}") {
+${command.typeAnnotation.params.length !== 0 ? `      ${command.typeAnnotation.params.map(param => {
+            const commandArgType = translateCommandParamType(param.typeAnnotation, commandAliases, `${componentName}_${command.name}`, cppCodegenOptions);
+            return `${(param.optional && !commandArgType.alreadySupportsOptionalOrHasDefault) ? `std::optional<${commandArgType.type}>` : commandArgType.type} ${param.name};`;
+      }).join('\n')}
+      winrt::Microsoft::ReactNative::ReadArgs(args, ${commaSeparatedCommandArgs});` : ''}
+      userData->Handle${capitalizeFirstLetter(command.name)}Command(${commaSeparatedCommandArgs});
+      return;
+    }`
+    }).join('\n\n')}
+  }` : '';
+
+      const registerCommandHandler = hasAnyCommands ? `        builder.SetCustomCommandHandler([](const winrt::Microsoft::ReactNative::ComponentView &view,
+                                          winrt::hstring commandName,
+                                          const winrt::Microsoft::ReactNative::IJSValueReader &args) noexcept {
+          auto userData = view.UserData().as<TUserData>();
+          userData->HandleCommand(view, commandName, args);
+        });` : '';
+
+        const baseType = baseStructTemplate
+        .replace(/::_COMPONENT_VIEW_COMMAND_HANDLERS_::/g, commandHandlers)
+        .replace(/::_COMPONENT_VIEW_COMMAND_HANDLER_::/g, commandHandler);
+
+        // Registration
+        const componentRegistration = registerTemplate.replace(/::_REGISTER_CUSTOM_COMMAND_HANDLER_::/g, registerCommandHandler);
+
+        // Final output
+        const replaceContent = function (template: string): string {
+          return template
+            .replace(/::_COMPONENT_PROP_OBJECT_TYPES_::/g, propObjectTypes)
+            .replace(/::_COMPONENT_PROP_TYPES_::/g, propsTemplate)
+            .replace(/::_COMPONENT_EVENT_EMITTER_::/g, eventEmitter)
+            .replace(/::_BASE_COMPONENT_STRUCT_::/g, baseType)
+            .replace(/::_COMPONENT_REGISTRATION_::/g, componentRegistration)
+            .replace(/::_EVENT_EMITTER_NAME_::/g, eventEmitterName)
+            .replace(/::_PROPS_NAME_::/g, propsName)
+            .replace(/::_COMPONENT_NAME_::/g, componentName)
+            .replace(/::_PROPS_FIELDS_::/g, propsFields)
+            .replace(/::_NAMESPACE_::/g, namespace)
+            .replace(/\n\n\n+/g, '\n\n');
+        };
+
+        files.set(
+          `${componentName}.g.h`,
+          replaceContent(fileTemplate),
+        );
+      }
+    }
+
+    return files;
+  };
+}

package/src/generators/PropObjectTypes.ts

@@ -0,0 +1,233 @@
+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 '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 'ObjectTypeAnnotation': {
+      return { type: getAnonymousAliasCppName<ObjectTypeAnnotation<EventTypeAnnotation>>(aliases, baseAliasName, type), initializer: '' };
+    }
+    case 'MixedTypeAnnotation': {
+      return { type: 'winrt::Microsoft::ReactNative::JSValue', initializer: '{nullptr}', alreadySupportsOptionalOrHasDefault: true };
+    }
+    case 'StringEnumTypeAnnotation':
+      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 'ArrayTypeAnnotation':
+            const innerType = translateCommandParamType(type.elementType, aliases, baseAliasName, options);
+            arrayTemplateArg = `std::vector<${innerType.type}>`;
+            break;
+          case 'ReservedPropTypeAnnotation':
+            arrayTemplateArg = 'winrt::Microsoft::ReactNative::JSValue';
+            break;
+          case 'ObjectTypeAnnotation':
+            arrayTemplateArg = 'winrt::Microsoft::ReactNative::JSValueObject'; // TODO - better typing
+            break;
+          case 'StringEnumTypeAnnotation':
+            arrayTemplateArg = options.cppStringType; // TODO - better enum type handling than just passing a string
+            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}`);
+  }
+}