first commit

node_modules/@react-native/codegen/lib/generators/components/ComponentsGeneratorUtils.js

@@ -0,0 +1,229 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+const {getEnumName} = require('../Utils');
+const {
+  generateStructName,
+  getCppTypeForAnnotation,
+  getEnumMaskName,
+  getImports,
+} = require('./CppHelpers.js');
+function getNativeTypeFromAnnotation(componentName, prop, nameParts) {
+  const typeAnnotation = prop.typeAnnotation;
+  switch (typeAnnotation.type) {
+    case 'BooleanTypeAnnotation':
+    case 'StringTypeAnnotation':
+    case 'Int32TypeAnnotation':
+    case 'DoubleTypeAnnotation':
+    case 'FloatTypeAnnotation':
+      return getCppTypeForAnnotation(typeAnnotation.type);
+    case 'ReservedPropTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'ColorPrimitive':
+          return 'SharedColor';
+        case 'ImageSourcePrimitive':
+          return 'ImageSource';
+        case 'ImageRequestPrimitive':
+          return 'ImageRequest';
+        case 'PointPrimitive':
+          return 'Point';
+        case 'EdgeInsetsPrimitive':
+          return 'EdgeInsets';
+        case 'DimensionPrimitive':
+          return 'YGValue';
+        default:
+          typeAnnotation.name;
+          throw new Error('Received unknown ReservedPropTypeAnnotation');
+      }
+    case 'ArrayTypeAnnotation': {
+      const arrayType = typeAnnotation.elementType.type;
+      if (arrayType === 'ArrayTypeAnnotation') {
+        return `std::vector<${getNativeTypeFromAnnotation(
+          componentName,
+          {
+            typeAnnotation: typeAnnotation.elementType,
+            name: '',
+          },
+          nameParts.concat([prop.name]),
+        )}>`;
+      }
+      if (arrayType === 'ObjectTypeAnnotation') {
+        const structName = generateStructName(
+          componentName,
+          nameParts.concat([prop.name]),
+        );
+        return `std::vector<${structName}>`;
+      }
+      if (arrayType === 'StringEnumTypeAnnotation') {
+        const enumName = getEnumName(componentName, prop.name);
+        return getEnumMaskName(enumName);
+      }
+      const itemAnnotation = getNativeTypeFromAnnotation(
+        componentName,
+        {
+          typeAnnotation: typeAnnotation.elementType,
+          name: componentName,
+        },
+        nameParts.concat([prop.name]),
+      );
+      return `std::vector<${itemAnnotation}>`;
+    }
+    case 'ObjectTypeAnnotation': {
+      return generateStructName(componentName, nameParts.concat([prop.name]));
+    }
+    case 'StringEnumTypeAnnotation':
+      return getEnumName(componentName, prop.name);
+    case 'Int32EnumTypeAnnotation':
+      return getEnumName(componentName, prop.name);
+    case 'MixedTypeAnnotation':
+      return 'folly::dynamic';
+    default:
+      typeAnnotation;
+      throw new Error(
+        `Received invalid typeAnnotation for ${componentName} prop ${prop.name}, received ${typeAnnotation.type}`,
+      );
+  }
+}
+
+/// This function process some types if we need to customize them
+/// For example, the ImageSource and the reserved types could be trasformed into
+/// const address instead of using them as plain types.
+function convertTypesToConstAddressIfNeeded(type, convertibleTypes) {
+  if (convertibleTypes.has(type)) {
+    return `${type} const &`;
+  }
+  return type;
+}
+function convertValueToSharedPointerWithMove(type, value, convertibleTypes) {
+  if (convertibleTypes.has(type)) {
+    return `std::make_shared<${type}>(std::move(${value}))`;
+  }
+  return value;
+}
+function convertVariableToSharedPointer(type, convertibleTypes) {
+  if (convertibleTypes.has(type)) {
+    return `std::shared_ptr<${type}>`;
+  }
+  return type;
+}
+function convertVariableToPointer(type, value, convertibleTypes) {
+  if (convertibleTypes.has(type)) {
+    return `*${value}`;
+  }
+  return value;
+}
+const convertCtorParamToAddressType = type => {
+  const typesToConvert = new Set();
+  typesToConvert.add('ImageSource');
+  return convertTypesToConstAddressIfNeeded(type, typesToConvert);
+};
+const convertCtorInitToSharedPointers = (type, value) => {
+  const typesToConvert = new Set();
+  typesToConvert.add('ImageRequest');
+  return convertValueToSharedPointerWithMove(type, value, typesToConvert);
+};
+const convertGettersReturnTypeToAddressType = type => {
+  const typesToConvert = new Set();
+  typesToConvert.add('ImageRequest');
+  return convertTypesToConstAddressIfNeeded(type, typesToConvert);
+};
+const convertVarTypeToSharedPointer = type => {
+  const typesToConvert = new Set();
+  typesToConvert.add('ImageRequest');
+  return convertVariableToSharedPointer(type, typesToConvert);
+};
+const convertVarValueToPointer = (type, value) => {
+  const typesToConvert = new Set();
+  typesToConvert.add('ImageRequest');
+  return convertVariableToPointer(type, value, typesToConvert);
+};
+function getLocalImports(properties) {
+  const imports = new Set();
+  function addImportsForNativeName(name) {
+    switch (name) {
+      case 'ColorPrimitive':
+        imports.add('#include <react/renderer/graphics/Color.h>');
+        return;
+      case 'ImageSourcePrimitive':
+        imports.add('#include <react/renderer/imagemanager/primitives.h>');
+        return;
+      case 'ImageRequestPrimitive':
+        imports.add('#include <react/renderer/imagemanager/ImageRequest.h>');
+        return;
+      case 'PointPrimitive':
+        imports.add('#include <react/renderer/graphics/Point.h>');
+        return;
+      case 'EdgeInsetsPrimitive':
+        imports.add('#include <react/renderer/graphics/RectangleEdges.h>');
+        return;
+      case 'DimensionPrimitive':
+        imports.add('#include <yoga/Yoga.h>');
+        imports.add('#include <react/renderer/core/graphicsConversions.h>');
+        return;
+      default:
+        name;
+        throw new Error(`Invalid ReservedPropTypeAnnotation name, got ${name}`);
+    }
+  }
+  properties.forEach(prop => {
+    const typeAnnotation = prop.typeAnnotation;
+    if (typeAnnotation.type === 'ReservedPropTypeAnnotation') {
+      addImportsForNativeName(typeAnnotation.name);
+    }
+    if (typeAnnotation.type === 'ArrayTypeAnnotation') {
+      imports.add('#include <vector>');
+      if (typeAnnotation.elementType.type === 'StringEnumTypeAnnotation') {
+        imports.add('#include <cinttypes>');
+      }
+    }
+    if (
+      typeAnnotation.type === 'ArrayTypeAnnotation' &&
+      typeAnnotation.elementType.type === 'ReservedPropTypeAnnotation'
+    ) {
+      addImportsForNativeName(typeAnnotation.elementType.name);
+    }
+    if (
+      typeAnnotation.type === 'ArrayTypeAnnotation' &&
+      typeAnnotation.elementType.type === 'ObjectTypeAnnotation'
+    ) {
+      imports.add('#include <react/renderer/core/propsConversions.h>');
+      const objectProps = typeAnnotation.elementType.properties;
+      // $FlowFixMe[incompatible-type] the type is guaranteed to be ObjectTypeAnnotation<PropTypeAnnotation>
+      const objectImports = getImports(objectProps);
+      // $FlowFixMe[incompatible-type] the type is guaranteed to be ObjectTypeAnnotation<PropTypeAnnotation>
+      const localImports = getLocalImports(objectProps);
+      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+      objectImports.forEach(imports.add, imports);
+      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+      localImports.forEach(imports.add, imports);
+    }
+    if (typeAnnotation.type === 'ObjectTypeAnnotation') {
+      imports.add('#include <react/renderer/core/propsConversions.h>');
+      const objectImports = getImports(typeAnnotation.properties);
+      const localImports = getLocalImports(typeAnnotation.properties);
+      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+      objectImports.forEach(imports.add, imports);
+      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+      localImports.forEach(imports.add, imports);
+    }
+  });
+  return imports;
+}
+module.exports = {
+  getNativeTypeFromAnnotation,
+  convertCtorParamToAddressType,
+  convertGettersReturnTypeToAddressType,
+  convertCtorInitToSharedPointers,
+  convertVarTypeToSharedPointer,
+  convertVarValueToPointer,
+  getLocalImports,
+};

node_modules/@react-native/codegen/lib/generators/components/ComponentsGeneratorUtils.js.flow

@@ -0,0 +1,315 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import type {NamedShape, PropTypeAnnotation} from '../../CodegenSchema';
+import type {
+  BooleanTypeAnnotation,
+  DoubleTypeAnnotation,
+  FloatTypeAnnotation,
+  Int32TypeAnnotation,
+  ObjectTypeAnnotation,
+  ReservedPropTypeAnnotation,
+  StringTypeAnnotation,
+} from '../../CodegenSchema';
+
+const {getEnumName} = require('../Utils');
+const {
+  generateStructName,
+  getCppTypeForAnnotation,
+  getEnumMaskName,
+  getImports,
+} = require('./CppHelpers.js');
+
+function getNativeTypeFromAnnotation(
+  componentName: string,
+  prop:
+    | NamedShape<PropTypeAnnotation>
+    | {
+        name: string,
+        typeAnnotation:
+          | $FlowFixMe
+          | DoubleTypeAnnotation
+          | FloatTypeAnnotation
+          | BooleanTypeAnnotation
+          | Int32TypeAnnotation
+          | StringTypeAnnotation
+          | ObjectTypeAnnotation<PropTypeAnnotation>
+          | ReservedPropTypeAnnotation
+          | {
+              +default: string,
+              +options: $ReadOnlyArray<string>,
+              +type: 'StringEnumTypeAnnotation',
+            }
+          | {
+              +elementType: ObjectTypeAnnotation<PropTypeAnnotation>,
+              +type: 'ArrayTypeAnnotation',
+            },
+      },
+  nameParts: $ReadOnlyArray<string>,
+): string {
+  const typeAnnotation = prop.typeAnnotation;
+
+  switch (typeAnnotation.type) {
+    case 'BooleanTypeAnnotation':
+    case 'StringTypeAnnotation':
+    case 'Int32TypeAnnotation':
+    case 'DoubleTypeAnnotation':
+    case 'FloatTypeAnnotation':
+      return getCppTypeForAnnotation(typeAnnotation.type);
+    case 'ReservedPropTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'ColorPrimitive':
+          return 'SharedColor';
+        case 'ImageSourcePrimitive':
+          return 'ImageSource';
+        case 'ImageRequestPrimitive':
+          return 'ImageRequest';
+        case 'PointPrimitive':
+          return 'Point';
+        case 'EdgeInsetsPrimitive':
+          return 'EdgeInsets';
+        case 'DimensionPrimitive':
+          return 'YGValue';
+        default:
+          (typeAnnotation.name: empty);
+          throw new Error('Received unknown ReservedPropTypeAnnotation');
+      }
+    case 'ArrayTypeAnnotation': {
+      const arrayType = typeAnnotation.elementType.type;
+      if (arrayType === 'ArrayTypeAnnotation') {
+        return `std::vector<${getNativeTypeFromAnnotation(
+          componentName,
+          {typeAnnotation: typeAnnotation.elementType, name: ''},
+          nameParts.concat([prop.name]),
+        )}>`;
+      }
+      if (arrayType === 'ObjectTypeAnnotation') {
+        const structName = generateStructName(
+          componentName,
+          nameParts.concat([prop.name]),
+        );
+        return `std::vector<${structName}>`;
+      }
+      if (arrayType === 'StringEnumTypeAnnotation') {
+        const enumName = getEnumName(componentName, prop.name);
+        return getEnumMaskName(enumName);
+      }
+      const itemAnnotation = getNativeTypeFromAnnotation(
+        componentName,
+        {
+          typeAnnotation: typeAnnotation.elementType,
+          name: componentName,
+        },
+        nameParts.concat([prop.name]),
+      );
+      return `std::vector<${itemAnnotation}>`;
+    }
+    case 'ObjectTypeAnnotation': {
+      return generateStructName(componentName, nameParts.concat([prop.name]));
+    }
+    case 'StringEnumTypeAnnotation':
+      return getEnumName(componentName, prop.name);
+    case 'Int32EnumTypeAnnotation':
+      return getEnumName(componentName, prop.name);
+    case 'MixedTypeAnnotation':
+      return 'folly::dynamic';
+    default:
+      (typeAnnotation: empty);
+      throw new Error(
+        `Received invalid typeAnnotation for ${componentName} prop ${prop.name}, received ${typeAnnotation.type}`,
+      );
+  }
+}
+
+/// This function process some types if we need to customize them
+/// For example, the ImageSource and the reserved types could be trasformed into
+/// const address instead of using them as plain types.
+function convertTypesToConstAddressIfNeeded(
+  type: string,
+  convertibleTypes: Set<string>,
+): string {
+  if (convertibleTypes.has(type)) {
+    return `${type} const &`;
+  }
+  return type;
+}
+
+function convertValueToSharedPointerWithMove(
+  type: string,
+  value: string,
+  convertibleTypes: Set<string>,
+): string {
+  if (convertibleTypes.has(type)) {
+    return `std::make_shared<${type}>(std::move(${value}))`;
+  }
+  return value;
+}
+
+function convertVariableToSharedPointer(
+  type: string,
+  convertibleTypes: Set<string>,
+): string {
+  if (convertibleTypes.has(type)) {
+    return `std::shared_ptr<${type}>`;
+  }
+  return type;
+}
+
+function convertVariableToPointer(
+  type: string,
+  value: string,
+  convertibleTypes: Set<string>,
+): string {
+  if (convertibleTypes.has(type)) {
+    return `*${value}`;
+  }
+  return value;
+}
+
+const convertCtorParamToAddressType = (type: string): string => {
+  const typesToConvert: Set<string> = new Set();
+  typesToConvert.add('ImageSource');
+
+  return convertTypesToConstAddressIfNeeded(type, typesToConvert);
+};
+
+const convertCtorInitToSharedPointers = (
+  type: string,
+  value: string,
+): string => {
+  const typesToConvert: Set<string> = new Set();
+  typesToConvert.add('ImageRequest');
+
+  return convertValueToSharedPointerWithMove(type, value, typesToConvert);
+};
+
+const convertGettersReturnTypeToAddressType = (type: string): string => {
+  const typesToConvert: Set<string> = new Set();
+  typesToConvert.add('ImageRequest');
+
+  return convertTypesToConstAddressIfNeeded(type, typesToConvert);
+};
+
+const convertVarTypeToSharedPointer = (type: string): string => {
+  const typesToConvert: Set<string> = new Set();
+  typesToConvert.add('ImageRequest');
+
+  return convertVariableToSharedPointer(type, typesToConvert);
+};
+
+const convertVarValueToPointer = (type: string, value: string): string => {
+  const typesToConvert: Set<string> = new Set();
+  typesToConvert.add('ImageRequest');
+
+  return convertVariableToPointer(type, value, typesToConvert);
+};
+
+function getLocalImports(
+  properties: $ReadOnlyArray<NamedShape<PropTypeAnnotation>>,
+): Set<string> {
+  const imports: Set<string> = new Set();
+
+  function addImportsForNativeName(
+    name:
+      | 'ColorPrimitive'
+      | 'EdgeInsetsPrimitive'
+      | 'ImageSourcePrimitive'
+      | 'PointPrimitive'
+      | 'ImageRequestPrimitive'
+      | 'DimensionPrimitive',
+  ) {
+    switch (name) {
+      case 'ColorPrimitive':
+        imports.add('#include <react/renderer/graphics/Color.h>');
+        return;
+      case 'ImageSourcePrimitive':
+        imports.add('#include <react/renderer/imagemanager/primitives.h>');
+        return;
+      case 'ImageRequestPrimitive':
+        imports.add('#include <react/renderer/imagemanager/ImageRequest.h>');
+        return;
+      case 'PointPrimitive':
+        imports.add('#include <react/renderer/graphics/Point.h>');
+        return;
+      case 'EdgeInsetsPrimitive':
+        imports.add('#include <react/renderer/graphics/RectangleEdges.h>');
+        return;
+      case 'DimensionPrimitive':
+        imports.add('#include <yoga/Yoga.h>');
+        imports.add('#include <react/renderer/core/graphicsConversions.h>');
+        return;
+      default:
+        (name: empty);
+        throw new Error(`Invalid ReservedPropTypeAnnotation name, got ${name}`);
+    }
+  }
+
+  properties.forEach(prop => {
+    const typeAnnotation = prop.typeAnnotation;
+
+    if (typeAnnotation.type === 'ReservedPropTypeAnnotation') {
+      addImportsForNativeName(typeAnnotation.name);
+    }
+
+    if (typeAnnotation.type === 'ArrayTypeAnnotation') {
+      imports.add('#include <vector>');
+      if (typeAnnotation.elementType.type === 'StringEnumTypeAnnotation') {
+        imports.add('#include <cinttypes>');
+      }
+    }
+
+    if (
+      typeAnnotation.type === 'ArrayTypeAnnotation' &&
+      typeAnnotation.elementType.type === 'ReservedPropTypeAnnotation'
+    ) {
+      addImportsForNativeName(typeAnnotation.elementType.name);
+    }
+
+    if (
+      typeAnnotation.type === 'ArrayTypeAnnotation' &&
+      typeAnnotation.elementType.type === 'ObjectTypeAnnotation'
+    ) {
+      imports.add('#include <react/renderer/core/propsConversions.h>');
+      const objectProps = typeAnnotation.elementType.properties;
+      // $FlowFixMe[incompatible-type] the type is guaranteed to be ObjectTypeAnnotation<PropTypeAnnotation>
+      const objectImports = getImports(objectProps);
+      // $FlowFixMe[incompatible-type] the type is guaranteed to be ObjectTypeAnnotation<PropTypeAnnotation>
+      const localImports = getLocalImports(objectProps);
+      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+      objectImports.forEach(imports.add, imports);
+      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+      localImports.forEach(imports.add, imports);
+    }
+
+    if (typeAnnotation.type === 'ObjectTypeAnnotation') {
+      imports.add('#include <react/renderer/core/propsConversions.h>');
+      const objectImports = getImports(typeAnnotation.properties);
+      const localImports = getLocalImports(typeAnnotation.properties);
+      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+      objectImports.forEach(imports.add, imports);
+      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+      localImports.forEach(imports.add, imports);
+    }
+  });
+
+  return imports;
+}
+
+module.exports = {
+  getNativeTypeFromAnnotation,
+  convertCtorParamToAddressType,
+  convertGettersReturnTypeToAddressType,
+  convertCtorInitToSharedPointers,
+  convertVarTypeToSharedPointer,
+  convertVarValueToPointer,
+  getLocalImports,
+};

node_modules/@react-native/codegen/lib/generators/components/ComponentsProviderUtils.js

@@ -0,0 +1,56 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+const APPLE_PLATFORMS_MACRO_MAP = {
+  ios: 'TARGET_OS_IOS',
+  macos: 'TARGET_OS_OSX',
+  tvos: 'TARGET_OS_TV',
+  visionos: 'TARGET_OS_VISION',
+};
+
+/**
+ * Adds compiler macros to the file template to exclude unsupported platforms.
+ */
+function generateSupportedApplePlatformsMacro(
+  fileTemplate,
+  supportedPlatformsMap,
+) {
+  if (!supportedPlatformsMap) {
+    return fileTemplate;
+  }
+
+  // According to Podspec Syntax Reference, when `platform` or `deployment_target` is not specified, it defaults to all platforms.
+  // https://guides.cocoapods.org/syntax/podspec.html#platform
+  const everyPlatformIsUnsupported = Object.keys(supportedPlatformsMap).every(
+    platform => supportedPlatformsMap[platform] === false,
+  );
+  if (everyPlatformIsUnsupported) {
+    return fileTemplate;
+  }
+  const compilerMacroString = Object.keys(supportedPlatformsMap)
+    .reduce((acc, platform) => {
+      if (!supportedPlatformsMap[platform]) {
+        // $FlowFixMe[invalid-computed-prop]
+        return [...acc, `!${APPLE_PLATFORMS_MACRO_MAP[platform]}`];
+      }
+      return acc;
+    }, [])
+    .join(' && ');
+  if (!compilerMacroString) {
+    return fileTemplate;
+  }
+  return `#if ${compilerMacroString}
+${fileTemplate}
+#endif
+`;
+}
+module.exports = {
+  generateSupportedApplePlatformsMacro,
+};

node_modules/@react-native/codegen/lib/generators/components/ComponentsProviderUtils.js.flow

@@ -0,0 +1,61 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+const APPLE_PLATFORMS_MACRO_MAP = {
+  ios: 'TARGET_OS_IOS',
+  macos: 'TARGET_OS_OSX',
+  tvos: 'TARGET_OS_TV',
+  visionos: 'TARGET_OS_VISION',
+};
+
+/**
+ * Adds compiler macros to the file template to exclude unsupported platforms.
+ */
+function generateSupportedApplePlatformsMacro(
+  fileTemplate: string,
+  supportedPlatformsMap: ?{[string]: boolean},
+): string {
+  if (!supportedPlatformsMap) {
+    return fileTemplate;
+  }
+
+  // According to Podspec Syntax Reference, when `platform` or `deployment_target` is not specified, it defaults to all platforms.
+  // https://guides.cocoapods.org/syntax/podspec.html#platform
+  const everyPlatformIsUnsupported = Object.keys(supportedPlatformsMap).every(
+    platform => supportedPlatformsMap[platform] === false,
+  );
+
+  if (everyPlatformIsUnsupported) {
+    return fileTemplate;
+  }
+
+  const compilerMacroString = Object.keys(supportedPlatformsMap)
+    .reduce((acc: string[], platform) => {
+      if (!supportedPlatformsMap[platform]) {
+        // $FlowFixMe[invalid-computed-prop]
+        return [...acc, `!${APPLE_PLATFORMS_MACRO_MAP[platform]}`];
+      }
+      return acc;
+    }, [])
+    .join(' && ');
+
+  if (!compilerMacroString) {
+    return fileTemplate;
+  }
+
+  return `#if ${compilerMacroString}
+${fileTemplate}
+#endif
+`;
+}
+
+module.exports = {
+  generateSupportedApplePlatformsMacro,
+};

node_modules/@react-native/codegen/lib/generators/components/CppHelpers.js

@@ -0,0 +1,247 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+const {getEnumName, toSafeCppString} = require('../Utils');
+function toIntEnumValueName(propName, value) {
+  return `${toSafeCppString(propName)}${value}`;
+}
+function getCppTypeForAnnotation(type) {
+  switch (type) {
+    case 'BooleanTypeAnnotation':
+      return 'bool';
+    case 'StringTypeAnnotation':
+      return 'std::string';
+    case 'Int32TypeAnnotation':
+      return 'int';
+    case 'DoubleTypeAnnotation':
+      return 'double';
+    case 'FloatTypeAnnotation':
+      return 'Float';
+    case 'MixedTypeAnnotation':
+      return 'folly::dynamic';
+    default:
+      type;
+      throw new Error(`Received invalid typeAnnotation ${type}`);
+  }
+}
+function getCppArrayTypeForAnnotation(typeElement, structParts) {
+  switch (typeElement.type) {
+    case 'BooleanTypeAnnotation':
+    case 'StringTypeAnnotation':
+    case 'DoubleTypeAnnotation':
+    case 'FloatTypeAnnotation':
+    case 'Int32TypeAnnotation':
+    case 'MixedTypeAnnotation':
+      return `std::vector<${getCppTypeForAnnotation(typeElement.type)}>`;
+    case 'StringLiteralUnionTypeAnnotation':
+    case 'ObjectTypeAnnotation':
+      if (!structParts) {
+        throw new Error(
+          `Trying to generate the event emitter for an Array of ${typeElement.type} without informations to generate the generic type`,
+        );
+      }
+      return `std::vector<${generateEventStructName(structParts)}>`;
+    case 'ArrayTypeAnnotation':
+      return `std::vector<${getCppArrayTypeForAnnotation(typeElement.elementType, structParts)}>`;
+    default:
+      throw new Error(
+        `Can't determine array type with typeElement: ${JSON.stringify(typeElement, null, 2)}`,
+      );
+  }
+}
+function getImports(properties) {
+  const imports = new Set();
+  function addImportsForNativeName(name) {
+    switch (name) {
+      case 'ColorPrimitive':
+        return;
+      case 'PointPrimitive':
+        return;
+      case 'EdgeInsetsPrimitive':
+        return;
+      case 'ImageRequestPrimitive':
+        return;
+      case 'ImageSourcePrimitive':
+        imports.add('#include <react/renderer/components/image/conversions.h>');
+        return;
+      case 'DimensionPrimitive':
+        imports.add('#include <react/renderer/components/view/conversions.h>');
+        return;
+      default:
+        name;
+        throw new Error(`Invalid name, got ${name}`);
+    }
+  }
+  properties.forEach(prop => {
+    const typeAnnotation = prop.typeAnnotation;
+    if (typeAnnotation.type === 'ReservedPropTypeAnnotation') {
+      addImportsForNativeName(typeAnnotation.name);
+    }
+    if (
+      typeAnnotation.type === 'ArrayTypeAnnotation' &&
+      typeAnnotation.elementType.type === 'ReservedPropTypeAnnotation'
+    ) {
+      addImportsForNativeName(typeAnnotation.elementType.name);
+    }
+    if (typeAnnotation.type === 'MixedTypeAnnotation') {
+      imports.add('#include <folly/dynamic.h>');
+    }
+    if (typeAnnotation.type === 'ObjectTypeAnnotation') {
+      const objectImports = getImports(typeAnnotation.properties);
+      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+      objectImports.forEach(imports.add, imports);
+    }
+  });
+  return imports;
+}
+function generateEventStructName(parts = []) {
+  return parts.map(toSafeCppString).join('');
+}
+function generateStructName(componentName, parts = []) {
+  const additional = parts.map(toSafeCppString).join('');
+  return `${componentName}${additional}Struct`;
+}
+function getEnumMaskName(enumName) {
+  return `${enumName}Mask`;
+}
+function getDefaultInitializerString(componentName, prop) {
+  const defaultValue = convertDefaultTypeToString(componentName, prop);
+  return `{${defaultValue}}`;
+}
+function convertDefaultTypeToString(componentName, prop, fromBuilder = false) {
+  const typeAnnotation = prop.typeAnnotation;
+  switch (typeAnnotation.type) {
+    case 'BooleanTypeAnnotation':
+      if (typeAnnotation.default == null) {
+        return '';
+      }
+      return String(typeAnnotation.default);
+    case 'StringTypeAnnotation':
+      if (typeAnnotation.default == null) {
+        return '';
+      }
+      return `std::string{"${typeAnnotation.default}"}`;
+    case 'Int32TypeAnnotation':
+      return String(typeAnnotation.default);
+    case 'DoubleTypeAnnotation':
+      const defaultDoubleVal = typeAnnotation.default;
+      return parseInt(defaultDoubleVal, 10) === defaultDoubleVal
+        ? typeAnnotation.default.toFixed(1)
+        : String(typeAnnotation.default);
+    case 'FloatTypeAnnotation':
+      const defaultFloatVal = typeAnnotation.default;
+      if (defaultFloatVal == null) {
+        return '';
+      }
+      return parseInt(defaultFloatVal, 10) === defaultFloatVal
+        ? defaultFloatVal.toFixed(1)
+        : String(typeAnnotation.default);
+    case 'ReservedPropTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'ColorPrimitive':
+          return '';
+        case 'ImageSourcePrimitive':
+          return '';
+        case 'ImageRequestPrimitive':
+          return '';
+        case 'PointPrimitive':
+          return '';
+        case 'EdgeInsetsPrimitive':
+          return '';
+        case 'DimensionPrimitive':
+          return '';
+        default:
+          typeAnnotation.name;
+          throw new Error(
+            `Unsupported type annotation: ${typeAnnotation.name}`,
+          );
+      }
+    case 'ArrayTypeAnnotation': {
+      const elementType = typeAnnotation.elementType;
+      switch (elementType.type) {
+        case 'StringEnumTypeAnnotation':
+          if (elementType.default == null) {
+            throw new Error(
+              'A default is required for array StringEnumTypeAnnotation',
+            );
+          }
+          const enumName = getEnumName(componentName, prop.name);
+          const enumMaskName = getEnumMaskName(enumName);
+          const defaultValue = `${enumName}::${toSafeCppString(elementType.default)}`;
+          if (fromBuilder) {
+            return `${enumMaskName}Wrapped{ .value = static_cast<${enumMaskName}>(${defaultValue})}`;
+          }
+          return `static_cast<${enumMaskName}>(${defaultValue})`;
+        default:
+          return '';
+      }
+    }
+    case 'ObjectTypeAnnotation': {
+      return '';
+    }
+    case 'StringEnumTypeAnnotation':
+      return `${getEnumName(componentName, prop.name)}::${toSafeCppString(typeAnnotation.default)}`;
+    case 'Int32EnumTypeAnnotation':
+      return `${getEnumName(componentName, prop.name)}::${toIntEnumValueName(prop.name, typeAnnotation.default)}`;
+    case 'MixedTypeAnnotation':
+      return '';
+    default:
+      typeAnnotation;
+      throw new Error(`Unsupported type annotation: ${typeAnnotation.type}`);
+  }
+}
+function getSourceProp(componentName, prop) {
+  const typeAnnotation = prop.typeAnnotation;
+  switch (typeAnnotation.type) {
+    case 'ArrayTypeAnnotation':
+      const elementType = typeAnnotation.elementType;
+      switch (elementType.type) {
+        case 'StringEnumTypeAnnotation':
+          const enumName = getEnumName(componentName, prop.name);
+          const enumMaskName = getEnumMaskName(enumName);
+          return `${enumMaskName}Wrapped{ .value = sourceProps.${prop.name} }`;
+      }
+  }
+  return `sourceProps.${prop.name}`;
+}
+function isWrappedPropType(prop) {
+  const typeAnnotation = prop.typeAnnotation;
+  switch (typeAnnotation.type) {
+    case 'ArrayTypeAnnotation':
+      const elementType = typeAnnotation.elementType;
+      switch (elementType.type) {
+        case 'StringEnumTypeAnnotation':
+          return true;
+      }
+  }
+  return false;
+}
+const IncludeTemplate = ({headerPrefix, file}) => {
+  if (headerPrefix === '') {
+    return `#include "${file}"`;
+  }
+  return `#include <${headerPrefix}${file}>`;
+};
+module.exports = {
+  getDefaultInitializerString,
+  convertDefaultTypeToString,
+  getCppArrayTypeForAnnotation,
+  getCppTypeForAnnotation,
+  getEnumMaskName,
+  getImports,
+  toIntEnumValueName,
+  generateStructName,
+  generateEventStructName,
+  IncludeTemplate,
+  getSourceProp,
+  isWrappedPropType,
+};

node_modules/@react-native/codegen/lib/generators/components/CppHelpers.js.flow

@@ -0,0 +1,328 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+import type {
+  EventTypeAnnotation,
+  NamedShape,
+  PropTypeAnnotation,
+} from '../../CodegenSchema';
+
+const {getEnumName, toSafeCppString} = require('../Utils');
+
+function toIntEnumValueName(propName: string, value: number): string {
+  return `${toSafeCppString(propName)}${value}`;
+}
+
+function getCppTypeForAnnotation(
+  type:
+    | 'BooleanTypeAnnotation'
+    | 'StringTypeAnnotation'
+    | 'Int32TypeAnnotation'
+    | 'DoubleTypeAnnotation'
+    | 'FloatTypeAnnotation'
+    | 'MixedTypeAnnotation',
+): string {
+  switch (type) {
+    case 'BooleanTypeAnnotation':
+      return 'bool';
+    case 'StringTypeAnnotation':
+      return 'std::string';
+    case 'Int32TypeAnnotation':
+      return 'int';
+    case 'DoubleTypeAnnotation':
+      return 'double';
+    case 'FloatTypeAnnotation':
+      return 'Float';
+    case 'MixedTypeAnnotation':
+      return 'folly::dynamic';
+    default:
+      (type: empty);
+      throw new Error(`Received invalid typeAnnotation ${type}`);
+  }
+}
+
+function getCppArrayTypeForAnnotation(
+  typeElement: EventTypeAnnotation,
+  structParts?: string[],
+): string {
+  switch (typeElement.type) {
+    case 'BooleanTypeAnnotation':
+    case 'StringTypeAnnotation':
+    case 'DoubleTypeAnnotation':
+    case 'FloatTypeAnnotation':
+    case 'Int32TypeAnnotation':
+    case 'MixedTypeAnnotation':
+      return `std::vector<${getCppTypeForAnnotation(typeElement.type)}>`;
+    case 'StringLiteralUnionTypeAnnotation':
+    case 'ObjectTypeAnnotation':
+      if (!structParts) {
+        throw new Error(
+          `Trying to generate the event emitter for an Array of ${typeElement.type} without informations to generate the generic type`,
+        );
+      }
+      return `std::vector<${generateEventStructName(structParts)}>`;
+    case 'ArrayTypeAnnotation':
+      return `std::vector<${getCppArrayTypeForAnnotation(
+        typeElement.elementType,
+        structParts,
+      )}>`;
+    default:
+      throw new Error(
+        `Can't determine array type with typeElement: ${JSON.stringify(
+          typeElement,
+          null,
+          2,
+        )}`,
+      );
+  }
+}
+
+function getImports(
+  properties:
+    | $ReadOnlyArray<NamedShape<PropTypeAnnotation>>
+    | $ReadOnlyArray<NamedShape<EventTypeAnnotation>>,
+): Set<string> {
+  const imports: Set<string> = new Set();
+
+  function addImportsForNativeName(
+    name:
+      | 'ColorPrimitive'
+      | 'EdgeInsetsPrimitive'
+      | 'ImageRequestPrimitive'
+      | 'ImageSourcePrimitive'
+      | 'PointPrimitive'
+      | 'DimensionPrimitive',
+  ) {
+    switch (name) {
+      case 'ColorPrimitive':
+        return;
+      case 'PointPrimitive':
+        return;
+      case 'EdgeInsetsPrimitive':
+        return;
+      case 'ImageRequestPrimitive':
+        return;
+      case 'ImageSourcePrimitive':
+        imports.add('#include <react/renderer/components/image/conversions.h>');
+        return;
+      case 'DimensionPrimitive':
+        imports.add('#include <react/renderer/components/view/conversions.h>');
+        return;
+      default:
+        (name: empty);
+        throw new Error(`Invalid name, got ${name}`);
+    }
+  }
+
+  properties.forEach(prop => {
+    const typeAnnotation = prop.typeAnnotation;
+
+    if (typeAnnotation.type === 'ReservedPropTypeAnnotation') {
+      addImportsForNativeName(typeAnnotation.name);
+    }
+
+    if (
+      typeAnnotation.type === 'ArrayTypeAnnotation' &&
+      typeAnnotation.elementType.type === 'ReservedPropTypeAnnotation'
+    ) {
+      addImportsForNativeName(typeAnnotation.elementType.name);
+    }
+
+    if (typeAnnotation.type === 'MixedTypeAnnotation') {
+      imports.add('#include <folly/dynamic.h>');
+    }
+
+    if (typeAnnotation.type === 'ObjectTypeAnnotation') {
+      const objectImports = getImports(typeAnnotation.properties);
+      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+      objectImports.forEach(imports.add, imports);
+    }
+  });
+
+  return imports;
+}
+
+function generateEventStructName(parts: $ReadOnlyArray<string> = []): string {
+  return parts.map(toSafeCppString).join('');
+}
+
+function generateStructName(
+  componentName: string,
+  parts: $ReadOnlyArray<string> = [],
+): string {
+  const additional = parts.map(toSafeCppString).join('');
+  return `${componentName}${additional}Struct`;
+}
+
+function getEnumMaskName(enumName: string): string {
+  return `${enumName}Mask`;
+}
+
+function getDefaultInitializerString(
+  componentName: string,
+  prop: NamedShape<PropTypeAnnotation>,
+): string {
+  const defaultValue = convertDefaultTypeToString(componentName, prop);
+  return `{${defaultValue}}`;
+}
+
+function convertDefaultTypeToString(
+  componentName: string,
+  prop: NamedShape<PropTypeAnnotation>,
+  fromBuilder: boolean = false,
+): string {
+  const typeAnnotation = prop.typeAnnotation;
+  switch (typeAnnotation.type) {
+    case 'BooleanTypeAnnotation':
+      if (typeAnnotation.default == null) {
+        return '';
+      }
+      return String(typeAnnotation.default);
+    case 'StringTypeAnnotation':
+      if (typeAnnotation.default == null) {
+        return '';
+      }
+      return `std::string{"${typeAnnotation.default}"}`;
+    case 'Int32TypeAnnotation':
+      return String(typeAnnotation.default);
+    case 'DoubleTypeAnnotation':
+      const defaultDoubleVal = typeAnnotation.default;
+      return parseInt(defaultDoubleVal, 10) === defaultDoubleVal
+        ? typeAnnotation.default.toFixed(1)
+        : String(typeAnnotation.default);
+    case 'FloatTypeAnnotation':
+      const defaultFloatVal = typeAnnotation.default;
+      if (defaultFloatVal == null) {
+        return '';
+      }
+      return parseInt(defaultFloatVal, 10) === defaultFloatVal
+        ? defaultFloatVal.toFixed(1)
+        : String(typeAnnotation.default);
+    case 'ReservedPropTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'ColorPrimitive':
+          return '';
+        case 'ImageSourcePrimitive':
+          return '';
+        case 'ImageRequestPrimitive':
+          return '';
+        case 'PointPrimitive':
+          return '';
+        case 'EdgeInsetsPrimitive':
+          return '';
+        case 'DimensionPrimitive':
+          return '';
+        default:
+          (typeAnnotation.name: empty);
+          throw new Error(
+            `Unsupported type annotation: ${typeAnnotation.name}`,
+          );
+      }
+    case 'ArrayTypeAnnotation': {
+      const elementType = typeAnnotation.elementType;
+      switch (elementType.type) {
+        case 'StringEnumTypeAnnotation':
+          if (elementType.default == null) {
+            throw new Error(
+              'A default is required for array StringEnumTypeAnnotation',
+            );
+          }
+          const enumName = getEnumName(componentName, prop.name);
+          const enumMaskName = getEnumMaskName(enumName);
+          const defaultValue = `${enumName}::${toSafeCppString(
+            elementType.default,
+          )}`;
+          if (fromBuilder) {
+            return `${enumMaskName}Wrapped{ .value = static_cast<${enumMaskName}>(${defaultValue})}`;
+          }
+          return `static_cast<${enumMaskName}>(${defaultValue})`;
+        default:
+          return '';
+      }
+    }
+    case 'ObjectTypeAnnotation': {
+      return '';
+    }
+    case 'StringEnumTypeAnnotation':
+      return `${getEnumName(componentName, prop.name)}::${toSafeCppString(
+        typeAnnotation.default,
+      )}`;
+    case 'Int32EnumTypeAnnotation':
+      return `${getEnumName(componentName, prop.name)}::${toIntEnumValueName(
+        prop.name,
+        typeAnnotation.default,
+      )}`;
+    case 'MixedTypeAnnotation':
+      return '';
+    default:
+      (typeAnnotation: empty);
+      throw new Error(`Unsupported type annotation: ${typeAnnotation.type}`);
+  }
+}
+
+function getSourceProp(
+  componentName: string,
+  prop: NamedShape<PropTypeAnnotation>,
+): string {
+  const typeAnnotation = prop.typeAnnotation;
+  switch (typeAnnotation.type) {
+    case 'ArrayTypeAnnotation':
+      const elementType = typeAnnotation.elementType;
+      switch (elementType.type) {
+        case 'StringEnumTypeAnnotation':
+          const enumName = getEnumName(componentName, prop.name);
+          const enumMaskName = getEnumMaskName(enumName);
+          return `${enumMaskName}Wrapped{ .value = sourceProps.${prop.name} }`;
+      }
+  }
+  return `sourceProps.${prop.name}`;
+}
+
+function isWrappedPropType(prop: NamedShape<PropTypeAnnotation>): boolean {
+  const typeAnnotation = prop.typeAnnotation;
+  switch (typeAnnotation.type) {
+    case 'ArrayTypeAnnotation':
+      const elementType = typeAnnotation.elementType;
+      switch (elementType.type) {
+        case 'StringEnumTypeAnnotation':
+          return true;
+      }
+  }
+  return false;
+}
+
+const IncludeTemplate = ({
+  headerPrefix,
+  file,
+}: {
+  headerPrefix: string,
+  file: string,
+}): string => {
+  if (headerPrefix === '') {
+    return `#include "${file}"`;
+  }
+  return `#include <${headerPrefix}${file}>`;
+};
+
+module.exports = {
+  getDefaultInitializerString,
+  convertDefaultTypeToString,
+  getCppArrayTypeForAnnotation,
+  getCppTypeForAnnotation,
+  getEnumMaskName,
+  getImports,
+  toIntEnumValueName,
+  generateStructName,
+  generateEventStructName,
+  IncludeTemplate,
+  getSourceProp,
+  isWrappedPropType,
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateComponentDescriptorCpp.js

@@ -0,0 +1,89 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+const {IncludeTemplate} = require('./CppHelpers');
+
+// File path -> contents
+
+const FileTemplate = ({libraryName, componentRegistrations, headerPrefix}) => `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by codegen project: GenerateComponentDescriptorCpp.js
+ */
+
+${IncludeTemplate({
+  headerPrefix,
+  file: 'ComponentDescriptors.h',
+})}
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
+
+namespace facebook::react {
+
+void ${libraryName}_registerComponentDescriptorsFromCodegen(
+  std::shared_ptr<const ComponentDescriptorProviderRegistry> registry) {
+${componentRegistrations}
+}
+
+} // namespace facebook::react
+`;
+const ComponentRegistrationTemplate = ({className}) =>
+  `
+registry->add(concreteComponentDescriptorProvider<${className}ComponentDescriptor>());
+`.trim();
+module.exports = {
+  generate(
+    libraryName,
+    schema,
+    packageName,
+    assumeNonnull = false,
+    headerPrefix,
+    includeGetDebugPropsImplementation = false,
+  ) {
+    const fileName = 'ComponentDescriptors.cpp';
+    const componentRegistrations = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+        const {components} = module;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+        return Object.keys(components)
+          .map(componentName => {
+            if (components[componentName].interfaceOnly === true) {
+              return;
+            }
+            return ComponentRegistrationTemplate({
+              className: componentName,
+            });
+          })
+          .join('\n');
+      })
+      .filter(Boolean)
+      .join('\n');
+    const replacedTemplate = FileTemplate({
+      libraryName,
+      componentRegistrations,
+      headerPrefix:
+        headerPrefix !== null && headerPrefix !== void 0 ? headerPrefix : '',
+    });
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateComponentDescriptorCpp.js.flow

@@ -0,0 +1,102 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import type {SchemaType} from '../../CodegenSchema';
+
+const {IncludeTemplate} = require('./CppHelpers');
+
+// File path -> contents
+type FilesOutput = Map<string, string>;
+
+const FileTemplate = ({
+  libraryName,
+  componentRegistrations,
+  headerPrefix,
+}: {
+  libraryName: string,
+  componentRegistrations: string,
+  headerPrefix: string,
+}) => `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by codegen project: GenerateComponentDescriptorCpp.js
+ */
+
+${IncludeTemplate({headerPrefix, file: 'ComponentDescriptors.h'})}
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
+
+namespace facebook::react {
+
+void ${libraryName}_registerComponentDescriptorsFromCodegen(
+  std::shared_ptr<const ComponentDescriptorProviderRegistry> registry) {
+${componentRegistrations}
+}
+
+} // namespace facebook::react
+`;
+
+const ComponentRegistrationTemplate = ({className}: {className: string}) =>
+  `
+registry->add(concreteComponentDescriptorProvider<${className}ComponentDescriptor>());
+`.trim();
+
+module.exports = {
+  generate(
+    libraryName: string,
+    schema: SchemaType,
+    packageName?: string,
+    assumeNonnull: boolean = false,
+    headerPrefix?: string,
+    includeGetDebugPropsImplementation?: boolean = false,
+  ): FilesOutput {
+    const fileName = 'ComponentDescriptors.cpp';
+
+    const componentRegistrations = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+
+        const {components} = module;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+
+        return Object.keys(components)
+          .map(componentName => {
+            if (components[componentName].interfaceOnly === true) {
+              return;
+            }
+
+            return ComponentRegistrationTemplate({className: componentName});
+          })
+          .join('\n');
+      })
+      .filter(Boolean)
+      .join('\n');
+
+    const replacedTemplate = FileTemplate({
+      libraryName,
+      componentRegistrations,
+      headerPrefix: headerPrefix ?? '',
+    });
+
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateComponentDescriptorH.js

@@ -0,0 +1,91 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+const {IncludeTemplate} = require('./CppHelpers');
+
+// File path -> contents
+
+const FileTemplate = ({libraryName, componentDefinitions, headerPrefix}) => `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by codegen project: GenerateComponentDescriptorH.js
+ */
+
+#pragma once
+
+${IncludeTemplate({
+  headerPrefix,
+  file: 'ShadowNodes.h',
+})}
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
+
+namespace facebook::react {
+
+${componentDefinitions}
+
+void ${libraryName}_registerComponentDescriptorsFromCodegen(
+  std::shared_ptr<const ComponentDescriptorProviderRegistry> registry);
+
+} // namespace facebook::react
+`;
+const ComponentDefinitionTemplate = ({className}) =>
+  `
+using ${className}ComponentDescriptor = ConcreteComponentDescriptor<${className}ShadowNode>;
+`.trim();
+module.exports = {
+  generate(
+    libraryName,
+    schema,
+    packageName,
+    assumeNonnull = false,
+    headerPrefix,
+    includeGetDebugPropsImplementation = false,
+  ) {
+    const fileName = 'ComponentDescriptors.h';
+    const componentDefinitions = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+        const {components} = module;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+        return Object.keys(components)
+          .map(componentName => {
+            if (components[componentName].interfaceOnly === true) {
+              return;
+            }
+            return ComponentDefinitionTemplate({
+              className: componentName,
+            });
+          })
+          .join('\n');
+      })
+      .filter(Boolean)
+      .join('\n');
+    const replacedTemplate = FileTemplate({
+      libraryName,
+      componentDefinitions,
+      headerPrefix:
+        headerPrefix !== null && headerPrefix !== void 0 ? headerPrefix : '',
+    });
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateComponentDescriptorH.js.flow

@@ -0,0 +1,104 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import type {SchemaType} from '../../CodegenSchema';
+
+const {IncludeTemplate} = require('./CppHelpers');
+
+// File path -> contents
+type FilesOutput = Map<string, string>;
+
+const FileTemplate = ({
+  libraryName,
+  componentDefinitions,
+  headerPrefix,
+}: {
+  libraryName: string,
+  componentDefinitions: string,
+  headerPrefix: string,
+}) => `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by codegen project: GenerateComponentDescriptorH.js
+ */
+
+#pragma once
+
+${IncludeTemplate({headerPrefix, file: 'ShadowNodes.h'})}
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
+
+namespace facebook::react {
+
+${componentDefinitions}
+
+void ${libraryName}_registerComponentDescriptorsFromCodegen(
+  std::shared_ptr<const ComponentDescriptorProviderRegistry> registry);
+
+} // namespace facebook::react
+`;
+
+const ComponentDefinitionTemplate = ({className}: {className: string}) =>
+  `
+using ${className}ComponentDescriptor = ConcreteComponentDescriptor<${className}ShadowNode>;
+`.trim();
+
+module.exports = {
+  generate(
+    libraryName: string,
+    schema: SchemaType,
+    packageName?: string,
+    assumeNonnull: boolean = false,
+    headerPrefix?: string,
+    includeGetDebugPropsImplementation?: boolean = false,
+  ): FilesOutput {
+    const fileName = 'ComponentDescriptors.h';
+
+    const componentDefinitions = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+
+        const {components} = module;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+
+        return Object.keys(components)
+          .map(componentName => {
+            if (components[componentName].interfaceOnly === true) {
+              return;
+            }
+
+            return ComponentDefinitionTemplate({className: componentName});
+          })
+          .join('\n');
+      })
+      .filter(Boolean)
+      .join('\n');
+
+    const replacedTemplate = FileTemplate({
+      libraryName,
+      componentDefinitions,
+      headerPrefix: headerPrefix ?? '',
+    });
+
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateComponentHObjCpp.js

@@ -0,0 +1,338 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+function getOrdinalNumber(num) {
+  switch (num) {
+    case 1:
+      return '1st';
+    case 2:
+      return '2nd';
+    case 3:
+      return '3rd';
+  }
+  if (num <= 20) {
+    return `${num}th`;
+  }
+  return 'unknown';
+}
+const ProtocolTemplate = ({componentName, methods}) =>
+  `
+@protocol RCT${componentName}ViewProtocol <NSObject>
+${methods}
+@end
+`.trim();
+const CommandHandlerIfCaseConvertArgTemplate = ({
+  componentName,
+  expectedKind,
+  argNumber,
+  argNumberString,
+  expectedKindString,
+  argConversion,
+}) =>
+  `
+  NSObject *arg${argNumber} = args[${argNumber}];
+#if RCT_DEBUG
+  if (!RCTValidateTypeOfViewCommandArgument(arg${argNumber}, ${expectedKind}, @"${expectedKindString}", @"${componentName}", commandName, @"${argNumberString}")) {
+    return;
+  }
+#endif
+  ${argConversion}
+`.trim();
+const CommandHandlerIfCaseTemplate = ({
+  componentName,
+  commandName,
+  numArgs,
+  convertArgs,
+  commandCall,
+}) =>
+  `
+if ([commandName isEqualToString:@"${commandName}"]) {
+#if RCT_DEBUG
+  if ([args count] != ${numArgs}) {
+    RCTLogError(@"%@ command %@ received %d arguments, expected %d.", @"${componentName}", commandName, (int)[args count], ${numArgs});
+    return;
+  }
+#endif
+
+  ${convertArgs}
+
+  ${commandCall}
+  return;
+}
+`.trim();
+const CommandHandlerTemplate = ({componentName, ifCases}) =>
+  `
+RCT_EXTERN inline void RCT${componentName}HandleCommand(
+  id<RCT${componentName}ViewProtocol> componentView,
+  NSString const *commandName,
+  NSArray const *args)
+{
+  ${ifCases}
+
+#if RCT_DEBUG
+  RCTLogError(@"%@ received command %@, which is not a supported command.", @"${componentName}", commandName);
+#endif
+}
+`.trim();
+const FileTemplate = ({componentContent}) =>
+  `
+/**
+* This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+*
+* Do not edit this file as changes may cause incorrect behavior and will be lost
+* once the code is regenerated.
+*
+* ${'@'}generated by codegen project: GenerateComponentHObjCpp.js
+*/
+
+#import <Foundation/Foundation.h>
+#import <React/RCTDefines.h>
+#import <React/RCTLog.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+${componentContent}
+
+NS_ASSUME_NONNULL_END
+`.trim();
+function getObjCParamType(param) {
+  const {typeAnnotation} = param;
+  switch (typeAnnotation.type) {
+    case 'ReservedTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'RootTag':
+          return 'double';
+        default:
+          typeAnnotation.name;
+          throw new Error(`Receieved invalid type: ${typeAnnotation.name}`);
+      }
+    case 'BooleanTypeAnnotation':
+      return 'BOOL';
+    case 'DoubleTypeAnnotation':
+      return 'double';
+    case 'FloatTypeAnnotation':
+      return 'float';
+    case 'Int32TypeAnnotation':
+      return 'NSInteger';
+    case 'StringTypeAnnotation':
+      return 'NSString *';
+    case 'ArrayTypeAnnotation':
+      return 'const NSArray *';
+    default:
+      typeAnnotation.type;
+      throw new Error('Received invalid param type annotation');
+  }
+}
+function getObjCExpectedKindParamType(param) {
+  const {typeAnnotation} = param;
+  switch (typeAnnotation.type) {
+    case 'ReservedTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'RootTag':
+          return '[NSNumber class]';
+        default:
+          typeAnnotation.name;
+          throw new Error(`Receieved invalid type: ${typeAnnotation.name}`);
+      }
+    case 'BooleanTypeAnnotation':
+      return '[NSNumber class]';
+    case 'DoubleTypeAnnotation':
+      return '[NSNumber class]';
+    case 'FloatTypeAnnotation':
+      return '[NSNumber class]';
+    case 'Int32TypeAnnotation':
+      return '[NSNumber class]';
+    case 'StringTypeAnnotation':
+      return '[NSString class]';
+    case 'ArrayTypeAnnotation':
+      return '[NSArray class]';
+    default:
+      typeAnnotation.type;
+      throw new Error('Received invalid param type annotation');
+  }
+}
+function getReadableExpectedKindParamType(param) {
+  const {typeAnnotation} = param;
+  switch (typeAnnotation.type) {
+    case 'ReservedTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'RootTag':
+          return 'double';
+        default:
+          typeAnnotation.name;
+          throw new Error(`Receieved invalid type: ${typeAnnotation.name}`);
+      }
+    case 'BooleanTypeAnnotation':
+      return 'boolean';
+    case 'DoubleTypeAnnotation':
+      return 'double';
+    case 'FloatTypeAnnotation':
+      return 'float';
+    case 'Int32TypeAnnotation':
+      return 'number';
+    case 'StringTypeAnnotation':
+      return 'string';
+    case 'ArrayTypeAnnotation':
+      return 'array';
+    default:
+      typeAnnotation.type;
+      throw new Error('Received invalid param type annotation');
+  }
+}
+function getObjCRightHandAssignmentParamType(param, index) {
+  const {typeAnnotation} = param;
+  switch (typeAnnotation.type) {
+    case 'ReservedTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'RootTag':
+          return `[(NSNumber *)arg${index} doubleValue]`;
+        default:
+          typeAnnotation.name;
+          throw new Error(`Receieved invalid type: ${typeAnnotation.name}`);
+      }
+    case 'BooleanTypeAnnotation':
+      return `[(NSNumber *)arg${index} boolValue]`;
+    case 'DoubleTypeAnnotation':
+      return `[(NSNumber *)arg${index} doubleValue]`;
+    case 'FloatTypeAnnotation':
+      return `[(NSNumber *)arg${index} floatValue]`;
+    case 'Int32TypeAnnotation':
+      return `[(NSNumber *)arg${index} intValue]`;
+    case 'StringTypeAnnotation':
+      return `(NSString *)arg${index}`;
+    case 'ArrayTypeAnnotation':
+      return `(NSArray *)arg${index}`;
+    default:
+      typeAnnotation.type;
+      throw new Error('Received invalid param type annotation');
+  }
+}
+function generateProtocol(component, componentName) {
+  const methods = component.commands
+    .map(command => {
+      const params = command.typeAnnotation.params;
+      const paramString =
+        params.length === 0
+          ? ''
+          : params
+              .map((param, index) => {
+                const objCType = getObjCParamType(param);
+                return `${index === 0 ? '' : param.name}:(${objCType})${param.name}`;
+              })
+              .join(' ');
+      return `- (void)${command.name}${paramString};`;
+    })
+    .join('\n')
+    .trim();
+  return ProtocolTemplate({
+    componentName,
+    methods,
+  });
+}
+function generateConvertAndValidateParam(param, index, componentName) {
+  const leftSideType = getObjCParamType(param);
+  const expectedKind = getObjCExpectedKindParamType(param);
+  const expectedKindString = getReadableExpectedKindParamType(param);
+  const argConversion = `${leftSideType} ${param.name} = ${getObjCRightHandAssignmentParamType(param, index)};`;
+  return CommandHandlerIfCaseConvertArgTemplate({
+    componentName,
+    argConversion,
+    argNumber: index,
+    argNumberString: getOrdinalNumber(index + 1),
+    expectedKind,
+    expectedKindString,
+  });
+}
+function generateCommandIfCase(command, componentName) {
+  const params = command.typeAnnotation.params;
+  const convertArgs = params
+    .map((param, index) =>
+      generateConvertAndValidateParam(param, index, componentName),
+    )
+    .join('\n\n')
+    .trim();
+  const commandCallArgs =
+    params.length === 0
+      ? ''
+      : params
+          .map((param, index) => {
+            return `${index === 0 ? '' : param.name}:${param.name}`;
+          })
+          .join(' ');
+  const commandCall = `[componentView ${command.name}${commandCallArgs}];`;
+  return CommandHandlerIfCaseTemplate({
+    componentName,
+    commandName: command.name,
+    numArgs: params.length,
+    convertArgs,
+    commandCall,
+  });
+}
+function generateCommandHandler(component, componentName) {
+  if (component.commands.length === 0) {
+    return null;
+  }
+  const ifCases = component.commands
+    .map(command => generateCommandIfCase(command, componentName))
+    .join('\n\n');
+  return CommandHandlerTemplate({
+    componentName,
+    ifCases,
+  });
+}
+module.exports = {
+  generate(
+    libraryName,
+    schema,
+    packageName,
+    assumeNonnull = false,
+    headerPrefix,
+    includeGetDebugPropsImplementation = false,
+  ) {
+    const fileName = 'RCTComponentViewHelpers.h';
+    const componentContent = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+        const {components} = module;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+        return Object.keys(components)
+          .filter(componentName => {
+            const component = components[componentName];
+            return !(
+              component.excludedPlatforms &&
+              component.excludedPlatforms.includes('iOS')
+            );
+          })
+          .map(componentName => {
+            return [
+              generateProtocol(components[componentName], componentName),
+              generateCommandHandler(components[componentName], componentName),
+            ]
+              .join('\n\n')
+              .trim();
+          })
+          .join('\n\n');
+      })
+      .filter(Boolean)
+      .join('\n\n');
+    const replacedTemplate = FileTemplate({
+      componentContent,
+    });
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateComponentHObjCpp.js.flow

@@ -0,0 +1,428 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import type {
+  CommandParamTypeAnnotation,
+  CommandTypeAnnotation,
+  ComponentShape,
+  NamedShape,
+  SchemaType,
+} from '../../CodegenSchema';
+
+type FilesOutput = Map<string, string>;
+
+function getOrdinalNumber(num: number): string {
+  switch (num) {
+    case 1:
+      return '1st';
+    case 2:
+      return '2nd';
+    case 3:
+      return '3rd';
+  }
+
+  if (num <= 20) {
+    return `${num}th`;
+  }
+
+  return 'unknown';
+}
+
+const ProtocolTemplate = ({
+  componentName,
+  methods,
+}: {
+  componentName: string,
+  methods: string,
+}) =>
+  `
+@protocol RCT${componentName}ViewProtocol <NSObject>
+${methods}
+@end
+`.trim();
+
+const CommandHandlerIfCaseConvertArgTemplate = ({
+  componentName,
+  expectedKind,
+  argNumber,
+  argNumberString,
+  expectedKindString,
+  argConversion,
+}: {
+  componentName: string,
+  expectedKind: string,
+  argNumber: number,
+  argNumberString: string,
+  expectedKindString: string,
+  argConversion: string,
+}) =>
+  `
+  NSObject *arg${argNumber} = args[${argNumber}];
+#if RCT_DEBUG
+  if (!RCTValidateTypeOfViewCommandArgument(arg${argNumber}, ${expectedKind}, @"${expectedKindString}", @"${componentName}", commandName, @"${argNumberString}")) {
+    return;
+  }
+#endif
+  ${argConversion}
+`.trim();
+
+const CommandHandlerIfCaseTemplate = ({
+  componentName,
+  commandName,
+  numArgs,
+  convertArgs,
+  commandCall,
+}: {
+  componentName: string,
+  commandName: string,
+  numArgs: number,
+  convertArgs: string,
+  commandCall: string,
+}) =>
+  `
+if ([commandName isEqualToString:@"${commandName}"]) {
+#if RCT_DEBUG
+  if ([args count] != ${numArgs}) {
+    RCTLogError(@"%@ command %@ received %d arguments, expected %d.", @"${componentName}", commandName, (int)[args count], ${numArgs});
+    return;
+  }
+#endif
+
+  ${convertArgs}
+
+  ${commandCall}
+  return;
+}
+`.trim();
+
+const CommandHandlerTemplate = ({
+  componentName,
+  ifCases,
+}: {
+  componentName: string,
+  ifCases: string,
+}) =>
+  `
+RCT_EXTERN inline void RCT${componentName}HandleCommand(
+  id<RCT${componentName}ViewProtocol> componentView,
+  NSString const *commandName,
+  NSArray const *args)
+{
+  ${ifCases}
+
+#if RCT_DEBUG
+  RCTLogError(@"%@ received command %@, which is not a supported command.", @"${componentName}", commandName);
+#endif
+}
+`.trim();
+
+const FileTemplate = ({componentContent}: {componentContent: string}) =>
+  `
+/**
+* This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+*
+* Do not edit this file as changes may cause incorrect behavior and will be lost
+* once the code is regenerated.
+*
+* ${'@'}generated by codegen project: GenerateComponentHObjCpp.js
+*/
+
+#import <Foundation/Foundation.h>
+#import <React/RCTDefines.h>
+#import <React/RCTLog.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+${componentContent}
+
+NS_ASSUME_NONNULL_END
+`.trim();
+
+type Param = NamedShape<CommandParamTypeAnnotation>;
+
+function getObjCParamType(param: Param): string {
+  const {typeAnnotation} = param;
+
+  switch (typeAnnotation.type) {
+    case 'ReservedTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'RootTag':
+          return 'double';
+        default:
+          (typeAnnotation.name: empty);
+          throw new Error(`Receieved invalid type: ${typeAnnotation.name}`);
+      }
+    case 'BooleanTypeAnnotation':
+      return 'BOOL';
+    case 'DoubleTypeAnnotation':
+      return 'double';
+    case 'FloatTypeAnnotation':
+      return 'float';
+    case 'Int32TypeAnnotation':
+      return 'NSInteger';
+    case 'StringTypeAnnotation':
+      return 'NSString *';
+    case 'ArrayTypeAnnotation':
+      return 'const NSArray *';
+    default:
+      (typeAnnotation.type: empty);
+      throw new Error('Received invalid param type annotation');
+  }
+}
+
+function getObjCExpectedKindParamType(param: Param): string {
+  const {typeAnnotation} = param;
+
+  switch (typeAnnotation.type) {
+    case 'ReservedTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'RootTag':
+          return '[NSNumber class]';
+        default:
+          (typeAnnotation.name: empty);
+          throw new Error(`Receieved invalid type: ${typeAnnotation.name}`);
+      }
+    case 'BooleanTypeAnnotation':
+      return '[NSNumber class]';
+    case 'DoubleTypeAnnotation':
+      return '[NSNumber class]';
+    case 'FloatTypeAnnotation':
+      return '[NSNumber class]';
+    case 'Int32TypeAnnotation':
+      return '[NSNumber class]';
+    case 'StringTypeAnnotation':
+      return '[NSString class]';
+    case 'ArrayTypeAnnotation':
+      return '[NSArray class]';
+    default:
+      (typeAnnotation.type: empty);
+      throw new Error('Received invalid param type annotation');
+  }
+}
+
+function getReadableExpectedKindParamType(param: Param): string {
+  const {typeAnnotation} = param;
+
+  switch (typeAnnotation.type) {
+    case 'ReservedTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'RootTag':
+          return 'double';
+        default:
+          (typeAnnotation.name: empty);
+          throw new Error(`Receieved invalid type: ${typeAnnotation.name}`);
+      }
+    case 'BooleanTypeAnnotation':
+      return 'boolean';
+    case 'DoubleTypeAnnotation':
+      return 'double';
+    case 'FloatTypeAnnotation':
+      return 'float';
+    case 'Int32TypeAnnotation':
+      return 'number';
+    case 'StringTypeAnnotation':
+      return 'string';
+    case 'ArrayTypeAnnotation':
+      return 'array';
+    default:
+      (typeAnnotation.type: empty);
+      throw new Error('Received invalid param type annotation');
+  }
+}
+
+function getObjCRightHandAssignmentParamType(
+  param: Param,
+  index: number,
+): string {
+  const {typeAnnotation} = param;
+
+  switch (typeAnnotation.type) {
+    case 'ReservedTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'RootTag':
+          return `[(NSNumber *)arg${index} doubleValue]`;
+        default:
+          (typeAnnotation.name: empty);
+          throw new Error(`Receieved invalid type: ${typeAnnotation.name}`);
+      }
+    case 'BooleanTypeAnnotation':
+      return `[(NSNumber *)arg${index} boolValue]`;
+    case 'DoubleTypeAnnotation':
+      return `[(NSNumber *)arg${index} doubleValue]`;
+    case 'FloatTypeAnnotation':
+      return `[(NSNumber *)arg${index} floatValue]`;
+    case 'Int32TypeAnnotation':
+      return `[(NSNumber *)arg${index} intValue]`;
+    case 'StringTypeAnnotation':
+      return `(NSString *)arg${index}`;
+    case 'ArrayTypeAnnotation':
+      return `(NSArray *)arg${index}`;
+    default:
+      (typeAnnotation.type: empty);
+      throw new Error('Received invalid param type annotation');
+  }
+}
+
+function generateProtocol(
+  component: ComponentShape,
+  componentName: string,
+): string {
+  const methods = component.commands
+    .map(command => {
+      const params = command.typeAnnotation.params;
+      const paramString =
+        params.length === 0
+          ? ''
+          : params
+              .map((param, index) => {
+                const objCType = getObjCParamType(param);
+
+                return `${index === 0 ? '' : param.name}:(${objCType})${
+                  param.name
+                }`;
+              })
+              .join(' ');
+      return `- (void)${command.name}${paramString};`;
+    })
+    .join('\n')
+    .trim();
+
+  return ProtocolTemplate({
+    componentName,
+    methods,
+  });
+}
+
+function generateConvertAndValidateParam(
+  param: Param,
+  index: number,
+  componentName: string,
+): string {
+  const leftSideType = getObjCParamType(param);
+  const expectedKind = getObjCExpectedKindParamType(param);
+  const expectedKindString = getReadableExpectedKindParamType(param);
+  const argConversion = `${leftSideType} ${
+    param.name
+  } = ${getObjCRightHandAssignmentParamType(param, index)};`;
+
+  return CommandHandlerIfCaseConvertArgTemplate({
+    componentName,
+    argConversion,
+    argNumber: index,
+    argNumberString: getOrdinalNumber(index + 1),
+    expectedKind,
+    expectedKindString,
+  });
+}
+
+function generateCommandIfCase(
+  command: NamedShape<CommandTypeAnnotation>,
+  componentName: string,
+) {
+  const params = command.typeAnnotation.params;
+
+  const convertArgs = params
+    .map((param, index) =>
+      generateConvertAndValidateParam(param, index, componentName),
+    )
+    .join('\n\n')
+    .trim();
+
+  const commandCallArgs =
+    params.length === 0
+      ? ''
+      : params
+          .map((param, index) => {
+            return `${index === 0 ? '' : param.name}:${param.name}`;
+          })
+          .join(' ');
+  const commandCall = `[componentView ${command.name}${commandCallArgs}];`;
+
+  return CommandHandlerIfCaseTemplate({
+    componentName,
+    commandName: command.name,
+    numArgs: params.length,
+    convertArgs,
+    commandCall,
+  });
+}
+
+function generateCommandHandler(
+  component: ComponentShape,
+  componentName: string,
+): ?string {
+  if (component.commands.length === 0) {
+    return null;
+  }
+
+  const ifCases = component.commands
+    .map(command => generateCommandIfCase(command, componentName))
+    .join('\n\n');
+
+  return CommandHandlerTemplate({
+    componentName,
+    ifCases,
+  });
+}
+
+module.exports = {
+  generate(
+    libraryName: string,
+    schema: SchemaType,
+    packageName?: string,
+    assumeNonnull: boolean = false,
+    headerPrefix?: string,
+    includeGetDebugPropsImplementation?: boolean = false,
+  ): FilesOutput {
+    const fileName = 'RCTComponentViewHelpers.h';
+
+    const componentContent = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+
+        const {components} = module;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+
+        return Object.keys(components)
+          .filter(componentName => {
+            const component = components[componentName];
+            return !(
+              component.excludedPlatforms &&
+              component.excludedPlatforms.includes('iOS')
+            );
+          })
+          .map(componentName => {
+            return [
+              generateProtocol(components[componentName], componentName),
+              generateCommandHandler(components[componentName], componentName),
+            ]
+              .join('\n\n')
+              .trim();
+          })
+          .join('\n\n');
+      })
+      .filter(Boolean)
+      .join('\n\n');
+
+    const replacedTemplate = FileTemplate({
+      componentContent,
+    });
+
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateEventEmitterCpp.js

@@ -0,0 +1,358 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+const {indent} = require('../Utils');
+const {IncludeTemplate, generateEventStructName} = require('./CppHelpers');
+
+// File path -> contents
+
+const FileTemplate = ({events, extraIncludes, headerPrefix}) => `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by codegen project: GenerateEventEmitterCpp.js
+ */
+
+${IncludeTemplate({
+  headerPrefix,
+  file: 'EventEmitters.h',
+})}
+${[...extraIncludes].join('\n')}
+
+namespace facebook::react {
+${events}
+} // namespace facebook::react
+`;
+const ComponentTemplate = ({
+  className,
+  eventName,
+  structName,
+  dispatchEventName,
+  implementation,
+}) => {
+  const capture = implementation.includes('event')
+    ? 'event=std::move(event)'
+    : '';
+  return `
+void ${className}EventEmitter::${eventName}(${structName} event) const {
+  dispatchEvent("${dispatchEventName}", [${capture}](jsi::Runtime &runtime) {
+    ${implementation}
+  });
+}
+`;
+};
+const BasicComponentTemplate = ({className, eventName, dispatchEventName}) =>
+  `
+void ${className}EventEmitter::${eventName}() const {
+  dispatchEvent("${dispatchEventName}");
+}
+`.trim();
+function generateSetter(
+  variableName,
+  propertyName,
+  propertyParts,
+  usingEvent,
+  valueMapper = value => value,
+) {
+  const eventChain = usingEvent
+    ? `event.${[...propertyParts, propertyName].join('.')}`
+    : [...propertyParts, propertyName].join('.');
+  return `${variableName}.setProperty(runtime, "${propertyName}", ${valueMapper(eventChain)});`;
+}
+function generateObjectSetter(
+  variableName,
+  propertyName,
+  propertyParts,
+  typeAnnotation,
+  extraIncludes,
+  usingEvent,
+) {
+  return `
+{
+  auto ${propertyName} = jsi::Object(runtime);
+  ${indent(generateSetters(propertyName, typeAnnotation.properties, propertyParts.concat([propertyName]), extraIncludes, usingEvent), 2)}
+  ${variableName}.setProperty(runtime, "${propertyName}", ${propertyName});
+}
+`.trim();
+}
+function setValueAtIndex(
+  propertyName,
+  indexVariable,
+  loopLocalVariable,
+  mappingFunction = value => value,
+) {
+  return `${propertyName}.setValueAtIndex(runtime, ${indexVariable}++, ${mappingFunction(loopLocalVariable)});`;
+}
+function generateArraySetter(
+  variableName,
+  propertyName,
+  propertyParts,
+  elementType,
+  extraIncludes,
+  usingEvent,
+) {
+  const eventChain = usingEvent
+    ? `event.${[...propertyParts, propertyName].join('.')}`
+    : [...propertyParts, propertyName].join('.');
+  const indexVar = `${propertyName}Index`;
+  const innerLoopVar = `${propertyName}Value`;
+  return `
+    auto ${propertyName} = jsi::Array(runtime, ${eventChain}.size());
+    size_t ${indexVar} = 0;
+    for (auto ${innerLoopVar} : ${eventChain}) {
+      ${handleArrayElementType(elementType, propertyName, indexVar, innerLoopVar, propertyParts, extraIncludes, usingEvent)}
+    }
+    ${variableName}.setProperty(runtime, "${propertyName}", ${propertyName});
+  `;
+}
+function handleArrayElementType(
+  elementType,
+  propertyName,
+  indexVariable,
+  loopLocalVariable,
+  propertyParts,
+  extraIncludes,
+  usingEvent,
+) {
+  switch (elementType.type) {
+    case 'BooleanTypeAnnotation':
+      return setValueAtIndex(
+        propertyName,
+        indexVariable,
+        loopLocalVariable,
+        val => `(bool)${val}`,
+      );
+    case 'StringTypeAnnotation':
+    case 'Int32TypeAnnotation':
+    case 'DoubleTypeAnnotation':
+    case 'FloatTypeAnnotation':
+      return setValueAtIndex(propertyName, indexVariable, loopLocalVariable);
+    case 'MixedTypeAnnotation':
+      return setValueAtIndex(
+        propertyName,
+        indexVariable,
+        loopLocalVariable,
+        val => `jsi::valueFromDynamic(runtime, ${val})`,
+      );
+    case 'StringLiteralUnionTypeAnnotation':
+      return setValueAtIndex(
+        propertyName,
+        indexVariable,
+        loopLocalVariable,
+        val => `toString(${val})`,
+      );
+    case 'ObjectTypeAnnotation':
+      return convertObjectTypeArray(
+        propertyName,
+        indexVariable,
+        loopLocalVariable,
+        propertyParts,
+        elementType,
+        extraIncludes,
+      );
+    case 'ArrayTypeAnnotation':
+      return convertArrayTypeArray(
+        propertyName,
+        indexVariable,
+        loopLocalVariable,
+        propertyParts,
+        elementType,
+        extraIncludes,
+        usingEvent,
+      );
+    default:
+      throw new Error(
+        `Received invalid elementType for array ${elementType.type}`,
+      );
+  }
+}
+function convertObjectTypeArray(
+  propertyName,
+  indexVariable,
+  loopLocalVariable,
+  propertyParts,
+  objectTypeAnnotation,
+  extraIncludes,
+) {
+  return `auto ${propertyName}Object = jsi::Object(runtime);
+      ${generateSetters(`${propertyName}Object`, objectTypeAnnotation.properties, [].concat([loopLocalVariable]), extraIncludes, false)}
+      ${setValueAtIndex(propertyName, indexVariable, `${propertyName}Object`)}`;
+}
+function convertArrayTypeArray(
+  propertyName,
+  indexVariable,
+  loopLocalVariable,
+  propertyParts,
+  eventTypeAnnotation,
+  extraIncludes,
+  usingEvent,
+) {
+  if (eventTypeAnnotation.type !== 'ArrayTypeAnnotation') {
+    throw new Error(
+      `Inconsistent eventTypeAnnotation received. Expected type = 'ArrayTypeAnnotation'; received = ${eventTypeAnnotation.type}`,
+    );
+  }
+  return `auto ${propertyName}Array = jsi::Array(runtime, ${loopLocalVariable}.size());
+      size_t ${indexVariable}Internal = 0;
+      for (auto ${loopLocalVariable}Internal : ${loopLocalVariable}) {
+        ${handleArrayElementType(eventTypeAnnotation.elementType, `${propertyName}Array`, `${indexVariable}Internal`, `${loopLocalVariable}Internal`, propertyParts, extraIncludes, usingEvent)}
+      }
+      ${setValueAtIndex(propertyName, indexVariable, `${propertyName}Array`)}`;
+}
+function generateSetters(
+  parentPropertyName,
+  properties,
+  propertyParts,
+  extraIncludes,
+  usingEvent = true,
+) {
+  const propSetters = properties
+    .map(eventProperty => {
+      const {typeAnnotation} = eventProperty;
+      switch (typeAnnotation.type) {
+        case 'BooleanTypeAnnotation':
+        case 'StringTypeAnnotation':
+        case 'Int32TypeAnnotation':
+        case 'DoubleTypeAnnotation':
+        case 'FloatTypeAnnotation':
+          return generateSetter(
+            parentPropertyName,
+            eventProperty.name,
+            propertyParts,
+            usingEvent,
+          );
+        case 'MixedTypeAnnotation':
+          extraIncludes.add('#include <jsi/JSIDynamic.h>');
+          return generateSetter(
+            parentPropertyName,
+            eventProperty.name,
+            propertyParts,
+            usingEvent,
+            prop => `jsi::valueFromDynamic(runtime, ${prop})`,
+          );
+        case 'StringLiteralUnionTypeAnnotation':
+          return generateSetter(
+            parentPropertyName,
+            eventProperty.name,
+            propertyParts,
+            usingEvent,
+            prop => `toString(${prop})`,
+          );
+        case 'ObjectTypeAnnotation':
+          return generateObjectSetter(
+            parentPropertyName,
+            eventProperty.name,
+            propertyParts,
+            typeAnnotation,
+            extraIncludes,
+            usingEvent,
+          );
+        case 'ArrayTypeAnnotation':
+          return generateArraySetter(
+            parentPropertyName,
+            eventProperty.name,
+            propertyParts,
+            typeAnnotation.elementType,
+            extraIncludes,
+            usingEvent,
+          );
+        default:
+          typeAnnotation.type;
+          throw new Error(
+            `Received invalid event property type ${typeAnnotation.type}`,
+          );
+      }
+    })
+    .join('\n');
+  return propSetters;
+}
+function generateEvent(componentName, event, extraIncludes) {
+  // This is a gross hack necessary because native code is sending
+  // events named things like topChange to JS which is then converted back to
+  // call the onChange prop. We should be consistent throughout the system.
+  // In order to migrate to this new system we have to support the current
+  // naming scheme. We should delete this once we are able to control this name
+  // throughout the system.
+  const dispatchEventName =
+    event.paperTopLevelNameDeprecated != null
+      ? event.paperTopLevelNameDeprecated
+      : `${event.name[2].toLowerCase()}${event.name.slice(3)}`;
+  if (event.typeAnnotation.argument) {
+    const implementation = `
+    auto payload = jsi::Object(runtime);
+    ${generateSetters('payload', event.typeAnnotation.argument.properties, [], extraIncludes)}
+    return payload;
+  `.trim();
+    if (!event.name.startsWith('on')) {
+      throw new Error('Expected the event name to start with `on`');
+    }
+    return ComponentTemplate({
+      className: componentName,
+      eventName: event.name,
+      dispatchEventName,
+      structName: generateEventStructName([event.name]),
+      implementation,
+    });
+  }
+  return BasicComponentTemplate({
+    className: componentName,
+    eventName: event.name,
+    dispatchEventName,
+  });
+}
+module.exports = {
+  generate(
+    libraryName,
+    schema,
+    packageName,
+    assumeNonnull = false,
+    headerPrefix,
+    includeGetDebugPropsImplementation = false,
+  ) {
+    const moduleComponents = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+        const {components} = module;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+        return components;
+      })
+      .filter(Boolean)
+      // $FlowFixMe[unsafe-object-assign]
+      .reduce((acc, components) => Object.assign(acc, components), {});
+    const extraIncludes = new Set();
+    const componentEmitters = Object.keys(moduleComponents)
+      .map(componentName => {
+        const component = moduleComponents[componentName];
+        return component.events
+          .map(event => generateEvent(componentName, event, extraIncludes))
+          .join('\n');
+      })
+      .join('\n');
+    const fileName = 'EventEmitters.cpp';
+    const replacedTemplate = FileTemplate({
+      events: componentEmitters,
+      extraIncludes,
+      headerPrefix:
+        headerPrefix !== null && headerPrefix !== void 0 ? headerPrefix : '',
+    });
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateEventEmitterCpp.js.flow

@@ -0,0 +1,456 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+import type {EventTypeShape} from '../../CodegenSchema';
+import type {
+  ComponentShape,
+  EventTypeAnnotation,
+  NamedShape,
+  ObjectTypeAnnotation,
+  SchemaType,
+} from '../../CodegenSchema';
+
+const {indent} = require('../Utils');
+const {IncludeTemplate, generateEventStructName} = require('./CppHelpers');
+
+// File path -> contents
+type FilesOutput = Map<string, string>;
+
+type ComponentCollection = $ReadOnly<{
+  [component: string]: ComponentShape,
+  ...
+}>;
+
+const FileTemplate = ({
+  events,
+  extraIncludes,
+  headerPrefix,
+}: {
+  events: string,
+  extraIncludes: Set<string>,
+  headerPrefix: string,
+}) => `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by codegen project: GenerateEventEmitterCpp.js
+ */
+
+${IncludeTemplate({headerPrefix, file: 'EventEmitters.h'})}
+${[...extraIncludes].join('\n')}
+
+namespace facebook::react {
+${events}
+} // namespace facebook::react
+`;
+
+const ComponentTemplate = ({
+  className,
+  eventName,
+  structName,
+  dispatchEventName,
+  implementation,
+}: {
+  className: string,
+  eventName: string,
+  structName: string,
+  dispatchEventName: string,
+  implementation: string,
+}) => {
+  const capture = implementation.includes('event')
+    ? 'event=std::move(event)'
+    : '';
+  return `
+void ${className}EventEmitter::${eventName}(${structName} event) const {
+  dispatchEvent("${dispatchEventName}", [${capture}](jsi::Runtime &runtime) {
+    ${implementation}
+  });
+}
+`;
+};
+
+const BasicComponentTemplate = ({
+  className,
+  eventName,
+  dispatchEventName,
+}: {
+  className: string,
+  eventName: string,
+  dispatchEventName: string,
+}) =>
+  `
+void ${className}EventEmitter::${eventName}() const {
+  dispatchEvent("${dispatchEventName}");
+}
+`.trim();
+
+function generateSetter(
+  variableName: string,
+  propertyName: string,
+  propertyParts: $ReadOnlyArray<string>,
+  usingEvent: boolean,
+  valueMapper: string => string = value => value,
+) {
+  const eventChain = usingEvent
+    ? `event.${[...propertyParts, propertyName].join('.')}`
+    : [...propertyParts, propertyName].join('.');
+  return `${variableName}.setProperty(runtime, "${propertyName}", ${valueMapper(
+    eventChain,
+  )});`;
+}
+
+function generateObjectSetter(
+  variableName: string,
+  propertyName: string,
+  propertyParts: $ReadOnlyArray<string>,
+  typeAnnotation: ObjectTypeAnnotation<EventTypeAnnotation>,
+  extraIncludes: Set<string>,
+  usingEvent: boolean,
+) {
+  return `
+{
+  auto ${propertyName} = jsi::Object(runtime);
+  ${indent(
+    generateSetters(
+      propertyName,
+      typeAnnotation.properties,
+      propertyParts.concat([propertyName]),
+      extraIncludes,
+      usingEvent,
+    ),
+    2,
+  )}
+  ${variableName}.setProperty(runtime, "${propertyName}", ${propertyName});
+}
+`.trim();
+}
+
+function setValueAtIndex(
+  propertyName: string,
+  indexVariable: string,
+  loopLocalVariable: string,
+  mappingFunction: string => string = value => value,
+) {
+  return `${propertyName}.setValueAtIndex(runtime, ${indexVariable}++, ${mappingFunction(
+    loopLocalVariable,
+  )});`;
+}
+
+function generateArraySetter(
+  variableName: string,
+  propertyName: string,
+  propertyParts: $ReadOnlyArray<string>,
+  elementType: EventTypeAnnotation,
+  extraIncludes: Set<string>,
+  usingEvent: boolean,
+): string {
+  const eventChain = usingEvent
+    ? `event.${[...propertyParts, propertyName].join('.')}`
+    : [...propertyParts, propertyName].join('.');
+  const indexVar = `${propertyName}Index`;
+  const innerLoopVar = `${propertyName}Value`;
+  return `
+    auto ${propertyName} = jsi::Array(runtime, ${eventChain}.size());
+    size_t ${indexVar} = 0;
+    for (auto ${innerLoopVar} : ${eventChain}) {
+      ${handleArrayElementType(
+        elementType,
+        propertyName,
+        indexVar,
+        innerLoopVar,
+        propertyParts,
+        extraIncludes,
+        usingEvent,
+      )}
+    }
+    ${variableName}.setProperty(runtime, "${propertyName}", ${propertyName});
+  `;
+}
+
+function handleArrayElementType(
+  elementType: EventTypeAnnotation,
+  propertyName: string,
+  indexVariable: string,
+  loopLocalVariable: string,
+  propertyParts: $ReadOnlyArray<string>,
+  extraIncludes: Set<string>,
+  usingEvent: boolean,
+): string {
+  switch (elementType.type) {
+    case 'BooleanTypeAnnotation':
+      return setValueAtIndex(
+        propertyName,
+        indexVariable,
+        loopLocalVariable,
+        val => `(bool)${val}`,
+      );
+    case 'StringTypeAnnotation':
+    case 'Int32TypeAnnotation':
+    case 'DoubleTypeAnnotation':
+    case 'FloatTypeAnnotation':
+      return setValueAtIndex(propertyName, indexVariable, loopLocalVariable);
+    case 'MixedTypeAnnotation':
+      return setValueAtIndex(
+        propertyName,
+        indexVariable,
+        loopLocalVariable,
+        val => `jsi::valueFromDynamic(runtime, ${val})`,
+      );
+    case 'StringLiteralUnionTypeAnnotation':
+      return setValueAtIndex(
+        propertyName,
+        indexVariable,
+        loopLocalVariable,
+        val => `toString(${val})`,
+      );
+    case 'ObjectTypeAnnotation':
+      return convertObjectTypeArray(
+        propertyName,
+        indexVariable,
+        loopLocalVariable,
+        propertyParts,
+        elementType,
+        extraIncludes,
+      );
+    case 'ArrayTypeAnnotation':
+      return convertArrayTypeArray(
+        propertyName,
+        indexVariable,
+        loopLocalVariable,
+        propertyParts,
+        elementType,
+        extraIncludes,
+        usingEvent,
+      );
+    default:
+      throw new Error(
+        `Received invalid elementType for array ${elementType.type}`,
+      );
+  }
+}
+
+function convertObjectTypeArray(
+  propertyName: string,
+  indexVariable: string,
+  loopLocalVariable: string,
+  propertyParts: $ReadOnlyArray<string>,
+  objectTypeAnnotation: ObjectTypeAnnotation<EventTypeAnnotation>,
+  extraIncludes: Set<string>,
+): string {
+  return `auto ${propertyName}Object = jsi::Object(runtime);
+      ${generateSetters(
+        `${propertyName}Object`,
+        objectTypeAnnotation.properties,
+        [].concat([loopLocalVariable]),
+        extraIncludes,
+        false,
+      )}
+      ${setValueAtIndex(propertyName, indexVariable, `${propertyName}Object`)}`;
+}
+
+function convertArrayTypeArray(
+  propertyName: string,
+  indexVariable: string,
+  loopLocalVariable: string,
+  propertyParts: $ReadOnlyArray<string>,
+  eventTypeAnnotation: EventTypeAnnotation,
+  extraIncludes: Set<string>,
+  usingEvent: boolean,
+): string {
+  if (eventTypeAnnotation.type !== 'ArrayTypeAnnotation') {
+    throw new Error(
+      `Inconsistent eventTypeAnnotation received. Expected type = 'ArrayTypeAnnotation'; received = ${eventTypeAnnotation.type}`,
+    );
+  }
+  return `auto ${propertyName}Array = jsi::Array(runtime, ${loopLocalVariable}.size());
+      size_t ${indexVariable}Internal = 0;
+      for (auto ${loopLocalVariable}Internal : ${loopLocalVariable}) {
+        ${handleArrayElementType(
+          eventTypeAnnotation.elementType,
+          `${propertyName}Array`,
+          `${indexVariable}Internal`,
+          `${loopLocalVariable}Internal`,
+          propertyParts,
+          extraIncludes,
+          usingEvent,
+        )}
+      }
+      ${setValueAtIndex(propertyName, indexVariable, `${propertyName}Array`)}`;
+}
+
+function generateSetters(
+  parentPropertyName: string,
+  properties: $ReadOnlyArray<NamedShape<EventTypeAnnotation>>,
+  propertyParts: $ReadOnlyArray<string>,
+  extraIncludes: Set<string>,
+  usingEvent: boolean = true,
+): string {
+  const propSetters = properties
+    .map(eventProperty => {
+      const {typeAnnotation} = eventProperty;
+      switch (typeAnnotation.type) {
+        case 'BooleanTypeAnnotation':
+        case 'StringTypeAnnotation':
+        case 'Int32TypeAnnotation':
+        case 'DoubleTypeAnnotation':
+        case 'FloatTypeAnnotation':
+          return generateSetter(
+            parentPropertyName,
+            eventProperty.name,
+            propertyParts,
+            usingEvent,
+          );
+        case 'MixedTypeAnnotation':
+          extraIncludes.add('#include <jsi/JSIDynamic.h>');
+          return generateSetter(
+            parentPropertyName,
+            eventProperty.name,
+            propertyParts,
+            usingEvent,
+            prop => `jsi::valueFromDynamic(runtime, ${prop})`,
+          );
+        case 'StringLiteralUnionTypeAnnotation':
+          return generateSetter(
+            parentPropertyName,
+            eventProperty.name,
+            propertyParts,
+            usingEvent,
+            prop => `toString(${prop})`,
+          );
+        case 'ObjectTypeAnnotation':
+          return generateObjectSetter(
+            parentPropertyName,
+            eventProperty.name,
+            propertyParts,
+            typeAnnotation,
+            extraIncludes,
+            usingEvent,
+          );
+        case 'ArrayTypeAnnotation':
+          return generateArraySetter(
+            parentPropertyName,
+            eventProperty.name,
+            propertyParts,
+            typeAnnotation.elementType,
+            extraIncludes,
+            usingEvent,
+          );
+        default:
+          (typeAnnotation.type: empty);
+          throw new Error(
+            `Received invalid event property type ${typeAnnotation.type}`,
+          );
+      }
+    })
+    .join('\n');
+
+  return propSetters;
+}
+
+function generateEvent(
+  componentName: string,
+  event: EventTypeShape,
+  extraIncludes: Set<string>,
+): string {
+  // This is a gross hack necessary because native code is sending
+  // events named things like topChange to JS which is then converted back to
+  // call the onChange prop. We should be consistent throughout the system.
+  // In order to migrate to this new system we have to support the current
+  // naming scheme. We should delete this once we are able to control this name
+  // throughout the system.
+  const dispatchEventName =
+    event.paperTopLevelNameDeprecated != null
+      ? event.paperTopLevelNameDeprecated
+      : `${event.name[2].toLowerCase()}${event.name.slice(3)}`;
+
+  if (event.typeAnnotation.argument) {
+    const implementation = `
+    auto payload = jsi::Object(runtime);
+    ${generateSetters(
+      'payload',
+      event.typeAnnotation.argument.properties,
+      [],
+      extraIncludes,
+    )}
+    return payload;
+  `.trim();
+
+    if (!event.name.startsWith('on')) {
+      throw new Error('Expected the event name to start with `on`');
+    }
+
+    return ComponentTemplate({
+      className: componentName,
+      eventName: event.name,
+      dispatchEventName,
+      structName: generateEventStructName([event.name]),
+      implementation,
+    });
+  }
+
+  return BasicComponentTemplate({
+    className: componentName,
+    eventName: event.name,
+    dispatchEventName,
+  });
+}
+
+module.exports = {
+  generate(
+    libraryName: string,
+    schema: SchemaType,
+    packageName?: string,
+    assumeNonnull: boolean = false,
+    headerPrefix?: string,
+    includeGetDebugPropsImplementation?: boolean = false,
+  ): FilesOutput {
+    const moduleComponents: ComponentCollection = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+
+        const {components} = module;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+
+        return components;
+      })
+      .filter(Boolean)
+      // $FlowFixMe[unsafe-object-assign]
+      .reduce((acc, components) => Object.assign(acc, components), {});
+
+    const extraIncludes = new Set<string>();
+    const componentEmitters = Object.keys(moduleComponents)
+      .map(componentName => {
+        const component = moduleComponents[componentName];
+        return component.events
+          .map(event => generateEvent(componentName, event, extraIncludes))
+          .join('\n');
+      })
+      .join('\n');
+
+    const fileName = 'EventEmitters.cpp';
+    const replacedTemplate = FileTemplate({
+      events: componentEmitters,
+      extraIncludes,
+      headerPrefix: headerPrefix ?? '',
+    });
+
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateEventEmitterH.js

@@ -0,0 +1,284 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+const {indent, toSafeCppString} = require('../Utils');
+const {
+  generateEventStructName,
+  getCppArrayTypeForAnnotation,
+  getCppTypeForAnnotation,
+  getImports,
+} = require('./CppHelpers');
+const nullthrows = require('nullthrows');
+
+// File path -> contents
+
+const FileTemplate = ({componentEmitters, extraIncludes}) => `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by codegen project: GenerateEventEmitterH.js
+ */
+#pragma once
+
+#include <react/renderer/components/view/ViewEventEmitter.h>
+${[...extraIncludes].join('\n')}
+
+namespace facebook::react {
+${componentEmitters}
+} // namespace facebook::react
+`;
+const ComponentTemplate = ({className, structs, events}) =>
+  `
+class ${className}EventEmitter : public ViewEventEmitter {
+ public:
+  using ViewEventEmitter::ViewEventEmitter;
+
+  ${structs}
+  ${events}
+};
+`.trim();
+const StructTemplate = ({structName, fields}) =>
+  `
+  struct ${structName} {
+    ${fields}
+  };
+`.trim();
+const EnumTemplate = ({enumName, values, toCases}) =>
+  `enum class ${enumName} {
+  ${values}
+};
+
+static char const *toString(const ${enumName} value) {
+  switch (value) {
+    ${toCases}
+  }
+}
+`.trim();
+function getNativeTypeFromAnnotation(componentName, eventProperty, nameParts) {
+  const {type} = eventProperty.typeAnnotation;
+  switch (type) {
+    case 'BooleanTypeAnnotation':
+    case 'StringTypeAnnotation':
+    case 'Int32TypeAnnotation':
+    case 'DoubleTypeAnnotation':
+    case 'FloatTypeAnnotation':
+    case 'MixedTypeAnnotation':
+      return getCppTypeForAnnotation(type);
+    case 'StringLiteralUnionTypeAnnotation':
+    case 'ObjectTypeAnnotation':
+      return generateEventStructName([...nameParts, eventProperty.name]);
+    case 'ArrayTypeAnnotation':
+      const eventTypeAnnotation = eventProperty.typeAnnotation;
+      if (eventTypeAnnotation.type !== 'ArrayTypeAnnotation') {
+        throw new Error(
+          "Inconsistent Codegen state: type was ArrayTypeAnnotation at the beginning of the body and now it isn't",
+        );
+      }
+      return getCppArrayTypeForAnnotation(eventTypeAnnotation.elementType, [
+        ...nameParts,
+        eventProperty.name,
+      ]);
+    default:
+      type;
+      throw new Error(`Received invalid event property type ${type}`);
+  }
+}
+function generateEnum(structs, options, nameParts) {
+  const structName = generateEventStructName(nameParts);
+  const fields = options
+    .map((option, index) => `${toSafeCppString(option)}`)
+    .join(',\n  ');
+  const toCases = options
+    .map(
+      option =>
+        `case ${structName}::${toSafeCppString(option)}: return "${option}";`,
+    )
+    .join('\n' + '    ');
+  structs.set(
+    structName,
+    EnumTemplate({
+      enumName: structName,
+      values: fields,
+      toCases: toCases,
+    }),
+  );
+}
+function handleGenerateStructForArray(
+  structs,
+  name,
+  componentName,
+  elementType,
+  nameParts,
+) {
+  if (elementType.type === 'ObjectTypeAnnotation') {
+    generateStruct(
+      structs,
+      componentName,
+      nameParts.concat([name]),
+      nullthrows(elementType.properties),
+    );
+  } else if (elementType.type === 'StringLiteralUnionTypeAnnotation') {
+    generateEnum(
+      structs,
+      elementType.types.map(literal => literal.value),
+      nameParts.concat([name]),
+    );
+  } else if (elementType.type === 'ArrayTypeAnnotation') {
+    handleGenerateStructForArray(
+      structs,
+      name,
+      componentName,
+      elementType.elementType,
+      nameParts,
+    );
+  }
+}
+function generateStruct(structs, componentName, nameParts, properties) {
+  const structNameParts = nameParts;
+  const structName = generateEventStructName(structNameParts);
+  const fields = properties
+    .map(property => {
+      return `${getNativeTypeFromAnnotation(componentName, property, structNameParts)} ${property.name};`;
+    })
+    .join('\n' + '  ');
+  properties.forEach(property => {
+    const {name, typeAnnotation} = property;
+    switch (typeAnnotation.type) {
+      case 'BooleanTypeAnnotation':
+      case 'StringTypeAnnotation':
+      case 'Int32TypeAnnotation':
+      case 'DoubleTypeAnnotation':
+      case 'FloatTypeAnnotation':
+      case 'MixedTypeAnnotation':
+        return;
+      case 'ArrayTypeAnnotation':
+        handleGenerateStructForArray(
+          structs,
+          name,
+          componentName,
+          typeAnnotation.elementType,
+          nameParts,
+        );
+        return;
+      case 'ObjectTypeAnnotation':
+        generateStruct(
+          structs,
+          componentName,
+          nameParts.concat([name]),
+          nullthrows(typeAnnotation.properties),
+        );
+        return;
+      case 'StringLiteralUnionTypeAnnotation':
+        generateEnum(
+          structs,
+          typeAnnotation.types.map(literal => literal.value),
+          nameParts.concat([name]),
+        );
+        return;
+      default:
+        typeAnnotation.type;
+        throw new Error(
+          `Received invalid event property type ${typeAnnotation.type}`,
+        );
+    }
+  });
+  structs.set(
+    structName,
+    StructTemplate({
+      structName,
+      fields,
+    }),
+  );
+}
+function generateStructs(componentName, component) {
+  const structs = new Map();
+  component.events.forEach(event => {
+    if (event.typeAnnotation.argument) {
+      generateStruct(
+        structs,
+        componentName,
+        [event.name],
+        event.typeAnnotation.argument.properties,
+      );
+    }
+  });
+  return Array.from(structs.values()).join('\n\n');
+}
+function generateEvent(componentName, event) {
+  if (event.typeAnnotation.argument) {
+    const structName = generateEventStructName([event.name]);
+    return `void ${event.name}(${structName} value) const;`;
+  }
+  return `void ${event.name}() const;`;
+}
+function generateEvents(componentName, component) {
+  return component.events
+    .map(event => generateEvent(componentName, event))
+    .join('\n\n' + '  ');
+}
+module.exports = {
+  generate(
+    libraryName,
+    schema,
+    packageName,
+    assumeNonnull = false,
+    headerPrefix,
+    includeGetDebugPropsImplementation = false,
+  ) {
+    const moduleComponents = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return null;
+        }
+        const {components} = module;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+        return components;
+      })
+      .filter(Boolean)
+      // $FlowFixMe[unsafe-object-assign]
+      .reduce((acc, components) => Object.assign(acc, components), {});
+    const extraIncludes = new Set();
+    const componentEmitters = Object.keys(moduleComponents)
+      .map(componentName => {
+        const component = moduleComponents[componentName];
+        component.events.forEach(event => {
+          if (event.typeAnnotation.argument) {
+            const argIncludes = getImports(
+              event.typeAnnotation.argument.properties,
+            );
+            // $FlowFixMe[method-unbinding]
+            argIncludes.forEach(extraIncludes.add, extraIncludes);
+          }
+        });
+        const replacedTemplate = ComponentTemplate({
+          className: componentName,
+          structs: indent(generateStructs(componentName, component), 2),
+          events: generateEvents(componentName, component),
+        });
+        return replacedTemplate;
+      })
+      .join('\n');
+    const fileName = 'EventEmitters.h';
+    const replacedTemplate = FileTemplate({
+      componentEmitters,
+      extraIncludes,
+    });
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateEventEmitterH.js.flow

@@ -0,0 +1,377 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import type {
+  ComponentShape,
+  EventTypeAnnotation,
+  EventTypeShape,
+  NamedShape,
+  SchemaType,
+} from '../../CodegenSchema';
+
+const {indent, toSafeCppString} = require('../Utils');
+const {
+  generateEventStructName,
+  getCppArrayTypeForAnnotation,
+  getCppTypeForAnnotation,
+  getImports,
+} = require('./CppHelpers');
+const nullthrows = require('nullthrows');
+
+// File path -> contents
+type FilesOutput = Map<string, string>;
+type StructsMap = Map<string, string>;
+
+type ComponentCollection = $ReadOnly<{
+  [component: string]: ComponentShape,
+  ...
+}>;
+
+const FileTemplate = ({
+  componentEmitters,
+  extraIncludes,
+}: {
+  componentEmitters: string,
+  extraIncludes: Set<string>,
+}) => `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by codegen project: GenerateEventEmitterH.js
+ */
+#pragma once
+
+#include <react/renderer/components/view/ViewEventEmitter.h>
+${[...extraIncludes].join('\n')}
+
+namespace facebook::react {
+${componentEmitters}
+} // namespace facebook::react
+`;
+
+const ComponentTemplate = ({
+  className,
+  structs,
+  events,
+}: {
+  className: string,
+  structs: string,
+  events: string,
+}) =>
+  `
+class ${className}EventEmitter : public ViewEventEmitter {
+ public:
+  using ViewEventEmitter::ViewEventEmitter;
+
+  ${structs}
+  ${events}
+};
+`.trim();
+
+const StructTemplate = ({
+  structName,
+  fields,
+}: {
+  structName: string,
+  fields: string,
+}) =>
+  `
+  struct ${structName} {
+    ${fields}
+  };
+`.trim();
+
+const EnumTemplate = ({
+  enumName,
+  values,
+  toCases,
+}: {
+  enumName: string,
+  values: string,
+  toCases: string,
+}) =>
+  `enum class ${enumName} {
+  ${values}
+};
+
+static char const *toString(const ${enumName} value) {
+  switch (value) {
+    ${toCases}
+  }
+}
+`.trim();
+
+function getNativeTypeFromAnnotation(
+  componentName: string,
+  eventProperty: NamedShape<EventTypeAnnotation>,
+  nameParts: $ReadOnlyArray<string>,
+): string {
+  const {type} = eventProperty.typeAnnotation;
+
+  switch (type) {
+    case 'BooleanTypeAnnotation':
+    case 'StringTypeAnnotation':
+    case 'Int32TypeAnnotation':
+    case 'DoubleTypeAnnotation':
+    case 'FloatTypeAnnotation':
+    case 'MixedTypeAnnotation':
+      return getCppTypeForAnnotation(type);
+    case 'StringLiteralUnionTypeAnnotation':
+    case 'ObjectTypeAnnotation':
+      return generateEventStructName([...nameParts, eventProperty.name]);
+    case 'ArrayTypeAnnotation':
+      const eventTypeAnnotation = eventProperty.typeAnnotation;
+      if (eventTypeAnnotation.type !== 'ArrayTypeAnnotation') {
+        throw new Error(
+          "Inconsistent Codegen state: type was ArrayTypeAnnotation at the beginning of the body and now it isn't",
+        );
+      }
+      return getCppArrayTypeForAnnotation(eventTypeAnnotation.elementType, [
+        ...nameParts,
+        eventProperty.name,
+      ]);
+    default:
+      (type: empty);
+      throw new Error(`Received invalid event property type ${type}`);
+  }
+}
+function generateEnum(
+  structs: StructsMap,
+  options: $ReadOnlyArray<string>,
+  nameParts: Array<string>,
+) {
+  const structName = generateEventStructName(nameParts);
+  const fields = options
+    .map((option, index) => `${toSafeCppString(option)}`)
+    .join(',\n  ');
+
+  const toCases = options
+    .map(
+      option =>
+        `case ${structName}::${toSafeCppString(option)}: return "${option}";`,
+    )
+    .join('\n' + '    ');
+
+  structs.set(
+    structName,
+    EnumTemplate({
+      enumName: structName,
+      values: fields,
+      toCases: toCases,
+    }),
+  );
+}
+
+function handleGenerateStructForArray(
+  structs: StructsMap,
+  name: string,
+  componentName: string,
+  elementType: EventTypeAnnotation,
+  nameParts: $ReadOnlyArray<string>,
+): void {
+  if (elementType.type === 'ObjectTypeAnnotation') {
+    generateStruct(
+      structs,
+      componentName,
+      nameParts.concat([name]),
+      nullthrows(elementType.properties),
+    );
+  } else if (elementType.type === 'StringLiteralUnionTypeAnnotation') {
+    generateEnum(
+      structs,
+      elementType.types.map(literal => literal.value),
+      nameParts.concat([name]),
+    );
+  } else if (elementType.type === 'ArrayTypeAnnotation') {
+    handleGenerateStructForArray(
+      structs,
+      name,
+      componentName,
+      elementType.elementType,
+      nameParts,
+    );
+  }
+}
+
+function generateStruct(
+  structs: StructsMap,
+  componentName: string,
+  nameParts: $ReadOnlyArray<string>,
+  properties: $ReadOnlyArray<NamedShape<EventTypeAnnotation>>,
+): void {
+  const structNameParts = nameParts;
+  const structName = generateEventStructName(structNameParts);
+
+  const fields = properties
+    .map(property => {
+      return `${getNativeTypeFromAnnotation(
+        componentName,
+        property,
+        structNameParts,
+      )} ${property.name};`;
+    })
+    .join('\n' + '  ');
+
+  properties.forEach(property => {
+    const {name, typeAnnotation} = property;
+    switch (typeAnnotation.type) {
+      case 'BooleanTypeAnnotation':
+      case 'StringTypeAnnotation':
+      case 'Int32TypeAnnotation':
+      case 'DoubleTypeAnnotation':
+      case 'FloatTypeAnnotation':
+      case 'MixedTypeAnnotation':
+        return;
+      case 'ArrayTypeAnnotation':
+        handleGenerateStructForArray(
+          structs,
+          name,
+          componentName,
+          typeAnnotation.elementType,
+          nameParts,
+        );
+        return;
+      case 'ObjectTypeAnnotation':
+        generateStruct(
+          structs,
+          componentName,
+          nameParts.concat([name]),
+          nullthrows(typeAnnotation.properties),
+        );
+        return;
+      case 'StringLiteralUnionTypeAnnotation':
+        generateEnum(
+          structs,
+          typeAnnotation.types.map(literal => literal.value),
+          nameParts.concat([name]),
+        );
+        return;
+      default:
+        (typeAnnotation.type: empty);
+        throw new Error(
+          `Received invalid event property type ${typeAnnotation.type}`,
+        );
+    }
+  });
+
+  structs.set(
+    structName,
+    StructTemplate({
+      structName,
+      fields,
+    }),
+  );
+}
+
+function generateStructs(
+  componentName: string,
+  component: ComponentShape,
+): string {
+  const structs: StructsMap = new Map();
+
+  component.events.forEach(event => {
+    if (event.typeAnnotation.argument) {
+      generateStruct(
+        structs,
+        componentName,
+        [event.name],
+        event.typeAnnotation.argument.properties,
+      );
+    }
+  });
+
+  return Array.from(structs.values()).join('\n\n');
+}
+
+function generateEvent(componentName: string, event: EventTypeShape): string {
+  if (event.typeAnnotation.argument) {
+    const structName = generateEventStructName([event.name]);
+
+    return `void ${event.name}(${structName} value) const;`;
+  }
+
+  return `void ${event.name}() const;`;
+}
+function generateEvents(
+  componentName: string,
+  component: ComponentShape,
+): string {
+  return component.events
+    .map(event => generateEvent(componentName, event))
+    .join('\n\n' + '  ');
+}
+
+module.exports = {
+  generate(
+    libraryName: string,
+    schema: SchemaType,
+    packageName?: string,
+    assumeNonnull: boolean = false,
+    headerPrefix?: string,
+    includeGetDebugPropsImplementation?: boolean = false,
+  ): FilesOutput {
+    const moduleComponents: ComponentCollection = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return null;
+        }
+
+        const {components} = module;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+
+        return components;
+      })
+      .filter(Boolean)
+      // $FlowFixMe[unsafe-object-assign]
+      .reduce((acc, components) => Object.assign(acc, components), {});
+
+    const extraIncludes = new Set<string>();
+    const componentEmitters = Object.keys(moduleComponents)
+      .map(componentName => {
+        const component = moduleComponents[componentName];
+
+        component.events.forEach(event => {
+          if (event.typeAnnotation.argument) {
+            const argIncludes = getImports(
+              event.typeAnnotation.argument.properties,
+            );
+            // $FlowFixMe[method-unbinding]
+            argIncludes.forEach(extraIncludes.add, extraIncludes);
+          }
+        });
+
+        const replacedTemplate = ComponentTemplate({
+          className: componentName,
+          structs: indent(generateStructs(componentName, component), 2),
+          events: generateEvents(componentName, component),
+        });
+
+        return replacedTemplate;
+      })
+      .join('\n');
+
+    const fileName = 'EventEmitters.h';
+    const replacedTemplate = FileTemplate({
+      componentEmitters,
+      extraIncludes,
+    });
+
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GeneratePropsCpp.js

@@ -0,0 +1,266 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+const {
+  IncludeTemplate,
+  convertDefaultTypeToString,
+  getImports,
+  getSourceProp,
+  isWrappedPropType,
+} = require('./CppHelpers');
+
+// File path -> contents
+
+const FileTemplate = ({imports, componentClasses, headerPrefix}) => `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by codegen project: GeneratePropsCpp.js
+ */
+
+${IncludeTemplate({
+  headerPrefix,
+  file: 'Props.h',
+})}
+${imports}
+
+namespace facebook::react {
+
+${componentClasses}
+
+} // namespace facebook::react
+`;
+const ComponentTemplate = ({className, extendClasses, props, diffProps}) =>
+  `
+${className}::${className}(
+    const PropsParserContext &context,
+    const ${className} &sourceProps,
+    const RawProps &rawProps):${extendClasses}
+
+    ${props} {}
+    ${diffProps}
+
+`.trim();
+function generatePropsDiffString(
+  className,
+  componentName,
+  component,
+  debugProps = '',
+  includeGetDebugPropsImplementation = false,
+) {
+  const diffProps = component.props
+    .map(prop => {
+      const typeAnnotation = prop.typeAnnotation;
+      switch (typeAnnotation.type) {
+        case 'StringTypeAnnotation':
+        case 'Int32TypeAnnotation':
+        case 'BooleanTypeAnnotation':
+        case 'MixedTypeAnnotation':
+          return `
+  if (${prop.name} != oldProps->${prop.name}) {
+    result["${prop.name}"] = ${prop.name};
+  }`;
+        case 'DoubleTypeAnnotation':
+        case 'FloatTypeAnnotation':
+          return `
+  if ((${prop.name} != oldProps->${prop.name}) && !(std::isnan(${prop.name}) && std::isnan(oldProps->${prop.name}))) {
+    result["${prop.name}"] = ${prop.name};
+  }`;
+        case 'ArrayTypeAnnotation':
+        case 'ObjectTypeAnnotation':
+        case 'StringEnumTypeAnnotation':
+        case 'Int32EnumTypeAnnotation':
+          return `
+  if (${prop.name} != oldProps->${prop.name}) {
+    result["${prop.name}"] = toDynamic(${prop.name});
+  }`;
+        case 'ReservedPropTypeAnnotation':
+          switch (typeAnnotation.name) {
+            case 'ColorPrimitive':
+              return `
+  if (${prop.name} != oldProps->${prop.name}) {
+    result["${prop.name}"] = *${prop.name};
+  }`;
+            case 'ImageSourcePrimitive':
+            case 'PointPrimitive':
+            case 'EdgeInsetsPrimitive':
+            case 'DimensionPrimitive':
+              return `
+  if (${prop.name} != oldProps->${prop.name}) {
+    result["${prop.name}"] = toDynamic(${prop.name});
+  }`;
+            case 'ImageRequestPrimitive':
+              // Shouldn't be used in props
+              throw new Error(
+                'ImageRequestPrimitive should not be used in Props',
+              );
+            default:
+              typeAnnotation.name;
+              throw new Error('Received unknown ReservedPropTypeAnnotation');
+          }
+        default:
+          return '';
+      }
+    })
+    .join('\n' + '    ');
+  const getDebugPropsString = `#if RN_DEBUG_STRING_CONVERTIBLE
+SharedDebugStringConvertibleList ${className}::getDebugProps() const {
+  return ViewProps::getDebugProps()${debugProps && debugProps.length > 0 ? ` +\n\t\tSharedDebugStringConvertibleList{${debugProps}\n\t}` : ''};
+}
+#endif`;
+  return `
+#ifdef RN_SERIALIZABLE_STATE
+ComponentName ${className}::getDiffPropsImplementationTarget() const {
+  return "${componentName}";
+}
+
+folly::dynamic ${className}::getDiffProps(
+    const Props* prevProps) const {
+  static const auto defaultProps = ${className}();
+  const ${className}* oldProps = prevProps == nullptr
+      ? &defaultProps
+      : static_cast<const ${className}*>(prevProps);
+  if (this == oldProps) {
+    return folly::dynamic::object();
+  }
+  folly::dynamic result = HostPlatformViewProps::getDiffProps(prevProps);
+  ${diffProps}
+  return result;
+}
+#endif
+${includeGetDebugPropsImplementation ? getDebugPropsString : ''}
+`;
+}
+function generatePropsString(componentName, component) {
+  return component.props
+    .map(prop => {
+      const sourceProp = getSourceProp(componentName, prop);
+      const defaultValue = convertDefaultTypeToString(componentName, prop);
+      const isWrappedProp = isWrappedPropType(prop);
+      let convertRawProp = `convertRawProp(context, rawProps, "${prop.name}", ${sourceProp}, {${defaultValue}})`;
+      if (isWrappedProp) {
+        convertRawProp += '.value';
+      }
+      return `${prop.name}(${convertRawProp})`;
+    })
+    .join(',\n' + '    ');
+}
+function generateDebugPropsString(componentName, component) {
+  return component.props
+    .map(prop => {
+      if (prop.typeAnnotation.type === 'ObjectTypeAnnotation') {
+        // Skip ObjectTypeAnnotation because there is no generic `toString`
+        // method for it. We would have to define an interface that the structs implement.
+        return '';
+      }
+      const defaultValue = convertDefaultTypeToString(componentName, prop);
+      return `\n\t\t\tdebugStringConvertibleItem("${prop.name}", ${prop.name}${defaultValue ? `, ${defaultValue}` : ''})`;
+    })
+    .join(',');
+}
+function getClassExtendString(component) {
+  const extendString =
+    ' ' +
+    component.extendsProps
+      .map(extendProps => {
+        switch (extendProps.type) {
+          case 'ReactNativeBuiltInType':
+            switch (extendProps.knownTypeName) {
+              case 'ReactNativeCoreViewProps':
+                return 'ViewProps(context, sourceProps, rawProps)';
+              default:
+                extendProps.knownTypeName;
+                throw new Error('Invalid knownTypeName');
+            }
+          default:
+            extendProps.type;
+            throw new Error('Invalid extended type');
+        }
+      })
+      .join(', ') +
+    `${component.props.length > 0 ? ',' : ''}`;
+  return extendString;
+}
+module.exports = {
+  generate(
+    libraryName,
+    schema,
+    packageName,
+    assumeNonnull = false,
+    headerPrefix,
+    includeGetDebugPropsImplementation = false,
+  ) {
+    const fileName = 'Props.cpp';
+    const allImports = new Set([
+      '#include <react/renderer/core/propsConversions.h>',
+      '#include <react/renderer/core/PropsParserContext.h>',
+    ]);
+    if (includeGetDebugPropsImplementation) {
+      allImports.add('#include <react/renderer/core/graphicsConversions.h>');
+      allImports.add(
+        '#include <react/renderer/debug/debugStringConvertibleUtils.h>',
+      );
+    }
+    const componentProps = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+        const {components} = module;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+        return Object.keys(components)
+          .map(componentName => {
+            const component = components[componentName];
+            const newName = `${componentName}Props`;
+            const propsString = generatePropsString(componentName, component);
+            const extendString = getClassExtendString(component);
+            const debugProps = includeGetDebugPropsImplementation
+              ? generateDebugPropsString(componentName, component)
+              : '';
+            const diffPropsString = generatePropsDiffString(
+              newName,
+              componentName,
+              component,
+              debugProps,
+              includeGetDebugPropsImplementation,
+            );
+            const imports = getImports(component.props);
+            // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+            imports.forEach(allImports.add, allImports);
+            const replacedTemplate = ComponentTemplate({
+              className: newName,
+              extendClasses: extendString,
+              props: propsString,
+              diffProps: diffPropsString,
+            });
+            return replacedTemplate;
+          })
+          .join('\n');
+      })
+      .filter(Boolean)
+      .join('\n');
+    const replacedTemplate = FileTemplate({
+      componentClasses: componentProps,
+      imports: Array.from(allImports).sort().join('\n').trim(),
+      headerPrefix:
+        headerPrefix !== null && headerPrefix !== void 0 ? headerPrefix : '',
+    });
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GeneratePropsCpp.js.flow

@@ -0,0 +1,306 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import type {ComponentShape, SchemaType} from '../../CodegenSchema';
+
+const {
+  IncludeTemplate,
+  convertDefaultTypeToString,
+  getImports,
+  getSourceProp,
+  isWrappedPropType,
+} = require('./CppHelpers');
+
+// File path -> contents
+type FilesOutput = Map<string, string>;
+
+const FileTemplate = ({
+  imports,
+  componentClasses,
+  headerPrefix,
+}: {
+  imports: string,
+  componentClasses: string,
+  headerPrefix: string,
+}) => `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by codegen project: GeneratePropsCpp.js
+ */
+
+${IncludeTemplate({headerPrefix, file: 'Props.h'})}
+${imports}
+
+namespace facebook::react {
+
+${componentClasses}
+
+} // namespace facebook::react
+`;
+
+const ComponentTemplate = ({
+  className,
+  extendClasses,
+  props,
+  diffProps,
+}: {
+  className: string,
+  extendClasses: string,
+  props: string,
+  diffProps: string,
+}) =>
+  `
+${className}::${className}(
+    const PropsParserContext &context,
+    const ${className} &sourceProps,
+    const RawProps &rawProps):${extendClasses}
+
+    ${props} {}
+    ${diffProps}
+
+`.trim();
+
+function generatePropsDiffString(
+  className: string,
+  componentName: string,
+  component: ComponentShape,
+  debugProps: string = '',
+  includeGetDebugPropsImplementation?: boolean = false,
+) {
+  const diffProps = component.props
+    .map(prop => {
+      const typeAnnotation = prop.typeAnnotation;
+      switch (typeAnnotation.type) {
+        case 'StringTypeAnnotation':
+        case 'Int32TypeAnnotation':
+        case 'BooleanTypeAnnotation':
+        case 'MixedTypeAnnotation':
+          return `
+  if (${prop.name} != oldProps->${prop.name}) {
+    result["${prop.name}"] = ${prop.name};
+  }`;
+        case 'DoubleTypeAnnotation':
+        case 'FloatTypeAnnotation':
+          return `
+  if ((${prop.name} != oldProps->${prop.name}) && !(std::isnan(${prop.name}) && std::isnan(oldProps->${prop.name}))) {
+    result["${prop.name}"] = ${prop.name};
+  }`;
+        case 'ArrayTypeAnnotation':
+        case 'ObjectTypeAnnotation':
+        case 'StringEnumTypeAnnotation':
+        case 'Int32EnumTypeAnnotation':
+          return `
+  if (${prop.name} != oldProps->${prop.name}) {
+    result["${prop.name}"] = toDynamic(${prop.name});
+  }`;
+        case 'ReservedPropTypeAnnotation':
+          switch (typeAnnotation.name) {
+            case 'ColorPrimitive':
+              return `
+  if (${prop.name} != oldProps->${prop.name}) {
+    result["${prop.name}"] = *${prop.name};
+  }`;
+            case 'ImageSourcePrimitive':
+            case 'PointPrimitive':
+            case 'EdgeInsetsPrimitive':
+            case 'DimensionPrimitive':
+              return `
+  if (${prop.name} != oldProps->${prop.name}) {
+    result["${prop.name}"] = toDynamic(${prop.name});
+  }`;
+            case 'ImageRequestPrimitive':
+              // Shouldn't be used in props
+              throw new Error(
+                'ImageRequestPrimitive should not be used in Props',
+              );
+            default:
+              (typeAnnotation.name: empty);
+              throw new Error('Received unknown ReservedPropTypeAnnotation');
+          }
+        default:
+          return '';
+      }
+    })
+    .join('\n' + '    ');
+
+  const getDebugPropsString = `#if RN_DEBUG_STRING_CONVERTIBLE
+SharedDebugStringConvertibleList ${className}::getDebugProps() const {
+  return ViewProps::getDebugProps()${debugProps && debugProps.length > 0 ? ` +\n\t\tSharedDebugStringConvertibleList{${debugProps}\n\t}` : ''};
+}
+#endif`;
+
+  return `
+#ifdef RN_SERIALIZABLE_STATE
+ComponentName ${className}::getDiffPropsImplementationTarget() const {
+  return "${componentName}";
+}
+
+folly::dynamic ${className}::getDiffProps(
+    const Props* prevProps) const {
+  static const auto defaultProps = ${className}();
+  const ${className}* oldProps = prevProps == nullptr
+      ? &defaultProps
+      : static_cast<const ${className}*>(prevProps);
+  if (this == oldProps) {
+    return folly::dynamic::object();
+  }
+  folly::dynamic result = HostPlatformViewProps::getDiffProps(prevProps);
+  ${diffProps}
+  return result;
+}
+#endif
+${includeGetDebugPropsImplementation ? getDebugPropsString : ''}
+`;
+}
+
+function generatePropsString(componentName: string, component: ComponentShape) {
+  return component.props
+    .map(prop => {
+      const sourceProp = getSourceProp(componentName, prop);
+      const defaultValue = convertDefaultTypeToString(componentName, prop);
+      const isWrappedProp = isWrappedPropType(prop);
+      let convertRawProp = `convertRawProp(context, rawProps, "${prop.name}", ${sourceProp}, {${defaultValue}})`;
+      if (isWrappedProp) {
+        convertRawProp += '.value';
+      }
+      return `${prop.name}(${convertRawProp})`;
+    })
+    .join(',\n' + '    ');
+}
+
+function generateDebugPropsString(
+  componentName: string,
+  component: ComponentShape,
+) {
+  return component.props
+    .map(prop => {
+      if (prop.typeAnnotation.type === 'ObjectTypeAnnotation') {
+        // Skip ObjectTypeAnnotation because there is no generic `toString`
+        // method for it. We would have to define an interface that the structs implement.
+        return '';
+      }
+
+      const defaultValue = convertDefaultTypeToString(componentName, prop);
+      return `\n\t\t\tdebugStringConvertibleItem("${prop.name}", ${prop.name}${defaultValue ? `, ${defaultValue}` : ''})`;
+    })
+    .join(',');
+}
+
+function getClassExtendString(component: ComponentShape): string {
+  const extendString =
+    ' ' +
+    component.extendsProps
+      .map(extendProps => {
+        switch (extendProps.type) {
+          case 'ReactNativeBuiltInType':
+            switch (extendProps.knownTypeName) {
+              case 'ReactNativeCoreViewProps':
+                return 'ViewProps(context, sourceProps, rawProps)';
+              default:
+                (extendProps.knownTypeName: empty);
+                throw new Error('Invalid knownTypeName');
+            }
+          default:
+            (extendProps.type: empty);
+            throw new Error('Invalid extended type');
+        }
+      })
+      .join(', ') +
+    `${component.props.length > 0 ? ',' : ''}`;
+
+  return extendString;
+}
+
+module.exports = {
+  generate(
+    libraryName: string,
+    schema: SchemaType,
+    packageName?: string,
+    assumeNonnull: boolean = false,
+    headerPrefix?: string,
+    includeGetDebugPropsImplementation?: boolean = false,
+  ): FilesOutput {
+    const fileName = 'Props.cpp';
+    const allImports: Set<string> = new Set([
+      '#include <react/renderer/core/propsConversions.h>',
+      '#include <react/renderer/core/PropsParserContext.h>',
+    ]);
+
+    if (includeGetDebugPropsImplementation) {
+      allImports.add('#include <react/renderer/core/graphicsConversions.h>');
+      allImports.add(
+        '#include <react/renderer/debug/debugStringConvertibleUtils.h>',
+      );
+    }
+
+    const componentProps = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+
+        const {components} = module;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+
+        return Object.keys(components)
+          .map(componentName => {
+            const component = components[componentName];
+            const newName = `${componentName}Props`;
+
+            const propsString = generatePropsString(componentName, component);
+            const extendString = getClassExtendString(component);
+            const debugProps = includeGetDebugPropsImplementation
+              ? generateDebugPropsString(componentName, component)
+              : '';
+            const diffPropsString = generatePropsDiffString(
+              newName,
+              componentName,
+              component,
+              debugProps,
+              includeGetDebugPropsImplementation,
+            );
+
+            const imports = getImports(component.props);
+            // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+            imports.forEach(allImports.add, allImports);
+
+            const replacedTemplate = ComponentTemplate({
+              className: newName,
+              extendClasses: extendString,
+              props: propsString,
+              diffProps: diffPropsString,
+            });
+
+            return replacedTemplate;
+          })
+          .join('\n');
+      })
+      .filter(Boolean)
+      .join('\n');
+
+    const replacedTemplate = FileTemplate({
+      componentClasses: componentProps,
+      imports: Array.from(allImports).sort().join('\n').trim(),
+      headerPrefix: headerPrefix ?? '',
+    });
+
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GeneratePropsH.js

@@ -0,0 +1,693 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+const {getEnumName, toSafeCppString} = require('../Utils');
+const {
+  getLocalImports,
+  getNativeTypeFromAnnotation,
+} = require('./ComponentsGeneratorUtils.js');
+const {
+  generateStructName,
+  getDefaultInitializerString,
+  getEnumMaskName,
+  toIntEnumValueName,
+} = require('./CppHelpers.js');
+
+// File path -> contents
+
+const FileTemplate = ({imports, componentClasses}) => `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by codegen project: GeneratePropsH.js
+ */
+#pragma once
+
+${imports}
+
+namespace facebook::react {
+
+${componentClasses}
+
+} // namespace facebook::react
+`;
+const ClassTemplate = ({
+  enums,
+  structs,
+  className,
+  props,
+  extendClasses,
+  includeGetDebugPropsImplementation,
+}) => {
+  const getDebugPropsString = `#if RN_DEBUG_STRING_CONVERTIBLE
+  SharedDebugStringConvertibleList getDebugProps() const override;
+  #endif`;
+  return `
+${enums}
+${structs}
+class ${className} final${extendClasses} {
+ public:
+  ${className}() = default;
+  ${className}(const PropsParserContext& context, const ${className} &sourceProps, const RawProps &rawProps);
+
+#pragma mark - Props
+
+  ${props}
+
+  #ifdef RN_SERIALIZABLE_STATE
+  ComponentName getDiffPropsImplementationTarget() const override;
+
+  folly::dynamic getDiffProps(const Props* prevProps) const override;
+  #endif
+
+  ${includeGetDebugPropsImplementation ? getDebugPropsString : ''}
+};
+`.trim();
+};
+const EnumTemplate = ({enumName, values, fromCases, toCases}) =>
+  `
+enum class ${enumName} { ${values} };
+
+static inline void fromRawValue(const PropsParserContext& context, const RawValue &value, ${enumName} &result) {
+  auto string = (std::string)value;
+  ${fromCases}
+  abort();
+}
+
+static inline std::string toString(const ${enumName} &value) {
+  switch (value) {
+    ${toCases}
+  }
+}
+
+#ifdef RN_SERIALIZABLE_STATE
+static inline folly::dynamic toDynamic(const ${enumName} &value) {
+  return toString(value);
+}
+#endif
+`.trim();
+const IntEnumTemplate = ({
+  enumName,
+  values,
+  fromCases,
+  toCases,
+  toDynamicCases,
+}) =>
+  `
+enum class ${enumName} { ${values} };
+
+static inline void fromRawValue(const PropsParserContext& context, const RawValue &value, ${enumName} &result) {
+  assert(value.hasType<int>());
+  auto integerValue = (int)value;
+  switch (integerValue) {${fromCases}
+  }
+  abort();
+}
+
+static inline std::string toString(const ${enumName} &value) {
+  switch (value) {
+    ${toCases}
+  }
+}
+
+#ifdef RN_SERIALIZABLE_STATE
+static inline folly::dynamic toDynamic(const ${enumName} &value) {
+  switch (value) {
+    ${toDynamicCases}
+  }
+}
+#endif
+`.trim();
+const StructTemplate = ({structName, fields, fromCases, toDynamicCases}) =>
+  `struct ${structName} {
+  ${fields}
+
+
+#ifdef RN_SERIALIZABLE_STATE
+  bool operator==(const ${structName}&) const = default;
+
+  folly::dynamic toDynamic() const {
+    folly::dynamic result = folly::dynamic::object();
+    ${toDynamicCases}
+    return result;
+  }
+#endif
+};
+
+static inline void fromRawValue(const PropsParserContext& context, const RawValue &value, ${structName} &result) {
+  auto map = (std::unordered_map<std::string, RawValue>)value;
+
+  ${fromCases}
+}
+
+static inline std::string toString(const ${structName} &value) {
+  return "[Object ${structName}]";
+}
+
+#ifdef RN_SERIALIZABLE_STATE
+static inline folly::dynamic toDynamic(const ${structName} &value) {
+  return value.toDynamic();
+}
+#endif
+`.trim();
+const ArrayConversionFunctionTemplate = ({
+  structName,
+}) => `static inline void fromRawValue(const PropsParserContext& context, const RawValue &value, std::vector<${structName}> &result) {
+  auto items = (std::vector<RawValue>)value;
+  for (const auto &item : items) {
+    ${structName} newItem;
+    fromRawValue(context, item, newItem);
+    result.emplace_back(newItem);
+  }
+}
+`;
+const DoubleArrayConversionFunctionTemplate = ({
+  structName,
+}) => `static inline void fromRawValue(const PropsParserContext& context, const RawValue &value, std::vector<std::vector<${structName}>> &result) {
+  auto items = (std::vector<std::vector<RawValue>>)value;
+  for (const std::vector<RawValue> &item : items) {
+    auto nestedArray = std::vector<${structName}>{};
+    for (const RawValue &nestedItem : item) {
+      ${structName} newItem;
+      fromRawValue(context, nestedItem, newItem);
+      nestedArray.emplace_back(newItem);
+    }
+    result.emplace_back(nestedArray);
+  }
+}
+`;
+const ArrayEnumTemplate = ({enumName, enumMask, values, fromCases, toCases}) =>
+  `
+using ${enumMask} = uint32_t;
+
+struct ${enumMask}Wrapped {
+  ${enumMask} value;
+};
+
+enum class ${enumName}: ${enumMask} {
+  ${values}
+};
+
+constexpr bool operator&(
+  ${enumMask} const lhs,
+  enum ${enumName} const rhs) {
+  return lhs & static_cast<${enumMask}>(rhs);
+}
+
+constexpr ${enumMask} operator|(
+  ${enumMask} const lhs,
+  enum ${enumName} const rhs) {
+  return lhs | static_cast<${enumMask}>(rhs);
+}
+
+constexpr void operator|=(
+  ${enumMask} &lhs,
+  enum ${enumName} const rhs) {
+  lhs = lhs | static_cast<${enumMask}>(rhs);
+}
+
+static inline void fromRawValue(const PropsParserContext& context, const RawValue &value, ${enumMask}Wrapped &wrapped) {
+  auto items = std::vector<std::string>{value};
+  for (const auto &item : items) {
+    ${fromCases}
+    abort();
+  }
+}
+
+static inline std::string toString(const ${enumMask}Wrapped &wrapped) {
+    auto result = std::string{};
+    auto separator = std::string{", "};
+
+    ${toCases}
+    if (!result.empty()) {
+      result.erase(result.length() - separator.length());
+    }
+    return result;
+}
+`.trim();
+function getClassExtendString(component) {
+  if (component.extendsProps.length === 0) {
+    throw new Error('Invalid: component.extendsProps is empty');
+  }
+  const extendString =
+    ' : ' +
+    component.extendsProps
+      .map(extendProps => {
+        switch (extendProps.type) {
+          case 'ReactNativeBuiltInType':
+            switch (extendProps.knownTypeName) {
+              case 'ReactNativeCoreViewProps':
+                return 'public ViewProps';
+              default:
+                extendProps.knownTypeName;
+                throw new Error('Invalid knownTypeName');
+            }
+          default:
+            extendProps.type;
+            throw new Error('Invalid extended type');
+        }
+      })
+      .join(' ');
+  return extendString;
+}
+function convertValueToEnumOption(value) {
+  return toSafeCppString(value);
+}
+function generateArrayEnumString(componentName, name, options) {
+  const enumName = getEnumName(componentName, name);
+  const values = options
+    .map((option, index) => `${toSafeCppString(option)} = 1 << ${index}`)
+    .join(',\n  ');
+  const fromCases = options
+    .map(
+      option => `if (item == "${option}") {
+      wrapped.value |= ${enumName}::${toSafeCppString(option)};
+      continue;
+    }`,
+    )
+    .join('\n    ');
+  const toCases = options
+    .map(
+      option => `if (wrapped.value & ${enumName}::${toSafeCppString(option)}) {
+      result += "${option}" + separator;
+    }`,
+    )
+    .join('\n' + '    ');
+  return ArrayEnumTemplate({
+    enumName,
+    enumMask: getEnumMaskName(enumName),
+    values,
+    fromCases,
+    toCases,
+  });
+}
+function generateStringEnum(componentName, prop) {
+  const typeAnnotation = prop.typeAnnotation;
+  if (typeAnnotation.type === 'StringEnumTypeAnnotation') {
+    const values = typeAnnotation.options;
+    const enumName = getEnumName(componentName, prop.name);
+    const fromCases = values
+      .map(
+        value =>
+          `if (string == "${value}") { result = ${enumName}::${convertValueToEnumOption(value)}; return; }`,
+      )
+      .join('\n' + '  ');
+    const toCases = values
+      .map(
+        value =>
+          `case ${enumName}::${convertValueToEnumOption(value)}: return "${value}";`,
+      )
+      .join('\n' + '    ');
+    return EnumTemplate({
+      enumName,
+      values: values.map(toSafeCppString).join(', '),
+      fromCases: fromCases,
+      toCases: toCases,
+    });
+  }
+  return '';
+}
+function generateIntEnum(componentName, prop) {
+  const typeAnnotation = prop.typeAnnotation;
+  if (typeAnnotation.type === 'Int32EnumTypeAnnotation') {
+    const values = typeAnnotation.options;
+    const enumName = getEnumName(componentName, prop.name);
+    const fromCases = values
+      .map(
+        value => `
+    case ${value}:
+      result = ${enumName}::${toIntEnumValueName(prop.name, value)};
+      return;`,
+      )
+      .join('');
+    const toCases = values
+      .map(
+        value =>
+          `case ${enumName}::${toIntEnumValueName(prop.name, value)}: return "${value}";`,
+      )
+      .join('\n' + '    ');
+    const toDynamicCases = values
+      .map(
+        value =>
+          `case ${enumName}::${toIntEnumValueName(prop.name, value)}: return ${value};`,
+      )
+      .join('\n' + '    ');
+    const valueVariables = values
+      .map(val => `${toIntEnumValueName(prop.name, val)} = ${val}`)
+      .join(', ');
+    return IntEnumTemplate({
+      enumName,
+      values: valueVariables,
+      fromCases,
+      toCases,
+      toDynamicCases,
+    });
+  }
+  return '';
+}
+function generateEnumString(componentName, component) {
+  return component.props
+    .map(prop => {
+      if (
+        prop.typeAnnotation.type === 'ArrayTypeAnnotation' &&
+        prop.typeAnnotation.elementType.type === 'StringEnumTypeAnnotation'
+      ) {
+        return generateArrayEnumString(
+          componentName,
+          prop.name,
+          prop.typeAnnotation.elementType.options,
+        );
+      }
+      if (prop.typeAnnotation.type === 'StringEnumTypeAnnotation') {
+        return generateStringEnum(componentName, prop);
+      }
+      if (prop.typeAnnotation.type === 'Int32EnumTypeAnnotation') {
+        return generateIntEnum(componentName, prop);
+      }
+      if (prop.typeAnnotation.type === 'ObjectTypeAnnotation') {
+        return prop.typeAnnotation.properties
+          .map(property => {
+            if (property.typeAnnotation.type === 'StringEnumTypeAnnotation') {
+              return generateStringEnum(componentName, property);
+            } else if (
+              property.typeAnnotation.type === 'Int32EnumTypeAnnotation'
+            ) {
+              return generateIntEnum(componentName, property);
+            }
+            return null;
+          })
+          .filter(Boolean)
+          .join('\n');
+      }
+    })
+    .filter(Boolean)
+    .join('\n');
+}
+function generatePropsString(componentName, props, nameParts) {
+  return props
+    .map(prop => {
+      const nativeType = getNativeTypeFromAnnotation(
+        componentName,
+        prop,
+        nameParts,
+      );
+      const defaultInitializer = getDefaultInitializerString(
+        componentName,
+        prop,
+      );
+      return `${nativeType} ${prop.name}${defaultInitializer};`;
+    })
+    .join('\n' + '  ');
+}
+function getExtendsImports(extendsProps) {
+  const imports = new Set();
+  imports.add('#include <react/renderer/core/PropsParserContext.h>');
+  imports.add('#include <react/renderer/debug/DebugStringConvertible.h>');
+  extendsProps.forEach(extendProps => {
+    switch (extendProps.type) {
+      case 'ReactNativeBuiltInType':
+        switch (extendProps.knownTypeName) {
+          case 'ReactNativeCoreViewProps':
+            imports.add(
+              '#include <react/renderer/components/view/ViewProps.h>',
+            );
+            return;
+          default:
+            extendProps.knownTypeName;
+            throw new Error('Invalid knownTypeName');
+        }
+      default:
+        extendProps.type;
+        throw new Error('Invalid extended type');
+    }
+  });
+  return imports;
+}
+function generateStructsForComponent(componentName, component) {
+  const structs = generateStructs(componentName, component.props, []);
+  const structArray = Array.from(structs.values());
+  if (structArray.length < 1) {
+    return '';
+  }
+  return structArray.join('\n\n');
+}
+function generateStructs(componentName, properties, nameParts) {
+  const structs = new Map();
+  properties.forEach(prop => {
+    const typeAnnotation = prop.typeAnnotation;
+    if (typeAnnotation.type === 'ObjectTypeAnnotation') {
+      // Recursively visit all of the object properties.
+      // Note: this is depth first so that the nested structs are ordered first.
+      const elementProperties = typeAnnotation.properties;
+      const nestedStructs = generateStructs(
+        componentName,
+        elementProperties,
+        nameParts.concat([prop.name]),
+      );
+      nestedStructs.forEach(function (value, key) {
+        structs.set(key, value);
+      });
+      generateStruct(
+        structs,
+        componentName,
+        nameParts.concat([prop.name]),
+        typeAnnotation.properties,
+      );
+    }
+    if (
+      prop.typeAnnotation.type === 'ArrayTypeAnnotation' &&
+      prop.typeAnnotation.elementType.type === 'ObjectTypeAnnotation'
+    ) {
+      // Recursively visit all of the object properties.
+      // Note: this is depth first so that the nested structs are ordered first.
+      const elementProperties = prop.typeAnnotation.elementType.properties;
+      const nestedStructs = generateStructs(
+        componentName,
+        elementProperties,
+        nameParts.concat([prop.name]),
+      );
+      nestedStructs.forEach(function (value, key) {
+        structs.set(key, value);
+      });
+
+      // Generate this struct and its conversion function.
+      generateStruct(
+        structs,
+        componentName,
+        nameParts.concat([prop.name]),
+        elementProperties,
+      );
+
+      // Generate the conversion function for std:vector<Object>.
+      // Note: This needs to be at the end since it references the struct above.
+      structs.set(
+        `${[componentName, ...nameParts.concat([prop.name])].join('')}ArrayStruct`,
+        ArrayConversionFunctionTemplate({
+          structName: generateStructName(
+            componentName,
+            nameParts.concat([prop.name]),
+          ),
+        }),
+      );
+    }
+    if (
+      prop.typeAnnotation.type === 'ArrayTypeAnnotation' &&
+      prop.typeAnnotation.elementType.type === 'ArrayTypeAnnotation' &&
+      prop.typeAnnotation.elementType.elementType.type ===
+        'ObjectTypeAnnotation'
+    ) {
+      // Recursively visit all of the object properties.
+      // Note: this is depth first so that the nested structs are ordered first.
+      const elementProperties =
+        prop.typeAnnotation.elementType.elementType.properties;
+      const nestedStructs = generateStructs(
+        componentName,
+        elementProperties,
+        nameParts.concat([prop.name]),
+      );
+      nestedStructs.forEach(function (value, key) {
+        structs.set(key, value);
+      });
+
+      // Generate this struct and its conversion function.
+      generateStruct(
+        structs,
+        componentName,
+        nameParts.concat([prop.name]),
+        elementProperties,
+      );
+
+      // Generate the conversion function for std:vector<Object>.
+      // Note: This needs to be at the end since it references the struct above.
+      structs.set(
+        `${[componentName, ...nameParts.concat([prop.name])].join('')}ArrayArrayStruct`,
+        DoubleArrayConversionFunctionTemplate({
+          structName: generateStructName(
+            componentName,
+            nameParts.concat([prop.name]),
+          ),
+        }),
+      );
+    }
+  });
+  return structs;
+}
+function generateStruct(structs, componentName, nameParts, properties) {
+  const structNameParts = nameParts;
+  const structName = generateStructName(componentName, structNameParts);
+  const fields = generatePropsString(
+    componentName,
+    properties,
+    structNameParts,
+  );
+  properties.forEach(property => {
+    const name = property.name;
+    switch (property.typeAnnotation.type) {
+      case 'BooleanTypeAnnotation':
+        return;
+      case 'StringTypeAnnotation':
+        return;
+      case 'Int32TypeAnnotation':
+        return;
+      case 'DoubleTypeAnnotation':
+        return;
+      case 'FloatTypeAnnotation':
+        return;
+      case 'ReservedPropTypeAnnotation':
+        return;
+      case 'ArrayTypeAnnotation':
+        return;
+      case 'StringEnumTypeAnnotation':
+        return;
+      case 'Int32EnumTypeAnnotation':
+        return;
+      case 'ObjectTypeAnnotation':
+        const props = property.typeAnnotation.properties;
+        if (props == null) {
+          throw new Error(
+            `Properties are expected for ObjectTypeAnnotation (see ${name} in ${componentName})`,
+          );
+        }
+        generateStruct(structs, componentName, nameParts.concat([name]), props);
+        return;
+      case 'MixedTypeAnnotation':
+        return;
+      default:
+        property.typeAnnotation.type;
+        throw new Error(
+          `Received invalid component property type ${property.typeAnnotation.type}`,
+        );
+    }
+  });
+  const fromCases = properties
+    .map(property => {
+      const variable = 'tmp_' + property.name;
+      return `auto ${variable} = map.find("${property.name}");
+  if (${variable} != map.end()) {
+    fromRawValue(context, ${variable}->second, result.${property.name});
+  }`;
+    })
+    .join('\n  ');
+  const toDynamicCases = properties
+    .map(property => {
+      const name = property.name;
+      switch (property.typeAnnotation.type) {
+        case 'BooleanTypeAnnotation':
+        case 'StringTypeAnnotation':
+        case 'Int32TypeAnnotation':
+        case 'DoubleTypeAnnotation':
+        case 'FloatTypeAnnotation':
+        case 'MixedTypeAnnotation':
+          return `result["${name}"] = ${name};`;
+        default:
+          return `result["${name}"] = ::facebook::react::toDynamic(${name});`;
+      }
+    })
+    .join('\n    ');
+  structs.set(
+    structName,
+    StructTemplate({
+      structName,
+      fields,
+      fromCases,
+      toDynamicCases,
+    }),
+  );
+}
+module.exports = {
+  generate(
+    libraryName,
+    schema,
+    packageName,
+    assumeNonnull = false,
+    headerPrefix,
+    includeGetDebugPropsImplementation = false,
+  ) {
+    const fileName = 'Props.h';
+    const allImports = new Set();
+    const componentClasses = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+        const {components} = module;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+        return Object.keys(components)
+          .map(componentName => {
+            const component = components[componentName];
+            const newName = `${componentName}Props`;
+            const structString = generateStructsForComponent(
+              componentName,
+              component,
+            );
+            const enumString = generateEnumString(componentName, component);
+            const propsString = generatePropsString(
+              componentName,
+              component.props,
+              [],
+            );
+            const extendString = getClassExtendString(component);
+            const extendsImports = getExtendsImports(component.extendsProps);
+            const imports = getLocalImports(component.props);
+
+            // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+            extendsImports.forEach(allImports.add, allImports);
+            // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+            imports.forEach(allImports.add, allImports);
+            const replacedTemplate = ClassTemplate({
+              enums: enumString,
+              structs: structString,
+              className: newName,
+              extendClasses: extendString,
+              props: propsString,
+              includeGetDebugPropsImplementation,
+            });
+            return replacedTemplate;
+          })
+          .join('\n\n');
+      })
+      .filter(Boolean)
+      .join('\n\n');
+    const replacedTemplate = FileTemplate({
+      componentClasses,
+      imports: Array.from(allImports).sort().join('\n'),
+    });
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GeneratePropsH.js.flow

@@ -0,0 +1,863 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+import type {ComponentShape} from '../../CodegenSchema';
+import type {
+  ExtendsPropsShape,
+  NamedShape,
+  PropTypeAnnotation,
+  SchemaType,
+} from '../../CodegenSchema';
+
+const {getEnumName, toSafeCppString} = require('../Utils');
+const {
+  getLocalImports,
+  getNativeTypeFromAnnotation,
+} = require('./ComponentsGeneratorUtils.js');
+const {
+  generateStructName,
+  getDefaultInitializerString,
+  getEnumMaskName,
+  toIntEnumValueName,
+} = require('./CppHelpers.js');
+
+// File path -> contents
+type FilesOutput = Map<string, string>;
+type StructsMap = Map<string, string>;
+
+const FileTemplate = ({
+  imports,
+  componentClasses,
+}: {
+  imports: string,
+  componentClasses: string,
+}) => `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by codegen project: GeneratePropsH.js
+ */
+#pragma once
+
+${imports}
+
+namespace facebook::react {
+
+${componentClasses}
+
+} // namespace facebook::react
+`;
+
+const ClassTemplate = ({
+  enums,
+  structs,
+  className,
+  props,
+  extendClasses,
+  includeGetDebugPropsImplementation,
+}: {
+  enums: string,
+  structs: string,
+  className: string,
+  props: string,
+  extendClasses: string,
+  includeGetDebugPropsImplementation: boolean,
+}) => {
+  const getDebugPropsString = `#if RN_DEBUG_STRING_CONVERTIBLE
+  SharedDebugStringConvertibleList getDebugProps() const override;
+  #endif`;
+
+  return `
+${enums}
+${structs}
+class ${className} final${extendClasses} {
+ public:
+  ${className}() = default;
+  ${className}(const PropsParserContext& context, const ${className} &sourceProps, const RawProps &rawProps);
+
+#pragma mark - Props
+
+  ${props}
+
+  #ifdef RN_SERIALIZABLE_STATE
+  ComponentName getDiffPropsImplementationTarget() const override;
+
+  folly::dynamic getDiffProps(const Props* prevProps) const override;
+  #endif
+
+  ${includeGetDebugPropsImplementation ? getDebugPropsString : ''}
+};
+`.trim();
+};
+
+const EnumTemplate = ({
+  enumName,
+  values,
+  fromCases,
+  toCases,
+}: {
+  enumName: string,
+  values: string,
+  fromCases: string,
+  toCases: string,
+}) =>
+  `
+enum class ${enumName} { ${values} };
+
+static inline void fromRawValue(const PropsParserContext& context, const RawValue &value, ${enumName} &result) {
+  auto string = (std::string)value;
+  ${fromCases}
+  abort();
+}
+
+static inline std::string toString(const ${enumName} &value) {
+  switch (value) {
+    ${toCases}
+  }
+}
+
+#ifdef RN_SERIALIZABLE_STATE
+static inline folly::dynamic toDynamic(const ${enumName} &value) {
+  return toString(value);
+}
+#endif
+`.trim();
+
+const IntEnumTemplate = ({
+  enumName,
+  values,
+  fromCases,
+  toCases,
+  toDynamicCases,
+}: {
+  enumName: string,
+  values: string,
+  fromCases: string,
+  toCases: string,
+  toDynamicCases: string,
+}) =>
+  `
+enum class ${enumName} { ${values} };
+
+static inline void fromRawValue(const PropsParserContext& context, const RawValue &value, ${enumName} &result) {
+  assert(value.hasType<int>());
+  auto integerValue = (int)value;
+  switch (integerValue) {${fromCases}
+  }
+  abort();
+}
+
+static inline std::string toString(const ${enumName} &value) {
+  switch (value) {
+    ${toCases}
+  }
+}
+
+#ifdef RN_SERIALIZABLE_STATE
+static inline folly::dynamic toDynamic(const ${enumName} &value) {
+  switch (value) {
+    ${toDynamicCases}
+  }
+}
+#endif
+`.trim();
+
+const StructTemplate = ({
+  structName,
+  fields,
+  fromCases,
+  toDynamicCases,
+}: {
+  structName: string,
+  fields: string,
+  fromCases: string,
+  toDynamicCases: string,
+}) =>
+  `struct ${structName} {
+  ${fields}
+
+
+#ifdef RN_SERIALIZABLE_STATE
+  bool operator==(const ${structName}&) const = default;
+
+  folly::dynamic toDynamic() const {
+    folly::dynamic result = folly::dynamic::object();
+    ${toDynamicCases}
+    return result;
+  }
+#endif
+};
+
+static inline void fromRawValue(const PropsParserContext& context, const RawValue &value, ${structName} &result) {
+  auto map = (std::unordered_map<std::string, RawValue>)value;
+
+  ${fromCases}
+}
+
+static inline std::string toString(const ${structName} &value) {
+  return "[Object ${structName}]";
+}
+
+#ifdef RN_SERIALIZABLE_STATE
+static inline folly::dynamic toDynamic(const ${structName} &value) {
+  return value.toDynamic();
+}
+#endif
+`.trim();
+
+const ArrayConversionFunctionTemplate = ({
+  structName,
+}: {
+  structName: string,
+}) => `static inline void fromRawValue(const PropsParserContext& context, const RawValue &value, std::vector<${structName}> &result) {
+  auto items = (std::vector<RawValue>)value;
+  for (const auto &item : items) {
+    ${structName} newItem;
+    fromRawValue(context, item, newItem);
+    result.emplace_back(newItem);
+  }
+}
+`;
+
+const DoubleArrayConversionFunctionTemplate = ({
+  structName,
+}: {
+  structName: string,
+}) => `static inline void fromRawValue(const PropsParserContext& context, const RawValue &value, std::vector<std::vector<${structName}>> &result) {
+  auto items = (std::vector<std::vector<RawValue>>)value;
+  for (const std::vector<RawValue> &item : items) {
+    auto nestedArray = std::vector<${structName}>{};
+    for (const RawValue &nestedItem : item) {
+      ${structName} newItem;
+      fromRawValue(context, nestedItem, newItem);
+      nestedArray.emplace_back(newItem);
+    }
+    result.emplace_back(nestedArray);
+  }
+}
+`;
+
+const ArrayEnumTemplate = ({
+  enumName,
+  enumMask,
+  values,
+  fromCases,
+  toCases,
+}: {
+  enumName: string,
+  enumMask: string,
+  values: string,
+  fromCases: string,
+  toCases: string,
+}) =>
+  `
+using ${enumMask} = uint32_t;
+
+struct ${enumMask}Wrapped {
+  ${enumMask} value;
+};
+
+enum class ${enumName}: ${enumMask} {
+  ${values}
+};
+
+constexpr bool operator&(
+  ${enumMask} const lhs,
+  enum ${enumName} const rhs) {
+  return lhs & static_cast<${enumMask}>(rhs);
+}
+
+constexpr ${enumMask} operator|(
+  ${enumMask} const lhs,
+  enum ${enumName} const rhs) {
+  return lhs | static_cast<${enumMask}>(rhs);
+}
+
+constexpr void operator|=(
+  ${enumMask} &lhs,
+  enum ${enumName} const rhs) {
+  lhs = lhs | static_cast<${enumMask}>(rhs);
+}
+
+static inline void fromRawValue(const PropsParserContext& context, const RawValue &value, ${enumMask}Wrapped &wrapped) {
+  auto items = std::vector<std::string>{value};
+  for (const auto &item : items) {
+    ${fromCases}
+    abort();
+  }
+}
+
+static inline std::string toString(const ${enumMask}Wrapped &wrapped) {
+    auto result = std::string{};
+    auto separator = std::string{", "};
+
+    ${toCases}
+    if (!result.empty()) {
+      result.erase(result.length() - separator.length());
+    }
+    return result;
+}
+`.trim();
+
+function getClassExtendString(component: ComponentShape): string {
+  if (component.extendsProps.length === 0) {
+    throw new Error('Invalid: component.extendsProps is empty');
+  }
+  const extendString =
+    ' : ' +
+    component.extendsProps
+      .map(extendProps => {
+        switch (extendProps.type) {
+          case 'ReactNativeBuiltInType':
+            switch (extendProps.knownTypeName) {
+              case 'ReactNativeCoreViewProps':
+                return 'public ViewProps';
+              default:
+                (extendProps.knownTypeName: empty);
+                throw new Error('Invalid knownTypeName');
+            }
+          default:
+            (extendProps.type: empty);
+            throw new Error('Invalid extended type');
+        }
+      })
+      .join(' ');
+
+  return extendString;
+}
+
+function convertValueToEnumOption(value: string): string {
+  return toSafeCppString(value);
+}
+
+function generateArrayEnumString(
+  componentName: string,
+  name: string,
+  options: $ReadOnlyArray<string>,
+): string {
+  const enumName = getEnumName(componentName, name);
+
+  const values = options
+    .map((option, index) => `${toSafeCppString(option)} = 1 << ${index}`)
+    .join(',\n  ');
+
+  const fromCases = options
+    .map(
+      option =>
+        `if (item == "${option}") {
+      wrapped.value |= ${enumName}::${toSafeCppString(option)};
+      continue;
+    }`,
+    )
+    .join('\n    ');
+
+  const toCases = options
+    .map(
+      option =>
+        `if (wrapped.value & ${enumName}::${toSafeCppString(option)}) {
+      result += "${option}" + separator;
+    }`,
+    )
+    .join('\n' + '    ');
+
+  return ArrayEnumTemplate({
+    enumName,
+    enumMask: getEnumMaskName(enumName),
+    values,
+    fromCases,
+    toCases,
+  });
+}
+
+function generateStringEnum(
+  componentName: string,
+  prop: NamedShape<PropTypeAnnotation>,
+) {
+  const typeAnnotation = prop.typeAnnotation;
+  if (typeAnnotation.type === 'StringEnumTypeAnnotation') {
+    const values: $ReadOnlyArray<string> = typeAnnotation.options;
+    const enumName = getEnumName(componentName, prop.name);
+
+    const fromCases = values
+      .map(
+        value =>
+          `if (string == "${value}") { result = ${enumName}::${convertValueToEnumOption(
+            value,
+          )}; return; }`,
+      )
+      .join('\n' + '  ');
+
+    const toCases = values
+      .map(
+        value =>
+          `case ${enumName}::${convertValueToEnumOption(
+            value,
+          )}: return "${value}";`,
+      )
+      .join('\n' + '    ');
+
+    return EnumTemplate({
+      enumName,
+      values: values.map(toSafeCppString).join(', '),
+      fromCases: fromCases,
+      toCases: toCases,
+    });
+  }
+
+  return '';
+}
+
+function generateIntEnum(
+  componentName: string,
+  prop: NamedShape<PropTypeAnnotation>,
+) {
+  const typeAnnotation = prop.typeAnnotation;
+  if (typeAnnotation.type === 'Int32EnumTypeAnnotation') {
+    const values: $ReadOnlyArray<number> = typeAnnotation.options;
+    const enumName = getEnumName(componentName, prop.name);
+
+    const fromCases = values
+      .map(
+        value =>
+          `
+    case ${value}:
+      result = ${enumName}::${toIntEnumValueName(prop.name, value)};
+      return;`,
+      )
+      .join('');
+
+    const toCases = values
+      .map(
+        value =>
+          `case ${enumName}::${toIntEnumValueName(
+            prop.name,
+            value,
+          )}: return "${value}";`,
+      )
+      .join('\n' + '    ');
+
+    const toDynamicCases = values
+      .map(
+        value =>
+          `case ${enumName}::${toIntEnumValueName(
+            prop.name,
+            value,
+          )}: return ${value};`,
+      )
+      .join('\n' + '    ');
+
+    const valueVariables = values
+      .map(val => `${toIntEnumValueName(prop.name, val)} = ${val}`)
+      .join(', ');
+
+    return IntEnumTemplate({
+      enumName,
+      values: valueVariables,
+      fromCases,
+      toCases,
+      toDynamicCases,
+    });
+  }
+
+  return '';
+}
+
+function generateEnumString(
+  componentName: string,
+  component: ComponentShape,
+): string {
+  return component.props
+    .map(prop => {
+      if (
+        prop.typeAnnotation.type === 'ArrayTypeAnnotation' &&
+        prop.typeAnnotation.elementType.type === 'StringEnumTypeAnnotation'
+      ) {
+        return generateArrayEnumString(
+          componentName,
+          prop.name,
+          prop.typeAnnotation.elementType.options,
+        );
+      }
+
+      if (prop.typeAnnotation.type === 'StringEnumTypeAnnotation') {
+        return generateStringEnum(componentName, prop);
+      }
+
+      if (prop.typeAnnotation.type === 'Int32EnumTypeAnnotation') {
+        return generateIntEnum(componentName, prop);
+      }
+
+      if (prop.typeAnnotation.type === 'ObjectTypeAnnotation') {
+        return prop.typeAnnotation.properties
+          .map(property => {
+            if (property.typeAnnotation.type === 'StringEnumTypeAnnotation') {
+              return generateStringEnum(componentName, property);
+            } else if (
+              property.typeAnnotation.type === 'Int32EnumTypeAnnotation'
+            ) {
+              return generateIntEnum(componentName, property);
+            }
+            return null;
+          })
+          .filter(Boolean)
+          .join('\n');
+      }
+    })
+    .filter(Boolean)
+    .join('\n');
+}
+
+function generatePropsString(
+  componentName: string,
+  props: $ReadOnlyArray<NamedShape<PropTypeAnnotation>>,
+  nameParts: $ReadOnlyArray<string>,
+) {
+  return props
+    .map(prop => {
+      const nativeType = getNativeTypeFromAnnotation(
+        componentName,
+        prop,
+        nameParts,
+      );
+      const defaultInitializer = getDefaultInitializerString(
+        componentName,
+        prop,
+      );
+
+      return `${nativeType} ${prop.name}${defaultInitializer};`;
+    })
+    .join('\n' + '  ');
+}
+
+function getExtendsImports(
+  extendsProps: $ReadOnlyArray<ExtendsPropsShape>,
+): Set<string> {
+  const imports: Set<string> = new Set();
+
+  imports.add('#include <react/renderer/core/PropsParserContext.h>');
+  imports.add('#include <react/renderer/debug/DebugStringConvertible.h>');
+
+  extendsProps.forEach(extendProps => {
+    switch (extendProps.type) {
+      case 'ReactNativeBuiltInType':
+        switch (extendProps.knownTypeName) {
+          case 'ReactNativeCoreViewProps':
+            imports.add(
+              '#include <react/renderer/components/view/ViewProps.h>',
+            );
+            return;
+          default:
+            (extendProps.knownTypeName: empty);
+            throw new Error('Invalid knownTypeName');
+        }
+      default:
+        (extendProps.type: empty);
+        throw new Error('Invalid extended type');
+    }
+  });
+
+  return imports;
+}
+
+function generateStructsForComponent(
+  componentName: string,
+  component: ComponentShape,
+): string {
+  const structs = generateStructs(componentName, component.props, []);
+  const structArray = Array.from(structs.values());
+  if (structArray.length < 1) {
+    return '';
+  }
+  return structArray.join('\n\n');
+}
+
+function generateStructs(
+  componentName: string,
+  properties: $ReadOnlyArray<NamedShape<PropTypeAnnotation>>,
+  nameParts: Array<string>,
+): StructsMap {
+  const structs: StructsMap = new Map();
+  properties.forEach(prop => {
+    const typeAnnotation = prop.typeAnnotation;
+    if (typeAnnotation.type === 'ObjectTypeAnnotation') {
+      // Recursively visit all of the object properties.
+      // Note: this is depth first so that the nested structs are ordered first.
+      const elementProperties = typeAnnotation.properties;
+      const nestedStructs = generateStructs(
+        componentName,
+        elementProperties,
+        nameParts.concat([prop.name]),
+      );
+      nestedStructs.forEach(function (value, key) {
+        structs.set(key, value);
+      });
+
+      generateStruct(
+        structs,
+        componentName,
+        nameParts.concat([prop.name]),
+        typeAnnotation.properties,
+      );
+    }
+
+    if (
+      prop.typeAnnotation.type === 'ArrayTypeAnnotation' &&
+      prop.typeAnnotation.elementType.type === 'ObjectTypeAnnotation'
+    ) {
+      // Recursively visit all of the object properties.
+      // Note: this is depth first so that the nested structs are ordered first.
+      const elementProperties = prop.typeAnnotation.elementType.properties;
+      const nestedStructs = generateStructs(
+        componentName,
+        elementProperties,
+        nameParts.concat([prop.name]),
+      );
+      nestedStructs.forEach(function (value, key) {
+        structs.set(key, value);
+      });
+
+      // Generate this struct and its conversion function.
+      generateStruct(
+        structs,
+        componentName,
+        nameParts.concat([prop.name]),
+        elementProperties,
+      );
+
+      // Generate the conversion function for std:vector<Object>.
+      // Note: This needs to be at the end since it references the struct above.
+      structs.set(
+        `${[componentName, ...nameParts.concat([prop.name])].join(
+          '',
+        )}ArrayStruct`,
+        ArrayConversionFunctionTemplate({
+          structName: generateStructName(
+            componentName,
+            nameParts.concat([prop.name]),
+          ),
+        }),
+      );
+    }
+    if (
+      prop.typeAnnotation.type === 'ArrayTypeAnnotation' &&
+      prop.typeAnnotation.elementType.type === 'ArrayTypeAnnotation' &&
+      prop.typeAnnotation.elementType.elementType.type ===
+        'ObjectTypeAnnotation'
+    ) {
+      // Recursively visit all of the object properties.
+      // Note: this is depth first so that the nested structs are ordered first.
+      const elementProperties =
+        prop.typeAnnotation.elementType.elementType.properties;
+      const nestedStructs = generateStructs(
+        componentName,
+        elementProperties,
+        nameParts.concat([prop.name]),
+      );
+      nestedStructs.forEach(function (value, key) {
+        structs.set(key, value);
+      });
+
+      // Generate this struct and its conversion function.
+      generateStruct(
+        structs,
+        componentName,
+        nameParts.concat([prop.name]),
+        elementProperties,
+      );
+
+      // Generate the conversion function for std:vector<Object>.
+      // Note: This needs to be at the end since it references the struct above.
+      structs.set(
+        `${[componentName, ...nameParts.concat([prop.name])].join(
+          '',
+        )}ArrayArrayStruct`,
+        DoubleArrayConversionFunctionTemplate({
+          structName: generateStructName(
+            componentName,
+            nameParts.concat([prop.name]),
+          ),
+        }),
+      );
+    }
+  });
+
+  return structs;
+}
+
+function generateStruct(
+  structs: StructsMap,
+  componentName: string,
+  nameParts: $ReadOnlyArray<string>,
+  properties: $ReadOnlyArray<NamedShape<PropTypeAnnotation>>,
+): void {
+  const structNameParts = nameParts;
+  const structName = generateStructName(componentName, structNameParts);
+  const fields = generatePropsString(
+    componentName,
+    properties,
+    structNameParts,
+  );
+
+  properties.forEach((property: NamedShape<PropTypeAnnotation>) => {
+    const name = property.name;
+    switch (property.typeAnnotation.type) {
+      case 'BooleanTypeAnnotation':
+        return;
+      case 'StringTypeAnnotation':
+        return;
+      case 'Int32TypeAnnotation':
+        return;
+      case 'DoubleTypeAnnotation':
+        return;
+      case 'FloatTypeAnnotation':
+        return;
+      case 'ReservedPropTypeAnnotation':
+        return;
+      case 'ArrayTypeAnnotation':
+        return;
+      case 'StringEnumTypeAnnotation':
+        return;
+      case 'Int32EnumTypeAnnotation':
+        return;
+      case 'ObjectTypeAnnotation':
+        const props = property.typeAnnotation.properties;
+        if (props == null) {
+          throw new Error(
+            `Properties are expected for ObjectTypeAnnotation (see ${name} in ${componentName})`,
+          );
+        }
+        generateStruct(structs, componentName, nameParts.concat([name]), props);
+        return;
+      case 'MixedTypeAnnotation':
+        return;
+      default:
+        (property.typeAnnotation.type: empty);
+        throw new Error(
+          `Received invalid component property type ${property.typeAnnotation.type}`,
+        );
+    }
+  });
+
+  const fromCases = properties
+    .map(property => {
+      const variable = 'tmp_' + property.name;
+      return `auto ${variable} = map.find("${property.name}");
+  if (${variable} != map.end()) {
+    fromRawValue(context, ${variable}->second, result.${property.name});
+  }`;
+    })
+    .join('\n  ');
+
+  const toDynamicCases = properties
+    .map((property: NamedShape<PropTypeAnnotation>) => {
+      const name = property.name;
+      switch (property.typeAnnotation.type) {
+        case 'BooleanTypeAnnotation':
+        case 'StringTypeAnnotation':
+        case 'Int32TypeAnnotation':
+        case 'DoubleTypeAnnotation':
+        case 'FloatTypeAnnotation':
+        case 'MixedTypeAnnotation':
+          return `result["${name}"] = ${name};`;
+        default:
+          return `result["${name}"] = ::facebook::react::toDynamic(${name});`;
+      }
+    })
+    .join('\n    ');
+
+  structs.set(
+    structName,
+    StructTemplate({
+      structName,
+      fields,
+      fromCases,
+      toDynamicCases,
+    }),
+  );
+}
+
+module.exports = {
+  generate(
+    libraryName: string,
+    schema: SchemaType,
+    packageName?: string,
+    assumeNonnull: boolean = false,
+    headerPrefix?: string,
+    includeGetDebugPropsImplementation?: boolean = false,
+  ): FilesOutput {
+    const fileName = 'Props.h';
+
+    const allImports: Set<string> = new Set();
+
+    const componentClasses = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+
+        const {components} = module;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+
+        return Object.keys(components)
+          .map(componentName => {
+            const component = components[componentName];
+
+            const newName = `${componentName}Props`;
+            const structString = generateStructsForComponent(
+              componentName,
+              component,
+            );
+            const enumString = generateEnumString(componentName, component);
+            const propsString = generatePropsString(
+              componentName,
+              component.props,
+              [],
+            );
+            const extendString = getClassExtendString(component);
+            const extendsImports = getExtendsImports(component.extendsProps);
+            const imports = getLocalImports(component.props);
+
+            // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+            extendsImports.forEach(allImports.add, allImports);
+            // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+            imports.forEach(allImports.add, allImports);
+
+            const replacedTemplate = ClassTemplate({
+              enums: enumString,
+              structs: structString,
+              className: newName,
+              extendClasses: extendString,
+              props: propsString,
+              includeGetDebugPropsImplementation,
+            });
+
+            return replacedTemplate;
+          })
+          .join('\n\n');
+      })
+      .filter(Boolean)
+      .join('\n\n');
+
+    const replacedTemplate = FileTemplate({
+      componentClasses,
+      imports: Array.from(allImports).sort().join('\n'),
+    });
+
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GeneratePropsJavaDelegate.js

@@ -0,0 +1,298 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+const {
+  getDelegateJavaClassName,
+  getImports,
+  getInterfaceJavaClassName,
+  toSafeJavaString,
+} = require('./JavaHelpers');
+
+// File path -> contents
+
+const FileTemplate = ({
+  packageName,
+  imports,
+  className,
+  extendClasses,
+  interfaceClassName,
+  methods,
+}) => `/**
+* This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+*
+* Do not edit this file as changes may cause incorrect behavior and will be lost
+* once the code is regenerated.
+*
+* ${'@'}generated by codegen project: GeneratePropsJavaDelegate.js
+*/
+
+package ${packageName};
+
+${imports}
+
+@SuppressWarnings("deprecation")
+public class ${className}<T extends ${extendClasses}, U extends BaseViewManager<T, ? extends LayoutShadowNode> & ${interfaceClassName}<T>> extends BaseViewManagerDelegate<T, U> {
+  public ${className}(U viewManager) {
+    super(viewManager);
+  }
+  ${methods}
+}
+`;
+const PropSetterTemplate = ({propCases}) =>
+  `
+  @Override
+  public void setProperty(T view, String propName, @Nullable Object value) {
+    ${propCases}
+  }
+`.trim();
+const CommandsTemplate = ({commandCases}) =>
+  `
+  @Override
+  public void receiveCommand(T view, String commandName, ReadableArray args) {
+    switch (commandName) {
+      ${commandCases}
+    }
+  }
+`.trim();
+function getJavaValueForProp(prop, componentName) {
+  const typeAnnotation = prop.typeAnnotation;
+  switch (typeAnnotation.type) {
+    case 'BooleanTypeAnnotation':
+      if (typeAnnotation.default === null) {
+        return 'value == null ? null : (Boolean) value';
+      } else {
+        return `value == null ? ${typeAnnotation.default.toString()} : (boolean) value`;
+      }
+    case 'StringTypeAnnotation':
+      const defaultValueString =
+        typeAnnotation.default === null
+          ? 'null'
+          : `"${typeAnnotation.default}"`;
+      return `value == null ? ${defaultValueString} : (String) value`;
+    case 'Int32TypeAnnotation':
+      return `value == null ? ${typeAnnotation.default} : ((Double) value).intValue()`;
+    case 'DoubleTypeAnnotation':
+      if (prop.optional) {
+        return `value == null ? ${typeAnnotation.default}f : ((Double) value).doubleValue()`;
+      } else {
+        return 'value == null ? Double.NaN : ((Double) value).doubleValue()';
+      }
+    case 'FloatTypeAnnotation':
+      if (typeAnnotation.default === null) {
+        return 'value == null ? null : ((Double) value).floatValue()';
+      } else if (prop.optional) {
+        return `value == null ? ${typeAnnotation.default}f : ((Double) value).floatValue()`;
+      } else {
+        return 'value == null ? Float.NaN : ((Double) value).floatValue()';
+      }
+    case 'ReservedPropTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'ColorPrimitive':
+          return 'ColorPropConverter.getColor(value, view.getContext())';
+        case 'ImageSourcePrimitive':
+          return '(ReadableMap) value';
+        case 'ImageRequestPrimitive':
+          return '(ReadableMap) value';
+        case 'PointPrimitive':
+          return '(ReadableMap) value';
+        case 'EdgeInsetsPrimitive':
+          return '(ReadableMap) value';
+        case 'DimensionPrimitive':
+          return 'DimensionPropConverter.getDimension(value)';
+        default:
+          typeAnnotation.name;
+          throw new Error('Received unknown ReservedPropTypeAnnotation');
+      }
+    case 'ArrayTypeAnnotation': {
+      return '(ReadableArray) value';
+    }
+    case 'ObjectTypeAnnotation': {
+      return '(ReadableMap) value';
+    }
+    case 'StringEnumTypeAnnotation':
+      return '(String) value';
+    case 'Int32EnumTypeAnnotation':
+      return `value == null ? ${typeAnnotation.default} : ((Double) value).intValue()`;
+    case 'MixedTypeAnnotation':
+      return 'new DynamicFromObject(value)';
+    default:
+      typeAnnotation;
+      throw new Error('Received invalid typeAnnotation');
+  }
+}
+function generatePropCasesString(component, componentName) {
+  if (component.props.length === 0) {
+    return 'super.setProperty(view, propName, value);';
+  }
+  const cases = component.props
+    .map(prop => {
+      return `case "${prop.name}":
+        mViewManager.set${toSafeJavaString(prop.name)}(view, ${getJavaValueForProp(prop, componentName)});
+        break;`;
+    })
+    .join('\n' + '      ');
+  return `switch (propName) {
+      ${cases}
+      default:
+        super.setProperty(view, propName, value);
+    }`;
+}
+function getCommandArgJavaType(param, index) {
+  const {typeAnnotation} = param;
+  switch (typeAnnotation.type) {
+    case 'ReservedTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'RootTag':
+          return `args.getDouble(${index})`;
+        default:
+          typeAnnotation.name;
+          throw new Error(`Receieved invalid type: ${typeAnnotation.name}`);
+      }
+    case 'BooleanTypeAnnotation':
+      return `args.getBoolean(${index})`;
+    case 'DoubleTypeAnnotation':
+      return `args.getDouble(${index})`;
+    case 'FloatTypeAnnotation':
+      return `(float) args.getDouble(${index})`;
+    case 'Int32TypeAnnotation':
+      return `args.getInt(${index})`;
+    case 'StringTypeAnnotation':
+      return `args.getString(${index})`;
+    case 'ArrayTypeAnnotation':
+      return `args.getArray(${index})`;
+    default:
+      typeAnnotation.type;
+      throw new Error(`Receieved invalid type: ${typeAnnotation.type}`);
+  }
+}
+function getCommandArguments(command) {
+  return [
+    'view',
+    ...command.typeAnnotation.params.map(getCommandArgJavaType),
+  ].join(', ');
+}
+function generateCommandCasesString(component, componentName) {
+  if (component.commands.length === 0) {
+    return null;
+  }
+  const commandMethods = component.commands
+    .map(command => {
+      return `case "${command.name}":
+        mViewManager.${toSafeJavaString(command.name, false)}(${getCommandArguments(command)});
+        break;`;
+    })
+    .join('\n' + '      ');
+  return commandMethods;
+}
+function getClassExtendString(component) {
+  const extendString = component.extendsProps
+    .map(extendProps => {
+      switch (extendProps.type) {
+        case 'ReactNativeBuiltInType':
+          switch (extendProps.knownTypeName) {
+            case 'ReactNativeCoreViewProps':
+              return 'View';
+            default:
+              extendProps.knownTypeName;
+              throw new Error('Invalid knownTypeName');
+          }
+        default:
+          extendProps.type;
+          throw new Error('Invalid extended type');
+      }
+    })
+    .join('');
+  return extendString;
+}
+function getDelegateImports(component) {
+  const imports = getImports(component, 'delegate');
+  // The delegate needs ReadableArray for commands always.
+  // The interface doesn't always need it
+  if (component.commands.length > 0) {
+    imports.add('import com.facebook.react.bridge.ReadableArray;');
+  }
+  imports.add('import androidx.annotation.Nullable;');
+  imports.add('import com.facebook.react.uimanager.BaseViewManagerDelegate;');
+  imports.add('import com.facebook.react.uimanager.BaseViewManager;');
+  imports.add('import com.facebook.react.uimanager.LayoutShadowNode;');
+  return imports;
+}
+function generateMethods(propsString, commandsString) {
+  return [
+    PropSetterTemplate({
+      propCases: propsString,
+    }),
+    commandsString != null
+      ? CommandsTemplate({
+          commandCases: commandsString,
+        })
+      : '',
+  ]
+    .join('\n\n  ')
+    .trimRight();
+}
+module.exports = {
+  generate(
+    libraryName,
+    schema,
+    packageName,
+    assumeNonnull = false,
+    headerPrefix,
+    includeGetDebugPropsImplementation = false,
+  ) {
+    // TODO: This doesn't support custom package name yet.
+    const normalizedPackageName = 'com.facebook.react.viewmanagers';
+    const outputDir = `java/${normalizedPackageName.replace(/\./g, '/')}`;
+    const files = new Map();
+    Object.keys(schema.modules).forEach(moduleName => {
+      const module = schema.modules[moduleName];
+      if (module.type !== 'Component') {
+        return;
+      }
+      const {components} = module;
+      // No components in this module
+      if (components == null) {
+        return;
+      }
+      return Object.keys(components)
+        .filter(componentName => {
+          const component = components[componentName];
+          return !(
+            component.excludedPlatforms &&
+            component.excludedPlatforms.includes('android')
+          );
+        })
+        .forEach(componentName => {
+          const component = components[componentName];
+          const className = getDelegateJavaClassName(componentName);
+          const interfaceClassName = getInterfaceJavaClassName(componentName);
+          const imports = getDelegateImports(component);
+          const propsString = generatePropCasesString(component, componentName);
+          const commandsString = generateCommandCasesString(
+            component,
+            componentName,
+          );
+          const extendString = getClassExtendString(component);
+          const replacedTemplate = FileTemplate({
+            imports: Array.from(imports).sort().join('\n'),
+            packageName: normalizedPackageName,
+            className,
+            extendClasses: extendString,
+            methods: generateMethods(propsString, commandsString),
+            interfaceClassName: interfaceClassName,
+          });
+          files.set(`${outputDir}/${className}.java`, replacedTemplate);
+        });
+    });
+    return files;
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GeneratePropsJavaDelegate.js.flow

@@ -0,0 +1,358 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+import type {CommandParamTypeAnnotation} from '../../CodegenSchema';
+import type {
+  CommandTypeAnnotation,
+  ComponentShape,
+  NamedShape,
+  PropTypeAnnotation,
+  SchemaType,
+} from '../../CodegenSchema';
+
+const {
+  getDelegateJavaClassName,
+  getImports,
+  getInterfaceJavaClassName,
+  toSafeJavaString,
+} = require('./JavaHelpers');
+
+// File path -> contents
+type FilesOutput = Map<string, string>;
+
+const FileTemplate = ({
+  packageName,
+  imports,
+  className,
+  extendClasses,
+  interfaceClassName,
+  methods,
+}: {
+  packageName: string,
+  imports: string,
+  className: string,
+  extendClasses: string,
+  interfaceClassName: string,
+  methods: string,
+}) => `/**
+* This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+*
+* Do not edit this file as changes may cause incorrect behavior and will be lost
+* once the code is regenerated.
+*
+* ${'@'}generated by codegen project: GeneratePropsJavaDelegate.js
+*/
+
+package ${packageName};
+
+${imports}
+
+@SuppressWarnings("deprecation")
+public class ${className}<T extends ${extendClasses}, U extends BaseViewManager<T, ? extends LayoutShadowNode> & ${interfaceClassName}<T>> extends BaseViewManagerDelegate<T, U> {
+  public ${className}(U viewManager) {
+    super(viewManager);
+  }
+  ${methods}
+}
+`;
+
+const PropSetterTemplate = ({propCases}: {propCases: string}) =>
+  `
+  @Override
+  public void setProperty(T view, String propName, @Nullable Object value) {
+    ${propCases}
+  }
+`.trim();
+
+const CommandsTemplate = ({commandCases}: {commandCases: string}) =>
+  `
+  @Override
+  public void receiveCommand(T view, String commandName, ReadableArray args) {
+    switch (commandName) {
+      ${commandCases}
+    }
+  }
+`.trim();
+
+function getJavaValueForProp(
+  prop: NamedShape<PropTypeAnnotation>,
+  componentName: string,
+): string {
+  const typeAnnotation = prop.typeAnnotation;
+
+  switch (typeAnnotation.type) {
+    case 'BooleanTypeAnnotation':
+      if (typeAnnotation.default === null) {
+        return 'value == null ? null : (Boolean) value';
+      } else {
+        return `value == null ? ${typeAnnotation.default.toString()} : (boolean) value`;
+      }
+    case 'StringTypeAnnotation':
+      const defaultValueString =
+        typeAnnotation.default === null
+          ? 'null'
+          : `"${typeAnnotation.default}"`;
+      return `value == null ? ${defaultValueString} : (String) value`;
+    case 'Int32TypeAnnotation':
+      return `value == null ? ${typeAnnotation.default} : ((Double) value).intValue()`;
+    case 'DoubleTypeAnnotation':
+      if (prop.optional) {
+        return `value == null ? ${typeAnnotation.default}f : ((Double) value).doubleValue()`;
+      } else {
+        return 'value == null ? Double.NaN : ((Double) value).doubleValue()';
+      }
+    case 'FloatTypeAnnotation':
+      if (typeAnnotation.default === null) {
+        return 'value == null ? null : ((Double) value).floatValue()';
+      } else if (prop.optional) {
+        return `value == null ? ${typeAnnotation.default}f : ((Double) value).floatValue()`;
+      } else {
+        return 'value == null ? Float.NaN : ((Double) value).floatValue()';
+      }
+    case 'ReservedPropTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'ColorPrimitive':
+          return 'ColorPropConverter.getColor(value, view.getContext())';
+        case 'ImageSourcePrimitive':
+          return '(ReadableMap) value';
+        case 'ImageRequestPrimitive':
+          return '(ReadableMap) value';
+        case 'PointPrimitive':
+          return '(ReadableMap) value';
+        case 'EdgeInsetsPrimitive':
+          return '(ReadableMap) value';
+        case 'DimensionPrimitive':
+          return 'DimensionPropConverter.getDimension(value)';
+        default:
+          (typeAnnotation.name: empty);
+          throw new Error('Received unknown ReservedPropTypeAnnotation');
+      }
+    case 'ArrayTypeAnnotation': {
+      return '(ReadableArray) value';
+    }
+    case 'ObjectTypeAnnotation': {
+      return '(ReadableMap) value';
+    }
+    case 'StringEnumTypeAnnotation':
+      return '(String) value';
+    case 'Int32EnumTypeAnnotation':
+      return `value == null ? ${typeAnnotation.default} : ((Double) value).intValue()`;
+    case 'MixedTypeAnnotation':
+      return 'new DynamicFromObject(value)';
+    default:
+      (typeAnnotation: empty);
+      throw new Error('Received invalid typeAnnotation');
+  }
+}
+
+function generatePropCasesString(
+  component: ComponentShape,
+  componentName: string,
+) {
+  if (component.props.length === 0) {
+    return 'super.setProperty(view, propName, value);';
+  }
+
+  const cases = component.props
+    .map(prop => {
+      return `case "${prop.name}":
+        mViewManager.set${toSafeJavaString(
+          prop.name,
+        )}(view, ${getJavaValueForProp(prop, componentName)});
+        break;`;
+    })
+    .join('\n' + '      ');
+
+  return `switch (propName) {
+      ${cases}
+      default:
+        super.setProperty(view, propName, value);
+    }`;
+}
+
+function getCommandArgJavaType(
+  param: NamedShape<CommandParamTypeAnnotation>,
+  index: number,
+) {
+  const {typeAnnotation} = param;
+
+  switch (typeAnnotation.type) {
+    case 'ReservedTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'RootTag':
+          return `args.getDouble(${index})`;
+        default:
+          (typeAnnotation.name: empty);
+          throw new Error(`Receieved invalid type: ${typeAnnotation.name}`);
+      }
+    case 'BooleanTypeAnnotation':
+      return `args.getBoolean(${index})`;
+    case 'DoubleTypeAnnotation':
+      return `args.getDouble(${index})`;
+    case 'FloatTypeAnnotation':
+      return `(float) args.getDouble(${index})`;
+    case 'Int32TypeAnnotation':
+      return `args.getInt(${index})`;
+    case 'StringTypeAnnotation':
+      return `args.getString(${index})`;
+    case 'ArrayTypeAnnotation':
+      return `args.getArray(${index})`;
+    default:
+      (typeAnnotation.type: empty);
+      throw new Error(`Receieved invalid type: ${typeAnnotation.type}`);
+  }
+}
+
+function getCommandArguments(
+  command: NamedShape<CommandTypeAnnotation>,
+): string {
+  return [
+    'view',
+    ...command.typeAnnotation.params.map(getCommandArgJavaType),
+  ].join(', ');
+}
+
+function generateCommandCasesString(
+  component: ComponentShape,
+  componentName: string,
+) {
+  if (component.commands.length === 0) {
+    return null;
+  }
+
+  const commandMethods = component.commands
+    .map(command => {
+      return `case "${command.name}":
+        mViewManager.${toSafeJavaString(
+          command.name,
+          false,
+        )}(${getCommandArguments(command)});
+        break;`;
+    })
+    .join('\n' + '      ');
+
+  return commandMethods;
+}
+
+function getClassExtendString(component: ComponentShape): string {
+  const extendString = component.extendsProps
+    .map(extendProps => {
+      switch (extendProps.type) {
+        case 'ReactNativeBuiltInType':
+          switch (extendProps.knownTypeName) {
+            case 'ReactNativeCoreViewProps':
+              return 'View';
+            default:
+              (extendProps.knownTypeName: empty);
+              throw new Error('Invalid knownTypeName');
+          }
+        default:
+          (extendProps.type: empty);
+          throw new Error('Invalid extended type');
+      }
+    })
+    .join('');
+
+  return extendString;
+}
+
+function getDelegateImports(component: ComponentShape) {
+  const imports = getImports(component, 'delegate');
+  // The delegate needs ReadableArray for commands always.
+  // The interface doesn't always need it
+  if (component.commands.length > 0) {
+    imports.add('import com.facebook.react.bridge.ReadableArray;');
+  }
+  imports.add('import androidx.annotation.Nullable;');
+  imports.add('import com.facebook.react.uimanager.BaseViewManagerDelegate;');
+  imports.add('import com.facebook.react.uimanager.BaseViewManager;');
+  imports.add('import com.facebook.react.uimanager.LayoutShadowNode;');
+
+  return imports;
+}
+
+function generateMethods(
+  propsString: string,
+  commandsString: null | string,
+): string {
+  return [
+    PropSetterTemplate({propCases: propsString}),
+    commandsString != null
+      ? CommandsTemplate({commandCases: commandsString})
+      : '',
+  ]
+    .join('\n\n  ')
+    .trimRight();
+}
+
+module.exports = {
+  generate(
+    libraryName: string,
+    schema: SchemaType,
+    packageName?: string,
+    assumeNonnull: boolean = false,
+    headerPrefix?: string,
+    includeGetDebugPropsImplementation?: boolean = false,
+  ): FilesOutput {
+    // TODO: This doesn't support custom package name yet.
+    const normalizedPackageName = 'com.facebook.react.viewmanagers';
+    const outputDir = `java/${normalizedPackageName.replace(/\./g, '/')}`;
+
+    const files = new Map<string, string>();
+    Object.keys(schema.modules).forEach(moduleName => {
+      const module = schema.modules[moduleName];
+      if (module.type !== 'Component') {
+        return;
+      }
+
+      const {components} = module;
+      // No components in this module
+      if (components == null) {
+        return;
+      }
+
+      return Object.keys(components)
+        .filter(componentName => {
+          const component = components[componentName];
+          return !(
+            component.excludedPlatforms &&
+            component.excludedPlatforms.includes('android')
+          );
+        })
+        .forEach(componentName => {
+          const component = components[componentName];
+          const className = getDelegateJavaClassName(componentName);
+          const interfaceClassName = getInterfaceJavaClassName(componentName);
+
+          const imports = getDelegateImports(component);
+          const propsString = generatePropCasesString(component, componentName);
+          const commandsString = generateCommandCasesString(
+            component,
+            componentName,
+          );
+          const extendString = getClassExtendString(component);
+
+          const replacedTemplate = FileTemplate({
+            imports: Array.from(imports).sort().join('\n'),
+            packageName: normalizedPackageName,
+            className,
+            extendClasses: extendString,
+            methods: generateMethods(propsString, commandsString),
+            interfaceClassName: interfaceClassName,
+          });
+
+          files.set(`${outputDir}/${className}.java`, replacedTemplate);
+        });
+    });
+
+    return files;
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GeneratePropsJavaInterface.js

@@ -0,0 +1,247 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+const {
+  getImports,
+  getInterfaceJavaClassName,
+  toSafeJavaString,
+} = require('./JavaHelpers');
+
+// File path -> contents
+
+const FileTemplate = ({
+  packageName,
+  imports,
+  className,
+  extendClasses,
+  methods,
+}) => `/**
+* This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+*
+* Do not edit this file as changes may cause incorrect behavior and will be lost
+* once the code is regenerated.
+*
+* ${'@'}generated by codegen project: GeneratePropsJavaInterface.js
+*/
+
+package ${packageName};
+
+${imports}
+
+public interface ${className}<T extends ${extendClasses}> extends ViewManagerWithGeneratedInterface {
+  ${methods}
+}
+`;
+function addNullable(imports) {
+  imports.add('import androidx.annotation.Nullable;');
+}
+function getJavaValueForProp(prop, imports) {
+  const typeAnnotation = prop.typeAnnotation;
+  switch (typeAnnotation.type) {
+    case 'BooleanTypeAnnotation':
+      if (typeAnnotation.default === null) {
+        addNullable(imports);
+        return '@Nullable Boolean value';
+      } else {
+        return 'boolean value';
+      }
+    case 'StringTypeAnnotation':
+      addNullable(imports);
+      return '@Nullable String value';
+    case 'Int32TypeAnnotation':
+      return 'int value';
+    case 'DoubleTypeAnnotation':
+      return 'double value';
+    case 'FloatTypeAnnotation':
+      if (typeAnnotation.default === null) {
+        addNullable(imports);
+        return '@Nullable Float value';
+      } else {
+        return 'float value';
+      }
+    case 'ReservedPropTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'ColorPrimitive':
+          addNullable(imports);
+          return '@Nullable Integer value';
+        case 'ImageSourcePrimitive':
+          addNullable(imports);
+          return '@Nullable ReadableMap value';
+        case 'ImageRequestPrimitive':
+          addNullable(imports);
+          return '@Nullable ReadableMap value';
+        case 'PointPrimitive':
+          addNullable(imports);
+          return '@Nullable ReadableMap value';
+        case 'EdgeInsetsPrimitive':
+          addNullable(imports);
+          return '@Nullable ReadableMap value';
+        case 'DimensionPrimitive':
+          addNullable(imports);
+          return '@Nullable YogaValue value';
+        default:
+          typeAnnotation.name;
+          throw new Error('Received unknown ReservedPropTypeAnnotation');
+      }
+    case 'ArrayTypeAnnotation': {
+      addNullable(imports);
+      return '@Nullable ReadableArray value';
+    }
+    case 'ObjectTypeAnnotation': {
+      addNullable(imports);
+      return '@Nullable ReadableMap value';
+    }
+    case 'StringEnumTypeAnnotation':
+      addNullable(imports);
+      return '@Nullable String value';
+    case 'Int32EnumTypeAnnotation':
+      addNullable(imports);
+      return '@Nullable Integer value';
+    case 'MixedTypeAnnotation':
+      return 'Dynamic value';
+    default:
+      typeAnnotation;
+      throw new Error('Received invalid typeAnnotation');
+  }
+}
+function generatePropsString(component, imports) {
+  if (component.props.length === 0) {
+    return '// No props';
+  }
+  return component.props
+    .map(prop => {
+      return `void set${toSafeJavaString(prop.name)}(T view, ${getJavaValueForProp(prop, imports)});`;
+    })
+    .join('\n' + '  ');
+}
+function getCommandArgJavaType(param) {
+  const {typeAnnotation} = param;
+  switch (typeAnnotation.type) {
+    case 'ReservedTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'RootTag':
+          return 'double';
+        default:
+          typeAnnotation.name;
+          throw new Error(`Receieved invalid type: ${typeAnnotation.name}`);
+      }
+    case 'BooleanTypeAnnotation':
+      return 'boolean';
+    case 'DoubleTypeAnnotation':
+      return 'double';
+    case 'FloatTypeAnnotation':
+      return 'float';
+    case 'Int32TypeAnnotation':
+      return 'int';
+    case 'StringTypeAnnotation':
+      return 'String';
+    case 'ArrayTypeAnnotation':
+      return 'ReadableArray';
+    default:
+      typeAnnotation.type;
+      throw new Error('Receieved invalid typeAnnotation');
+  }
+}
+function getCommandArguments(command, componentName) {
+  return [
+    'T view',
+    ...command.typeAnnotation.params.map(param => {
+      const commandArgJavaType = getCommandArgJavaType(param);
+      return `${commandArgJavaType} ${param.name}`;
+    }),
+  ].join(', ');
+}
+function generateCommandsString(component, componentName) {
+  return component.commands
+    .map(command => {
+      const safeJavaName = toSafeJavaString(command.name, false);
+      return `void ${safeJavaName}(${getCommandArguments(command, componentName)});`;
+    })
+    .join('\n' + '  ');
+}
+function getClassExtendString(component) {
+  const extendString = component.extendsProps
+    .map(extendProps => {
+      switch (extendProps.type) {
+        case 'ReactNativeBuiltInType':
+          switch (extendProps.knownTypeName) {
+            case 'ReactNativeCoreViewProps':
+              return 'View';
+            default:
+              extendProps.knownTypeName;
+              throw new Error('Invalid knownTypeName');
+          }
+        default:
+          extendProps.type;
+          throw new Error('Invalid extended type');
+      }
+    })
+    .join('');
+  return extendString;
+}
+module.exports = {
+  generate(
+    libraryName,
+    schema,
+    packageName,
+    assumeNonnull = false,
+    headerPrefix,
+    includeGetDebugPropsImplementation = false,
+  ) {
+    // TODO: This doesn't support custom package name yet.
+    const normalizedPackageName = 'com.facebook.react.viewmanagers';
+    const outputDir = `java/${normalizedPackageName.replace(/\./g, '/')}`;
+    const files = new Map();
+    Object.keys(schema.modules).forEach(moduleName => {
+      const module = schema.modules[moduleName];
+      if (module.type !== 'Component') {
+        return;
+      }
+      const {components} = module;
+
+      // No components in this module
+      if (components == null) {
+        return;
+      }
+      return Object.keys(components)
+        .filter(componentName => {
+          const component = components[componentName];
+          return !(
+            component.excludedPlatforms &&
+            component.excludedPlatforms.includes('android')
+          );
+        })
+        .forEach(componentName => {
+          const component = components[componentName];
+          const className = getInterfaceJavaClassName(componentName);
+          const imports = getImports(component, 'interface');
+          const propsString = generatePropsString(component, imports);
+          const commandsString = generateCommandsString(
+            component,
+            componentName,
+          );
+          const extendString = getClassExtendString(component);
+          const replacedTemplate = FileTemplate({
+            imports: Array.from(imports).sort().join('\n'),
+            packageName: normalizedPackageName,
+            className,
+            extendClasses: extendString,
+            methods: [propsString, commandsString]
+              .join('\n' + '  ')
+              .trimRight(),
+          });
+          files.set(`${outputDir}/${className}.java`, replacedTemplate);
+        });
+    });
+    return files;
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GeneratePropsJavaInterface.js.flow

@@ -0,0 +1,297 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+import type {CommandParamTypeAnnotation} from '../../CodegenSchema';
+import type {
+  CommandTypeAnnotation,
+  ComponentShape,
+  NamedShape,
+  PropTypeAnnotation,
+  SchemaType,
+} from '../../CodegenSchema';
+
+const {
+  getImports,
+  getInterfaceJavaClassName,
+  toSafeJavaString,
+} = require('./JavaHelpers');
+
+// File path -> contents
+type FilesOutput = Map<string, string>;
+
+const FileTemplate = ({
+  packageName,
+  imports,
+  className,
+  extendClasses,
+  methods,
+}: {
+  packageName: string,
+  imports: string,
+  className: string,
+  extendClasses: string,
+  methods: string,
+}) => `/**
+* This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+*
+* Do not edit this file as changes may cause incorrect behavior and will be lost
+* once the code is regenerated.
+*
+* ${'@'}generated by codegen project: GeneratePropsJavaInterface.js
+*/
+
+package ${packageName};
+
+${imports}
+
+public interface ${className}<T extends ${extendClasses}> extends ViewManagerWithGeneratedInterface {
+  ${methods}
+}
+`;
+
+function addNullable(imports: Set<string>) {
+  imports.add('import androidx.annotation.Nullable;');
+}
+
+function getJavaValueForProp(
+  prop: NamedShape<PropTypeAnnotation>,
+  imports: Set<string>,
+): string {
+  const typeAnnotation = prop.typeAnnotation;
+
+  switch (typeAnnotation.type) {
+    case 'BooleanTypeAnnotation':
+      if (typeAnnotation.default === null) {
+        addNullable(imports);
+        return '@Nullable Boolean value';
+      } else {
+        return 'boolean value';
+      }
+    case 'StringTypeAnnotation':
+      addNullable(imports);
+      return '@Nullable String value';
+    case 'Int32TypeAnnotation':
+      return 'int value';
+    case 'DoubleTypeAnnotation':
+      return 'double value';
+    case 'FloatTypeAnnotation':
+      if (typeAnnotation.default === null) {
+        addNullable(imports);
+        return '@Nullable Float value';
+      } else {
+        return 'float value';
+      }
+    case 'ReservedPropTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'ColorPrimitive':
+          addNullable(imports);
+          return '@Nullable Integer value';
+        case 'ImageSourcePrimitive':
+          addNullable(imports);
+          return '@Nullable ReadableMap value';
+        case 'ImageRequestPrimitive':
+          addNullable(imports);
+          return '@Nullable ReadableMap value';
+        case 'PointPrimitive':
+          addNullable(imports);
+          return '@Nullable ReadableMap value';
+        case 'EdgeInsetsPrimitive':
+          addNullable(imports);
+          return '@Nullable ReadableMap value';
+        case 'DimensionPrimitive':
+          addNullable(imports);
+          return '@Nullable YogaValue value';
+        default:
+          (typeAnnotation.name: empty);
+          throw new Error('Received unknown ReservedPropTypeAnnotation');
+      }
+    case 'ArrayTypeAnnotation': {
+      addNullable(imports);
+      return '@Nullable ReadableArray value';
+    }
+    case 'ObjectTypeAnnotation': {
+      addNullable(imports);
+      return '@Nullable ReadableMap value';
+    }
+    case 'StringEnumTypeAnnotation':
+      addNullable(imports);
+      return '@Nullable String value';
+    case 'Int32EnumTypeAnnotation':
+      addNullable(imports);
+      return '@Nullable Integer value';
+    case 'MixedTypeAnnotation':
+      return 'Dynamic value';
+    default:
+      (typeAnnotation: empty);
+      throw new Error('Received invalid typeAnnotation');
+  }
+}
+
+function generatePropsString(component: ComponentShape, imports: Set<string>) {
+  if (component.props.length === 0) {
+    return '// No props';
+  }
+
+  return component.props
+    .map(prop => {
+      return `void set${toSafeJavaString(
+        prop.name,
+      )}(T view, ${getJavaValueForProp(prop, imports)});`;
+    })
+    .join('\n' + '  ');
+}
+
+function getCommandArgJavaType(param: NamedShape<CommandParamTypeAnnotation>) {
+  const {typeAnnotation} = param;
+
+  switch (typeAnnotation.type) {
+    case 'ReservedTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'RootTag':
+          return 'double';
+        default:
+          (typeAnnotation.name: empty);
+          throw new Error(`Receieved invalid type: ${typeAnnotation.name}`);
+      }
+    case 'BooleanTypeAnnotation':
+      return 'boolean';
+    case 'DoubleTypeAnnotation':
+      return 'double';
+    case 'FloatTypeAnnotation':
+      return 'float';
+    case 'Int32TypeAnnotation':
+      return 'int';
+    case 'StringTypeAnnotation':
+      return 'String';
+    case 'ArrayTypeAnnotation':
+      return 'ReadableArray';
+    default:
+      (typeAnnotation.type: empty);
+      throw new Error('Receieved invalid typeAnnotation');
+  }
+}
+
+function getCommandArguments(
+  command: NamedShape<CommandTypeAnnotation>,
+  componentName: string,
+): string {
+  return [
+    'T view',
+    ...command.typeAnnotation.params.map(param => {
+      const commandArgJavaType = getCommandArgJavaType(param);
+
+      return `${commandArgJavaType} ${param.name}`;
+    }),
+  ].join(', ');
+}
+
+function generateCommandsString(
+  component: ComponentShape,
+  componentName: string,
+) {
+  return component.commands
+    .map(command => {
+      const safeJavaName = toSafeJavaString(command.name, false);
+
+      return `void ${safeJavaName}(${getCommandArguments(
+        command,
+        componentName,
+      )});`;
+    })
+    .join('\n' + '  ');
+}
+
+function getClassExtendString(component: ComponentShape): string {
+  const extendString = component.extendsProps
+    .map(extendProps => {
+      switch (extendProps.type) {
+        case 'ReactNativeBuiltInType':
+          switch (extendProps.knownTypeName) {
+            case 'ReactNativeCoreViewProps':
+              return 'View';
+            default:
+              (extendProps.knownTypeName: empty);
+              throw new Error('Invalid knownTypeName');
+          }
+        default:
+          (extendProps.type: empty);
+          throw new Error('Invalid extended type');
+      }
+    })
+    .join('');
+
+  return extendString;
+}
+
+module.exports = {
+  generate(
+    libraryName: string,
+    schema: SchemaType,
+    packageName?: string,
+    assumeNonnull: boolean = false,
+    headerPrefix?: string,
+    includeGetDebugPropsImplementation?: boolean = false,
+  ): FilesOutput {
+    // TODO: This doesn't support custom package name yet.
+    const normalizedPackageName = 'com.facebook.react.viewmanagers';
+    const outputDir = `java/${normalizedPackageName.replace(/\./g, '/')}`;
+
+    const files = new Map<string, string>();
+    Object.keys(schema.modules).forEach(moduleName => {
+      const module = schema.modules[moduleName];
+      if (module.type !== 'Component') {
+        return;
+      }
+
+      const {components} = module;
+
+      // No components in this module
+      if (components == null) {
+        return;
+      }
+
+      return Object.keys(components)
+        .filter(componentName => {
+          const component = components[componentName];
+          return !(
+            component.excludedPlatforms &&
+            component.excludedPlatforms.includes('android')
+          );
+        })
+        .forEach(componentName => {
+          const component = components[componentName];
+          const className = getInterfaceJavaClassName(componentName);
+
+          const imports = getImports(component, 'interface');
+          const propsString = generatePropsString(component, imports);
+          const commandsString = generateCommandsString(
+            component,
+            componentName,
+          );
+          const extendString = getClassExtendString(component);
+
+          const replacedTemplate = FileTemplate({
+            imports: Array.from(imports).sort().join('\n'),
+            packageName: normalizedPackageName,
+            className,
+            extendClasses: extendString,
+            methods: [propsString, commandsString]
+              .join('\n' + '  ')
+              .trimRight(),
+          });
+
+          files.set(`${outputDir}/${className}.java`, replacedTemplate);
+        });
+    });
+
+    return files;
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GeneratePropsJavaPojo/PojoCollector.js

@@ -0,0 +1,120 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+function _defineProperty(e, r, t) {
+  return (
+    (r = _toPropertyKey(r)) in e
+      ? Object.defineProperty(e, r, {
+          value: t,
+          enumerable: !0,
+          configurable: !0,
+          writable: !0,
+        })
+      : (e[r] = t),
+    e
+  );
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, 'string');
+  return 'symbol' == typeof i ? i : i + '';
+}
+function _toPrimitive(t, r) {
+  if ('object' != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || 'default');
+    if ('object' != typeof i) return i;
+    throw new TypeError('@@toPrimitive must return a primitive value.');
+  }
+  return ('string' === r ? String : Number)(t);
+}
+const {capitalize} = require('../../Utils');
+class PojoCollector {
+  constructor() {
+    _defineProperty(this, '_pojos', new Map());
+  }
+  process(namespace, pojoName, typeAnnotation) {
+    switch (typeAnnotation.type) {
+      case 'ObjectTypeAnnotation': {
+        this._insertPojo(namespace, pojoName, typeAnnotation);
+        return {
+          type: 'PojoTypeAliasTypeAnnotation',
+          name: pojoName,
+        };
+      }
+      case 'ArrayTypeAnnotation': {
+        const arrayTypeAnnotation = typeAnnotation;
+        const elementType = arrayTypeAnnotation.elementType;
+        const pojoElementType = (() => {
+          switch (elementType.type) {
+            case 'ObjectTypeAnnotation': {
+              this._insertPojo(namespace, `${pojoName}Element`, elementType);
+              return {
+                type: 'PojoTypeAliasTypeAnnotation',
+                name: `${pojoName}Element`,
+              };
+            }
+            case 'ArrayTypeAnnotation': {
+              const {elementType: objectTypeAnnotation} = elementType;
+              this._insertPojo(
+                namespace,
+                `${pojoName}ElementElement`,
+                objectTypeAnnotation,
+              );
+              return {
+                type: 'ArrayTypeAnnotation',
+                elementType: {
+                  type: 'PojoTypeAliasTypeAnnotation',
+                  name: `${pojoName}ElementElement`,
+                },
+              };
+            }
+            default: {
+              return elementType;
+            }
+          }
+        })();
+
+        /* $FlowFixMe[incompatible-type] Natural Inference rollout. See
+         * https://fburl.com/workplace/6291gfvu */
+        return {
+          type: 'ArrayTypeAnnotation',
+          elementType: pojoElementType,
+        };
+      }
+      default:
+        return typeAnnotation;
+    }
+  }
+  _insertPojo(namespace, pojoName, objectTypeAnnotation) {
+    const properties = objectTypeAnnotation.properties.map(property => {
+      const propertyPojoName = pojoName + capitalize(property.name);
+      return {
+        ...property,
+        typeAnnotation: this.process(
+          namespace,
+          propertyPojoName,
+          property.typeAnnotation,
+        ),
+      };
+    });
+    this._pojos.set(pojoName, {
+      name: pojoName,
+      namespace,
+      properties,
+    });
+  }
+  getAllPojos() {
+    return [...this._pojos.values()];
+  }
+}
+module.exports = PojoCollector;

node_modules/@react-native/codegen/lib/generators/components/GeneratePropsJavaPojo/PojoCollector.js.flow

@@ -0,0 +1,190 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import type {
+  BooleanTypeAnnotation,
+  ComponentArrayTypeAnnotation,
+  DoubleTypeAnnotation,
+  FloatTypeAnnotation,
+  Int32TypeAnnotation,
+  MixedTypeAnnotation,
+  NamedShape,
+  ObjectTypeAnnotation,
+  PropTypeAnnotation,
+  ReservedPropTypeAnnotation,
+  StringTypeAnnotation,
+} from '../../../CodegenSchema';
+
+const {capitalize} = require('../../Utils');
+
+export type Pojo = {
+  name: string,
+  namespace: string,
+  properties: $ReadOnlyArray<PojoProperty>,
+};
+
+export type PojoProperty = NamedShape<PojoTypeAnnotation>;
+
+export type PojoTypeAliasAnnotation = {
+  type: 'PojoTypeAliasTypeAnnotation',
+  name: string,
+};
+
+export type PojoTypeAnnotation =
+  | $ReadOnly<{
+      type: 'BooleanTypeAnnotation',
+      default: boolean | null,
+    }>
+  | $ReadOnly<{
+      type: 'StringTypeAnnotation',
+      default: string | null,
+    }>
+  | $ReadOnly<{
+      type: 'DoubleTypeAnnotation',
+      default: number,
+    }>
+  | $ReadOnly<{
+      type: 'FloatTypeAnnotation',
+      default: number | null,
+    }>
+  | $ReadOnly<{
+      type: 'Int32TypeAnnotation',
+      default: number,
+    }>
+  | $ReadOnly<{
+      type: 'StringEnumTypeAnnotation',
+      default: string,
+      options: $ReadOnlyArray<string>,
+    }>
+  | $ReadOnly<{
+      type: 'Int32EnumTypeAnnotation',
+      default: number,
+      options: $ReadOnlyArray<number>,
+    }>
+  | ReservedPropTypeAnnotation
+  | PojoTypeAliasAnnotation
+  | $ReadOnly<{
+      type: 'ArrayTypeAnnotation',
+      elementType:
+        | BooleanTypeAnnotation
+        | StringTypeAnnotation
+        | DoubleTypeAnnotation
+        | FloatTypeAnnotation
+        | Int32TypeAnnotation
+        | MixedTypeAnnotation
+        | $ReadOnly<{
+            type: 'StringEnumTypeAnnotation',
+            default: string,
+            options: $ReadOnlyArray<string>,
+          }>
+        | PojoTypeAliasAnnotation
+        | ReservedPropTypeAnnotation
+        | $ReadOnly<{
+            type: 'ArrayTypeAnnotation',
+            elementType: PojoTypeAliasAnnotation,
+          }>,
+    }>
+  | MixedTypeAnnotation;
+
+class PojoCollector {
+  _pojos: Map<string, Pojo> = new Map();
+  process(
+    namespace: string,
+    pojoName: string,
+    typeAnnotation: PropTypeAnnotation,
+  ): PojoTypeAnnotation {
+    switch (typeAnnotation.type) {
+      case 'ObjectTypeAnnotation': {
+        this._insertPojo(namespace, pojoName, typeAnnotation);
+        return {
+          type: 'PojoTypeAliasTypeAnnotation',
+          name: pojoName,
+        };
+      }
+      case 'ArrayTypeAnnotation': {
+        const arrayTypeAnnotation = typeAnnotation;
+        const elementType: ComponentArrayTypeAnnotation['elementType'] =
+          arrayTypeAnnotation.elementType;
+
+        const pojoElementType = (() => {
+          switch (elementType.type) {
+            case 'ObjectTypeAnnotation': {
+              this._insertPojo(namespace, `${pojoName}Element`, elementType);
+              return {
+                type: 'PojoTypeAliasTypeAnnotation',
+                name: `${pojoName}Element`,
+              };
+            }
+            case 'ArrayTypeAnnotation': {
+              const {elementType: objectTypeAnnotation} = elementType;
+              this._insertPojo(
+                namespace,
+                `${pojoName}ElementElement`,
+                objectTypeAnnotation,
+              );
+              return {
+                type: 'ArrayTypeAnnotation',
+                elementType: {
+                  type: 'PojoTypeAliasTypeAnnotation',
+                  name: `${pojoName}ElementElement`,
+                },
+              };
+            }
+            default: {
+              return elementType;
+            }
+          }
+        })();
+
+        /* $FlowFixMe[incompatible-type] Natural Inference rollout. See
+         * https://fburl.com/workplace/6291gfvu */
+        return {
+          type: 'ArrayTypeAnnotation',
+          elementType: pojoElementType,
+        };
+      }
+      default:
+        return typeAnnotation;
+    }
+  }
+
+  _insertPojo(
+    namespace: string,
+    pojoName: string,
+    objectTypeAnnotation: ObjectTypeAnnotation<PropTypeAnnotation>,
+  ) {
+    const properties = objectTypeAnnotation.properties.map(property => {
+      const propertyPojoName = pojoName + capitalize(property.name);
+
+      return {
+        ...property,
+        typeAnnotation: this.process(
+          namespace,
+          propertyPojoName,
+          property.typeAnnotation,
+        ),
+      };
+    });
+
+    this._pojos.set(pojoName, {
+      name: pojoName,
+      namespace,
+      properties,
+    });
+  }
+
+  getAllPojos(): $ReadOnlyArray<Pojo> {
+    return [...this._pojos.values()];
+  }
+}
+
+module.exports = PojoCollector;

node_modules/@react-native/codegen/lib/generators/components/GeneratePropsJavaPojo/index.js

@@ -0,0 +1,64 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+const {capitalize} = require('../../Utils');
+const PojoCollector = require('./PojoCollector');
+const {serializePojo} = require('./serializePojo');
+module.exports = {
+  generate(libraryName, schema, packageName) {
+    const pojoCollector = new PojoCollector();
+    const basePackageName = 'com.facebook.react.viewmanagers';
+    Object.keys(schema.modules).forEach(hasteModuleName => {
+      const module = schema.modules[hasteModuleName];
+      if (module.type !== 'Component') {
+        return;
+      }
+      const {components} = module;
+      // No components in this module
+      if (components == null) {
+        return null;
+      }
+      Object.keys(components)
+        .filter(componentName => {
+          const component = components[componentName];
+          return !(
+            component.excludedPlatforms &&
+            component.excludedPlatforms.includes('android')
+          );
+        })
+        .forEach(componentName => {
+          const component = components[componentName];
+          if (component == null) {
+            return;
+          }
+          const {props} = component;
+          pojoCollector.process(
+            capitalize(hasteModuleName),
+            `${capitalize(componentName)}Props`,
+            {
+              type: 'ObjectTypeAnnotation',
+              properties: props,
+            },
+          );
+        });
+    });
+    const pojoDir = basePackageName.split('.').join('/');
+    return new Map(
+      pojoCollector.getAllPojos().map(pojo => {
+        return [
+          `java/${pojoDir}/${pojo.namespace}/${pojo.name}.java`,
+          serializePojo(pojo, basePackageName),
+        ];
+      }),
+    );
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GeneratePropsJavaPojo/index.js.flow

@@ -0,0 +1,80 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import type {SchemaType} from '../../../CodegenSchema';
+
+const {capitalize} = require('../../Utils');
+const PojoCollector = require('./PojoCollector');
+const {serializePojo} = require('./serializePojo');
+
+type FilesOutput = Map<string, string>;
+
+module.exports = {
+  generate(
+    libraryName: string,
+    schema: SchemaType,
+    packageName?: string,
+  ): FilesOutput {
+    const pojoCollector = new PojoCollector();
+    const basePackageName = 'com.facebook.react.viewmanagers';
+
+    Object.keys(schema.modules).forEach(hasteModuleName => {
+      const module = schema.modules[hasteModuleName];
+      if (module.type !== 'Component') {
+        return;
+      }
+
+      const {components} = module;
+      // No components in this module
+      if (components == null) {
+        return null;
+      }
+
+      Object.keys(components)
+        .filter(componentName => {
+          const component = components[componentName];
+          return !(
+            component.excludedPlatforms &&
+            component.excludedPlatforms.includes('android')
+          );
+        })
+        .forEach(componentName => {
+          const component = components[componentName];
+          if (component == null) {
+            return;
+          }
+
+          const {props} = component;
+
+          pojoCollector.process(
+            capitalize(hasteModuleName),
+            `${capitalize(componentName)}Props`,
+            {
+              type: 'ObjectTypeAnnotation',
+              properties: props,
+            },
+          );
+        });
+    });
+
+    const pojoDir = basePackageName.split('.').join('/');
+
+    return new Map(
+      pojoCollector.getAllPojos().map(pojo => {
+        return [
+          `java/${pojoDir}/${pojo.namespace}/${pojo.name}.java`,
+          serializePojo(pojo, basePackageName),
+        ];
+      }),
+    );
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GeneratePropsJavaPojo/serializePojo.js

@@ -0,0 +1,289 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+const {capitalize} = require('../../Utils');
+function toJavaType(typeAnnotation, addImport) {
+  const importNullable = () => addImport('androidx.annotation.Nullable');
+  const importReadableMap = () =>
+    addImport('com.facebook.react.bridge.ReadableMap');
+  const importArrayList = () => addImport('java.util.ArrayList');
+  const importYogaValue = () => addImport('com.facebook.yoga.YogaValue');
+  const importDynamic = () => addImport('com.facebook.react.bridge.Dynamic');
+  switch (typeAnnotation.type) {
+    /**
+     * Primitives
+     */
+    case 'BooleanTypeAnnotation': {
+      if (typeAnnotation.default === null) {
+        importNullable();
+        return '@Nullable Boolean';
+      } else {
+        return 'boolean';
+      }
+    }
+    case 'StringTypeAnnotation': {
+      importNullable();
+      return '@Nullable String';
+    }
+    case 'DoubleTypeAnnotation': {
+      return 'double';
+    }
+    case 'FloatTypeAnnotation': {
+      if (typeAnnotation.default === null) {
+        importNullable();
+        return '@Nullable Float';
+      } else {
+        return 'float';
+      }
+    }
+    case 'Int32TypeAnnotation': {
+      return 'int';
+    }
+
+    /**
+     * Enums
+     */
+    // TODO: Make StringEnumTypeAnnotation type-safe?
+    case 'StringEnumTypeAnnotation':
+      importNullable();
+      return '@Nullable String';
+    // TODO: Make Int32EnumTypeAnnotation type-safe?
+    case 'Int32EnumTypeAnnotation':
+      importNullable();
+      return '@Nullable Integer';
+
+    /**
+     * Reserved types
+     */
+    case 'ReservedPropTypeAnnotation': {
+      switch (typeAnnotation.name) {
+        case 'ColorPrimitive':
+          importNullable();
+          return '@Nullable Integer';
+
+        // TODO: Make ImageSourcePrimitive type-safe
+        case 'ImageSourcePrimitive':
+          importNullable();
+          importReadableMap();
+          return '@Nullable ReadableMap';
+
+        // TODO: Make ImageRequestPrimitive type-safe
+        case 'ImageRequestPrimitive':
+          importNullable();
+          importReadableMap();
+          return '@Nullable ReadableMap';
+
+        // TODO: Make PointPrimitive type-safe
+        case 'PointPrimitive':
+          importNullable();
+          importReadableMap();
+          return '@Nullable ReadableMap';
+
+        // TODO: Make EdgeInsetsPrimitive type-safe
+        case 'EdgeInsetsPrimitive':
+          importNullable();
+          importReadableMap();
+          return '@Nullable ReadableMap';
+        case 'DimensionPrimitive':
+          importNullable();
+          importYogaValue();
+          return '@Nullable YogaValue';
+        default:
+          typeAnnotation.name;
+          throw new Error(
+            `Received unknown ReservedPropTypeAnnotation ${typeAnnotation.name}`,
+          );
+      }
+    }
+
+    /**
+     * Other Pojo objects
+     */
+    case 'PojoTypeAliasTypeAnnotation': {
+      return typeAnnotation.name;
+    }
+
+    /**
+     * Arrays
+     */
+    case 'ArrayTypeAnnotation': {
+      const {elementType} = typeAnnotation;
+      const elementTypeString = (() => {
+        switch (elementType.type) {
+          /**
+           * Primitives
+           */
+          case 'BooleanTypeAnnotation': {
+            return 'Boolean';
+          }
+          case 'StringTypeAnnotation': {
+            return 'String';
+          }
+          case 'DoubleTypeAnnotation': {
+            return 'Double';
+          }
+          case 'FloatTypeAnnotation': {
+            return 'Float';
+          }
+          case 'Int32TypeAnnotation': {
+            return 'Integer';
+          }
+          case 'MixedTypeAnnotation': {
+            importDynamic();
+            return 'Dynamic';
+          }
+
+          /**
+           * Enums
+           */
+          // TODO: Make StringEnums type-safe in Pojos
+          case 'StringEnumTypeAnnotation': {
+            return 'String';
+          }
+
+          /**
+           * Other Pojo objects
+           */
+          case 'PojoTypeAliasTypeAnnotation': {
+            return elementType.name;
+          }
+
+          /**
+           * Reserved types
+           */
+          case 'ReservedPropTypeAnnotation': {
+            switch (elementType.name) {
+              case 'ColorPrimitive':
+                return 'Integer';
+
+              // TODO: Make ImageSourcePrimitive type-safe
+              case 'ImageSourcePrimitive':
+                importReadableMap();
+                return 'ReadableMap';
+
+              // TODO: Make ImageRequestPrimitive type-safe
+              case 'ImageRequestPrimitive':
+                importReadableMap();
+                return 'ReadableMap';
+
+              // TODO: Make PointPrimitive type-safe
+              case 'PointPrimitive':
+                importReadableMap();
+                return 'ReadableMap';
+
+              // TODO: Make EdgeInsetsPrimitive type-safe
+              case 'EdgeInsetsPrimitive':
+                importReadableMap();
+                return 'ReadableMap';
+              case 'DimensionPrimitive':
+                importYogaValue();
+                return 'YogaValue';
+              default:
+                elementType.name;
+                throw new Error(
+                  `Received unknown ReservedPropTypeAnnotation ${elementType.name}`,
+                );
+            }
+          }
+
+          // Arrays
+          case 'ArrayTypeAnnotation': {
+            const {elementType: pojoTypeAliasTypeAnnotation} = elementType;
+            importArrayList();
+            return `ArrayList<${pojoTypeAliasTypeAnnotation.name}>`;
+          }
+          default: {
+            elementType.type;
+            throw new Error(
+              `Unrecognized PojoTypeAnnotation Array element type annotation '${elementType.type}'`,
+            );
+          }
+        }
+      })();
+      importArrayList();
+      return `ArrayList<${elementTypeString}>`;
+    }
+    case 'MixedTypeAnnotation': {
+      importDynamic();
+      return 'Dynamic';
+    }
+    default: {
+      typeAnnotation.type;
+      throw new Error(
+        `Unrecognized PojoTypeAnnotation '${typeAnnotation.type}'`,
+      );
+    }
+  }
+}
+function toJavaMemberName(property) {
+  return `m${capitalize(property.name)}`;
+}
+function toJavaMemberDeclaration(property, addImport) {
+  const type = toJavaType(property.typeAnnotation, addImport);
+  const memberName = toJavaMemberName(property);
+  return `private ${type} ${memberName};`;
+}
+function toJavaGetter(property, addImport) {
+  const type = toJavaType(property.typeAnnotation, addImport);
+  const getterName = `get${capitalize(property.name)}`;
+  const memberName = toJavaMemberName(property);
+  addImport('com.facebook.proguard.annotations.DoNotStrip');
+  return `@DoNotStrip
+public ${type} ${getterName}() {
+  return ${memberName};
+}`;
+}
+function serializePojo(pojo, basePackageName) {
+  const importSet = new Set();
+  const addImport = $import => {
+    importSet.add($import);
+  };
+  addImport('com.facebook.proguard.annotations.DoNotStrip');
+  const indent = ' '.repeat(2);
+  const members = pojo.properties
+    .map(property => toJavaMemberDeclaration(property, addImport))
+    .map(member => `${indent}${member}`)
+    .join('\n');
+  const getters = pojo.properties
+    .map(property => toJavaGetter(property, addImport))
+    .map(getter =>
+      getter
+        .split('\n')
+        .map(line => `${indent}${line}`)
+        .join('\n'),
+    )
+    .join('\n');
+  const imports = [...importSet]
+    .map($import => `import ${$import};`)
+    .sort()
+    .join('\n');
+  return `/**
+* 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.
+*
+* ${'@'}generated by codegen project: GeneratePropsJavaPojo.js
+*/
+
+package ${basePackageName}.${pojo.namespace};
+${imports === '' ? '' : `\n${imports}\n`}
+@DoNotStrip
+public class ${pojo.name} {
+${members}
+${getters}
+}
+`;
+}
+module.exports = {
+  serializePojo,
+};

node_modules/@react-native/codegen/lib/generators/components/GeneratePropsJavaPojo/serializePojo.js.flow

@@ -0,0 +1,319 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import type {Pojo, PojoProperty, PojoTypeAnnotation} from './PojoCollector';
+
+const {capitalize} = require('../../Utils');
+
+type ImportCollector = ($import: string) => void;
+
+function toJavaType(
+  typeAnnotation: PojoTypeAnnotation,
+  addImport: ImportCollector,
+): string {
+  const importNullable = () => addImport('androidx.annotation.Nullable');
+  const importReadableMap = () =>
+    addImport('com.facebook.react.bridge.ReadableMap');
+  const importArrayList = () => addImport('java.util.ArrayList');
+  const importYogaValue = () => addImport('com.facebook.yoga.YogaValue');
+  const importDynamic = () => addImport('com.facebook.react.bridge.Dynamic');
+  switch (typeAnnotation.type) {
+    /**
+     * Primitives
+     */
+    case 'BooleanTypeAnnotation': {
+      if (typeAnnotation.default === null) {
+        importNullable();
+        return '@Nullable Boolean';
+      } else {
+        return 'boolean';
+      }
+    }
+    case 'StringTypeAnnotation': {
+      importNullable();
+      return '@Nullable String';
+    }
+    case 'DoubleTypeAnnotation': {
+      return 'double';
+    }
+    case 'FloatTypeAnnotation': {
+      if (typeAnnotation.default === null) {
+        importNullable();
+        return '@Nullable Float';
+      } else {
+        return 'float';
+      }
+    }
+    case 'Int32TypeAnnotation': {
+      return 'int';
+    }
+
+    /**
+     * Enums
+     */
+    // TODO: Make StringEnumTypeAnnotation type-safe?
+    case 'StringEnumTypeAnnotation':
+      importNullable();
+      return '@Nullable String';
+    // TODO: Make Int32EnumTypeAnnotation type-safe?
+    case 'Int32EnumTypeAnnotation':
+      importNullable();
+      return '@Nullable Integer';
+
+    /**
+     * Reserved types
+     */
+    case 'ReservedPropTypeAnnotation': {
+      switch (typeAnnotation.name) {
+        case 'ColorPrimitive':
+          importNullable();
+          return '@Nullable Integer';
+
+        // TODO: Make ImageSourcePrimitive type-safe
+        case 'ImageSourcePrimitive':
+          importNullable();
+          importReadableMap();
+          return '@Nullable ReadableMap';
+
+        // TODO: Make ImageRequestPrimitive type-safe
+        case 'ImageRequestPrimitive':
+          importNullable();
+          importReadableMap();
+          return '@Nullable ReadableMap';
+
+        // TODO: Make PointPrimitive type-safe
+        case 'PointPrimitive':
+          importNullable();
+          importReadableMap();
+          return '@Nullable ReadableMap';
+
+        // TODO: Make EdgeInsetsPrimitive type-safe
+        case 'EdgeInsetsPrimitive':
+          importNullable();
+          importReadableMap();
+          return '@Nullable ReadableMap';
+
+        case 'DimensionPrimitive':
+          importNullable();
+          importYogaValue();
+          return '@Nullable YogaValue';
+
+        default:
+          (typeAnnotation.name: empty);
+          throw new Error(
+            `Received unknown ReservedPropTypeAnnotation ${typeAnnotation.name}`,
+          );
+      }
+    }
+
+    /**
+     * Other Pojo objects
+     */
+    case 'PojoTypeAliasTypeAnnotation': {
+      return typeAnnotation.name;
+    }
+
+    /**
+     * Arrays
+     */
+    case 'ArrayTypeAnnotation': {
+      const {elementType} = typeAnnotation;
+
+      const elementTypeString = (() => {
+        switch (elementType.type) {
+          /**
+           * Primitives
+           */
+          case 'BooleanTypeAnnotation': {
+            return 'Boolean';
+          }
+          case 'StringTypeAnnotation': {
+            return 'String';
+          }
+          case 'DoubleTypeAnnotation': {
+            return 'Double';
+          }
+          case 'FloatTypeAnnotation': {
+            return 'Float';
+          }
+          case 'Int32TypeAnnotation': {
+            return 'Integer';
+          }
+          case 'MixedTypeAnnotation': {
+            importDynamic();
+            return 'Dynamic';
+          }
+
+          /**
+           * Enums
+           */
+          // TODO: Make StringEnums type-safe in Pojos
+          case 'StringEnumTypeAnnotation': {
+            return 'String';
+          }
+
+          /**
+           * Other Pojo objects
+           */
+          case 'PojoTypeAliasTypeAnnotation': {
+            return elementType.name;
+          }
+
+          /**
+           * Reserved types
+           */
+          case 'ReservedPropTypeAnnotation': {
+            switch (elementType.name) {
+              case 'ColorPrimitive':
+                return 'Integer';
+
+              // TODO: Make ImageSourcePrimitive type-safe
+              case 'ImageSourcePrimitive':
+                importReadableMap();
+                return 'ReadableMap';
+
+              // TODO: Make ImageRequestPrimitive type-safe
+              case 'ImageRequestPrimitive':
+                importReadableMap();
+                return 'ReadableMap';
+
+              // TODO: Make PointPrimitive type-safe
+              case 'PointPrimitive':
+                importReadableMap();
+                return 'ReadableMap';
+
+              // TODO: Make EdgeInsetsPrimitive type-safe
+              case 'EdgeInsetsPrimitive':
+                importReadableMap();
+                return 'ReadableMap';
+
+              case 'DimensionPrimitive':
+                importYogaValue();
+                return 'YogaValue';
+
+              default:
+                (elementType.name: empty);
+                throw new Error(
+                  `Received unknown ReservedPropTypeAnnotation ${elementType.name}`,
+                );
+            }
+          }
+
+          // Arrays
+          case 'ArrayTypeAnnotation': {
+            const {elementType: pojoTypeAliasTypeAnnotation} = elementType;
+
+            importArrayList();
+            return `ArrayList<${pojoTypeAliasTypeAnnotation.name}>`;
+          }
+          default: {
+            (elementType.type: empty);
+            throw new Error(
+              `Unrecognized PojoTypeAnnotation Array element type annotation '${elementType.type}'`,
+            );
+          }
+        }
+      })();
+
+      importArrayList();
+      return `ArrayList<${elementTypeString}>`;
+    }
+
+    case 'MixedTypeAnnotation': {
+      importDynamic();
+      return 'Dynamic';
+    }
+
+    default: {
+      (typeAnnotation.type: empty);
+      throw new Error(
+        `Unrecognized PojoTypeAnnotation '${typeAnnotation.type}'`,
+      );
+    }
+  }
+}
+
+function toJavaMemberName(property: PojoProperty): string {
+  return `m${capitalize(property.name)}`;
+}
+
+function toJavaMemberDeclaration(
+  property: PojoProperty,
+  addImport: ImportCollector,
+): string {
+  const type = toJavaType(property.typeAnnotation, addImport);
+  const memberName = toJavaMemberName(property);
+  return `private ${type} ${memberName};`;
+}
+
+function toJavaGetter(property: PojoProperty, addImport: ImportCollector) {
+  const type = toJavaType(property.typeAnnotation, addImport);
+  const getterName = `get${capitalize(property.name)}`;
+  const memberName = toJavaMemberName(property);
+
+  addImport('com.facebook.proguard.annotations.DoNotStrip');
+  return `@DoNotStrip
+public ${type} ${getterName}() {
+  return ${memberName};
+}`;
+}
+
+function serializePojo(pojo: Pojo, basePackageName: string): string {
+  const importSet: Set<string> = new Set();
+  const addImport = ($import: string) => {
+    importSet.add($import);
+  };
+
+  addImport('com.facebook.proguard.annotations.DoNotStrip');
+
+  const indent = ' '.repeat(2);
+
+  const members = pojo.properties
+    .map(property => toJavaMemberDeclaration(property, addImport))
+    .map(member => `${indent}${member}`)
+    .join('\n');
+
+  const getters = pojo.properties
+    .map(property => toJavaGetter(property, addImport))
+    .map(getter =>
+      getter
+        .split('\n')
+        .map(line => `${indent}${line}`)
+        .join('\n'),
+    )
+    .join('\n');
+
+  const imports = [...importSet]
+    .map($import => `import ${$import};`)
+    .sort()
+    .join('\n');
+
+  return `/**
+* 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.
+*
+* ${'@'}generated by codegen project: GeneratePropsJavaPojo.js
+*/
+
+package ${basePackageName}.${pojo.namespace};
+${imports === '' ? '' : `\n${imports}\n`}
+@DoNotStrip
+public class ${pojo.name} {
+${members}
+${getters}
+}
+`;
+}
+
+module.exports = {serializePojo};

node_modules/@react-native/codegen/lib/generators/components/GenerateShadowNodeCpp.js

@@ -0,0 +1,84 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+const {IncludeTemplate} = require('./CppHelpers');
+
+// File path -> contents
+
+const FileTemplate = ({componentNames, headerPrefix}) => `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by codegen project: GenerateShadowNodeCpp.js
+ */
+
+${IncludeTemplate({
+  headerPrefix,
+  file: 'ShadowNodes.h',
+})}
+
+namespace facebook::react {
+
+${componentNames}
+
+} // namespace facebook::react
+`;
+const ComponentTemplate = ({className}) =>
+  `
+extern const char ${className}ComponentName[] = "${className}";
+`.trim();
+module.exports = {
+  generate(
+    libraryName,
+    schema,
+    packageName,
+    assumeNonnull = false,
+    headerPrefix,
+    includeGetDebugPropsImplementation = false,
+  ) {
+    const fileName = 'ShadowNodes.cpp';
+    const componentNames = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+        const {components} = module;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+        return Object.keys(components)
+          .map(componentName => {
+            if (components[componentName].interfaceOnly === true) {
+              return;
+            }
+            const replacedTemplate = ComponentTemplate({
+              className: componentName,
+            });
+            return replacedTemplate;
+          })
+          .join('\n');
+      })
+      .filter(Boolean)
+      .join('\n');
+    const replacedTemplate = FileTemplate({
+      componentNames,
+      headerPrefix:
+        headerPrefix !== null && headerPrefix !== void 0 ? headerPrefix : '',
+    });
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateShadowNodeCpp.js.flow

@@ -0,0 +1,97 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import type {SchemaType} from '../../CodegenSchema';
+
+const {IncludeTemplate} = require('./CppHelpers');
+
+// File path -> contents
+type FilesOutput = Map<string, string>;
+
+const FileTemplate = ({
+  componentNames,
+  headerPrefix,
+}: {
+  componentNames: string,
+  headerPrefix: string,
+}) => `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by codegen project: GenerateShadowNodeCpp.js
+ */
+
+${IncludeTemplate({headerPrefix, file: 'ShadowNodes.h'})}
+
+namespace facebook::react {
+
+${componentNames}
+
+} // namespace facebook::react
+`;
+
+const ComponentTemplate = ({className}: {className: string}) =>
+  `
+extern const char ${className}ComponentName[] = "${className}";
+`.trim();
+
+module.exports = {
+  generate(
+    libraryName: string,
+    schema: SchemaType,
+    packageName?: string,
+    assumeNonnull: boolean = false,
+    headerPrefix?: string,
+    includeGetDebugPropsImplementation?: boolean = false,
+  ): FilesOutput {
+    const fileName = 'ShadowNodes.cpp';
+
+    const componentNames = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+
+        const {components} = module;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+
+        return Object.keys(components)
+          .map(componentName => {
+            if (components[componentName].interfaceOnly === true) {
+              return;
+            }
+            const replacedTemplate = ComponentTemplate({
+              className: componentName,
+            });
+
+            return replacedTemplate;
+          })
+          .join('\n');
+      })
+      .filter(Boolean)
+      .join('\n');
+
+    const replacedTemplate = FileTemplate({
+      componentNames,
+      headerPrefix: headerPrefix ?? '',
+    });
+
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateShadowNodeH.js

@@ -0,0 +1,107 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+const {IncludeTemplate} = require('./CppHelpers');
+
+// File path -> contents
+
+const FileTemplate = ({componentClasses, headerPrefix}) => `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by codegen project: GenerateShadowNodeH.js
+ */
+
+#pragma once
+
+${IncludeTemplate({
+  headerPrefix,
+  file: 'EventEmitters.h',
+})}
+${IncludeTemplate({
+  headerPrefix,
+  file: 'Props.h',
+})}
+${IncludeTemplate({
+  headerPrefix,
+  file: 'States.h',
+})}
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <jsi/jsi.h>
+
+namespace facebook::react {
+
+${componentClasses}
+
+} // namespace facebook::react
+`;
+const ComponentTemplate = ({className, eventEmitter}) =>
+  `
+JSI_EXPORT extern const char ${className}ComponentName[];
+
+/*
+ * \`ShadowNode\` for <${className}> component.
+ */
+using ${className}ShadowNode = ConcreteViewShadowNode<
+    ${className}ComponentName,
+    ${className}Props${eventEmitter},
+    ${className}State>;
+`.trim();
+module.exports = {
+  generate(
+    libraryName,
+    schema,
+    packageName,
+    assumeNonnull = false,
+    headerPrefix,
+    includeGetDebugPropsImplementation = false,
+  ) {
+    const fileName = 'ShadowNodes.h';
+    const moduleResults = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+        const {components} = module;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+        return Object.keys(components)
+          .map(componentName => {
+            const component = components[componentName];
+            if (component.interfaceOnly === true) {
+              return;
+            }
+            const eventEmitter = `,\n    ${componentName}EventEmitter`;
+            const replacedTemplate = ComponentTemplate({
+              className: componentName,
+              eventEmitter,
+            });
+            return replacedTemplate;
+          })
+          .join('\n\n');
+      })
+      .filter(Boolean)
+      .join('\n\n');
+    const replacedTemplate = FileTemplate({
+      componentClasses: moduleResults,
+      headerPrefix:
+        headerPrefix !== null && headerPrefix !== void 0 ? headerPrefix : '',
+    });
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateShadowNodeH.js.flow

@@ -0,0 +1,122 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import type {SchemaType} from '../../CodegenSchema';
+
+const {IncludeTemplate} = require('./CppHelpers');
+
+// File path -> contents
+type FilesOutput = Map<string, string>;
+
+const FileTemplate = ({
+  componentClasses,
+  headerPrefix,
+}: {
+  componentClasses: string,
+  headerPrefix: string,
+}) => `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by codegen project: GenerateShadowNodeH.js
+ */
+
+#pragma once
+
+${IncludeTemplate({headerPrefix, file: 'EventEmitters.h'})}
+${IncludeTemplate({headerPrefix, file: 'Props.h'})}
+${IncludeTemplate({headerPrefix, file: 'States.h'})}
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <jsi/jsi.h>
+
+namespace facebook::react {
+
+${componentClasses}
+
+} // namespace facebook::react
+`;
+
+const ComponentTemplate = ({
+  className,
+  eventEmitter,
+}: {
+  className: string,
+  eventEmitter: string,
+}) =>
+  `
+JSI_EXPORT extern const char ${className}ComponentName[];
+
+/*
+ * \`ShadowNode\` for <${className}> component.
+ */
+using ${className}ShadowNode = ConcreteViewShadowNode<
+    ${className}ComponentName,
+    ${className}Props${eventEmitter},
+    ${className}State>;
+`.trim();
+
+module.exports = {
+  generate(
+    libraryName: string,
+    schema: SchemaType,
+    packageName?: string,
+    assumeNonnull: boolean = false,
+    headerPrefix?: string,
+    includeGetDebugPropsImplementation?: boolean = false,
+  ): FilesOutput {
+    const fileName = 'ShadowNodes.h';
+
+    const moduleResults = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+
+        const {components} = module;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+
+        return Object.keys(components)
+          .map(componentName => {
+            const component = components[componentName];
+            if (component.interfaceOnly === true) {
+              return;
+            }
+
+            const eventEmitter = `,\n    ${componentName}EventEmitter`;
+
+            const replacedTemplate = ComponentTemplate({
+              className: componentName,
+              eventEmitter,
+            });
+
+            return replacedTemplate;
+          })
+          .join('\n\n');
+      })
+      .filter(Boolean)
+      .join('\n\n');
+
+    const replacedTemplate = FileTemplate({
+      componentClasses: moduleResults,
+      headerPrefix: headerPrefix ?? '',
+    });
+
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateStateCpp.js

@@ -0,0 +1,81 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+const {IncludeTemplate} = require('./CppHelpers');
+
+// File path -> contents
+
+const FileTemplate = ({stateClasses, headerPrefix}) => `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by codegen project: GenerateStateCpp.js
+ */
+${IncludeTemplate({
+  headerPrefix,
+  file: 'States.h',
+})}
+
+namespace facebook::react {
+
+${stateClasses}
+
+} // namespace facebook::react
+`;
+const StateTemplate = ({stateName}) => '';
+module.exports = {
+  generate(
+    libraryName,
+    schema,
+    packageName,
+    assumeNonnull = false,
+    headerPrefix,
+    includeGetDebugPropsImplementation = false,
+  ) {
+    const fileName = 'States.cpp';
+    const stateClasses = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+        const {components} = module;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+        return Object.keys(components)
+          .map(componentName => {
+            const component = components[componentName];
+            if (component.interfaceOnly === true) {
+              return null;
+            }
+            return StateTemplate({
+              stateName: `${componentName}State`,
+            });
+          })
+          .filter(Boolean)
+          .join('\n');
+      })
+      .filter(Boolean)
+      .join('\n');
+    const replacedTemplate = FileTemplate({
+      stateClasses,
+      headerPrefix:
+        headerPrefix !== null && headerPrefix !== void 0 ? headerPrefix : '',
+    });
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateStateCpp.js.flow

@@ -0,0 +1,94 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import type {SchemaType} from '../../CodegenSchema';
+
+const {IncludeTemplate} = require('./CppHelpers');
+
+// File path -> contents
+type FilesOutput = Map<string, string>;
+
+const FileTemplate = ({
+  stateClasses,
+  headerPrefix,
+}: {
+  stateClasses: string,
+  headerPrefix: string,
+}) => `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by codegen project: GenerateStateCpp.js
+ */
+${IncludeTemplate({headerPrefix, file: 'States.h'})}
+
+namespace facebook::react {
+
+${stateClasses}
+
+} // namespace facebook::react
+`;
+
+const StateTemplate = ({stateName}: {stateName: string}) => '';
+
+module.exports = {
+  generate(
+    libraryName: string,
+    schema: SchemaType,
+    packageName?: string,
+    assumeNonnull: boolean = false,
+    headerPrefix?: string,
+    includeGetDebugPropsImplementation?: boolean = false,
+  ): FilesOutput {
+    const fileName = 'States.cpp';
+
+    const stateClasses = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+
+        const {components} = module;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+
+        return Object.keys(components)
+          .map(componentName => {
+            const component = components[componentName];
+            if (component.interfaceOnly === true) {
+              return null;
+            }
+
+            return StateTemplate({
+              stateName: `${componentName}State`,
+            });
+          })
+          .filter(Boolean)
+          .join('\n');
+      })
+      .filter(Boolean)
+      .join('\n');
+
+    const replacedTemplate = FileTemplate({
+      stateClasses,
+      headerPrefix: headerPrefix ?? '',
+    });
+
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateStateH.js

@@ -0,0 +1,84 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+// File path -> contents
+
+const FileTemplate = ({libraryName, stateClasses}) =>
+  `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by codegen project: GenerateStateH.js
+ */
+#pragma once
+
+#include <react/renderer/core/StateData.h>
+#ifdef RN_SERIALIZABLE_STATE
+#include <folly/dynamic.h>
+#endif
+
+namespace facebook::react {
+
+${stateClasses}
+
+} // namespace facebook::react
+`.trim();
+const StateTemplate = ({stateName}) =>
+  `
+using ${stateName}State = StateData;
+`.trim();
+module.exports = {
+  generate(
+    libraryName,
+    schema,
+    packageName,
+    assumeNonnull = false,
+    headerPrefix,
+    includeGetDebugPropsImplementation = false,
+  ) {
+    const fileName = 'States.h';
+    const stateClasses = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+        const {components} = module;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+        return Object.keys(components)
+          .map(componentName => {
+            const component = components[componentName];
+            if (component.interfaceOnly === true) {
+              return null;
+            }
+            return StateTemplate({
+              stateName: componentName,
+            });
+          })
+          .filter(Boolean)
+          .join('\n\n');
+      })
+      .filter(Boolean)
+      .join('\n\n');
+    const template = FileTemplate({
+      libraryName,
+      stateClasses,
+    });
+    return new Map([[fileName, template]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateStateH.js.flow

@@ -0,0 +1,97 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import type {SchemaType} from '../../CodegenSchema';
+
+// File path -> contents
+type FilesOutput = Map<string, string>;
+
+const FileTemplate = ({
+  libraryName,
+  stateClasses,
+}: {
+  libraryName: string,
+  stateClasses: string,
+}) =>
+  `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by codegen project: GenerateStateH.js
+ */
+#pragma once
+
+#include <react/renderer/core/StateData.h>
+#ifdef RN_SERIALIZABLE_STATE
+#include <folly/dynamic.h>
+#endif
+
+namespace facebook::react {
+
+${stateClasses}
+
+} // namespace facebook::react
+`.trim();
+
+const StateTemplate = ({stateName}: {stateName: string}) =>
+  `
+using ${stateName}State = StateData;
+`.trim();
+
+module.exports = {
+  generate(
+    libraryName: string,
+    schema: SchemaType,
+    packageName?: string,
+    assumeNonnull: boolean = false,
+    headerPrefix?: string,
+    includeGetDebugPropsImplementation?: boolean = false,
+  ): FilesOutput {
+    const fileName = 'States.h';
+
+    const stateClasses = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+
+        const {components} = module;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+
+        return Object.keys(components)
+          .map(componentName => {
+            const component = components[componentName];
+            if (component.interfaceOnly === true) {
+              return null;
+            }
+            return StateTemplate({stateName: componentName});
+          })
+          .filter(Boolean)
+          .join('\n\n');
+      })
+      .filter(Boolean)
+      .join('\n\n');
+
+    const template = FileTemplate({
+      libraryName,
+      stateClasses,
+    });
+    return new Map([[fileName, template]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateTests.js

@@ -0,0 +1,172 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+const {toSafeCppString} = require('../Utils');
+const {getImports} = require('./CppHelpers');
+const FileTemplate = ({libraryName, imports, componentTests}) =>
+  `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by codegen project: GenerateTests.js
+ * */
+
+#include <gtest/gtest.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/components/${libraryName}/Props.h>
+${imports}
+
+using namespace facebook::react;
+${componentTests}
+`.trim();
+const TestTemplate = ({componentName, testName, propName, propValue}) => `
+TEST(${componentName}_${testName}, etc) {
+  RawPropsParser propParser{};
+  propParser.prepare<${componentName}>();
+  ${componentName} sourceProps{};
+  RawProps rawProps(folly::dynamic::object("${propName}", ${propValue}));
+
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
+  rawProps.parse(propParser);
+  ${componentName}(parserContext, sourceProps, rawProps);
+}
+`;
+function getTestCasesForProp(propName, typeAnnotation) {
+  const cases = [];
+  if (typeAnnotation.type === 'StringEnumTypeAnnotation') {
+    typeAnnotation.options.forEach(option =>
+      cases.push({
+        propName,
+        testName: `${propName}_${toSafeCppString(option)}`,
+        propValue: option,
+      }),
+    );
+  } else if (typeAnnotation.type === 'StringTypeAnnotation') {
+    cases.push({
+      propName,
+      propValue:
+        typeAnnotation.default != null && typeAnnotation.default !== ''
+          ? typeAnnotation.default
+          : 'foo',
+    });
+  } else if (typeAnnotation.type === 'BooleanTypeAnnotation') {
+    cases.push({
+      propName: propName,
+      propValue: typeAnnotation.default != null ? typeAnnotation.default : true,
+    });
+    // $FlowFixMe[incompatible-type]
+    /* $FlowFixMe[invalid-compare] Error discovered during Constant Condition
+     * roll out. See https://fburl.com/workplace/4oq3zi07. */
+  } else if (typeAnnotation.type === 'IntegerTypeAnnotation') {
+    cases.push({
+      propName,
+      propValue: typeAnnotation.default || 10,
+    });
+  } else if (typeAnnotation.type === 'FloatTypeAnnotation') {
+    cases.push({
+      propName,
+      propValue: typeAnnotation.default != null ? typeAnnotation.default : 0.1,
+    });
+  } else if (typeAnnotation.type === 'ReservedPropTypeAnnotation') {
+    if (typeAnnotation.name === 'ColorPrimitive') {
+      cases.push({
+        propName,
+        propValue: 1,
+      });
+    } else if (typeAnnotation.name === 'PointPrimitive') {
+      cases.push({
+        propName,
+        propValue: 'folly::dynamic::object("x", 1)("y", 1)',
+        raw: true,
+      });
+    } else if (typeAnnotation.name === 'ImageSourcePrimitive') {
+      cases.push({
+        propName,
+        propValue: 'folly::dynamic::object("url", "testurl")',
+        raw: true,
+      });
+    }
+  }
+  return cases;
+}
+function generateTestsString(name, component) {
+  function createTest({testName, propName, propValue, raw = false}) {
+    const value =
+      !raw && typeof propValue === 'string' ? `"${propValue}"` : propValue;
+    return TestTemplate({
+      componentName: name,
+      testName: testName != null ? testName : propName,
+      propName,
+      propValue: String(value),
+    });
+  }
+  const testCases = component.props.reduce((cases, prop) => {
+    return cases.concat(getTestCasesForProp(prop.name, prop.typeAnnotation));
+  }, []);
+  const baseTest = {
+    testName: 'DoesNotDie',
+    propName: 'xx_invalid_xx',
+    propValue: 'xx_invalid_xx',
+  };
+  return [baseTest, ...testCases].map(createTest).join('');
+}
+module.exports = {
+  generate(
+    libraryName,
+    schema,
+    packageName,
+    assumeNonnull = false,
+    headerPrefix,
+  ) {
+    const fileName = 'Tests.cpp';
+    const allImports = new Set([
+      '#include <react/renderer/core/propsConversions.h>',
+      '#include <react/renderer/core/RawProps.h>',
+      '#include <react/renderer/core/RawPropsParser.h>',
+    ]);
+    const componentTests = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+        const {components} = module;
+        if (components == null) {
+          return null;
+        }
+        return Object.keys(components)
+          .map(componentName => {
+            const component = components[componentName];
+            const name = `${componentName}Props`;
+            const imports = getImports(component.props);
+            // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+            imports.forEach(allImports.add, allImports);
+            return generateTestsString(name, component);
+          })
+          .join('');
+      })
+      .filter(Boolean)
+      .join('');
+    const imports = Array.from(allImports).sort().join('\n').trim();
+    const replacedTemplate = FileTemplate({
+      imports,
+      libraryName,
+      componentTests,
+    });
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateTests.js.flow

@@ -0,0 +1,223 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+import type {ComponentShape, PropTypeAnnotation} from '../../CodegenSchema';
+import type {SchemaType} from '../../CodegenSchema';
+
+const {toSafeCppString} = require('../Utils');
+const {getImports} = require('./CppHelpers');
+
+type FilesOutput = Map<string, string>;
+type PropValueType = string | number | boolean;
+
+type TestCase = $ReadOnly<{
+  propName: string,
+  propValue: ?PropValueType,
+  testName?: string,
+  raw?: boolean,
+}>;
+
+const FileTemplate = ({
+  libraryName,
+  imports,
+  componentTests,
+}: {
+  libraryName: string,
+  imports: string,
+  componentTests: string,
+}) =>
+  `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by codegen project: GenerateTests.js
+ * */
+
+#include <gtest/gtest.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/components/${libraryName}/Props.h>
+${imports}
+
+using namespace facebook::react;
+${componentTests}
+`.trim();
+
+const TestTemplate = ({
+  componentName,
+  testName,
+  propName,
+  propValue,
+}: {
+  componentName: string,
+  testName: string,
+  propName: string,
+  propValue: string,
+}) => `
+TEST(${componentName}_${testName}, etc) {
+  RawPropsParser propParser{};
+  propParser.prepare<${componentName}>();
+  ${componentName} sourceProps{};
+  RawProps rawProps(folly::dynamic::object("${propName}", ${propValue}));
+
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
+  rawProps.parse(propParser);
+  ${componentName}(parserContext, sourceProps, rawProps);
+}
+`;
+
+function getTestCasesForProp(
+  propName: string,
+  typeAnnotation: PropTypeAnnotation,
+): Array<TestCase> {
+  const cases: Array<TestCase> = [];
+  if (typeAnnotation.type === 'StringEnumTypeAnnotation') {
+    typeAnnotation.options.forEach(option =>
+      cases.push({
+        propName,
+        testName: `${propName}_${toSafeCppString(option)}`,
+        propValue: option,
+      }),
+    );
+  } else if (typeAnnotation.type === 'StringTypeAnnotation') {
+    cases.push({
+      propName,
+      propValue:
+        typeAnnotation.default != null && typeAnnotation.default !== ''
+          ? typeAnnotation.default
+          : 'foo',
+    });
+  } else if (typeAnnotation.type === 'BooleanTypeAnnotation') {
+    cases.push({
+      propName: propName,
+      propValue: typeAnnotation.default != null ? typeAnnotation.default : true,
+    });
+    // $FlowFixMe[incompatible-type]
+    /* $FlowFixMe[invalid-compare] Error discovered during Constant Condition
+     * roll out. See https://fburl.com/workplace/4oq3zi07. */
+  } else if (typeAnnotation.type === 'IntegerTypeAnnotation') {
+    cases.push({
+      propName,
+      propValue: typeAnnotation.default || 10,
+    });
+  } else if (typeAnnotation.type === 'FloatTypeAnnotation') {
+    cases.push({
+      propName,
+      propValue: typeAnnotation.default != null ? typeAnnotation.default : 0.1,
+    });
+  } else if (typeAnnotation.type === 'ReservedPropTypeAnnotation') {
+    if (typeAnnotation.name === 'ColorPrimitive') {
+      cases.push({
+        propName,
+        propValue: 1,
+      });
+    } else if (typeAnnotation.name === 'PointPrimitive') {
+      cases.push({
+        propName,
+        propValue: 'folly::dynamic::object("x", 1)("y", 1)',
+        raw: true,
+      });
+    } else if (typeAnnotation.name === 'ImageSourcePrimitive') {
+      cases.push({
+        propName,
+        propValue: 'folly::dynamic::object("url", "testurl")',
+        raw: true,
+      });
+    }
+  }
+
+  return cases;
+}
+
+function generateTestsString(name: string, component: ComponentShape) {
+  function createTest({testName, propName, propValue, raw = false}: TestCase) {
+    const value =
+      !raw && typeof propValue === 'string' ? `"${propValue}"` : propValue;
+
+    return TestTemplate({
+      componentName: name,
+      testName: testName != null ? testName : propName,
+      propName,
+      propValue: String(value),
+    });
+  }
+
+  const testCases = component.props.reduce((cases: Array<TestCase>, prop) => {
+    return cases.concat(getTestCasesForProp(prop.name, prop.typeAnnotation));
+  }, []);
+
+  const baseTest = {
+    testName: 'DoesNotDie',
+    propName: 'xx_invalid_xx',
+    propValue: 'xx_invalid_xx',
+  };
+
+  return [baseTest, ...testCases].map(createTest).join('');
+}
+
+module.exports = {
+  generate(
+    libraryName: string,
+    schema: SchemaType,
+    packageName?: string,
+    assumeNonnull: boolean = false,
+    headerPrefix?: string,
+  ): FilesOutput {
+    const fileName = 'Tests.cpp';
+    const allImports = new Set([
+      '#include <react/renderer/core/propsConversions.h>',
+      '#include <react/renderer/core/RawProps.h>',
+      '#include <react/renderer/core/RawPropsParser.h>',
+    ]);
+
+    const componentTests = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+
+        const {components} = module;
+        if (components == null) {
+          return null;
+        }
+
+        return Object.keys(components)
+          .map(componentName => {
+            const component = components[componentName];
+            const name = `${componentName}Props`;
+
+            const imports = getImports(component.props);
+            // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+            imports.forEach(allImports.add, allImports);
+
+            return generateTestsString(name, component);
+          })
+          .join('');
+      })
+      .filter(Boolean)
+      .join('');
+
+    const imports = Array.from(allImports).sort().join('\n').trim();
+
+    const replacedTemplate = FileTemplate({
+      imports,
+      libraryName,
+      componentTests,
+    });
+
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateThirdPartyFabricComponentsProviderH.js

@@ -0,0 +1,108 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+const {
+  generateSupportedApplePlatformsMacro,
+} = require('./ComponentsProviderUtils');
+
+// File path -> contents
+
+const FileTemplate = ({lookupFuncs}) => `
+/*
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by GenerateRCTThirdPartyFabricComponentsProviderH
+ */
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wreturn-type-c-linkage"
+
+#import <React/RCTComponentViewProtocol.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+Class<RCTComponentViewProtocol> RCTThirdPartyFabricComponentsProvider(const char *name);
+#if RCT_NEW_ARCH_ENABLED
+#ifndef RCT_DYNAMIC_FRAMEWORKS
+
+${lookupFuncs}
+
+#endif
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#pragma GCC diagnostic pop
+
+`;
+const LookupFuncTemplate = ({className, libraryName}) =>
+  `
+Class<RCTComponentViewProtocol> ${className}Cls(void) __attribute__((used)); // ${libraryName}
+`.trim();
+module.exports = {
+  generate(schemas, supportedApplePlatforms) {
+    const fileName = 'RCTThirdPartyFabricComponentsProvider.h';
+    const lookupFuncs = Object.keys(schemas)
+      .map(libraryName => {
+        const schema = schemas[libraryName];
+        const librarySupportedApplePlatforms =
+          supportedApplePlatforms === null || supportedApplePlatforms === void 0
+            ? void 0
+            : supportedApplePlatforms[libraryName];
+        const generatedLookup = Object.keys(schema.modules)
+          .map(moduleName => {
+            const module = schema.modules[moduleName];
+            if (module.type !== 'Component') {
+              return;
+            }
+            const {components} = module;
+            // No components in this module
+            if (components == null) {
+              return null;
+            }
+            return Object.keys(components)
+              .filter(componentName => {
+                const component = components[componentName];
+                return !(
+                  component.excludedPlatforms &&
+                  component.excludedPlatforms.includes('iOS')
+                );
+              })
+              .map(componentName => {
+                return LookupFuncTemplate({
+                  className: componentName,
+                  libraryName,
+                });
+              })
+              .join('\n');
+          })
+          .filter(Boolean)
+          .join('\n');
+        return generateSupportedApplePlatformsMacro(
+          generatedLookup,
+          librarySupportedApplePlatforms,
+        );
+      })
+      .join('\n');
+    const replacedTemplate = FileTemplate({
+      lookupFuncs,
+    });
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateThirdPartyFabricComponentsProviderH.js.flow

@@ -0,0 +1,126 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import type {SchemaType} from '../../CodegenSchema';
+
+const {
+  generateSupportedApplePlatformsMacro,
+} = require('./ComponentsProviderUtils');
+
+// File path -> contents
+type FilesOutput = Map<string, string>;
+
+const FileTemplate = ({lookupFuncs}: {lookupFuncs: string}) => `
+/*
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by GenerateRCTThirdPartyFabricComponentsProviderH
+ */
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wreturn-type-c-linkage"
+
+#import <React/RCTComponentViewProtocol.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+Class<RCTComponentViewProtocol> RCTThirdPartyFabricComponentsProvider(const char *name);
+#if RCT_NEW_ARCH_ENABLED
+#ifndef RCT_DYNAMIC_FRAMEWORKS
+
+${lookupFuncs}
+
+#endif
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#pragma GCC diagnostic pop
+
+`;
+
+const LookupFuncTemplate = ({
+  className,
+  libraryName,
+}: {
+  className: string,
+  libraryName: string,
+}) =>
+  `
+Class<RCTComponentViewProtocol> ${className}Cls(void) __attribute__((used)); // ${libraryName}
+`.trim();
+
+module.exports = {
+  generate(
+    schemas: {[string]: SchemaType},
+    supportedApplePlatforms?: {[string]: {[string]: boolean}},
+  ): FilesOutput {
+    const fileName = 'RCTThirdPartyFabricComponentsProvider.h';
+
+    const lookupFuncs = Object.keys(schemas)
+      .map(libraryName => {
+        const schema = schemas[libraryName];
+        const librarySupportedApplePlatforms =
+          supportedApplePlatforms?.[libraryName];
+        const generatedLookup = Object.keys(schema.modules)
+          .map(moduleName => {
+            const module = schema.modules[moduleName];
+            if (module.type !== 'Component') {
+              return;
+            }
+
+            const {components} = module;
+            // No components in this module
+            if (components == null) {
+              return null;
+            }
+
+            return Object.keys(components)
+              .filter(componentName => {
+                const component = components[componentName];
+                return !(
+                  component.excludedPlatforms &&
+                  component.excludedPlatforms.includes('iOS')
+                );
+              })
+              .map(componentName => {
+                return LookupFuncTemplate({
+                  className: componentName,
+                  libraryName,
+                });
+              })
+              .join('\n');
+          })
+          .filter(Boolean)
+          .join('\n');
+
+        return generateSupportedApplePlatformsMacro(
+          generatedLookup,
+          librarySupportedApplePlatforms,
+        );
+      })
+      .join('\n');
+
+    const replacedTemplate = FileTemplate({
+      lookupFuncs,
+    });
+
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateThirdPartyFabricComponentsProviderObjCpp.js

@@ -0,0 +1,106 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+const {
+  generateSupportedApplePlatformsMacro,
+} = require('./ComponentsProviderUtils');
+
+// File path -> contents
+
+const FileTemplate = ({lookupMap}) => `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by GenerateRCTThirdPartyFabricComponentsProviderCpp
+ */
+
+// OSS-compatibility layer
+
+#import "RCTThirdPartyFabricComponentsProvider.h"
+
+#import <string>
+#import <unordered_map>
+
+Class<RCTComponentViewProtocol> RCTThirdPartyFabricComponentsProvider(const char *name) {
+  static std::unordered_map<std::string, Class (*)(void)> sFabricComponentsClassMap = {
+    #if RCT_NEW_ARCH_ENABLED
+    #ifndef RCT_DYNAMIC_FRAMEWORKS
+${lookupMap}
+    #endif
+    #endif
+  };
+
+  auto p = sFabricComponentsClassMap.find(name);
+  if (p != sFabricComponentsClassMap.end()) {
+    auto classFunc = p->second;
+    return classFunc();
+  }
+  return nil;
+}
+`;
+const LookupMapTemplate = ({className, libraryName}) => `
+    {"${className}", ${className}Cls}, // ${libraryName}`;
+module.exports = {
+  generate(schemas, supportedApplePlatforms) {
+    const fileName = 'RCTThirdPartyFabricComponentsProvider.mm';
+    const lookupMap = Object.keys(schemas)
+      .map(libraryName => {
+        const schema = schemas[libraryName];
+        const librarySupportedApplePlatforms =
+          supportedApplePlatforms === null || supportedApplePlatforms === void 0
+            ? void 0
+            : supportedApplePlatforms[libraryName];
+        const generatedLookup = Object.keys(schema.modules)
+          .map(moduleName => {
+            const module = schema.modules[moduleName];
+            if (module.type !== 'Component') {
+              return;
+            }
+            const {components} = module;
+            // No components in this module
+            if (components == null) {
+              return null;
+            }
+            const componentTemplates = Object.keys(components)
+              .filter(componentName => {
+                const component = components[componentName];
+                return !(
+                  component.excludedPlatforms &&
+                  component.excludedPlatforms.includes('iOS')
+                );
+              })
+              .map(componentName => {
+                const replacedTemplate = LookupMapTemplate({
+                  className: componentName,
+                  libraryName,
+                });
+                return replacedTemplate;
+              });
+            return componentTemplates.length > 0 ? componentTemplates : null;
+          })
+          .filter(Boolean)
+          .join('\n');
+        return generateSupportedApplePlatformsMacro(
+          generatedLookup,
+          librarySupportedApplePlatforms,
+        );
+      })
+      .join('\n');
+    const replacedTemplate = FileTemplate({
+      lookupMap,
+    });
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateThirdPartyFabricComponentsProviderObjCpp.js.flow

@@ -0,0 +1,125 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import type {SchemaType} from '../../CodegenSchema';
+
+const {
+  generateSupportedApplePlatformsMacro,
+} = require('./ComponentsProviderUtils');
+
+// File path -> contents
+type FilesOutput = Map<string, string>;
+
+const FileTemplate = ({lookupMap}: {lookupMap: string}) => `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by GenerateRCTThirdPartyFabricComponentsProviderCpp
+ */
+
+// OSS-compatibility layer
+
+#import "RCTThirdPartyFabricComponentsProvider.h"
+
+#import <string>
+#import <unordered_map>
+
+Class<RCTComponentViewProtocol> RCTThirdPartyFabricComponentsProvider(const char *name) {
+  static std::unordered_map<std::string, Class (*)(void)> sFabricComponentsClassMap = {
+    #if RCT_NEW_ARCH_ENABLED
+    #ifndef RCT_DYNAMIC_FRAMEWORKS
+${lookupMap}
+    #endif
+    #endif
+  };
+
+  auto p = sFabricComponentsClassMap.find(name);
+  if (p != sFabricComponentsClassMap.end()) {
+    auto classFunc = p->second;
+    return classFunc();
+  }
+  return nil;
+}
+`;
+
+const LookupMapTemplate = ({
+  className,
+  libraryName,
+}: {
+  className: string,
+  libraryName: string,
+}) => `
+    {"${className}", ${className}Cls}, // ${libraryName}`;
+
+module.exports = {
+  generate(
+    schemas: {[string]: SchemaType},
+    supportedApplePlatforms?: {[string]: {[string]: boolean}},
+  ): FilesOutput {
+    const fileName = 'RCTThirdPartyFabricComponentsProvider.mm';
+
+    const lookupMap = Object.keys(schemas)
+      .map(libraryName => {
+        const schema = schemas[libraryName];
+        const librarySupportedApplePlatforms =
+          supportedApplePlatforms?.[libraryName];
+
+        const generatedLookup = Object.keys(schema.modules)
+          .map(moduleName => {
+            const module = schema.modules[moduleName];
+            if (module.type !== 'Component') {
+              return;
+            }
+
+            const {components} = module;
+            // No components in this module
+            if (components == null) {
+              return null;
+            }
+
+            const componentTemplates = Object.keys(components)
+              .filter(componentName => {
+                const component = components[componentName];
+                return !(
+                  component.excludedPlatforms &&
+                  component.excludedPlatforms.includes('iOS')
+                );
+              })
+              .map(componentName => {
+                const replacedTemplate = LookupMapTemplate({
+                  className: componentName,
+                  libraryName,
+                });
+
+                return replacedTemplate;
+              });
+
+            return componentTemplates.length > 0 ? componentTemplates : null;
+          })
+          .filter(Boolean)
+          .join('\n');
+
+        return generateSupportedApplePlatformsMacro(
+          generatedLookup,
+          librarySupportedApplePlatforms,
+        );
+      })
+      .join('\n');
+
+    const replacedTemplate = FileTemplate({lookupMap});
+
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateViewConfigJs.js

@@ -0,0 +1,408 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+const core = require('@babel/core');
+const t = core.types;
+
+// File path -> contents
+
+const FileTemplate = ({imports, componentConfig}) => `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @flow
+ *
+ * ${'@'}generated by codegen project: GenerateViewConfigJs.js
+ */
+
+'use strict';
+
+${imports}
+
+${componentConfig}
+`;
+
+// We use this to add to a set. Need to make sure we aren't importing
+// this multiple times.
+const UIMANAGER_IMPORT = 'const {UIManager} = require("react-native")';
+function expression(input) {
+  return core.template.expression(input)();
+}
+function getReactDiffProcessValue(typeAnnotation) {
+  switch (typeAnnotation.type) {
+    case 'BooleanTypeAnnotation':
+    case 'StringTypeAnnotation':
+    case 'Int32TypeAnnotation':
+    case 'DoubleTypeAnnotation':
+    case 'FloatTypeAnnotation':
+    case 'ObjectTypeAnnotation':
+    case 'StringEnumTypeAnnotation':
+    case 'Int32EnumTypeAnnotation':
+    case 'MixedTypeAnnotation':
+      return t.booleanLiteral(true);
+    case 'ReservedPropTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'ColorPrimitive':
+          return expression(
+            "{ process: require('react-native/Libraries/StyleSheet/processColor').default }",
+          );
+        case 'ImageSourcePrimitive':
+          return expression(
+            "{ process: ((req) => 'default' in req ? req.default : req)(require('react-native/Libraries/Image/resolveAssetSource')) }",
+          );
+        case 'ImageRequestPrimitive':
+          throw new Error('ImageRequest should not be used in props');
+        case 'PointPrimitive':
+          return expression(
+            "{ diff: ((req) => 'default' in req ? req.default : req)(require('react-native/Libraries/Utilities/differ/pointsDiffer')) }",
+          );
+        case 'EdgeInsetsPrimitive':
+          return expression(
+            "{ diff: ((req) => 'default' in req ? req.default : req)(require('react-native/Libraries/Utilities/differ/insetsDiffer')) }",
+          );
+        case 'DimensionPrimitive':
+          return t.booleanLiteral(true);
+        default:
+          typeAnnotation.name;
+          throw new Error(
+            `Received unknown native typeAnnotation: "${typeAnnotation.name}"`,
+          );
+      }
+    case 'ArrayTypeAnnotation':
+      if (typeAnnotation.elementType.type === 'ReservedPropTypeAnnotation') {
+        switch (typeAnnotation.elementType.name) {
+          case 'ColorPrimitive':
+            return expression(
+              "{ process: ((req) => 'default' in req ? req.default : req)(require('react-native/Libraries/StyleSheet/processColorArray')) }",
+            );
+          case 'ImageSourcePrimitive':
+          case 'PointPrimitive':
+          case 'EdgeInsetsPrimitive':
+          case 'DimensionPrimitive':
+            return t.booleanLiteral(true);
+          default:
+            throw new Error(
+              `Received unknown array native typeAnnotation: "${typeAnnotation.elementType.name}"`,
+            );
+        }
+      }
+      return t.booleanLiteral(true);
+    default:
+      typeAnnotation;
+      throw new Error(
+        `Received unknown typeAnnotation: "${typeAnnotation.type}"`,
+      );
+  }
+}
+const ComponentTemplate = ({
+  componentName,
+  paperComponentName,
+  paperComponentNameDeprecated,
+}) => {
+  const nativeComponentName =
+    paperComponentName !== null && paperComponentName !== void 0
+      ? paperComponentName
+      : componentName;
+  return `
+let nativeComponentName = '${nativeComponentName}';
+${
+  paperComponentNameDeprecated != null
+    ? DeprecatedComponentNameCheckTemplate({
+        componentName,
+        paperComponentNameDeprecated,
+      })
+    : ''
+}
+
+export const __INTERNAL_VIEW_CONFIG = %%VIEW_CONFIG%%;
+
+export default NativeComponentRegistry.get(nativeComponentName, () => __INTERNAL_VIEW_CONFIG);
+`.trim();
+};
+
+// Check whether the native component exists in the app binary.
+// Old getViewManagerConfig() checks for the existance of the native Paper view manager. Not available in Bridgeless.
+// New hasViewManagerConfig() queries Fabric’s native component registry directly.
+const DeprecatedComponentNameCheckTemplate = ({
+  componentName,
+  paperComponentNameDeprecated,
+}) =>
+  `
+if (UIManager.hasViewManagerConfig('${componentName}')) {
+  nativeComponentName = '${componentName}';
+} else if (UIManager.hasViewManagerConfig('${paperComponentNameDeprecated}')) {
+  nativeComponentName = '${paperComponentNameDeprecated}';
+} else {
+  throw new Error('Failed to find native component for either "${componentName}" or "${paperComponentNameDeprecated}"');
+}
+`.trim();
+
+// Replicates the behavior of RCTNormalizeInputEventName in RCTEventDispatcher.m
+function normalizeInputEventName(name) {
+  if (name.startsWith('on')) {
+    return name.replace(/^on/, 'top');
+  } else if (!name.startsWith('top')) {
+    return `top${name[0].toUpperCase()}${name.slice(1)}`;
+  }
+  return name;
+}
+
+// Replicates the behavior of viewConfig in RCTComponentData.m
+function getValidAttributesForEvents(events, imports) {
+  imports.add(
+    "const {ConditionallyIgnoredEventHandlers} = require('react-native/Libraries/NativeComponent/ViewConfigIgnore');",
+  );
+  const validAttributes = t.objectExpression(
+    events.map(eventType => {
+      return t.objectProperty(
+        t.identifier(eventType.name),
+        t.booleanLiteral(true),
+      );
+    }),
+  );
+  return t.callExpression(t.identifier('ConditionallyIgnoredEventHandlers'), [
+    validAttributes,
+  ]);
+}
+function generateBubblingEventInfo(event, nameOveride) {
+  return t.objectProperty(
+    t.identifier(normalizeInputEventName(nameOveride || event.name)),
+    t.objectExpression([
+      t.objectProperty(
+        t.identifier('phasedRegistrationNames'),
+        t.objectExpression([
+          t.objectProperty(
+            t.identifier('captured'),
+            t.stringLiteral(`${event.name}Capture`),
+          ),
+          t.objectProperty(
+            t.identifier('bubbled'),
+            t.stringLiteral(event.name),
+          ),
+        ]),
+      ),
+    ]),
+  );
+}
+function generateDirectEventInfo(event, nameOveride) {
+  return t.objectProperty(
+    t.identifier(normalizeInputEventName(nameOveride || event.name)),
+    t.objectExpression([
+      t.objectProperty(
+        t.identifier('registrationName'),
+        t.stringLiteral(event.name),
+      ),
+    ]),
+  );
+}
+function buildViewConfig(schema, componentName, component, imports) {
+  const componentProps = component.props;
+  const componentEvents = component.events;
+  component.extendsProps.forEach(extendProps => {
+    switch (extendProps.type) {
+      case 'ReactNativeBuiltInType':
+        switch (extendProps.knownTypeName) {
+          case 'ReactNativeCoreViewProps':
+            imports.add(
+              "const NativeComponentRegistry = require('react-native/Libraries/NativeComponent/NativeComponentRegistry');",
+            );
+            return;
+          default:
+            extendProps.knownTypeName;
+            throw new Error('Invalid knownTypeName');
+        }
+      default:
+        extendProps.type;
+        throw new Error('Invalid extended type');
+    }
+  });
+  const validAttributes = t.objectExpression([
+    ...componentProps.map(schemaProp => {
+      return t.objectProperty(
+        t.identifier(schemaProp.name),
+        getReactDiffProcessValue(schemaProp.typeAnnotation),
+      );
+    }),
+    ...(componentEvents.length > 0
+      ? [t.spreadElement(getValidAttributesForEvents(componentEvents, imports))]
+      : []),
+  ]);
+  const bubblingEventNames = component.events
+    .filter(event => event.bubblingType === 'bubble')
+    .reduce((bubblingEvents, event) => {
+      // We add in the deprecated paper name so that it is in the view config.
+      // This means either the old event name or the new event name can fire
+      // and be sent to the listener until the old top level name is removed.
+      if (event.paperTopLevelNameDeprecated) {
+        bubblingEvents.push(
+          generateBubblingEventInfo(event, event.paperTopLevelNameDeprecated),
+        );
+      } else {
+        bubblingEvents.push(generateBubblingEventInfo(event));
+      }
+      return bubblingEvents;
+    }, []);
+  const directEventNames = component.events
+    .filter(event => event.bubblingType === 'direct')
+    .reduce((directEvents, event) => {
+      // We add in the deprecated paper name so that it is in the view config.
+      // This means either the old event name or the new event name can fire
+      // and be sent to the listener until the old top level name is removed.
+      if (event.paperTopLevelNameDeprecated) {
+        directEvents.push(
+          generateDirectEventInfo(event, event.paperTopLevelNameDeprecated),
+        );
+      } else {
+        directEvents.push(generateDirectEventInfo(event));
+      }
+      return directEvents;
+    }, []);
+  const properties = [
+    t.objectProperty(
+      t.identifier('uiViewClassName'),
+      t.stringLiteral(componentName),
+    ),
+  ];
+  if (bubblingEventNames.length > 0) {
+    properties.push(
+      t.objectProperty(
+        t.identifier('bubblingEventTypes'),
+        t.objectExpression(bubblingEventNames),
+      ),
+    );
+  }
+  if (directEventNames.length > 0) {
+    properties.push(
+      t.objectProperty(
+        t.identifier('directEventTypes'),
+        t.objectExpression(directEventNames),
+      ),
+    );
+  }
+  properties.push(
+    t.objectProperty(t.identifier('validAttributes'), validAttributes),
+  );
+  return t.objectExpression(properties);
+}
+function buildCommands(schema, componentName, component, imports) {
+  const commands = component.commands;
+  if (commands.length === 0) {
+    return null;
+  }
+  imports.add(
+    'const {dispatchCommand} = require("react-native/Libraries/ReactNative/RendererProxy");',
+  );
+  const commandsObject = t.objectExpression(
+    commands.map(command => {
+      const commandName = command.name;
+      const params = command.typeAnnotation.params;
+      const dispatchCommandCall = t.callExpression(
+        t.identifier('dispatchCommand'),
+        [
+          t.identifier('ref'),
+          t.stringLiteral(commandName),
+          t.arrayExpression(params.map(param => t.identifier(param.name))),
+        ],
+      );
+      return t.objectMethod(
+        'method',
+        t.identifier(commandName),
+        [t.identifier('ref'), ...params.map(param => t.identifier(param.name))],
+        t.blockStatement([t.expressionStatement(dispatchCommandCall)]),
+      );
+    }),
+  );
+  return t.exportNamedDeclaration(
+    t.variableDeclaration('const', [
+      t.variableDeclarator(t.identifier('Commands'), commandsObject),
+    ]),
+  );
+}
+module.exports = {
+  generate(libraryName, schema) {
+    try {
+      const fileName = `${libraryName}NativeViewConfig.js`;
+      const imports = new Set();
+      const moduleResults = Object.keys(schema.modules)
+        .map(moduleName => {
+          const module = schema.modules[moduleName];
+          if (module.type !== 'Component') {
+            return;
+          }
+          const {components} = module;
+          return Object.keys(components)
+            .map(componentName => {
+              var _component$paperCompo;
+              const component = components[componentName];
+              if (component.paperComponentNameDeprecated) {
+                imports.add(UIMANAGER_IMPORT);
+              }
+              const replacedTemplate = ComponentTemplate({
+                componentName,
+                paperComponentName: component.paperComponentName,
+                paperComponentNameDeprecated:
+                  component.paperComponentNameDeprecated,
+              });
+              const paperComponentName =
+                (_component$paperCompo = component.paperComponentName) !==
+                  null && _component$paperCompo !== void 0
+                  ? _component$paperCompo
+                  : componentName;
+              const replacedSourceRoot = core.template.program(
+                replacedTemplate,
+              )({
+                VIEW_CONFIG: buildViewConfig(
+                  schema,
+                  paperComponentName,
+                  component,
+                  imports,
+                ),
+              });
+              const commandsExport = buildCommands(
+                schema,
+                paperComponentName,
+                component,
+                imports,
+              );
+              if (commandsExport) {
+                replacedSourceRoot.body.push(commandsExport);
+              }
+              const replacedSource = core.transformFromAstSync(
+                replacedSourceRoot,
+                undefined,
+                {
+                  babelrc: false,
+                  browserslistConfigFile: false,
+                  configFile: false,
+                },
+              );
+              return replacedSource.code;
+            })
+            .join('\n\n');
+        })
+        .filter(Boolean)
+        .join('\n\n');
+      const replacedTemplate = FileTemplate({
+        componentConfig: moduleResults,
+        imports: Array.from(imports).sort().join('\n'),
+      });
+      return new Map([[fileName, replacedTemplate]]);
+    } catch (error) {
+      console.error(`\nError parsing schema for ${libraryName}\n`);
+      console.error(JSON.stringify(schema));
+      throw error;
+    }
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/GenerateViewConfigJs.js.flow

@@ -0,0 +1,480 @@
+/**
+ * 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.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+import type {
+  ComponentShape,
+  EventTypeShape,
+  PropTypeAnnotation,
+} from '../../CodegenSchema';
+import type {SchemaType} from '../../CodegenSchema';
+
+const core = require('@babel/core');
+
+const t = core.types;
+
+// File path -> contents
+type FilesOutput = Map<string, string>;
+
+const FileTemplate = ({
+  imports,
+  componentConfig,
+}: {
+  imports: string,
+  componentConfig: string,
+}) => `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @flow
+ *
+ * ${'@'}generated by codegen project: GenerateViewConfigJs.js
+ */
+
+'use strict';
+
+${imports}
+
+${componentConfig}
+`;
+
+// We use this to add to a set. Need to make sure we aren't importing
+// this multiple times.
+const UIMANAGER_IMPORT = 'const {UIManager} = require("react-native")';
+
+function expression(input: string) {
+  return core.template.expression(input)();
+}
+
+function getReactDiffProcessValue(typeAnnotation: PropTypeAnnotation) {
+  switch (typeAnnotation.type) {
+    case 'BooleanTypeAnnotation':
+    case 'StringTypeAnnotation':
+    case 'Int32TypeAnnotation':
+    case 'DoubleTypeAnnotation':
+    case 'FloatTypeAnnotation':
+    case 'ObjectTypeAnnotation':
+    case 'StringEnumTypeAnnotation':
+    case 'Int32EnumTypeAnnotation':
+    case 'MixedTypeAnnotation':
+      return t.booleanLiteral(true);
+    case 'ReservedPropTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'ColorPrimitive':
+          return expression(
+            "{ process: require('react-native/Libraries/StyleSheet/processColor').default }",
+          );
+        case 'ImageSourcePrimitive':
+          return expression(
+            "{ process: ((req) => 'default' in req ? req.default : req)(require('react-native/Libraries/Image/resolveAssetSource')) }",
+          );
+        case 'ImageRequestPrimitive':
+          throw new Error('ImageRequest should not be used in props');
+        case 'PointPrimitive':
+          return expression(
+            "{ diff: ((req) => 'default' in req ? req.default : req)(require('react-native/Libraries/Utilities/differ/pointsDiffer')) }",
+          );
+        case 'EdgeInsetsPrimitive':
+          return expression(
+            "{ diff: ((req) => 'default' in req ? req.default : req)(require('react-native/Libraries/Utilities/differ/insetsDiffer')) }",
+          );
+        case 'DimensionPrimitive':
+          return t.booleanLiteral(true);
+        default:
+          (typeAnnotation.name: empty);
+          throw new Error(
+            `Received unknown native typeAnnotation: "${typeAnnotation.name}"`,
+          );
+      }
+    case 'ArrayTypeAnnotation':
+      if (typeAnnotation.elementType.type === 'ReservedPropTypeAnnotation') {
+        switch (typeAnnotation.elementType.name) {
+          case 'ColorPrimitive':
+            return expression(
+              "{ process: ((req) => 'default' in req ? req.default : req)(require('react-native/Libraries/StyleSheet/processColorArray')) }",
+            );
+          case 'ImageSourcePrimitive':
+          case 'PointPrimitive':
+          case 'EdgeInsetsPrimitive':
+          case 'DimensionPrimitive':
+            return t.booleanLiteral(true);
+          default:
+            throw new Error(
+              `Received unknown array native typeAnnotation: "${typeAnnotation.elementType.name}"`,
+            );
+        }
+      }
+      return t.booleanLiteral(true);
+    default:
+      (typeAnnotation: empty);
+      throw new Error(
+        `Received unknown typeAnnotation: "${typeAnnotation.type}"`,
+      );
+  }
+}
+
+const ComponentTemplate = ({
+  componentName,
+  paperComponentName,
+  paperComponentNameDeprecated,
+}: {
+  componentName: string,
+  paperComponentName: ?string,
+  paperComponentNameDeprecated: ?string,
+}) => {
+  const nativeComponentName = paperComponentName ?? componentName;
+
+  return `
+let nativeComponentName = '${nativeComponentName}';
+${
+  paperComponentNameDeprecated != null
+    ? DeprecatedComponentNameCheckTemplate({
+        componentName,
+        paperComponentNameDeprecated,
+      })
+    : ''
+}
+
+export const __INTERNAL_VIEW_CONFIG = %%VIEW_CONFIG%%;
+
+export default NativeComponentRegistry.get(nativeComponentName, () => __INTERNAL_VIEW_CONFIG);
+`.trim();
+};
+
+// Check whether the native component exists in the app binary.
+// Old getViewManagerConfig() checks for the existance of the native Paper view manager. Not available in Bridgeless.
+// New hasViewManagerConfig() queries Fabric’s native component registry directly.
+const DeprecatedComponentNameCheckTemplate = ({
+  componentName,
+  paperComponentNameDeprecated,
+}: {
+  componentName: string,
+  paperComponentNameDeprecated: string,
+}) =>
+  `
+if (UIManager.hasViewManagerConfig('${componentName}')) {
+  nativeComponentName = '${componentName}';
+} else if (UIManager.hasViewManagerConfig('${paperComponentNameDeprecated}')) {
+  nativeComponentName = '${paperComponentNameDeprecated}';
+} else {
+  throw new Error('Failed to find native component for either "${componentName}" or "${paperComponentNameDeprecated}"');
+}
+`.trim();
+
+// Replicates the behavior of RCTNormalizeInputEventName in RCTEventDispatcher.m
+function normalizeInputEventName(name: string) {
+  if (name.startsWith('on')) {
+    return name.replace(/^on/, 'top');
+  } else if (!name.startsWith('top')) {
+    return `top${name[0].toUpperCase()}${name.slice(1)}`;
+  }
+
+  return name;
+}
+
+// Replicates the behavior of viewConfig in RCTComponentData.m
+function getValidAttributesForEvents(
+  events: $ReadOnlyArray<EventTypeShape>,
+  imports: Set<string>,
+) {
+  imports.add(
+    "const {ConditionallyIgnoredEventHandlers} = require('react-native/Libraries/NativeComponent/ViewConfigIgnore');",
+  );
+
+  const validAttributes = t.objectExpression(
+    events.map(eventType => {
+      return t.objectProperty(
+        t.identifier(eventType.name),
+        t.booleanLiteral(true),
+      );
+    }),
+  );
+
+  return t.callExpression(t.identifier('ConditionallyIgnoredEventHandlers'), [
+    validAttributes,
+  ]);
+}
+
+function generateBubblingEventInfo(
+  event: EventTypeShape,
+  nameOveride: void | string,
+) {
+  return t.objectProperty(
+    t.identifier(normalizeInputEventName(nameOveride || event.name)),
+    t.objectExpression([
+      t.objectProperty(
+        t.identifier('phasedRegistrationNames'),
+        t.objectExpression([
+          t.objectProperty(
+            t.identifier('captured'),
+            t.stringLiteral(`${event.name}Capture`),
+          ),
+          t.objectProperty(
+            t.identifier('bubbled'),
+            t.stringLiteral(event.name),
+          ),
+        ]),
+      ),
+    ]),
+  );
+}
+
+function generateDirectEventInfo(
+  event: EventTypeShape,
+  nameOveride: void | string,
+) {
+  return t.objectProperty(
+    t.identifier(normalizeInputEventName(nameOveride || event.name)),
+    t.objectExpression([
+      t.objectProperty(
+        t.identifier('registrationName'),
+        t.stringLiteral(event.name),
+      ),
+    ]),
+  );
+}
+
+function buildViewConfig(
+  schema: SchemaType,
+  componentName: string,
+  component: ComponentShape,
+  imports: Set<string>,
+) {
+  const componentProps = component.props;
+  const componentEvents = component.events;
+
+  component.extendsProps.forEach(extendProps => {
+    switch (extendProps.type) {
+      case 'ReactNativeBuiltInType':
+        switch (extendProps.knownTypeName) {
+          case 'ReactNativeCoreViewProps':
+            imports.add(
+              "const NativeComponentRegistry = require('react-native/Libraries/NativeComponent/NativeComponentRegistry');",
+            );
+
+            return;
+          default:
+            (extendProps.knownTypeName: empty);
+            throw new Error('Invalid knownTypeName');
+        }
+      default:
+        (extendProps.type: empty);
+        throw new Error('Invalid extended type');
+    }
+  });
+
+  const validAttributes = t.objectExpression([
+    ...componentProps.map(schemaProp => {
+      return t.objectProperty(
+        t.identifier(schemaProp.name),
+        getReactDiffProcessValue(schemaProp.typeAnnotation),
+      );
+    }),
+    ...(componentEvents.length > 0
+      ? [t.spreadElement(getValidAttributesForEvents(componentEvents, imports))]
+      : []),
+  ]);
+
+  const bubblingEventNames = component.events
+    .filter(event => event.bubblingType === 'bubble')
+    .reduce((bubblingEvents: Array<any>, event) => {
+      // We add in the deprecated paper name so that it is in the view config.
+      // This means either the old event name or the new event name can fire
+      // and be sent to the listener until the old top level name is removed.
+      if (event.paperTopLevelNameDeprecated) {
+        bubblingEvents.push(
+          generateBubblingEventInfo(event, event.paperTopLevelNameDeprecated),
+        );
+      } else {
+        bubblingEvents.push(generateBubblingEventInfo(event));
+      }
+      return bubblingEvents;
+    }, []);
+
+  const directEventNames = component.events
+    .filter(event => event.bubblingType === 'direct')
+    .reduce((directEvents: Array<any>, event) => {
+      // We add in the deprecated paper name so that it is in the view config.
+      // This means either the old event name or the new event name can fire
+      // and be sent to the listener until the old top level name is removed.
+      if (event.paperTopLevelNameDeprecated) {
+        directEvents.push(
+          generateDirectEventInfo(event, event.paperTopLevelNameDeprecated),
+        );
+      } else {
+        directEvents.push(generateDirectEventInfo(event));
+      }
+      return directEvents;
+    }, []);
+
+  const properties: Array<
+    BabelNodeObjectMethod | BabelNodeObjectProperty | BabelNodeSpreadElement,
+  > = [
+    t.objectProperty(
+      t.identifier('uiViewClassName'),
+      t.stringLiteral(componentName),
+    ),
+  ];
+
+  if (bubblingEventNames.length > 0) {
+    properties.push(
+      t.objectProperty(
+        t.identifier('bubblingEventTypes'),
+        t.objectExpression(bubblingEventNames),
+      ),
+    );
+  }
+  if (directEventNames.length > 0) {
+    properties.push(
+      t.objectProperty(
+        t.identifier('directEventTypes'),
+        t.objectExpression(directEventNames),
+      ),
+    );
+  }
+
+  properties.push(
+    t.objectProperty(t.identifier('validAttributes'), validAttributes),
+  );
+  return t.objectExpression(properties);
+}
+
+function buildCommands(
+  schema: SchemaType,
+  componentName: string,
+  component: ComponentShape,
+  imports: Set<string>,
+) {
+  const commands = component.commands;
+
+  if (commands.length === 0) {
+    return null;
+  }
+
+  imports.add(
+    'const {dispatchCommand} = require("react-native/Libraries/ReactNative/RendererProxy");',
+  );
+
+  const commandsObject = t.objectExpression(
+    commands.map(command => {
+      const commandName = command.name;
+      const params = command.typeAnnotation.params;
+
+      const dispatchCommandCall = t.callExpression(
+        t.identifier('dispatchCommand'),
+        [
+          t.identifier('ref'),
+          t.stringLiteral(commandName),
+          t.arrayExpression(params.map(param => t.identifier(param.name))),
+        ],
+      );
+
+      return t.objectMethod(
+        'method',
+        t.identifier(commandName),
+        [t.identifier('ref'), ...params.map(param => t.identifier(param.name))],
+        t.blockStatement([t.expressionStatement(dispatchCommandCall)]),
+      );
+    }),
+  );
+
+  return t.exportNamedDeclaration(
+    t.variableDeclaration('const', [
+      t.variableDeclarator(t.identifier('Commands'), commandsObject),
+    ]),
+  );
+}
+
+module.exports = {
+  generate(libraryName: string, schema: SchemaType): FilesOutput {
+    try {
+      const fileName = `${libraryName}NativeViewConfig.js`;
+      const imports: Set<string> = new Set();
+
+      const moduleResults = Object.keys(schema.modules)
+        .map(moduleName => {
+          const module = schema.modules[moduleName];
+          if (module.type !== 'Component') {
+            return;
+          }
+
+          const {components} = module;
+
+          return Object.keys(components)
+            .map((componentName: string) => {
+              const component = components[componentName];
+
+              if (component.paperComponentNameDeprecated) {
+                imports.add(UIMANAGER_IMPORT);
+              }
+
+              const replacedTemplate = ComponentTemplate({
+                componentName,
+                paperComponentName: component.paperComponentName,
+                paperComponentNameDeprecated:
+                  component.paperComponentNameDeprecated,
+              });
+
+              const paperComponentName =
+                component.paperComponentName ?? componentName;
+
+              const replacedSourceRoot = core.template.program(
+                replacedTemplate,
+              )({
+                VIEW_CONFIG: buildViewConfig(
+                  schema,
+                  paperComponentName,
+                  component,
+                  imports,
+                ),
+              });
+
+              const commandsExport = buildCommands(
+                schema,
+                paperComponentName,
+                component,
+                imports,
+              );
+              if (commandsExport) {
+                replacedSourceRoot.body.push(commandsExport);
+              }
+
+              const replacedSource = core.transformFromAstSync(
+                replacedSourceRoot,
+                undefined,
+                {
+                  babelrc: false,
+                  browserslistConfigFile: false,
+                  configFile: false,
+                },
+              );
+              return replacedSource.code;
+            })
+            .join('\n\n');
+        })
+        .filter(Boolean)
+        .join('\n\n');
+
+      const replacedTemplate = FileTemplate({
+        componentConfig: moduleResults,
+        imports: Array.from(imports).sort().join('\n'),
+      });
+
+      return new Map([[fileName, replacedTemplate]]);
+    } catch (error) {
+      console.error(`\nError parsing schema for ${libraryName}\n`);
+      console.error(JSON.stringify(schema));
+      throw error;
+    }
+  },
+};

node_modules/@react-native/codegen/lib/generators/components/JavaHelpers.js

@@ -0,0 +1,117 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+function upperCaseFirst(inString) {
+  return inString[0].toUpperCase() + inString.slice(1);
+}
+function getInterfaceJavaClassName(componentName) {
+  return `${componentName.replace(/^RCT/, '')}ManagerInterface`;
+}
+function getDelegateJavaClassName(componentName) {
+  return `${componentName.replace(/^RCT/, '')}ManagerDelegate`;
+}
+function toSafeJavaString(input, shouldUpperCaseFirst) {
+  const parts = input.split('-');
+  if (shouldUpperCaseFirst === false) {
+    return parts.join('');
+  }
+  return parts.map(upperCaseFirst).join('');
+}
+function getImports(component, type) {
+  const imports = new Set();
+  if (type === 'interface') {
+    imports.add(
+      'import com.facebook.react.uimanager.ViewManagerWithGeneratedInterface;',
+    );
+  }
+  component.extendsProps.forEach(extendProps => {
+    switch (extendProps.type) {
+      case 'ReactNativeBuiltInType':
+        switch (extendProps.knownTypeName) {
+          case 'ReactNativeCoreViewProps':
+            imports.add('import android.view.View;');
+            return;
+          default:
+            extendProps.knownTypeName;
+            throw new Error('Invalid knownTypeName');
+        }
+      default:
+        extendProps.type;
+        throw new Error('Invalid extended type');
+    }
+  });
+  function addImportsForNativeName(name) {
+    switch (name) {
+      case 'ColorPrimitive':
+        if (type === 'delegate') {
+          imports.add('import com.facebook.react.bridge.ColorPropConverter;');
+        }
+        return;
+      case 'ImageSourcePrimitive':
+        imports.add('import com.facebook.react.bridge.ReadableMap;');
+        return;
+      case 'PointPrimitive':
+        imports.add('import com.facebook.react.bridge.ReadableMap;');
+        return;
+      case 'EdgeInsetsPrimitive':
+        imports.add('import com.facebook.react.bridge.ReadableMap;');
+        return;
+      case 'DimensionPrimitive':
+        if (type === 'delegate') {
+          imports.add(
+            'import com.facebook.react.bridge.DimensionPropConverter;',
+          );
+        } else {
+          imports.add('import com.facebook.yoga.YogaValue;');
+        }
+        return;
+      default:
+        name;
+        throw new Error(`Invalid ReservedPropTypeAnnotation name, got ${name}`);
+    }
+  }
+  component.props.forEach(prop => {
+    const typeAnnotation = prop.typeAnnotation;
+    if (typeAnnotation.type === 'ReservedPropTypeAnnotation') {
+      // $FlowFixMe[incompatible-type]
+      addImportsForNativeName(typeAnnotation.name);
+    }
+    if (typeAnnotation.type === 'ArrayTypeAnnotation') {
+      imports.add('import com.facebook.react.bridge.ReadableArray;');
+    }
+    if (typeAnnotation.type === 'ObjectTypeAnnotation') {
+      imports.add('import com.facebook.react.bridge.ReadableMap;');
+    }
+    if (typeAnnotation.type === 'MixedTypeAnnotation') {
+      if (type === 'delegate') {
+        imports.add('import com.facebook.react.bridge.DynamicFromObject;');
+      } else {
+        imports.add('import com.facebook.react.bridge.Dynamic;');
+      }
+    }
+  });
+  component.commands.forEach(command => {
+    command.typeAnnotation.params.forEach(param => {
+      const cmdParamType = param.typeAnnotation.type;
+      if (cmdParamType === 'ArrayTypeAnnotation') {
+        imports.add('import com.facebook.react.bridge.ReadableArray;');
+      }
+    });
+  });
+  return imports;
+}
+module.exports = {
+  getInterfaceJavaClassName,
+  getDelegateJavaClassName,
+  toSafeJavaString,
+  getImports,
+};

node_modules/@react-native/codegen/lib/generators/components/JavaHelpers.js.flow

@@ -0,0 +1,149 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import type {ComponentShape} from '../../CodegenSchema';
+
+function upperCaseFirst(inString: string): string {
+  return inString[0].toUpperCase() + inString.slice(1);
+}
+
+function getInterfaceJavaClassName(componentName: string): string {
+  return `${componentName.replace(/^RCT/, '')}ManagerInterface`;
+}
+
+function getDelegateJavaClassName(componentName: string): string {
+  return `${componentName.replace(/^RCT/, '')}ManagerDelegate`;
+}
+
+function toSafeJavaString(
+  input: string,
+  shouldUpperCaseFirst?: boolean,
+): string {
+  const parts = input.split('-');
+
+  if (shouldUpperCaseFirst === false) {
+    return parts.join('');
+  }
+
+  return parts.map(upperCaseFirst).join('');
+}
+
+function getImports(
+  component: ComponentShape,
+  type: 'interface' | 'delegate',
+): Set<string> {
+  const imports: Set<string> = new Set();
+
+  if (type === 'interface') {
+    imports.add(
+      'import com.facebook.react.uimanager.ViewManagerWithGeneratedInterface;',
+    );
+  }
+
+  component.extendsProps.forEach(extendProps => {
+    switch (extendProps.type) {
+      case 'ReactNativeBuiltInType':
+        switch (extendProps.knownTypeName) {
+          case 'ReactNativeCoreViewProps':
+            imports.add('import android.view.View;');
+            return;
+          default:
+            (extendProps.knownTypeName: empty);
+            throw new Error('Invalid knownTypeName');
+        }
+      default:
+        (extendProps.type: empty);
+        throw new Error('Invalid extended type');
+    }
+  });
+
+  function addImportsForNativeName(
+    name:
+      | 'ColorPrimitive'
+      | 'EdgeInsetsPrimitive'
+      | 'ImageSourcePrimitive'
+      | 'PointPrimitive'
+      | 'DimensionPrimitive',
+  ) {
+    switch (name) {
+      case 'ColorPrimitive':
+        if (type === 'delegate') {
+          imports.add('import com.facebook.react.bridge.ColorPropConverter;');
+        }
+        return;
+      case 'ImageSourcePrimitive':
+        imports.add('import com.facebook.react.bridge.ReadableMap;');
+        return;
+      case 'PointPrimitive':
+        imports.add('import com.facebook.react.bridge.ReadableMap;');
+        return;
+      case 'EdgeInsetsPrimitive':
+        imports.add('import com.facebook.react.bridge.ReadableMap;');
+        return;
+      case 'DimensionPrimitive':
+        if (type === 'delegate') {
+          imports.add(
+            'import com.facebook.react.bridge.DimensionPropConverter;',
+          );
+        } else {
+          imports.add('import com.facebook.yoga.YogaValue;');
+        }
+        return;
+      default:
+        (name: empty);
+        throw new Error(`Invalid ReservedPropTypeAnnotation name, got ${name}`);
+    }
+  }
+
+  component.props.forEach(prop => {
+    const typeAnnotation = prop.typeAnnotation;
+
+    if (typeAnnotation.type === 'ReservedPropTypeAnnotation') {
+      // $FlowFixMe[incompatible-type]
+      addImportsForNativeName(typeAnnotation.name);
+    }
+
+    if (typeAnnotation.type === 'ArrayTypeAnnotation') {
+      imports.add('import com.facebook.react.bridge.ReadableArray;');
+    }
+
+    if (typeAnnotation.type === 'ObjectTypeAnnotation') {
+      imports.add('import com.facebook.react.bridge.ReadableMap;');
+    }
+
+    if (typeAnnotation.type === 'MixedTypeAnnotation') {
+      if (type === 'delegate') {
+        imports.add('import com.facebook.react.bridge.DynamicFromObject;');
+      } else {
+        imports.add('import com.facebook.react.bridge.Dynamic;');
+      }
+    }
+  });
+
+  component.commands.forEach(command => {
+    command.typeAnnotation.params.forEach(param => {
+      const cmdParamType = param.typeAnnotation.type;
+      if (cmdParamType === 'ArrayTypeAnnotation') {
+        imports.add('import com.facebook.react.bridge.ReadableArray;');
+      }
+    });
+  });
+
+  return imports;
+}
+
+module.exports = {
+  getInterfaceJavaClassName,
+  getDelegateJavaClassName,
+  toSafeJavaString,
+  getImports,
+};