@react-native/codegen 0.72.3 → 0.73.0

package/lib/CodegenSchema.d.ts

@@ -47,7 +47,7 @@ export interface VoidTypeAnnotation {
 export interface ObjectTypeAnnotation<T> {
   readonly type: 'ObjectTypeAnnotation';
   readonly properties: readonly NamedShape<T>[];
-  readonly baseTypes?: readonly string[];
+  readonly baseTypes?: readonly string[] | undefined;
 }
 
 export interface FunctionTypeAnnotation<P, R> {
@@ -77,10 +77,10 @@ export interface ComponentShape extends OptionsShape {
 }
 
 export interface OptionsShape {
-  readonly interfaceOnly?: boolean;
-  readonly paperComponentName?: string;
-  readonly excludedPlatforms?: readonly PlatformType[];
-  readonly paperComponentNameDeprecated?: string;
+  readonly interfaceOnly?: boolean | undefined;
+  readonly paperComponentName?: string | undefined;
+  readonly excludedPlatforms?: readonly PlatformType[] | undefined;
+  readonly paperComponentNameDeprecated?: string | undefined;
 }
 
 export interface ExtendsPropsShape {
@@ -94,10 +94,10 @@ export interface EventTypeShape {
     | 'direct'
     | 'bubble';
   readonly optional: boolean;
-  readonly paperTopLevelNameDeprecated?: string;
+  readonly paperTopLevelNameDeprecated?: string | undefined;
   readonly typeAnnotation: {
     readonly type: 'EventTypeAnnotation';
-    readonly argument?: ObjectTypeAnnotation<EventTypeAnnotation>;
+    readonly argument?: ObjectTypeAnnotation<EventTypeAnnotation> | undefined;
   };
 }
 
@@ -211,7 +211,7 @@ export interface NativeModuleSchema {
   readonly enumMap: NativeModuleEnumMap;
   readonly spec: NativeModuleSpec;
   readonly moduleName: string;
-  readonly excludedPlatforms?: readonly PlatformType[];
+  readonly excludedPlatforms?: readonly PlatformType[] | undefined;
 }
 
 export interface NativeModuleSpec {
@@ -234,7 +234,7 @@ export type NativeModuleObjectTypeAnnotation = ObjectTypeAnnotation<Nullable<Nat
 
 export interface NativeModuleArrayTypeAnnotation<T extends Nullable<NativeModuleBaseTypeAnnotation>> {
   readonly type: 'ArrayTypeAnnotation';
-  readonly elementType?: T;
+  readonly elementType?: T | undefined;
 }
 
 export interface NativeModuleStringTypeAnnotation {
@@ -294,7 +294,7 @@ export interface NativeModuleTypeAliasTypeAnnotation {
 
 export interface NativeModulePromiseTypeAnnotation {
   readonly type: 'PromiseTypeAnnotation';
-  readonly elementType?: Nullable<NativeModuleBaseTypeAnnotation>;
+  readonly elementType?: Nullable<NativeModuleBaseTypeAnnotation> | undefined;
 }
 
 export type UnionTypeAnnotationMemberType =

package/lib/CodegenSchema.js.flow

@@ -58,6 +58,10 @@ export type ObjectTypeAnnotation<+T> = $ReadOnly<{
   baseTypes?: $ReadOnlyArray<string>,
 }>;
 
+export type MixedTypeAnnotation = $ReadOnly<{
+  type: 'MixedTypeAnnotation',
+}>;
+
 type FunctionTypeAnnotation<+P, +R> = $ReadOnly<{
   type: 'FunctionTypeAnnotation',
   params: $ReadOnlyArray<NamedShape<P>>,
@@ -177,7 +181,8 @@ export type PropTypeAnnotation =
             type: 'ArrayTypeAnnotation',
             elementType: ObjectTypeAnnotation<PropTypeAnnotation>,
           }>,
-    }>;
+    }>
+  | MixedTypeAnnotation;
 
 export type ReservedPropTypeAnnotation = $ReadOnly<{
   type: 'ReservedPropTypeAnnotation',

package/lib/SchemaValidator.d.ts

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import type { SchemaType } from "./CodegenSchema";
+import type { SchemaType } from './CodegenSchema';
 
 export declare function getErrors(schema: SchemaType): readonly string[];
 export declare function validate(schema: SchemaType): void;

package/lib/generators/RNCodegen.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import type { SchemaType } from '../CodegenSchema';
+
+export type FilesOutput = Map<string, string>;
+export type LibraryGeneratorFunction = (libraryName: string, schema: SchemaType, packageName: string | undefined, assumeNonnull: boolean) => FilesOutput;
+export type SchemaGeneratorFunction = (schemas: { [key: string]: SchemaType }) => FilesOutput;
+export type ViewGeneratorFunction = (libraryName: string, schema: SchemaType) => FilesOutput;
+
+type LibraryGeneratorNames =
+    | 'generateComponentDescriptorH'
+    | 'generateComponentHObjCpp'
+    | 'generateEventEmitterCpp'
+    | 'generateEventEmitterH'
+    | 'generatePropsCpp'
+    | 'generatePropsH'
+    | 'generateStateCpp'
+    | 'generateStateH'
+    | 'generateModuleH'
+    | 'generateModuleCpp'
+    | 'generateModuleObjCpp'
+    | 'generateModuleJavaSpec'
+    | 'generateModuleJniCpp'
+    | 'generateModuleJniH'
+    | 'generatePropsJavaInterface'
+    | 'generatePropsJavaDelegate'
+    | 'generateTests'
+    | 'generateShadowNodeCpp'
+    | 'generateShadowNodeH'
+    ;
+
+type SchemaGeneratorNames =
+    | 'generateThirdPartyFabricComponentsProviderObjCpp'
+    | 'generateThirdPartyFabricComponentsProviderH'
+    ;
+
+type ViewGeneratorNames =
+    | 'generateViewConfigJs'
+    ;
+
+export type AllGenerators =
+    & { readonly [key in LibraryGeneratorNames]: LibraryGeneratorFunction; }
+    & { readonly [key in SchemaGeneratorNames]: SchemaGeneratorFunction; }
+    & { readonly [key in ViewGeneratorNames]: ViewGeneratorFunction; }
+    ;
+
+export type LibraryGenerators =
+    | 'componentsAndroid'
+    | 'componentsIOS'
+    | 'descriptors'
+    | 'events'
+    | 'props'
+    | 'states'
+    | 'tests'
+    | 'shadow-nodes'
+    | 'modulesAndroid'
+    | 'modulesCxx'
+    | 'modulesIOS'
+    ;
+
+export type SchemaGenerators =
+    | 'providerIOS'
+    ;
+
+export interface LibraryOptions {
+    libraryName: string;
+    schema: SchemaType;
+    outputDirectory: string;
+    packageName?: string | undefined;
+    assumeNonnull: boolean;
+}
+
+export interface LibraryConfig {
+    generators: LibraryGenerators[];
+    test?: boolean | undefined;
+}
+
+export interface SchemasOptions {
+    schemas: { [key: string]: SchemaType };
+    outputDirectory: string;
+}
+
+export interface SchemasConfig {
+    generators: SchemaGenerators[];
+    test?: boolean | undefined;
+}
+
+export declare const allGenerators: AllGenerators;
+export declare const libraryGenerators: { readonly [key in LibraryGenerators]: LibraryGeneratorFunction };
+export declare const schemaGenerators: { readonly [key in SchemaGenerators]: SchemaGeneratorFunction };
+export declare function generate(options: LibraryOptions, config: LibraryConfig): boolean;
+export declare function generateFromSchemas(options: SchemasOptions, config: SchemasConfig): boolean;
+export declare function generateViewConfig(options: LibraryOptions): string;

package/lib/generators/RNCodegen.js

@@ -28,8 +28,8 @@ const generateModuleH = require('./modules/GenerateModuleH.js');
 const generateModuleCpp = require('./modules/GenerateModuleCpp.js');
 const generateModuleObjCpp = require('./modules/GenerateModuleObjCpp');
 const generateModuleJavaSpec = require('./modules/GenerateModuleJavaSpec.js');
-const GenerateModuleJniCpp = require('./modules/GenerateModuleJniCpp.js');
-const GenerateModuleJniH = require('./modules/GenerateModuleJniH.js');
+const generateModuleJniCpp = require('./modules/GenerateModuleJniCpp.js');
+const generateModuleJniH = require('./modules/GenerateModuleJniH.js');
 const generatePropsJavaInterface = require('./components/GeneratePropsJavaInterface.js');
 const generatePropsJavaDelegate = require('./components/GeneratePropsJavaDelegate.js');
 const generateTests = require('./components/GenerateTests.js');
@@ -40,6 +40,32 @@ const generateThirdPartyFabricComponentsProviderH = require('./components/Genera
 const generateViewConfigJs = require('./components/GenerateViewConfigJs.js');
 const path = require('path');
 const schemaValidator = require('../SchemaValidator.js');
+const ALL_GENERATORS = {
+  generateComponentDescriptorH: generateComponentDescriptorH.generate,
+  generateComponentHObjCpp: generateComponentHObjCpp.generate,
+  generateEventEmitterCpp: generateEventEmitterCpp.generate,
+  generateEventEmitterH: generateEventEmitterH.generate,
+  generatePropsCpp: generatePropsCpp.generate,
+  generatePropsH: generatePropsH.generate,
+  generateStateCpp: generateStateCpp.generate,
+  generateStateH: generateStateH.generate,
+  generateModuleH: generateModuleH.generate,
+  generateModuleCpp: generateModuleCpp.generate,
+  generateModuleObjCpp: generateModuleObjCpp.generate,
+  generateModuleJavaSpec: generateModuleJavaSpec.generate,
+  generateModuleJniCpp: generateModuleJniCpp.generate,
+  generateModuleJniH: generateModuleJniH.generate,
+  generatePropsJavaInterface: generatePropsJavaInterface.generate,
+  generatePropsJavaDelegate: generatePropsJavaDelegate.generate,
+  generateTests: generateTests.generate,
+  generateShadowNodeCpp: generateShadowNodeCpp.generate,
+  generateShadowNodeH: generateShadowNodeH.generate,
+  generateThirdPartyFabricComponentsProviderObjCpp:
+    generateThirdPartyFabricComponentsProviderObjCpp.generate,
+  generateThirdPartyFabricComponentsProviderH:
+    generateThirdPartyFabricComponentsProviderH.generate,
+  generateViewConfigJs: generateViewConfigJs.generate,
+};
 const LIBRARY_GENERATORS = {
   descriptors: [generateComponentDescriptorH.generate],
   events: [generateEventEmitterCpp.generate, generateEventEmitterH.generate],
@@ -80,8 +106,8 @@ const LIBRARY_GENERATORS = {
     generateShadowNodeH.generate,
   ],
   modulesAndroid: [
-    GenerateModuleJniCpp.generate,
-    GenerateModuleJniH.generate,
+    generateModuleJniCpp.generate,
+    generateModuleJniH.generate,
     generateModuleJavaSpec.generate,
   ],
   modulesCxx: [generateModuleCpp.generate, generateModuleH.generate],
@@ -136,6 +162,9 @@ function checkOrWriteFiles(generatedFiles, test) {
   return writeMapToFiles(generatedFiles);
 }
 module.exports = {
+  allGenerators: ALL_GENERATORS,
+  libraryGenerators: LIBRARY_GENERATORS,
+  schemaGenerators: SCHEMAS_GENERATORS,
   generate(
     {libraryName, schema, outputDirectory, packageName, assumeNonnull},
     {generators, test},

package/lib/generators/RNCodegen.js.flow

@@ -29,8 +29,8 @@ const generateModuleH = require('./modules/GenerateModuleH.js');
 const generateModuleCpp = require('./modules/GenerateModuleCpp.js');
 const generateModuleObjCpp = require('./modules/GenerateModuleObjCpp');
 const generateModuleJavaSpec = require('./modules/GenerateModuleJavaSpec.js');
-const GenerateModuleJniCpp = require('./modules/GenerateModuleJniCpp.js');
-const GenerateModuleJniH = require('./modules/GenerateModuleJniH.js');
+const generateModuleJniCpp = require('./modules/GenerateModuleJniCpp.js');
+const generateModuleJniH = require('./modules/GenerateModuleJniH.js');
 const generatePropsJavaInterface = require('./components/GeneratePropsJavaInterface.js');
 const generatePropsJavaDelegate = require('./components/GeneratePropsJavaDelegate.js');
 const generateTests = require('./components/GenerateTests.js');
@@ -42,6 +42,33 @@ const generateViewConfigJs = require('./components/GenerateViewConfigJs.js');
 const path = require('path');
 const schemaValidator = require('../SchemaValidator.js');
 
+const ALL_GENERATORS = {
+  generateComponentDescriptorH: generateComponentDescriptorH.generate,
+  generateComponentHObjCpp: generateComponentHObjCpp.generate,
+  generateEventEmitterCpp: generateEventEmitterCpp.generate,
+  generateEventEmitterH: generateEventEmitterH.generate,
+  generatePropsCpp: generatePropsCpp.generate,
+  generatePropsH: generatePropsH.generate,
+  generateStateCpp: generateStateCpp.generate,
+  generateStateH: generateStateH.generate,
+  generateModuleH: generateModuleH.generate,
+  generateModuleCpp: generateModuleCpp.generate,
+  generateModuleObjCpp: generateModuleObjCpp.generate,
+  generateModuleJavaSpec: generateModuleJavaSpec.generate,
+  generateModuleJniCpp: generateModuleJniCpp.generate,
+  generateModuleJniH: generateModuleJniH.generate,
+  generatePropsJavaInterface: generatePropsJavaInterface.generate,
+  generatePropsJavaDelegate: generatePropsJavaDelegate.generate,
+  generateTests: generateTests.generate,
+  generateShadowNodeCpp: generateShadowNodeCpp.generate,
+  generateShadowNodeH: generateShadowNodeH.generate,
+  generateThirdPartyFabricComponentsProviderObjCpp:
+    generateThirdPartyFabricComponentsProviderObjCpp.generate,
+  generateThirdPartyFabricComponentsProviderH:
+    generateThirdPartyFabricComponentsProviderH.generate,
+  generateViewConfigJs: generateViewConfigJs.generate,
+};
+
 import type {SchemaType} from '../CodegenSchema';
 
 type LibraryOptions = $ReadOnly<{
@@ -122,8 +149,8 @@ const LIBRARY_GENERATORS = {
     generateShadowNodeH.generate,
   ],
   modulesAndroid: [
-    GenerateModuleJniCpp.generate,
-    GenerateModuleJniH.generate,
+    generateModuleJniCpp.generate,
+    generateModuleJniH.generate,
     generateModuleJavaSpec.generate,
   ],
   modulesCxx: [generateModuleCpp.generate, generateModuleH.generate],
@@ -194,6 +221,10 @@ function checkOrWriteFiles(
 }
 
 module.exports = {
+  allGenerators: ALL_GENERATORS,
+  libraryGenerators: LIBRARY_GENERATORS,
+  schemaGenerators: SCHEMAS_GENERATORS,
+
   generate(
     {
       libraryName,

package/lib/generators/components/ComponentsGeneratorUtils.js

@@ -84,6 +84,8 @@ function getNativeTypeFromAnnotation(componentName, prop, nameParts) {
       return getEnumName(componentName, prop.name);
     case 'Int32EnumTypeAnnotation':
       return getEnumName(componentName, prop.name);
+    case 'MixedTypeAnnotation':
+      return 'folly::dynamic';
     default:
       typeAnnotation;
       throw new Error(

package/lib/generators/components/ComponentsGeneratorUtils.js.flow

@@ -122,6 +122,8 @@ function getNativeTypeFromAnnotation(
       return getEnumName(componentName, prop.name);
     case 'Int32EnumTypeAnnotation':
       return getEnumName(componentName, prop.name);
+    case 'MixedTypeAnnotation':
+      return 'folly::dynamic';
     default:
       (typeAnnotation: empty);
       throw new Error(

package/lib/generators/components/CppHelpers.js

@@ -165,6 +165,8 @@ function convertDefaultTypeToString(componentName, prop) {
         prop.name,
         typeAnnotation.default,
       )}`;
+    case 'MixedTypeAnnotation':
+      return '';
     default:
       typeAnnotation;
       throw new Error(`Unsupported type annotation: ${typeAnnotation.type}`);

package/lib/generators/components/CppHelpers.js.flow

@@ -200,6 +200,8 @@ function convertDefaultTypeToString(
         prop.name,
         typeAnnotation.default,
       )}`;
+    case 'MixedTypeAnnotation':
+      return '';
     default:
       (typeAnnotation: empty);
       throw new Error(`Unsupported type annotation: ${typeAnnotation.type}`);

package/lib/generators/components/GenerateEventEmitterCpp.js

@@ -26,9 +26,7 @@ const FileTemplate = ({events, libraryName}) => `
 
 namespace facebook {
 namespace react {
-
 ${events}
-
 } // namespace react
 } // namespace facebook
 `;
@@ -39,16 +37,16 @@ const ComponentTemplate = ({
   dispatchEventName,
   implementation,
 }) => {
-  const capture = implementation.includes('event')
-    ? 'event=std::move(event)'
+  const capture = implementation.includes('$event')
+    ? '$event=std::move($event)'
     : '';
   return `
-void ${className}EventEmitter::${eventName}(${structName} event) const {
+void ${className}EventEmitter::${eventName}(${structName} $event) const {
   dispatchEvent("${dispatchEventName}", [${capture}](jsi::Runtime &runtime) {
     ${implementation}
   });
 }
-`.trim();
+`;
 };
 const BasicComponentTemplate = ({className, eventName, dispatchEventName}) =>
   `
@@ -58,47 +56,45 @@ void ${className}EventEmitter::${eventName}() const {
 `.trim();
 function generateSetter(variableName, propertyName, propertyParts) {
   const trailingPeriod = propertyParts.length === 0 ? '' : '.';
-  const eventChain = `event.${propertyParts.join(
+  const eventChain = `$event.${propertyParts.join(
     '.',
   )}${trailingPeriod}${propertyName});`;
   return `${variableName}.setProperty(runtime, "${propertyName}", ${eventChain}`;
 }
 function generateEnumSetter(variableName, propertyName, propertyParts) {
   const trailingPeriod = propertyParts.length === 0 ? '' : '.';
-  const eventChain = `event.${propertyParts.join(
+  const eventChain = `$event.${propertyParts.join(
     '.',
   )}${trailingPeriod}${propertyName})`;
   return `${variableName}.setProperty(runtime, "${propertyName}", toString(${eventChain});`;
 }
+function generateObjectSetter(
+  variableName,
+  propertyName,
+  propertyParts,
+  typeAnnotation,
+) {
+  return `
+{
+  auto ${propertyName} = jsi::Object(runtime);
+  ${generateSetters(
+    propertyName,
+    typeAnnotation.properties,
+    propertyParts.concat([propertyName]),
+  )}
+  ${variableName}.setProperty(runtime, "${propertyName}", ${propertyName});
+}
+`.trim();
+}
 function generateSetters(parentPropertyName, properties, propertyParts) {
   const propSetters = properties
     .map(eventProperty => {
       const typeAnnotation = eventProperty.typeAnnotation;
       switch (typeAnnotation.type) {
         case 'BooleanTypeAnnotation':
-          return generateSetter(
-            parentPropertyName,
-            eventProperty.name,
-            propertyParts,
-          );
         case 'StringTypeAnnotation':
-          return generateSetter(
-            parentPropertyName,
-            eventProperty.name,
-            propertyParts,
-          );
         case 'Int32TypeAnnotation':
-          return generateSetter(
-            parentPropertyName,
-            eventProperty.name,
-            propertyParts,
-          );
         case 'DoubleTypeAnnotation':
-          return generateSetter(
-            parentPropertyName,
-            eventProperty.name,
-            propertyParts,
-          );
         case 'FloatTypeAnnotation':
           return generateSetter(
             parentPropertyName,
@@ -112,19 +108,12 @@ function generateSetters(parentPropertyName, properties, propertyParts) {
             propertyParts,
           );
         case 'ObjectTypeAnnotation':
-          const propertyName = eventProperty.name;
-          return `
-            {
-              auto ${propertyName} = jsi::Object(runtime);
-              ${generateSetters(
-                propertyName,
-                typeAnnotation.properties,
-                propertyParts.concat([propertyName]),
-              )}
-
-              ${parentPropertyName}.setProperty(runtime, "${propertyName}", ${propertyName});
-            }
-          `.trim();
+          return generateObjectSetter(
+            parentPropertyName,
+            eventProperty.name,
+            propertyParts,
+            typeAnnotation,
+          );
         default:
           typeAnnotation.type;
           throw new Error('Received invalid event property type');
@@ -145,9 +134,9 @@ function generateEvent(componentName, event) {
   )}`;
   if (event.typeAnnotation.argument) {
     const implementation = `
-    auto payload = jsi::Object(runtime);
-    ${generateSetters('payload', event.typeAnnotation.argument.properties, [])}
-    return payload;
+    auto $payload = jsi::Object(runtime);
+    ${generateSetters('$payload', event.typeAnnotation.argument.properties, [])}
+    return $payload;
   `.trim();
     if (!event.name.startsWith('on')) {
       throw new Error('Expected the event name to start with `on`');

package/lib/generators/components/GenerateEventEmitterCpp.js.flow

@@ -18,6 +18,7 @@ import type {
   NamedShape,
   EventTypeAnnotation,
   SchemaType,
+  ObjectTypeAnnotation,
 } from '../../CodegenSchema';
 
 // File path -> contents
@@ -48,9 +49,7 @@ const FileTemplate = ({
 
 namespace facebook {
 namespace react {
-
 ${events}
-
 } // namespace react
 } // namespace facebook
 `;
@@ -68,16 +67,16 @@ const ComponentTemplate = ({
   dispatchEventName: string,
   implementation: string,
 }) => {
-  const capture = implementation.includes('event')
-    ? 'event=std::move(event)'
+  const capture = implementation.includes('$event')
+    ? '$event=std::move($event)'
     : '';
   return `
-void ${className}EventEmitter::${eventName}(${structName} event) const {
+void ${className}EventEmitter::${eventName}(${structName} $event) const {
   dispatchEvent("${dispatchEventName}", [${capture}](jsi::Runtime &runtime) {
     ${implementation}
   });
 }
-`.trim();
+`;
 };
 
 const BasicComponentTemplate = ({
@@ -101,7 +100,7 @@ function generateSetter(
   propertyParts: $ReadOnlyArray<string>,
 ) {
   const trailingPeriod = propertyParts.length === 0 ? '' : '.';
-  const eventChain = `event.${propertyParts.join(
+  const eventChain = `$event.${propertyParts.join(
     '.',
   )}${trailingPeriod}${propertyName});`;
 
@@ -114,13 +113,32 @@ function generateEnumSetter(
   propertyParts: $ReadOnlyArray<string>,
 ) {
   const trailingPeriod = propertyParts.length === 0 ? '' : '.';
-  const eventChain = `event.${propertyParts.join(
+  const eventChain = `$event.${propertyParts.join(
     '.',
   )}${trailingPeriod}${propertyName})`;
 
   return `${variableName}.setProperty(runtime, "${propertyName}", toString(${eventChain});`;
 }
 
+function generateObjectSetter(
+  variableName: string,
+  propertyName: string,
+  propertyParts: $ReadOnlyArray<string>,
+  typeAnnotation: ObjectTypeAnnotation<EventTypeAnnotation>,
+) {
+  return `
+{
+  auto ${propertyName} = jsi::Object(runtime);
+  ${generateSetters(
+    propertyName,
+    typeAnnotation.properties,
+    propertyParts.concat([propertyName]),
+  )}
+  ${variableName}.setProperty(runtime, "${propertyName}", ${propertyName});
+}
+`.trim();
+}
+
 function generateSetters(
   parentPropertyName: string,
   properties: $ReadOnlyArray<NamedShape<EventTypeAnnotation>>,
@@ -131,29 +149,9 @@ function generateSetters(
       const {typeAnnotation} = eventProperty;
       switch (typeAnnotation.type) {
         case 'BooleanTypeAnnotation':
-          return generateSetter(
-            parentPropertyName,
-            eventProperty.name,
-            propertyParts,
-          );
         case 'StringTypeAnnotation':
-          return generateSetter(
-            parentPropertyName,
-            eventProperty.name,
-            propertyParts,
-          );
         case 'Int32TypeAnnotation':
-          return generateSetter(
-            parentPropertyName,
-            eventProperty.name,
-            propertyParts,
-          );
         case 'DoubleTypeAnnotation':
-          return generateSetter(
-            parentPropertyName,
-            eventProperty.name,
-            propertyParts,
-          );
         case 'FloatTypeAnnotation':
           return generateSetter(
             parentPropertyName,
@@ -167,19 +165,12 @@ function generateSetters(
             propertyParts,
           );
         case 'ObjectTypeAnnotation':
-          const propertyName = eventProperty.name;
-          return `
-            {
-              auto ${propertyName} = jsi::Object(runtime);
-              ${generateSetters(
-                propertyName,
-                typeAnnotation.properties,
-                propertyParts.concat([propertyName]),
-              )}
-
-              ${parentPropertyName}.setProperty(runtime, "${propertyName}", ${propertyName});
-            }
-          `.trim();
+          return generateObjectSetter(
+            parentPropertyName,
+            eventProperty.name,
+            propertyParts,
+            typeAnnotation,
+          );
         default:
           (typeAnnotation.type: empty);
           throw new Error('Received invalid event property type');
@@ -203,9 +194,9 @@ function generateEvent(componentName: string, event: EventTypeShape): string {
 
   if (event.typeAnnotation.argument) {
     const implementation = `
-    auto payload = jsi::Object(runtime);
-    ${generateSetters('payload', event.typeAnnotation.argument.properties, [])}
-    return payload;
+    auto $payload = jsi::Object(runtime);
+    ${generateSetters('$payload', event.typeAnnotation.argument.properties, [])}
+    return $payload;
   `.trim();
 
     if (!event.name.startsWith('on')) {

package/lib/generators/components/GenerateEventEmitterH.js

@@ -33,9 +33,7 @@ const FileTemplate = ({componentEmitters}) => `
 
 namespace facebook {
 namespace react {
-
 ${componentEmitters}
-
 } // namespace react
 } // namespace facebook
 `;

package/lib/generators/components/GenerateEventEmitterH.js.flow

@@ -51,9 +51,7 @@ const FileTemplate = ({componentEmitters}: {componentEmitters: string}) => `
 
 namespace facebook {
 namespace react {
-
 ${componentEmitters}
-
 } // namespace react
 } // namespace facebook
 `;

package/lib/generators/components/GeneratePropsH.js

@@ -522,6 +522,8 @@ function generateStruct(structs, componentName, nameParts, properties) {
         }
         generateStruct(structs, componentName, nameParts.concat([name]), props);
         return;
+      case 'MixedTypeAnnotation':
+        return;
       default:
         property.typeAnnotation.type;
         throw new Error(