first commit

node_modules/@react-native/codegen/lib/parsers/flow/components/commands.js

@@ -0,0 +1,187 @@
+/**
+ * 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 {getValueFromTypes} = require('../utils.js');
+
+// $FlowFixMe[unclear-type] there's no flowtype for ASTs
+
+function buildCommandSchema(property, types, parser) {
+  const name = property.key.name;
+  const optional = property.optional;
+  const value = getValueFromTypes(property.value, types);
+  const firstParam = value.params[0].typeAnnotation;
+  if (
+    !(
+      firstParam.id != null &&
+      firstParam.id.type === 'QualifiedTypeIdentifier' &&
+      firstParam.id.qualification.name === 'React' &&
+      firstParam.id.id.name === 'ElementRef'
+    )
+  ) {
+    throw new Error(
+      `The first argument of method ${name} must be of type React.ElementRef<>`,
+    );
+  }
+  const params = value.params.slice(1).map(param => {
+    const paramName = param.name.name;
+    const paramValue = getValueFromTypes(param.typeAnnotation, types);
+    const type =
+      paramValue.type === 'GenericTypeAnnotation'
+        ? parser.getTypeAnnotationName(paramValue)
+        : paramValue.type;
+    let returnType;
+    switch (type) {
+      case 'RootTag':
+        returnType = {
+          type: 'ReservedTypeAnnotation',
+          name: 'RootTag',
+        };
+        break;
+      case 'BooleanTypeAnnotation':
+        returnType = {
+          type: 'BooleanTypeAnnotation',
+        };
+        break;
+      case 'Int32':
+        returnType = {
+          type: 'Int32TypeAnnotation',
+        };
+        break;
+      case 'Double':
+        returnType = {
+          type: 'DoubleTypeAnnotation',
+        };
+        break;
+      case 'Float':
+        returnType = {
+          type: 'FloatTypeAnnotation',
+        };
+        break;
+      case 'StringTypeAnnotation':
+        returnType = {
+          type: 'StringTypeAnnotation',
+        };
+        break;
+      case 'Array':
+      case '$ReadOnlyArray':
+        /* $FlowFixMe[invalid-compare] Error discovered during Constant
+         * Condition roll out. See https://fburl.com/workplace/4oq3zi07. */
+        if (!paramValue.type === 'GenericTypeAnnotation') {
+          throw new Error(
+            'Array and $ReadOnlyArray are GenericTypeAnnotation for array',
+          );
+        }
+        returnType = {
+          type: 'ArrayTypeAnnotation',
+          elementType: getCommandArrayElementTypeType(
+            paramValue.typeParameters.params[0],
+            parser,
+          ),
+        };
+        break;
+      case 'ArrayTypeAnnotation':
+        returnType = {
+          type: 'ArrayTypeAnnotation',
+          elementType: getCommandArrayElementTypeType(
+            paramValue.elementType,
+            parser,
+          ),
+        };
+        break;
+      default:
+        type;
+        throw new Error(
+          `Unsupported param type for method "${name}", param "${paramName}". Found ${type}`,
+        );
+    }
+    return {
+      name: paramName,
+      optional: false,
+      typeAnnotation: returnType,
+    };
+  });
+  return {
+    name,
+    optional,
+    typeAnnotation: {
+      type: 'FunctionTypeAnnotation',
+      params,
+      returnTypeAnnotation: {
+        type: 'VoidTypeAnnotation',
+      },
+    },
+  };
+}
+function getCommandArrayElementTypeType(inputType, parser) {
+  // TODO: T172453752 support more complex type annotation for array element
+  if (typeof inputType !== 'object') {
+    throw new Error('Expected an object');
+  }
+  const type =
+    inputType === null || inputType === void 0 ? void 0 : inputType.type;
+  if (inputType == null || typeof type !== 'string') {
+    throw new Error('Command array element type must be a string');
+  }
+  switch (type) {
+    case 'BooleanTypeAnnotation':
+      return {
+        type: 'BooleanTypeAnnotation',
+      };
+    case 'StringTypeAnnotation':
+      return {
+        type: 'StringTypeAnnotation',
+      };
+    case 'GenericTypeAnnotation':
+      const name =
+        typeof inputType.id === 'object'
+          ? parser.getTypeAnnotationName(inputType)
+          : null;
+      if (typeof name !== 'string') {
+        throw new Error(
+          'Expected GenericTypeAnnotation AST name to be a string',
+        );
+      }
+      switch (name) {
+        case 'Int32':
+          return {
+            type: 'Int32TypeAnnotation',
+          };
+        case 'Float':
+          return {
+            type: 'FloatTypeAnnotation',
+          };
+        case 'Double':
+          return {
+            type: 'DoubleTypeAnnotation',
+          };
+        default:
+          // This is not a great solution. This generally means its a type alias to another type
+          // like an object or union. Ideally we'd encode that in the schema so the compat-check can
+          // validate those deeper objects for breaking changes and the generators can do something smarter.
+          // As of now, the generators just create ReadableMap or (const NSArray *) which are untyped
+          return {
+            type: 'MixedTypeAnnotation',
+          };
+      }
+    default:
+      throw new Error(`Unsupported array element type ${type}`);
+  }
+}
+function getCommands(commandTypeAST, types, parser) {
+  return commandTypeAST
+    .filter(property => property.type === 'ObjectTypeProperty')
+    .map(property => buildCommandSchema(property, types, parser))
+    .filter(Boolean);
+}
+module.exports = {
+  getCommands,
+};

node_modules/@react-native/codegen/lib/parsers/flow/components/commands.js.flow

@@ -0,0 +1,238 @@
+/**
+ * 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,
+  ComponentCommandArrayTypeAnnotation,
+  NamedShape,
+} from '../../../CodegenSchema.js';
+import type {Parser} from '../../parser';
+import type {TypeDeclarationMap} from '../../utils';
+
+const {getValueFromTypes} = require('../utils.js');
+
+// $FlowFixMe[unclear-type] there's no flowtype for ASTs
+type EventTypeAST = Object;
+
+function buildCommandSchema(
+  property: EventTypeAST,
+  types: TypeDeclarationMap,
+  parser: Parser,
+): $ReadOnly<{
+  name: string,
+  optional: boolean,
+  typeAnnotation: {
+    type: 'FunctionTypeAnnotation',
+    params: $ReadOnlyArray<{
+      name: string,
+      optional: boolean,
+      typeAnnotation: CommandParamTypeAnnotation,
+    }>,
+    returnTypeAnnotation: {
+      type: 'VoidTypeAnnotation',
+    },
+  },
+}> {
+  const name = property.key.name;
+  const optional = property.optional;
+  const value = getValueFromTypes(property.value, types);
+
+  const firstParam = value.params[0].typeAnnotation;
+
+  if (
+    !(
+      firstParam.id != null &&
+      firstParam.id.type === 'QualifiedTypeIdentifier' &&
+      firstParam.id.qualification.name === 'React' &&
+      firstParam.id.id.name === 'ElementRef'
+    )
+  ) {
+    throw new Error(
+      `The first argument of method ${name} must be of type React.ElementRef<>`,
+    );
+  }
+
+  const params = value.params.slice(1).map(param => {
+    const paramName = param.name.name;
+    const paramValue = getValueFromTypes(param.typeAnnotation, types);
+    const type =
+      paramValue.type === 'GenericTypeAnnotation'
+        ? parser.getTypeAnnotationName(paramValue)
+        : paramValue.type;
+    let returnType: CommandParamTypeAnnotation;
+
+    switch (type) {
+      case 'RootTag':
+        returnType = {
+          type: 'ReservedTypeAnnotation',
+          name: 'RootTag',
+        };
+        break;
+      case 'BooleanTypeAnnotation':
+        returnType = {
+          type: 'BooleanTypeAnnotation',
+        };
+        break;
+      case 'Int32':
+        returnType = {
+          type: 'Int32TypeAnnotation',
+        };
+        break;
+      case 'Double':
+        returnType = {
+          type: 'DoubleTypeAnnotation',
+        };
+        break;
+      case 'Float':
+        returnType = {
+          type: 'FloatTypeAnnotation',
+        };
+        break;
+      case 'StringTypeAnnotation':
+        returnType = {
+          type: 'StringTypeAnnotation',
+        };
+        break;
+      case 'Array':
+      case '$ReadOnlyArray':
+        /* $FlowFixMe[invalid-compare] Error discovered during Constant
+         * Condition roll out. See https://fburl.com/workplace/4oq3zi07. */
+        if (!paramValue.type === 'GenericTypeAnnotation') {
+          throw new Error(
+            'Array and $ReadOnlyArray are GenericTypeAnnotation for array',
+          );
+        }
+        returnType = {
+          type: 'ArrayTypeAnnotation',
+          elementType: getCommandArrayElementTypeType(
+            paramValue.typeParameters.params[0],
+            parser,
+          ),
+        };
+        break;
+      case 'ArrayTypeAnnotation':
+        returnType = {
+          type: 'ArrayTypeAnnotation',
+          elementType: getCommandArrayElementTypeType(
+            paramValue.elementType,
+            parser,
+          ),
+        };
+        break;
+      default:
+        (type: mixed);
+        throw new Error(
+          `Unsupported param type for method "${name}", param "${paramName}". Found ${type}`,
+        );
+    }
+
+    return {
+      name: paramName,
+      optional: false,
+      typeAnnotation: returnType,
+    };
+  });
+
+  return {
+    name,
+    optional,
+    typeAnnotation: {
+      type: 'FunctionTypeAnnotation',
+      params,
+      returnTypeAnnotation: {
+        type: 'VoidTypeAnnotation',
+      },
+    },
+  };
+}
+
+type Allowed = ComponentCommandArrayTypeAnnotation['elementType'];
+
+function getCommandArrayElementTypeType(
+  inputType: mixed,
+  parser: Parser,
+): Allowed {
+  // TODO: T172453752 support more complex type annotation for array element
+  if (typeof inputType !== 'object') {
+    throw new Error('Expected an object');
+  }
+
+  const type = inputType?.type;
+
+  if (inputType == null || typeof type !== 'string') {
+    throw new Error('Command array element type must be a string');
+  }
+
+  switch (type) {
+    case 'BooleanTypeAnnotation':
+      return {
+        type: 'BooleanTypeAnnotation',
+      };
+    case 'StringTypeAnnotation':
+      return {
+        type: 'StringTypeAnnotation',
+      };
+    case 'GenericTypeAnnotation':
+      const name =
+        typeof inputType.id === 'object'
+          ? parser.getTypeAnnotationName(inputType)
+          : null;
+
+      if (typeof name !== 'string') {
+        throw new Error(
+          'Expected GenericTypeAnnotation AST name to be a string',
+        );
+      }
+
+      switch (name) {
+        case 'Int32':
+          return {
+            type: 'Int32TypeAnnotation',
+          };
+        case 'Float':
+          return {
+            type: 'FloatTypeAnnotation',
+          };
+        case 'Double':
+          return {
+            type: 'DoubleTypeAnnotation',
+          };
+        default:
+          // This is not a great solution. This generally means its a type alias to another type
+          // like an object or union. Ideally we'd encode that in the schema so the compat-check can
+          // validate those deeper objects for breaking changes and the generators can do something smarter.
+          // As of now, the generators just create ReadableMap or (const NSArray *) which are untyped
+          return {
+            type: 'MixedTypeAnnotation',
+          };
+      }
+
+    default:
+      throw new Error(`Unsupported array element type ${type}`);
+  }
+}
+
+function getCommands(
+  commandTypeAST: $ReadOnlyArray<EventTypeAST>,
+  types: TypeDeclarationMap,
+  parser: Parser,
+): $ReadOnlyArray<NamedShape<CommandTypeAnnotation>> {
+  return commandTypeAST
+    .filter(property => property.type === 'ObjectTypeProperty')
+    .map(property => buildCommandSchema(property, types, parser))
+    .filter(Boolean);
+}
+
+module.exports = {
+  getCommands,
+};

node_modules/@react-native/codegen/lib/parsers/flow/components/componentsUtils.js

@@ -0,0 +1,453 @@
+/**
+ * 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 {verifyPropNotAlreadyDefined} = require('../../parsers-commons');
+const {getValueFromTypes} = require('../utils.js');
+
+// $FlowFixMe[unsupported-variance-annotation]
+function getTypeAnnotationForArray(
+  name,
+  typeAnnotation,
+  defaultValue,
+  types,
+  parser,
+  buildSchema,
+) {
+  const extractedTypeAnnotation = getValueFromTypes(typeAnnotation, types);
+  if (extractedTypeAnnotation.type === 'NullableTypeAnnotation') {
+    throw new Error(
+      'Nested optionals such as "$ReadOnlyArray<?boolean>" are not supported, please declare optionals at the top level of value definitions as in "?$ReadOnlyArray<boolean>"',
+    );
+  }
+  if (
+    extractedTypeAnnotation.type === 'GenericTypeAnnotation' &&
+    parser.getTypeAnnotationName(extractedTypeAnnotation) === 'WithDefault'
+  ) {
+    throw new Error(
+      'Nested defaults such as "$ReadOnlyArray<WithDefault<boolean, false>>" are not supported, please declare defaults at the top level of value definitions as in "WithDefault<$ReadOnlyArray<boolean>, false>"',
+    );
+  }
+  if (extractedTypeAnnotation.type === 'GenericTypeAnnotation') {
+    // Resolve the type alias if it's not defined inline
+    const objectType = getValueFromTypes(extractedTypeAnnotation, types);
+    if (objectType.id.name === '$ReadOnly') {
+      return {
+        type: 'ObjectTypeAnnotation',
+        properties: flattenProperties(
+          objectType.typeParameters.params[0].properties,
+          types,
+          parser,
+        )
+          .map(prop => buildSchema(prop, types, parser))
+          .filter(Boolean),
+      };
+    }
+    if (objectType.id.name === '$ReadOnlyArray') {
+      // We need to go yet another level deeper to resolve
+      // types that may be defined in a type alias
+      const nestedObjectType = getValueFromTypes(
+        objectType.typeParameters.params[0],
+        types,
+      );
+      return {
+        type: 'ArrayTypeAnnotation',
+        elementType: {
+          type: 'ObjectTypeAnnotation',
+          properties: flattenProperties(
+            nestedObjectType.typeParameters.params[0].properties,
+            types,
+            parser,
+          )
+            .map(prop => buildSchema(prop, types, parser))
+            .filter(Boolean),
+        },
+      };
+    }
+  }
+  const type =
+    extractedTypeAnnotation.type === 'GenericTypeAnnotation'
+      ? parser.getTypeAnnotationName(extractedTypeAnnotation)
+      : extractedTypeAnnotation.type;
+  switch (type) {
+    case 'ImageSource':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'ImageSourcePrimitive',
+      };
+    case 'ImageRequest':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'ImageRequestPrimitive',
+      };
+    case 'ColorValue':
+    case 'ProcessedColorValue':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'ColorPrimitive',
+      };
+    case 'PointValue':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'PointPrimitive',
+      };
+    case 'EdgeInsetsValue':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'EdgeInsetsPrimitive',
+      };
+    case 'DimensionValue':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'DimensionPrimitive',
+      };
+    case 'Stringish':
+      return {
+        type: 'StringTypeAnnotation',
+      };
+    case 'Int32':
+      return {
+        type: 'Int32TypeAnnotation',
+      };
+    case 'Double':
+      return {
+        type: 'DoubleTypeAnnotation',
+      };
+    case 'Float':
+      return {
+        type: 'FloatTypeAnnotation',
+      };
+    case 'BooleanTypeAnnotation':
+      return {
+        type: 'BooleanTypeAnnotation',
+      };
+    case 'StringTypeAnnotation':
+      return {
+        type: 'StringTypeAnnotation',
+      };
+    case 'UnsafeMixed':
+      return {
+        type: 'MixedTypeAnnotation',
+      };
+    case 'UnionTypeAnnotation':
+      typeAnnotation.types.reduce((lastType, currType) => {
+        if (lastType && currType.type !== lastType.type) {
+          throw new Error(`Mixed types are not supported (see "${name}")`);
+        }
+        return currType;
+      });
+      if (defaultValue === null) {
+        throw new Error(`A default enum value is required for "${name}"`);
+      }
+      const unionType = typeAnnotation.types[0].type;
+      if (unionType === 'StringLiteralTypeAnnotation') {
+        return {
+          type: 'StringEnumTypeAnnotation',
+          default: defaultValue,
+          options: typeAnnotation.types.map(option => option.value),
+        };
+      } else if (unionType === 'NumberLiteralTypeAnnotation') {
+        throw new Error(
+          `Arrays of int enums are not supported (see: "${name}")`,
+        );
+      } else {
+        throw new Error(
+          `Unsupported union type for "${name}", received "${unionType}"`,
+        );
+      }
+    default:
+      throw new Error(`Unknown property type for "${name}": ${type}`);
+  }
+}
+function flattenProperties(typeDefinition, types, parser) {
+  return typeDefinition
+    .map(property => {
+      if (property.type === 'ObjectTypeProperty') {
+        return property;
+      } else if (property.type === 'ObjectTypeSpreadProperty') {
+        return flattenProperties(
+          parser.getProperties(property.argument.id.name, types),
+          types,
+          parser,
+        );
+      }
+    })
+    .reduce((acc, item) => {
+      if (Array.isArray(item)) {
+        item.forEach(prop => {
+          verifyPropNotAlreadyDefined(acc, prop);
+        });
+        return acc.concat(item);
+      } else {
+        verifyPropNotAlreadyDefined(acc, item);
+        acc.push(item);
+        return acc;
+      }
+    }, [])
+    .filter(Boolean);
+}
+
+// $FlowFixMe[unsupported-variance-annotation]
+function getTypeAnnotation(
+  name,
+  annotation,
+  defaultValue,
+  withNullDefault,
+  types,
+  parser,
+  buildSchema,
+) {
+  const typeAnnotation = getValueFromTypes(annotation, types);
+  if (
+    typeAnnotation.type === 'GenericTypeAnnotation' &&
+    parser.getTypeAnnotationName(typeAnnotation) === '$ReadOnlyArray'
+  ) {
+    return {
+      type: 'ArrayTypeAnnotation',
+      elementType: getTypeAnnotationForArray(
+        name,
+        typeAnnotation.typeParameters.params[0],
+        defaultValue,
+        types,
+        parser,
+        buildSchema,
+      ),
+    };
+  }
+  if (
+    typeAnnotation.type === 'GenericTypeAnnotation' &&
+    parser.getTypeAnnotationName(typeAnnotation) === '$ReadOnly'
+  ) {
+    return {
+      type: 'ObjectTypeAnnotation',
+      properties: flattenProperties(
+        typeAnnotation.typeParameters.params[0].properties,
+        types,
+        parser,
+      )
+        .map(prop => buildSchema(prop, types, parser))
+        .filter(Boolean),
+    };
+  }
+  const type =
+    typeAnnotation.type === 'GenericTypeAnnotation'
+      ? parser.getTypeAnnotationName(typeAnnotation)
+      : typeAnnotation.type;
+  switch (type) {
+    case 'ImageSource':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'ImageSourcePrimitive',
+      };
+    case 'ImageRequest':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'ImageRequestPrimitive',
+      };
+    case 'ColorValue':
+    case 'ProcessedColorValue':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'ColorPrimitive',
+      };
+    case 'ColorArrayValue':
+      return {
+        type: 'ArrayTypeAnnotation',
+        elementType: {
+          type: 'ReservedPropTypeAnnotation',
+          name: 'ColorPrimitive',
+        },
+      };
+    case 'PointValue':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'PointPrimitive',
+      };
+    case 'EdgeInsetsValue':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'EdgeInsetsPrimitive',
+      };
+    case 'DimensionValue':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'DimensionPrimitive',
+      };
+    case 'Int32':
+      return {
+        type: 'Int32TypeAnnotation',
+        default: defaultValue ? defaultValue : 0,
+      };
+    case 'Double':
+      return {
+        type: 'DoubleTypeAnnotation',
+        default: defaultValue ? defaultValue : 0,
+      };
+    case 'Float':
+      return {
+        type: 'FloatTypeAnnotation',
+        default: withNullDefault
+          ? defaultValue
+          : defaultValue
+            ? defaultValue
+            : 0,
+      };
+    case 'BooleanTypeAnnotation':
+      return {
+        type: 'BooleanTypeAnnotation',
+        default: withNullDefault
+          ? defaultValue
+          : defaultValue == null
+            ? false
+            : defaultValue,
+      };
+    case 'StringTypeAnnotation':
+      if (typeof defaultValue !== 'undefined') {
+        return {
+          type: 'StringTypeAnnotation',
+          default: defaultValue,
+        };
+      }
+      throw new Error(`A default string (or null) is required for "${name}"`);
+    case 'Stringish':
+      if (typeof defaultValue !== 'undefined') {
+        return {
+          type: 'StringTypeAnnotation',
+          default: defaultValue,
+        };
+      }
+      throw new Error(`A default string (or null) is required for "${name}"`);
+    case 'UnionTypeAnnotation':
+      typeAnnotation.types.reduce((lastType, currType) => {
+        if (lastType && currType.type !== lastType.type) {
+          throw new Error(`Mixed types are not supported (see "${name}").`);
+        }
+        return currType;
+      });
+      if (defaultValue === null) {
+        throw new Error(`A default enum value is required for "${name}"`);
+      }
+      const unionType = typeAnnotation.types[0].type;
+      if (unionType === 'StringLiteralTypeAnnotation') {
+        return {
+          type: 'StringEnumTypeAnnotation',
+          default: defaultValue,
+          options: typeAnnotation.types.map(option => option.value),
+        };
+      } else if (unionType === 'NumberLiteralTypeAnnotation') {
+        return {
+          type: 'Int32EnumTypeAnnotation',
+          default: defaultValue,
+          options: typeAnnotation.types.map(option => option.value),
+        };
+      } else {
+        throw new Error(
+          `Unsupported union type for "${name}", received "${unionType}"`,
+        );
+      }
+    case 'ObjectTypeAnnotation':
+      throw new Error(
+        `Cannot use "${type}" type annotation for "${name}": object types must be declared using $ReadOnly<>`,
+      );
+    case 'NumberTypeAnnotation':
+      throw new Error(
+        `Cannot use "${type}" type annotation for "${name}": must use a specific numeric type like Int32, Double, or Float`,
+      );
+    case 'UnsafeMixed':
+      return {
+        type: 'MixedTypeAnnotation',
+      };
+    default:
+      throw new Error(
+        `Unknown property type for "${name}": "${type}" in the State`,
+      );
+  }
+}
+function getSchemaInfo(property, types, parser) {
+  const name = property.key.name;
+  const value = getValueFromTypes(property.value, types);
+  let typeAnnotation =
+    value.type === 'NullableTypeAnnotation' ? value.typeAnnotation : value;
+  let typeAnnotationName = parser.getTypeAnnotationName(typeAnnotation);
+  const optional =
+    value.type === 'NullableTypeAnnotation' ||
+    property.optional ||
+    (value.type === 'GenericTypeAnnotation' &&
+      typeAnnotationName === 'WithDefault');
+  if (
+    !property.optional &&
+    value.type === 'GenericTypeAnnotation' &&
+    typeAnnotationName === 'WithDefault'
+  ) {
+    throw new Error(
+      `key ${name} must be optional if used with WithDefault<> annotation`,
+    );
+  }
+  if (
+    value.type === 'NullableTypeAnnotation' &&
+    typeAnnotation.type === 'GenericTypeAnnotation' &&
+    typeAnnotationName === 'WithDefault'
+  ) {
+    throw new Error(
+      'WithDefault<> is optional and does not need to be marked as optional. Please remove the ? annotation in front of it.',
+    );
+  }
+  let type = typeAnnotation.type;
+  if (
+    type === 'GenericTypeAnnotation' &&
+    (typeAnnotationName === 'DirectEventHandler' ||
+      typeAnnotationName === 'BubblingEventHandler')
+  ) {
+    return null;
+  }
+  if (
+    name === 'style' &&
+    type === 'GenericTypeAnnotation' &&
+    typeAnnotationName === 'ViewStyleProp'
+  ) {
+    return null;
+  }
+  let defaultValue = null;
+  let withNullDefault = false;
+  if (
+    type === 'GenericTypeAnnotation' &&
+    typeAnnotationName === 'WithDefault'
+  ) {
+    if (typeAnnotation.typeParameters.params.length === 1) {
+      throw new Error(
+        `WithDefault requires two parameters, did you forget to provide a default value for "${name}"?`,
+      );
+    }
+    defaultValue = typeAnnotation.typeParameters.params[1].value;
+    const defaultValueType = typeAnnotation.typeParameters.params[1].type;
+    typeAnnotation = typeAnnotation.typeParameters.params[0];
+    type =
+      typeAnnotation.type === 'GenericTypeAnnotation'
+        ? typeAnnotationName
+        : typeAnnotation.type;
+    if (defaultValueType === 'NullLiteralTypeAnnotation') {
+      defaultValue = null;
+      withNullDefault = true;
+    }
+  }
+  return {
+    name,
+    optional,
+    typeAnnotation,
+    defaultValue,
+    withNullDefault,
+  };
+}
+module.exports = {
+  getSchemaInfo,
+  getTypeAnnotation,
+  flattenProperties,
+};

node_modules/@react-native/codegen/lib/parsers/flow/components/componentsUtils.js.flow

@@ -0,0 +1,496 @@
+/**
+ * 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 {BuildSchemaFN, Parser} from '../../parser';
+import type {ASTNode, PropAST, TypeDeclarationMap} from '../../utils';
+
+const {verifyPropNotAlreadyDefined} = require('../../parsers-commons');
+const {getValueFromTypes} = require('../utils.js');
+
+// $FlowFixMe[unsupported-variance-annotation]
+function getTypeAnnotationForArray<+T>(
+  name: string,
+  typeAnnotation: $FlowFixMe,
+  defaultValue: $FlowFixMe | null,
+  types: TypeDeclarationMap,
+  parser: Parser,
+  buildSchema: BuildSchemaFN<T>,
+): $FlowFixMe {
+  const extractedTypeAnnotation = getValueFromTypes(typeAnnotation, types);
+  if (extractedTypeAnnotation.type === 'NullableTypeAnnotation') {
+    throw new Error(
+      'Nested optionals such as "$ReadOnlyArray<?boolean>" are not supported, please declare optionals at the top level of value definitions as in "?$ReadOnlyArray<boolean>"',
+    );
+  }
+
+  if (
+    extractedTypeAnnotation.type === 'GenericTypeAnnotation' &&
+    parser.getTypeAnnotationName(extractedTypeAnnotation) === 'WithDefault'
+  ) {
+    throw new Error(
+      'Nested defaults such as "$ReadOnlyArray<WithDefault<boolean, false>>" are not supported, please declare defaults at the top level of value definitions as in "WithDefault<$ReadOnlyArray<boolean>, false>"',
+    );
+  }
+
+  if (extractedTypeAnnotation.type === 'GenericTypeAnnotation') {
+    // Resolve the type alias if it's not defined inline
+    const objectType = getValueFromTypes(extractedTypeAnnotation, types);
+
+    if (objectType.id.name === '$ReadOnly') {
+      return {
+        type: 'ObjectTypeAnnotation',
+        properties: flattenProperties(
+          objectType.typeParameters.params[0].properties,
+          types,
+          parser,
+        )
+          .map(prop => buildSchema(prop, types, parser))
+          .filter(Boolean),
+      };
+    }
+
+    if (objectType.id.name === '$ReadOnlyArray') {
+      // We need to go yet another level deeper to resolve
+      // types that may be defined in a type alias
+      const nestedObjectType = getValueFromTypes(
+        objectType.typeParameters.params[0],
+        types,
+      );
+
+      return {
+        type: 'ArrayTypeAnnotation',
+        elementType: {
+          type: 'ObjectTypeAnnotation',
+          properties: flattenProperties(
+            nestedObjectType.typeParameters.params[0].properties,
+            types,
+            parser,
+          )
+            .map(prop => buildSchema(prop, types, parser))
+            .filter(Boolean),
+        },
+      };
+    }
+  }
+
+  const type =
+    extractedTypeAnnotation.type === 'GenericTypeAnnotation'
+      ? parser.getTypeAnnotationName(extractedTypeAnnotation)
+      : extractedTypeAnnotation.type;
+
+  switch (type) {
+    case 'ImageSource':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'ImageSourcePrimitive',
+      };
+    case 'ImageRequest':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'ImageRequestPrimitive',
+      };
+    case 'ColorValue':
+    case 'ProcessedColorValue':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'ColorPrimitive',
+      };
+    case 'PointValue':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'PointPrimitive',
+      };
+    case 'EdgeInsetsValue':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'EdgeInsetsPrimitive',
+      };
+    case 'DimensionValue':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'DimensionPrimitive',
+      };
+    case 'Stringish':
+      return {
+        type: 'StringTypeAnnotation',
+      };
+    case 'Int32':
+      return {
+        type: 'Int32TypeAnnotation',
+      };
+    case 'Double':
+      return {
+        type: 'DoubleTypeAnnotation',
+      };
+    case 'Float':
+      return {
+        type: 'FloatTypeAnnotation',
+      };
+    case 'BooleanTypeAnnotation':
+      return {
+        type: 'BooleanTypeAnnotation',
+      };
+    case 'StringTypeAnnotation':
+      return {
+        type: 'StringTypeAnnotation',
+      };
+    case 'UnsafeMixed':
+      return {
+        type: 'MixedTypeAnnotation',
+      };
+    case 'UnionTypeAnnotation':
+      typeAnnotation.types.reduce((lastType, currType) => {
+        if (lastType && currType.type !== lastType.type) {
+          throw new Error(`Mixed types are not supported (see "${name}")`);
+        }
+        return currType;
+      });
+
+      if (defaultValue === null) {
+        throw new Error(`A default enum value is required for "${name}"`);
+      }
+
+      const unionType = typeAnnotation.types[0].type;
+      if (unionType === 'StringLiteralTypeAnnotation') {
+        return {
+          type: 'StringEnumTypeAnnotation',
+          default: (defaultValue: string),
+          options: typeAnnotation.types.map(option => option.value),
+        };
+      } else if (unionType === 'NumberLiteralTypeAnnotation') {
+        throw new Error(
+          `Arrays of int enums are not supported (see: "${name}")`,
+        );
+      } else {
+        throw new Error(
+          `Unsupported union type for "${name}", received "${unionType}"`,
+        );
+      }
+    default:
+      throw new Error(`Unknown property type for "${name}": ${type}`);
+  }
+}
+
+function flattenProperties(
+  typeDefinition: $ReadOnlyArray<PropAST>,
+  types: TypeDeclarationMap,
+  parser: Parser,
+): $ReadOnlyArray<PropAST> {
+  return typeDefinition
+    .map(property => {
+      if (property.type === 'ObjectTypeProperty') {
+        return property;
+      } else if (property.type === 'ObjectTypeSpreadProperty') {
+        return flattenProperties(
+          parser.getProperties(property.argument.id.name, types),
+          types,
+          parser,
+        );
+      }
+    })
+    .reduce((acc: Array<PropAST>, item) => {
+      if (Array.isArray(item)) {
+        item.forEach(prop => {
+          verifyPropNotAlreadyDefined(acc, prop);
+        });
+        return acc.concat(item);
+      } else {
+        verifyPropNotAlreadyDefined(acc, item);
+        acc.push(item);
+        return acc;
+      }
+    }, [])
+    .filter(Boolean);
+}
+
+// $FlowFixMe[unsupported-variance-annotation]
+function getTypeAnnotation<+T>(
+  name: string,
+  annotation: $FlowFixMe | ASTNode,
+  defaultValue: $FlowFixMe | null,
+  withNullDefault: boolean,
+  types: TypeDeclarationMap,
+  parser: Parser,
+  buildSchema: BuildSchemaFN<T>,
+): $FlowFixMe {
+  const typeAnnotation = getValueFromTypes(annotation, types);
+
+  if (
+    typeAnnotation.type === 'GenericTypeAnnotation' &&
+    parser.getTypeAnnotationName(typeAnnotation) === '$ReadOnlyArray'
+  ) {
+    return {
+      type: 'ArrayTypeAnnotation',
+      elementType: getTypeAnnotationForArray(
+        name,
+        typeAnnotation.typeParameters.params[0],
+        defaultValue,
+        types,
+        parser,
+        buildSchema,
+      ),
+    };
+  }
+
+  if (
+    typeAnnotation.type === 'GenericTypeAnnotation' &&
+    parser.getTypeAnnotationName(typeAnnotation) === '$ReadOnly'
+  ) {
+    return {
+      type: 'ObjectTypeAnnotation',
+      properties: flattenProperties(
+        typeAnnotation.typeParameters.params[0].properties,
+        types,
+        parser,
+      )
+        .map(prop => buildSchema(prop, types, parser))
+        .filter(Boolean),
+    };
+  }
+
+  const type =
+    typeAnnotation.type === 'GenericTypeAnnotation'
+      ? parser.getTypeAnnotationName(typeAnnotation)
+      : typeAnnotation.type;
+
+  switch (type) {
+    case 'ImageSource':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'ImageSourcePrimitive',
+      };
+    case 'ImageRequest':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'ImageRequestPrimitive',
+      };
+    case 'ColorValue':
+    case 'ProcessedColorValue':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'ColorPrimitive',
+      };
+    case 'ColorArrayValue':
+      return {
+        type: 'ArrayTypeAnnotation',
+        elementType: {
+          type: 'ReservedPropTypeAnnotation',
+          name: 'ColorPrimitive',
+        },
+      };
+    case 'PointValue':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'PointPrimitive',
+      };
+    case 'EdgeInsetsValue':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'EdgeInsetsPrimitive',
+      };
+    case 'DimensionValue':
+      return {
+        type: 'ReservedPropTypeAnnotation',
+        name: 'DimensionPrimitive',
+      };
+    case 'Int32':
+      return {
+        type: 'Int32TypeAnnotation',
+        default: ((defaultValue ? defaultValue : 0): number),
+      };
+    case 'Double':
+      return {
+        type: 'DoubleTypeAnnotation',
+        default: ((defaultValue ? defaultValue : 0): number),
+      };
+    case 'Float':
+      return {
+        type: 'FloatTypeAnnotation',
+        default: withNullDefault
+          ? (defaultValue: number | null)
+          : ((defaultValue ? defaultValue : 0): number),
+      };
+    case 'BooleanTypeAnnotation':
+      return {
+        type: 'BooleanTypeAnnotation',
+        default: withNullDefault
+          ? (defaultValue: boolean | null)
+          : ((defaultValue == null ? false : defaultValue): boolean),
+      };
+    case 'StringTypeAnnotation':
+      if (typeof defaultValue !== 'undefined') {
+        return {
+          type: 'StringTypeAnnotation',
+          default: (defaultValue: string | null),
+        };
+      }
+      throw new Error(`A default string (or null) is required for "${name}"`);
+    case 'Stringish':
+      if (typeof defaultValue !== 'undefined') {
+        return {
+          type: 'StringTypeAnnotation',
+          default: (defaultValue: string | null),
+        };
+      }
+      throw new Error(`A default string (or null) is required for "${name}"`);
+    case 'UnionTypeAnnotation':
+      typeAnnotation.types.reduce((lastType, currType) => {
+        if (lastType && currType.type !== lastType.type) {
+          throw new Error(`Mixed types are not supported (see "${name}").`);
+        }
+        return currType;
+      });
+
+      if (defaultValue === null) {
+        throw new Error(`A default enum value is required for "${name}"`);
+      }
+
+      const unionType = typeAnnotation.types[0].type;
+      if (unionType === 'StringLiteralTypeAnnotation') {
+        return {
+          type: 'StringEnumTypeAnnotation',
+          default: (defaultValue: string),
+          options: typeAnnotation.types.map(option => option.value),
+        };
+      } else if (unionType === 'NumberLiteralTypeAnnotation') {
+        return {
+          type: 'Int32EnumTypeAnnotation',
+          default: (defaultValue: number),
+          options: typeAnnotation.types.map(option => option.value),
+        };
+      } else {
+        throw new Error(
+          `Unsupported union type for "${name}", received "${unionType}"`,
+        );
+      }
+    case 'ObjectTypeAnnotation':
+      throw new Error(
+        `Cannot use "${type}" type annotation for "${name}": object types must be declared using $ReadOnly<>`,
+      );
+    case 'NumberTypeAnnotation':
+      throw new Error(
+        `Cannot use "${type}" type annotation for "${name}": must use a specific numeric type like Int32, Double, or Float`,
+      );
+    case 'UnsafeMixed':
+      return {
+        type: 'MixedTypeAnnotation',
+      };
+    default:
+      throw new Error(
+        `Unknown property type for "${name}": "${type}" in the State`,
+      );
+  }
+}
+
+type SchemaInfo = {
+  name: string,
+  optional: boolean,
+  typeAnnotation: $FlowFixMe,
+  defaultValue: $FlowFixMe,
+  withNullDefault: boolean,
+};
+
+function getSchemaInfo(
+  property: PropAST,
+  types: TypeDeclarationMap,
+  parser: Parser,
+): ?SchemaInfo {
+  const name = property.key.name;
+
+  const value = getValueFromTypes(property.value, types);
+  let typeAnnotation =
+    value.type === 'NullableTypeAnnotation' ? value.typeAnnotation : value;
+  let typeAnnotationName = parser.getTypeAnnotationName(typeAnnotation);
+
+  const optional =
+    value.type === 'NullableTypeAnnotation' ||
+    property.optional ||
+    (value.type === 'GenericTypeAnnotation' &&
+      typeAnnotationName === 'WithDefault');
+
+  if (
+    !property.optional &&
+    value.type === 'GenericTypeAnnotation' &&
+    typeAnnotationName === 'WithDefault'
+  ) {
+    throw new Error(
+      `key ${name} must be optional if used with WithDefault<> annotation`,
+    );
+  }
+  if (
+    value.type === 'NullableTypeAnnotation' &&
+    typeAnnotation.type === 'GenericTypeAnnotation' &&
+    typeAnnotationName === 'WithDefault'
+  ) {
+    throw new Error(
+      'WithDefault<> is optional and does not need to be marked as optional. Please remove the ? annotation in front of it.',
+    );
+  }
+
+  let type = typeAnnotation.type;
+  if (
+    type === 'GenericTypeAnnotation' &&
+    (typeAnnotationName === 'DirectEventHandler' ||
+      typeAnnotationName === 'BubblingEventHandler')
+  ) {
+    return null;
+  }
+
+  if (
+    name === 'style' &&
+    type === 'GenericTypeAnnotation' &&
+    typeAnnotationName === 'ViewStyleProp'
+  ) {
+    return null;
+  }
+
+  let defaultValue = null;
+  let withNullDefault = false;
+  if (
+    type === 'GenericTypeAnnotation' &&
+    typeAnnotationName === 'WithDefault'
+  ) {
+    if (typeAnnotation.typeParameters.params.length === 1) {
+      throw new Error(
+        `WithDefault requires two parameters, did you forget to provide a default value for "${name}"?`,
+      );
+    }
+
+    defaultValue = typeAnnotation.typeParameters.params[1].value;
+    const defaultValueType = typeAnnotation.typeParameters.params[1].type;
+
+    typeAnnotation = typeAnnotation.typeParameters.params[0];
+    type =
+      typeAnnotation.type === 'GenericTypeAnnotation'
+        ? typeAnnotationName
+        : typeAnnotation.type;
+
+    if (defaultValueType === 'NullLiteralTypeAnnotation') {
+      defaultValue = null;
+      withNullDefault = true;
+    }
+  }
+
+  return {
+    name,
+    optional,
+    typeAnnotation,
+    defaultValue,
+    withNullDefault,
+  };
+}
+
+module.exports = {
+  getSchemaInfo,
+  getTypeAnnotation,
+  flattenProperties,
+};

node_modules/@react-native/codegen/lib/parsers/flow/components/events.js

@@ -0,0 +1,249 @@
+/**
+ * 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 {
+  throwIfArgumentPropsAreNull,
+  throwIfBubblingTypeIsNull,
+  throwIfEventHasNoName,
+} = require('../../error-utils');
+const {
+  buildPropertiesForEvent,
+  emitBuildEventSchema,
+  getEventArgument,
+  handleEventHandler,
+} = require('../../parsers-commons');
+const {
+  emitBoolProp,
+  emitDoubleProp,
+  emitFloatProp,
+  emitInt32Prop,
+  emitMixedProp,
+  emitObjectProp,
+  emitStringProp,
+  emitUnionProp,
+} = require('../../parsers-primitives');
+function getPropertyType(
+  /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
+   * LTI update could not be added via codemod */
+  name,
+  optional,
+  typeAnnotation,
+  parser,
+) {
+  const type = extractTypeFromTypeAnnotation(typeAnnotation, parser);
+  switch (type) {
+    case 'BooleanTypeAnnotation':
+      return emitBoolProp(name, optional);
+    case 'StringTypeAnnotation':
+      return emitStringProp(name, optional);
+    case 'Int32':
+      return emitInt32Prop(name, optional);
+    case 'Double':
+      return emitDoubleProp(name, optional);
+    case 'Float':
+      return emitFloatProp(name, optional);
+    case '$ReadOnly':
+      return getPropertyType(
+        name,
+        optional,
+        typeAnnotation.typeParameters.params[0],
+        parser,
+      );
+    case 'ObjectTypeAnnotation':
+      return emitObjectProp(
+        name,
+        optional,
+        parser,
+        typeAnnotation,
+        extractArrayElementType,
+      );
+    case 'UnionTypeAnnotation':
+      return emitUnionProp(name, optional, parser, typeAnnotation);
+    case 'UnsafeMixed':
+      return emitMixedProp(name, optional);
+    case 'ArrayTypeAnnotation':
+    case '$ReadOnlyArray':
+      return {
+        name,
+        optional,
+        typeAnnotation: extractArrayElementType(typeAnnotation, name, parser),
+      };
+    default:
+      throw new Error(`Unable to determine event type for "${name}": ${type}`);
+  }
+}
+function extractArrayElementType(typeAnnotation, name, parser) {
+  const type = extractTypeFromTypeAnnotation(typeAnnotation, parser);
+  switch (type) {
+    case 'BooleanTypeAnnotation':
+      return {
+        type: 'BooleanTypeAnnotation',
+      };
+    case 'StringTypeAnnotation':
+      return {
+        type: 'StringTypeAnnotation',
+      };
+    case 'Int32':
+      return {
+        type: 'Int32TypeAnnotation',
+      };
+    case 'Float':
+      return {
+        type: 'FloatTypeAnnotation',
+      };
+    case 'NumberTypeAnnotation':
+    case 'Double':
+      return {
+        type: 'DoubleTypeAnnotation',
+      };
+    case 'UnionTypeAnnotation':
+      return {
+        type: 'StringLiteralUnionTypeAnnotation',
+        types: typeAnnotation.types.map(option => ({
+          type: 'StringLiteralTypeAnnotation',
+          value: parser.getLiteralValue(option),
+        })),
+      };
+    case 'UnsafeMixed':
+      return {
+        type: 'MixedTypeAnnotation',
+      };
+    case 'ObjectTypeAnnotation':
+      return {
+        type: 'ObjectTypeAnnotation',
+        properties: parser
+          .getObjectProperties(typeAnnotation)
+          .map(member =>
+            buildPropertiesForEvent(member, parser, getPropertyType),
+          ),
+      };
+    case 'ArrayTypeAnnotation':
+      return {
+        type: 'ArrayTypeAnnotation',
+        elementType: extractArrayElementType(
+          typeAnnotation.elementType,
+          name,
+          parser,
+        ),
+      };
+    case '$ReadOnlyArray':
+      const genericParams = typeAnnotation.typeParameters.params;
+      if (genericParams.length !== 1) {
+        throw new Error(
+          `Events only supports arrays with 1 Generic type. Found ${genericParams.length} types:\n${prettify(genericParams)}`,
+        );
+      }
+      return {
+        type: 'ArrayTypeAnnotation',
+        elementType: extractArrayElementType(genericParams[0], name, parser),
+      };
+    default:
+      throw new Error(
+        `Unrecognized ${type} for Array ${name} in events.\n${prettify(typeAnnotation)}`,
+      );
+  }
+}
+function prettify(jsonObject) {
+  return JSON.stringify(jsonObject, null, 2);
+}
+function extractTypeFromTypeAnnotation(typeAnnotation, parser) {
+  return typeAnnotation.type === 'GenericTypeAnnotation'
+    ? parser.getTypeAnnotationName(typeAnnotation)
+    : typeAnnotation.type;
+}
+function findEventArgumentsAndType(
+  parser,
+  typeAnnotation,
+  types,
+  bubblingType,
+  paperName,
+) {
+  throwIfEventHasNoName(typeAnnotation, parser);
+  const name = parser.getTypeAnnotationName(typeAnnotation);
+  if (name === '$ReadOnly') {
+    return {
+      argumentProps: typeAnnotation.typeParameters.params[0].properties,
+      paperTopLevelNameDeprecated: paperName,
+      bubblingType,
+    };
+  } else if (name === 'BubblingEventHandler' || name === 'DirectEventHandler') {
+    return handleEventHandler(
+      name,
+      typeAnnotation,
+      parser,
+      types,
+      findEventArgumentsAndType,
+    );
+  } else if (types[name]) {
+    return findEventArgumentsAndType(
+      parser,
+      types[name].right,
+      types,
+      bubblingType,
+      paperName,
+    );
+  } else {
+    return {
+      argumentProps: null,
+      bubblingType: null,
+      paperTopLevelNameDeprecated: null,
+    };
+  }
+}
+function buildEventSchema(types, property, parser) {
+  const name = property.key.name;
+  const optional =
+    property.optional || property.value.type === 'NullableTypeAnnotation';
+  let typeAnnotation =
+    property.value.type === 'NullableTypeAnnotation'
+      ? property.value.typeAnnotation
+      : property.value;
+  if (
+    typeAnnotation.type !== 'GenericTypeAnnotation' ||
+    (parser.getTypeAnnotationName(typeAnnotation) !== 'BubblingEventHandler' &&
+      parser.getTypeAnnotationName(typeAnnotation) !== 'DirectEventHandler')
+  ) {
+    return null;
+  }
+  const {argumentProps, bubblingType, paperTopLevelNameDeprecated} =
+    findEventArgumentsAndType(parser, typeAnnotation, types);
+  const nonNullableArgumentProps = throwIfArgumentPropsAreNull(
+    argumentProps,
+    name,
+  );
+  const nonNullableBubblingType = throwIfBubblingTypeIsNull(bubblingType, name);
+  const argument = getEventArgument(
+    nonNullableArgumentProps,
+    parser,
+    getPropertyType,
+  );
+  return emitBuildEventSchema(
+    paperTopLevelNameDeprecated,
+    name,
+    optional,
+    nonNullableBubblingType,
+    argument,
+  );
+}
+
+// $FlowFixMe[unclear-type] there's no flowtype for ASTs
+
+function getEvents(eventTypeAST, types, parser) {
+  return eventTypeAST
+    .filter(property => property.type === 'ObjectTypeProperty')
+    .map(property => buildEventSchema(types, property, parser))
+    .filter(Boolean);
+}
+module.exports = {
+  getEvents,
+  extractArrayElementType,
+};

node_modules/@react-native/codegen/lib/parsers/flow/components/events.js.flow

@@ -0,0 +1,288 @@
+/**
+ * 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,
+  EventTypeShape,
+  NamedShape,
+} from '../../../CodegenSchema.js';
+import type {Parser} from '../../parser';
+import type {EventArgumentReturnType} from '../../parsers-commons';
+
+const {
+  throwIfArgumentPropsAreNull,
+  throwIfBubblingTypeIsNull,
+  throwIfEventHasNoName,
+} = require('../../error-utils');
+const {
+  buildPropertiesForEvent,
+  emitBuildEventSchema,
+  getEventArgument,
+  handleEventHandler,
+} = require('../../parsers-commons');
+const {
+  emitBoolProp,
+  emitDoubleProp,
+  emitFloatProp,
+  emitInt32Prop,
+  emitMixedProp,
+  emitObjectProp,
+  emitStringProp,
+  emitUnionProp,
+} = require('../../parsers-primitives');
+
+function getPropertyType(
+  /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
+   * LTI update could not be added via codemod */
+  name: string,
+  optional: boolean,
+  typeAnnotation: $FlowFixMe,
+  parser: Parser,
+): NamedShape<EventTypeAnnotation> {
+  const type = extractTypeFromTypeAnnotation(typeAnnotation, parser);
+
+  switch (type) {
+    case 'BooleanTypeAnnotation':
+      return emitBoolProp(name, optional);
+    case 'StringTypeAnnotation':
+      return emitStringProp(name, optional);
+    case 'Int32':
+      return emitInt32Prop(name, optional);
+    case 'Double':
+      return emitDoubleProp(name, optional);
+    case 'Float':
+      return emitFloatProp(name, optional);
+    case '$ReadOnly':
+      return getPropertyType(
+        name,
+        optional,
+        typeAnnotation.typeParameters.params[0],
+        parser,
+      );
+    case 'ObjectTypeAnnotation':
+      return emitObjectProp(
+        name,
+        optional,
+        parser,
+        typeAnnotation,
+        extractArrayElementType,
+      );
+    case 'UnionTypeAnnotation':
+      return emitUnionProp(name, optional, parser, typeAnnotation);
+    case 'UnsafeMixed':
+      return emitMixedProp(name, optional);
+    case 'ArrayTypeAnnotation':
+    case '$ReadOnlyArray':
+      return {
+        name,
+        optional,
+        typeAnnotation: extractArrayElementType(typeAnnotation, name, parser),
+      };
+    default:
+      throw new Error(`Unable to determine event type for "${name}": ${type}`);
+  }
+}
+
+function extractArrayElementType(
+  typeAnnotation: $FlowFixMe,
+  name: string,
+  parser: Parser,
+): EventTypeAnnotation {
+  const type = extractTypeFromTypeAnnotation(typeAnnotation, parser);
+
+  switch (type) {
+    case 'BooleanTypeAnnotation':
+      return {type: 'BooleanTypeAnnotation'};
+    case 'StringTypeAnnotation':
+      return {type: 'StringTypeAnnotation'};
+    case 'Int32':
+      return {type: 'Int32TypeAnnotation'};
+    case 'Float':
+      return {type: 'FloatTypeAnnotation'};
+    case 'NumberTypeAnnotation':
+    case 'Double':
+      return {
+        type: 'DoubleTypeAnnotation',
+      };
+    case 'UnionTypeAnnotation':
+      return {
+        type: 'StringLiteralUnionTypeAnnotation',
+        types: typeAnnotation.types.map(option => ({
+          type: 'StringLiteralTypeAnnotation',
+          value: parser.getLiteralValue(option),
+        })),
+      };
+    case 'UnsafeMixed':
+      return {type: 'MixedTypeAnnotation'};
+    case 'ObjectTypeAnnotation':
+      return {
+        type: 'ObjectTypeAnnotation',
+        properties: parser
+          .getObjectProperties(typeAnnotation)
+          .map(member =>
+            buildPropertiesForEvent(member, parser, getPropertyType),
+          ),
+      };
+    case 'ArrayTypeAnnotation':
+      return {
+        type: 'ArrayTypeAnnotation',
+        elementType: extractArrayElementType(
+          typeAnnotation.elementType,
+          name,
+          parser,
+        ),
+      };
+    case '$ReadOnlyArray':
+      const genericParams = typeAnnotation.typeParameters.params;
+      if (genericParams.length !== 1) {
+        throw new Error(
+          `Events only supports arrays with 1 Generic type. Found ${
+            genericParams.length
+          } types:\n${prettify(genericParams)}`,
+        );
+      }
+      return {
+        type: 'ArrayTypeAnnotation',
+        elementType: extractArrayElementType(genericParams[0], name, parser),
+      };
+    default:
+      throw new Error(
+        `Unrecognized ${type} for Array ${name} in events.\n${prettify(
+          typeAnnotation,
+        )}`,
+      );
+  }
+}
+
+function prettify(jsonObject: $FlowFixMe): string {
+  return JSON.stringify(jsonObject, null, 2);
+}
+
+function extractTypeFromTypeAnnotation(
+  typeAnnotation: $FlowFixMe,
+  parser: Parser,
+): string {
+  return typeAnnotation.type === 'GenericTypeAnnotation'
+    ? parser.getTypeAnnotationName(typeAnnotation)
+    : typeAnnotation.type;
+}
+
+function findEventArgumentsAndType(
+  parser: Parser,
+  typeAnnotation: $FlowFixMe,
+  types: TypeMap,
+  bubblingType: void | 'direct' | 'bubble',
+  paperName: ?$FlowFixMe,
+): EventArgumentReturnType {
+  throwIfEventHasNoName(typeAnnotation, parser);
+  const name = parser.getTypeAnnotationName(typeAnnotation);
+  if (name === '$ReadOnly') {
+    return {
+      argumentProps: typeAnnotation.typeParameters.params[0].properties,
+      paperTopLevelNameDeprecated: paperName,
+      bubblingType,
+    };
+  } else if (name === 'BubblingEventHandler' || name === 'DirectEventHandler') {
+    return handleEventHandler(
+      name,
+      typeAnnotation,
+      parser,
+      types,
+      findEventArgumentsAndType,
+    );
+  } else if (types[name]) {
+    return findEventArgumentsAndType(
+      parser,
+      types[name].right,
+      types,
+      bubblingType,
+      paperName,
+    );
+  } else {
+    return {
+      argumentProps: null,
+      bubblingType: null,
+      paperTopLevelNameDeprecated: null,
+    };
+  }
+}
+
+function buildEventSchema(
+  types: TypeMap,
+  property: EventTypeAST,
+  parser: Parser,
+): ?EventTypeShape {
+  const name = property.key.name;
+  const optional =
+    property.optional || property.value.type === 'NullableTypeAnnotation';
+
+  let typeAnnotation =
+    property.value.type === 'NullableTypeAnnotation'
+      ? property.value.typeAnnotation
+      : property.value;
+
+  if (
+    typeAnnotation.type !== 'GenericTypeAnnotation' ||
+    (parser.getTypeAnnotationName(typeAnnotation) !== 'BubblingEventHandler' &&
+      parser.getTypeAnnotationName(typeAnnotation) !== 'DirectEventHandler')
+  ) {
+    return null;
+  }
+
+  const {argumentProps, bubblingType, paperTopLevelNameDeprecated} =
+    findEventArgumentsAndType(parser, typeAnnotation, types);
+
+  const nonNullableArgumentProps = throwIfArgumentPropsAreNull(
+    argumentProps,
+    name,
+  );
+  const nonNullableBubblingType = throwIfBubblingTypeIsNull(bubblingType, name);
+
+  const argument = getEventArgument(
+    nonNullableArgumentProps,
+    parser,
+    getPropertyType,
+  );
+
+  return emitBuildEventSchema(
+    paperTopLevelNameDeprecated,
+    name,
+    optional,
+    nonNullableBubblingType,
+    argument,
+  );
+}
+
+// $FlowFixMe[unclear-type] there's no flowtype for ASTs
+type EventTypeAST = Object;
+
+type TypeMap = {
+  // $FlowFixMe[unclear-type] there's no flowtype for ASTs
+  [string]: Object,
+  ...
+};
+
+function getEvents(
+  eventTypeAST: $ReadOnlyArray<EventTypeAST>,
+  types: TypeMap,
+  parser: Parser,
+): $ReadOnlyArray<EventTypeShape> {
+  return eventTypeAST
+    .filter(property => property.type === 'ObjectTypeProperty')
+    .map(property => buildEventSchema(types, property, parser))
+    .filter(Boolean);
+}
+
+module.exports = {
+  getEvents,
+  extractArrayElementType,
+};

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

@@ -0,0 +1,46 @@
+/**
+ * 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 {
+  findComponentConfig,
+  getCommandProperties,
+  getOptions,
+} = require('../../parsers-commons');
+const {getCommands} = require('./commands');
+const {getEvents} = require('./events');
+
+// $FlowFixMe[signature-verification-failure] there's no flowtype for AST
+function buildComponentSchema(ast, parser) {
+  const {componentName, propsTypeName, optionsExpression} = findComponentConfig(
+    ast,
+    parser,
+  );
+  const types = parser.getTypes(ast);
+  const propProperties = parser.getProperties(propsTypeName, types);
+  const commandProperties = getCommandProperties(ast, parser);
+  const {extendsProps, props} = parser.getProps(propProperties, types);
+  const options = getOptions(optionsExpression);
+  const events = getEvents(propProperties, types, parser);
+  const commands = getCommands(commandProperties, types, parser);
+  return {
+    filename: componentName,
+    componentName,
+    options,
+    extendsProps,
+    events,
+    props,
+    commands,
+  };
+}
+module.exports = {
+  buildComponentSchema,
+};

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

@@ -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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+import type {Parser} from '../../parser';
+import type {ComponentSchemaBuilderConfig} from '../../schema.js';
+
+const {
+  findComponentConfig,
+  getCommandProperties,
+  getOptions,
+} = require('../../parsers-commons');
+const {getCommands} = require('./commands');
+const {getEvents} = require('./events');
+
+// $FlowFixMe[signature-verification-failure] there's no flowtype for AST
+function buildComponentSchema(
+  ast: $FlowFixMe,
+  parser: Parser,
+): ComponentSchemaBuilderConfig {
+  const {componentName, propsTypeName, optionsExpression} = findComponentConfig(
+    ast,
+    parser,
+  );
+
+  const types = parser.getTypes(ast);
+
+  const propProperties = parser.getProperties(propsTypeName, types);
+  const commandProperties = getCommandProperties(ast, parser);
+  const {extendsProps, props} = parser.getProps(propProperties, types);
+
+  const options = getOptions(optionsExpression);
+  const events = getEvents(propProperties, types, parser);
+  const commands = getCommands(commandProperties, types, parser);
+
+  return {
+    filename: componentName,
+    componentName,
+    options,
+    extendsProps,
+    events,
+    props,
+    commands,
+  };
+}
+
+module.exports = {
+  buildComponentSchema,
+};

node_modules/@react-native/codegen/lib/parsers/flow/modules/index.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 {
+  UnsupportedEnumDeclarationParserError,
+  UnsupportedGenericParserError,
+  UnsupportedObjectPropertyWithIndexerTypeAnnotationParserError,
+  UnsupportedTypeAnnotationParserError,
+} = require('../../errors');
+const {
+  assertGenericTypeAnnotationHasExactlyOneTypeParameter,
+  parseObjectProperty,
+  unwrapNullable,
+  wrapNullable,
+} = require('../../parsers-commons');
+const {
+  emitArrayType,
+  emitCommonTypes,
+  emitDictionary,
+  emitFunction,
+  emitNumberLiteral,
+  emitPromise,
+  emitRootTag,
+  emitUnion,
+  translateArrayTypeAnnotation,
+  typeAliasResolution,
+  typeEnumResolution,
+} = require('../../parsers-primitives');
+function translateTypeAnnotation(
+  hasteModuleName,
+  /**
+   * TODO(T71778680): Flow-type this node.
+   */
+  flowTypeAnnotation,
+  types,
+  aliasMap,
+  enumMap,
+  tryParse,
+  cxxOnly,
+  parser,
+) {
+  const resolveTypeAnnotationFN = parser.getResolveTypeAnnotationFN();
+  const {nullable, typeAnnotation, typeResolutionStatus} =
+    resolveTypeAnnotationFN(flowTypeAnnotation, types, parser);
+  switch (typeAnnotation.type) {
+    case 'ArrayTypeAnnotation': {
+      return translateArrayTypeAnnotation(
+        hasteModuleName,
+        types,
+        aliasMap,
+        enumMap,
+        cxxOnly,
+        'Array',
+        typeAnnotation.elementType,
+        nullable,
+        translateTypeAnnotation,
+        parser,
+      );
+    }
+    case 'GenericTypeAnnotation': {
+      switch (parser.getTypeAnnotationName(typeAnnotation)) {
+        case 'RootTag': {
+          return emitRootTag(nullable);
+        }
+        case 'Promise': {
+          return emitPromise(
+            hasteModuleName,
+            typeAnnotation,
+            parser,
+            nullable,
+            types,
+            aliasMap,
+            enumMap,
+            tryParse,
+            cxxOnly,
+            translateTypeAnnotation,
+          );
+        }
+        case 'Array':
+        case '$ReadOnlyArray': {
+          return emitArrayType(
+            hasteModuleName,
+            typeAnnotation,
+            parser,
+            types,
+            aliasMap,
+            enumMap,
+            cxxOnly,
+            nullable,
+            translateTypeAnnotation,
+          );
+        }
+        case '$ReadOnly': {
+          assertGenericTypeAnnotationHasExactlyOneTypeParameter(
+            hasteModuleName,
+            typeAnnotation,
+            parser,
+          );
+          const [paramType, isParamNullable] = unwrapNullable(
+            translateTypeAnnotation(
+              hasteModuleName,
+              typeAnnotation.typeParameters.params[0],
+              types,
+              aliasMap,
+              enumMap,
+              tryParse,
+              cxxOnly,
+              parser,
+            ),
+          );
+          return wrapNullable(nullable || isParamNullable, paramType);
+        }
+        default: {
+          const commonType = emitCommonTypes(
+            hasteModuleName,
+            types,
+            typeAnnotation,
+            aliasMap,
+            enumMap,
+            tryParse,
+            cxxOnly,
+            nullable,
+            parser,
+          );
+          if (!commonType) {
+            throw new UnsupportedGenericParserError(
+              hasteModuleName,
+              typeAnnotation,
+              parser,
+            );
+          }
+          return commonType;
+        }
+      }
+    }
+    case 'ObjectTypeAnnotation': {
+      // if there is any indexer, then it is a dictionary
+      if (typeAnnotation.indexers) {
+        const indexers = typeAnnotation.indexers.filter(
+          member => member.type === 'ObjectTypeIndexer',
+        );
+        if (indexers.length > 0 && typeAnnotation.properties.length > 0) {
+          throw new UnsupportedObjectPropertyWithIndexerTypeAnnotationParserError(
+            hasteModuleName,
+            typeAnnotation,
+          );
+        }
+        if (indexers.length > 0) {
+          // check the property type to prevent developers from using unsupported types
+          // the return value from `translateTypeAnnotation` is unused
+          const propertyType = indexers[0].value;
+          const valueType = translateTypeAnnotation(
+            hasteModuleName,
+            propertyType,
+            types,
+            aliasMap,
+            enumMap,
+            tryParse,
+            cxxOnly,
+            parser,
+          );
+          // no need to do further checking
+          return emitDictionary(nullable, valueType);
+        }
+      }
+      const objectTypeAnnotation = {
+        type: 'ObjectTypeAnnotation',
+        // $FlowFixMe[missing-type-arg]
+        properties: [...typeAnnotation.properties, ...typeAnnotation.indexers]
+          .map(property => {
+            return tryParse(() => {
+              return parseObjectProperty(
+                flowTypeAnnotation,
+                property,
+                hasteModuleName,
+                types,
+                aliasMap,
+                enumMap,
+                tryParse,
+                cxxOnly,
+                nullable,
+                translateTypeAnnotation,
+                parser,
+              );
+            });
+          })
+          .filter(Boolean),
+      };
+      return typeAliasResolution(
+        typeResolutionStatus,
+        /* $FlowFixMe[incompatible-type] Natural Inference rollout. See
+         * https://fburl.com/workplace/6291gfvu */
+        objectTypeAnnotation,
+        aliasMap,
+        nullable,
+      );
+    }
+    case 'FunctionTypeAnnotation': {
+      return emitFunction(
+        nullable,
+        hasteModuleName,
+        typeAnnotation,
+        types,
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        translateTypeAnnotation,
+        parser,
+      );
+    }
+    case 'UnionTypeAnnotation': {
+      return emitUnion(nullable, hasteModuleName, typeAnnotation, parser);
+    }
+    case 'NumberLiteralTypeAnnotation': {
+      return emitNumberLiteral(nullable, typeAnnotation.value);
+    }
+    case 'StringLiteralTypeAnnotation': {
+      return wrapNullable(nullable, {
+        type: 'StringLiteralTypeAnnotation',
+        value: typeAnnotation.value,
+      });
+    }
+    case 'EnumStringBody':
+    case 'EnumNumberBody': {
+      if (
+        typeAnnotation.type === 'EnumNumberBody' &&
+        typeAnnotation.members.some(m => {
+          var _m$init;
+          return (
+            m.type === 'EnumNumberMember' &&
+            !Number.isInteger(
+              (_m$init = m.init) === null || _m$init === void 0
+                ? void 0
+                : _m$init.value,
+            )
+          );
+        })
+      ) {
+        throw new UnsupportedEnumDeclarationParserError(
+          hasteModuleName,
+          typeAnnotation,
+          parser.language(),
+        );
+      }
+      return typeEnumResolution(
+        typeAnnotation,
+        typeResolutionStatus,
+        nullable,
+        hasteModuleName,
+        enumMap,
+        parser,
+      );
+    }
+    default: {
+      const commonType = emitCommonTypes(
+        hasteModuleName,
+        types,
+        typeAnnotation,
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        nullable,
+        parser,
+      );
+      if (!commonType) {
+        throw new UnsupportedTypeAnnotationParserError(
+          hasteModuleName,
+          typeAnnotation,
+          parser.language(),
+        );
+      }
+      return commonType;
+    }
+  }
+}
+module.exports = {
+  flowTranslateTypeAnnotation: translateTypeAnnotation,
+};

node_modules/@react-native/codegen/lib/parsers/flow/modules/index.js.flow

@@ -0,0 +1,309 @@
+/**
+ * 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,
+  NativeModuleAliasMap,
+  NativeModuleBaseTypeAnnotation,
+  NativeModuleEnumMap,
+  NativeModuleTypeAnnotation,
+  Nullable,
+} from '../../../CodegenSchema';
+import type {Parser} from '../../parser';
+import type {ParserErrorCapturer, TypeDeclarationMap} from '../../utils';
+
+const {
+  UnsupportedEnumDeclarationParserError,
+  UnsupportedGenericParserError,
+  UnsupportedObjectPropertyWithIndexerTypeAnnotationParserError,
+  UnsupportedTypeAnnotationParserError,
+} = require('../../errors');
+const {
+  assertGenericTypeAnnotationHasExactlyOneTypeParameter,
+  parseObjectProperty,
+  unwrapNullable,
+  wrapNullable,
+} = require('../../parsers-commons');
+const {
+  emitArrayType,
+  emitCommonTypes,
+  emitDictionary,
+  emitFunction,
+  emitNumberLiteral,
+  emitPromise,
+  emitRootTag,
+  emitUnion,
+  translateArrayTypeAnnotation,
+  typeAliasResolution,
+  typeEnumResolution,
+} = require('../../parsers-primitives');
+
+function translateTypeAnnotation(
+  hasteModuleName: string,
+  /**
+   * TODO(T71778680): Flow-type this node.
+   */
+  flowTypeAnnotation: $FlowFixMe,
+  types: TypeDeclarationMap,
+  aliasMap: {...NativeModuleAliasMap},
+  enumMap: {...NativeModuleEnumMap},
+  tryParse: ParserErrorCapturer,
+  cxxOnly: boolean,
+  parser: Parser,
+): Nullable<NativeModuleTypeAnnotation> {
+  const resolveTypeAnnotationFN = parser.getResolveTypeAnnotationFN();
+  const {nullable, typeAnnotation, typeResolutionStatus} =
+    resolveTypeAnnotationFN(flowTypeAnnotation, types, parser);
+
+  switch (typeAnnotation.type) {
+    case 'ArrayTypeAnnotation': {
+      return translateArrayTypeAnnotation(
+        hasteModuleName,
+        types,
+        aliasMap,
+        enumMap,
+        cxxOnly,
+        'Array',
+        typeAnnotation.elementType,
+        nullable,
+        translateTypeAnnotation,
+        parser,
+      );
+    }
+    case 'GenericTypeAnnotation': {
+      switch (parser.getTypeAnnotationName(typeAnnotation)) {
+        case 'RootTag': {
+          return emitRootTag(nullable);
+        }
+        case 'Promise': {
+          return emitPromise(
+            hasteModuleName,
+            typeAnnotation,
+            parser,
+            nullable,
+            types,
+            aliasMap,
+            enumMap,
+            tryParse,
+            cxxOnly,
+            translateTypeAnnotation,
+          );
+        }
+        case 'Array':
+        case '$ReadOnlyArray': {
+          return emitArrayType(
+            hasteModuleName,
+            typeAnnotation,
+            parser,
+            types,
+            aliasMap,
+            enumMap,
+            cxxOnly,
+            nullable,
+            translateTypeAnnotation,
+          );
+        }
+        case '$ReadOnly': {
+          assertGenericTypeAnnotationHasExactlyOneTypeParameter(
+            hasteModuleName,
+            typeAnnotation,
+            parser,
+          );
+
+          const [paramType, isParamNullable] = unwrapNullable(
+            translateTypeAnnotation(
+              hasteModuleName,
+              typeAnnotation.typeParameters.params[0],
+              types,
+              aliasMap,
+              enumMap,
+              tryParse,
+              cxxOnly,
+              parser,
+            ),
+          );
+
+          return wrapNullable(nullable || isParamNullable, paramType);
+        }
+        default: {
+          const commonType = emitCommonTypes(
+            hasteModuleName,
+            types,
+            typeAnnotation,
+            aliasMap,
+            enumMap,
+            tryParse,
+            cxxOnly,
+            nullable,
+            parser,
+          );
+
+          if (!commonType) {
+            throw new UnsupportedGenericParserError(
+              hasteModuleName,
+              typeAnnotation,
+              parser,
+            );
+          }
+          return commonType;
+        }
+      }
+    }
+    case 'ObjectTypeAnnotation': {
+      // if there is any indexer, then it is a dictionary
+      if (typeAnnotation.indexers) {
+        const indexers = typeAnnotation.indexers.filter(
+          member => member.type === 'ObjectTypeIndexer',
+        );
+
+        if (indexers.length > 0 && typeAnnotation.properties.length > 0) {
+          throw new UnsupportedObjectPropertyWithIndexerTypeAnnotationParserError(
+            hasteModuleName,
+            typeAnnotation,
+          );
+        }
+
+        if (indexers.length > 0) {
+          // check the property type to prevent developers from using unsupported types
+          // the return value from `translateTypeAnnotation` is unused
+          const propertyType = indexers[0].value;
+          const valueType = translateTypeAnnotation(
+            hasteModuleName,
+            propertyType,
+            types,
+            aliasMap,
+            enumMap,
+            tryParse,
+            cxxOnly,
+            parser,
+          );
+          // no need to do further checking
+          return emitDictionary(nullable, valueType);
+        }
+      }
+
+      const objectTypeAnnotation = {
+        type: 'ObjectTypeAnnotation',
+        // $FlowFixMe[missing-type-arg]
+        properties: ([
+          ...typeAnnotation.properties,
+          ...typeAnnotation.indexers,
+        ]: Array<$FlowFixMe>)
+          .map<?NamedShape<Nullable<NativeModuleBaseTypeAnnotation>>>(
+            property => {
+              return tryParse(() => {
+                return parseObjectProperty(
+                  flowTypeAnnotation,
+                  property,
+                  hasteModuleName,
+                  types,
+                  aliasMap,
+                  enumMap,
+                  tryParse,
+                  cxxOnly,
+                  nullable,
+                  translateTypeAnnotation,
+                  parser,
+                );
+              });
+            },
+          )
+          .filter(Boolean),
+      };
+
+      return typeAliasResolution(
+        typeResolutionStatus,
+        /* $FlowFixMe[incompatible-type] Natural Inference rollout. See
+         * https://fburl.com/workplace/6291gfvu */
+        objectTypeAnnotation,
+        aliasMap,
+        nullable,
+      );
+    }
+    case 'FunctionTypeAnnotation': {
+      return emitFunction(
+        nullable,
+        hasteModuleName,
+        typeAnnotation,
+        types,
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        translateTypeAnnotation,
+        parser,
+      );
+    }
+    case 'UnionTypeAnnotation': {
+      return emitUnion(nullable, hasteModuleName, typeAnnotation, parser);
+    }
+    case 'NumberLiteralTypeAnnotation': {
+      return emitNumberLiteral(nullable, typeAnnotation.value);
+    }
+    case 'StringLiteralTypeAnnotation': {
+      return wrapNullable(nullable, {
+        type: 'StringLiteralTypeAnnotation',
+        value: typeAnnotation.value,
+      });
+    }
+    case 'EnumStringBody':
+    case 'EnumNumberBody': {
+      if (
+        typeAnnotation.type === 'EnumNumberBody' &&
+        typeAnnotation.members.some(
+          m =>
+            m.type === 'EnumNumberMember' && !Number.isInteger(m.init?.value),
+        )
+      ) {
+        throw new UnsupportedEnumDeclarationParserError(
+          hasteModuleName,
+          typeAnnotation,
+          parser.language(),
+        );
+      }
+      return typeEnumResolution(
+        typeAnnotation,
+        typeResolutionStatus,
+        nullable,
+        hasteModuleName,
+        enumMap,
+        parser,
+      );
+    }
+    default: {
+      const commonType = emitCommonTypes(
+        hasteModuleName,
+        types,
+        typeAnnotation,
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        nullable,
+        parser,
+      );
+
+      if (!commonType) {
+        throw new UnsupportedTypeAnnotationParserError(
+          hasteModuleName,
+          typeAnnotation,
+          parser.language(),
+        );
+      }
+      return commonType;
+    }
+  }
+}
+
+module.exports = {
+  flowTranslateTypeAnnotation: translateTypeAnnotation,
+};

node_modules/@react-native/codegen/lib/parsers/flow/parseFlowAndThrowErrors.js

@@ -0,0 +1,39 @@
+/**
+ * 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 hermesParser = require('hermes-parser');
+function parseFlowAndThrowErrors(code, options = {}) {
+  let ast;
+  try {
+    ast = hermesParser.parse(code, {
+      // Produce an ESTree-compliant AST
+      babel: false,
+      // Parse Flow without a pragma
+      flow: 'all',
+      reactRuntimeTarget: '19',
+      ...(options.filename != null
+        ? {
+            sourceFilename: options.filename,
+          }
+        : {}),
+    });
+  } catch (e) {
+    if (options.filename != null) {
+      e.message = `Syntax error in ${options.filename}: ${e.message}`;
+    }
+    throw e;
+  }
+  return ast;
+}
+module.exports = {
+  parseFlowAndThrowErrors,
+};

node_modules/@react-native/codegen/lib/parsers/flow/parseFlowAndThrowErrors.js.flow

@@ -0,0 +1,42 @@
+/**
+ * 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 {Program as ESTreeProgram} from 'hermes-estree';
+
+const hermesParser = require('hermes-parser');
+
+function parseFlowAndThrowErrors(
+  code: string,
+  options: $ReadOnly<{filename?: ?string}> = {},
+): ESTreeProgram {
+  let ast;
+  try {
+    ast = hermesParser.parse(code, {
+      // Produce an ESTree-compliant AST
+      babel: false,
+      // Parse Flow without a pragma
+      flow: 'all',
+      reactRuntimeTarget: '19',
+      ...(options.filename != null ? {sourceFilename: options.filename} : {}),
+    });
+  } catch (e) {
+    if (options.filename != null) {
+      e.message = `Syntax error in ${options.filename}: ${e.message}`;
+    }
+    throw e;
+  }
+  return ast;
+}
+
+module.exports = {
+  parseFlowAndThrowErrors,
+};

node_modules/@react-native/codegen/lib/parsers/flow/parser.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import type { Parser } from '../parser';
+import type { SchemaType } from '../../CodegenSchema';
+import type { ParserType } from '../errors';
+
+export declare class FlowParser implements Parser {
+    language(): ParserType;
+    parseFile(filename: string): SchemaType;
+    parseString(contents: string, filename?: string): SchemaType;
+    parseModuleFixture(filename: string): SchemaType;
+}

node_modules/@react-native/codegen/lib/parsers/flow/parser.js

@@ -0,0 +1,504 @@
+/**
+ * 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 {
+  UnsupportedObjectPropertyTypeAnnotationParserError,
+} = require('../errors');
+const {
+  buildModuleSchema,
+  buildPropSchema,
+  buildSchema,
+  handleGenericTypeAnnotation,
+} = require('../parsers-commons');
+const {Visitor} = require('../parsers-primitives');
+const {wrapComponentSchema} = require('../schema.js');
+const {buildComponentSchema} = require('./components');
+const {
+  flattenProperties,
+  getSchemaInfo,
+  getTypeAnnotation,
+} = require('./components/componentsUtils');
+const {flowTranslateTypeAnnotation} = require('./modules');
+const {parseFlowAndThrowErrors} = require('./parseFlowAndThrowErrors');
+const fs = require('fs');
+const invariant = require('invariant');
+class FlowParser {
+  constructor() {
+    _defineProperty(
+      this,
+      'typeParameterInstantiation',
+      'TypeParameterInstantiation',
+    );
+    _defineProperty(this, 'typeAlias', 'TypeAlias');
+    _defineProperty(this, 'enumDeclaration', 'EnumDeclaration');
+    _defineProperty(this, 'interfaceDeclaration', 'InterfaceDeclaration');
+    _defineProperty(
+      this,
+      'nullLiteralTypeAnnotation',
+      'NullLiteralTypeAnnotation',
+    );
+    _defineProperty(
+      this,
+      'undefinedLiteralTypeAnnotation',
+      'VoidLiteralTypeAnnotation',
+    );
+  }
+  isProperty(property) {
+    return property.type === 'ObjectTypeProperty';
+  }
+  getKeyName(property, hasteModuleName) {
+    if (!this.isProperty(property)) {
+      throw new UnsupportedObjectPropertyTypeAnnotationParserError(
+        hasteModuleName,
+        property,
+        property.type,
+        this.language(),
+      );
+    }
+    return property.key.name;
+  }
+  language() {
+    return 'Flow';
+  }
+  getTypeAnnotationName(typeAnnotation) {
+    var _typeAnnotation$id, _typeAnnotation$id2;
+    if (
+      (typeAnnotation === null ||
+      typeAnnotation === void 0 ||
+      (_typeAnnotation$id = typeAnnotation.id) === null ||
+      _typeAnnotation$id === void 0
+        ? void 0
+        : _typeAnnotation$id.type) === 'QualifiedTypeIdentifier'
+    ) {
+      return typeAnnotation.id.id.name;
+    }
+    return typeAnnotation === null ||
+      typeAnnotation === void 0 ||
+      (_typeAnnotation$id2 = typeAnnotation.id) === null ||
+      _typeAnnotation$id2 === void 0
+      ? void 0
+      : _typeAnnotation$id2.name;
+  }
+  checkIfInvalidModule(typeArguments) {
+    return (
+      typeArguments.type !== 'TypeParameterInstantiation' ||
+      typeArguments.params.length !== 1 ||
+      typeArguments.params[0].type !== 'GenericTypeAnnotation' ||
+      typeArguments.params[0].id.name !== 'Spec'
+    );
+  }
+  remapUnionTypeAnnotationMemberNames(membersTypes) {
+    const remapLiteral = item => {
+      return item.type
+        .replace('NumberLiteralTypeAnnotation', 'NumberTypeAnnotation')
+        .replace('StringLiteralTypeAnnotation', 'StringTypeAnnotation');
+    };
+    return [...new Set(membersTypes.map(remapLiteral))];
+  }
+  getStringLiteralUnionTypeAnnotationStringLiterals(membersTypes) {
+    return membersTypes.map(item => item.value);
+  }
+  parseFile(filename) {
+    const contents = fs.readFileSync(filename, 'utf8');
+    return this.parseString(contents, filename);
+  }
+  parseString(contents, filename) {
+    return buildSchema(
+      contents,
+      filename,
+      wrapComponentSchema,
+      buildComponentSchema,
+      buildModuleSchema,
+      Visitor,
+      this,
+      flowTranslateTypeAnnotation,
+    );
+  }
+  parseModuleFixture(filename) {
+    const contents = fs.readFileSync(filename, 'utf8');
+    return this.parseString(contents, 'path/NativeSampleTurboModule.js');
+  }
+  getAst(contents, filename) {
+    return parseFlowAndThrowErrors(contents, {
+      filename,
+    });
+  }
+  getFunctionTypeAnnotationParameters(functionTypeAnnotation) {
+    return functionTypeAnnotation.params;
+  }
+  getFunctionNameFromParameter(parameter) {
+    return parameter.name;
+  }
+  getParameterName(parameter) {
+    return parameter.name.name;
+  }
+  getParameterTypeAnnotation(parameter) {
+    return parameter.typeAnnotation;
+  }
+  getFunctionTypeAnnotationReturnType(functionTypeAnnotation) {
+    return functionTypeAnnotation.returnType;
+  }
+  parseEnumMembersType(typeAnnotation) {
+    const enumMembersType =
+      typeAnnotation.type === 'EnumStringBody'
+        ? 'StringTypeAnnotation'
+        : typeAnnotation.type === 'EnumNumberBody'
+          ? 'NumberTypeAnnotation'
+          : null;
+    if (!enumMembersType) {
+      throw new Error(
+        `Unknown enum type annotation type. Got: ${typeAnnotation.type}. Expected: EnumStringBody or EnumNumberBody.`,
+      );
+    }
+    return enumMembersType;
+  }
+  validateEnumMembersSupported(typeAnnotation, enumMembersType) {
+    if (!typeAnnotation.members || typeAnnotation.members.length === 0) {
+      // passing mixed members to flow would result in a flow error
+      // if the tool is launched ignoring that error, the enum would appear like not having enums
+      throw new Error(
+        'Enums should have at least one member and member values can not be mixed- they all must be either blank, number, or string values.',
+      );
+    }
+    typeAnnotation.members.forEach(member => {
+      if (
+        enumMembersType === 'StringTypeAnnotation' &&
+        (!member.init || typeof member.init.value === 'string')
+      ) {
+        return;
+      }
+      if (
+        enumMembersType === 'NumberTypeAnnotation' &&
+        member.init &&
+        typeof member.init.value === 'number'
+      ) {
+        return;
+      }
+      throw new Error(
+        'Enums can not be mixed- they all must be either blank, number, or string values.',
+      );
+    });
+  }
+  parseEnumMembers(typeAnnotation) {
+    return typeAnnotation.members.map(member => {
+      var _member$init, _member$init2;
+      const value =
+        typeof ((_member$init = member.init) === null || _member$init === void 0
+          ? void 0
+          : _member$init.value) === 'number'
+          ? {
+              type: 'NumberLiteralTypeAnnotation',
+              value: member.init.value,
+            }
+          : typeof ((_member$init2 = member.init) === null ||
+              _member$init2 === void 0
+                ? void 0
+                : _member$init2.value) === 'string'
+            ? {
+                type: 'StringLiteralTypeAnnotation',
+                value: member.init.value,
+              }
+            : {
+                type: 'StringLiteralTypeAnnotation',
+                value: member.id.name,
+              };
+      return {
+        name: member.id.name,
+        value: value,
+      };
+    });
+  }
+  isModuleInterface(node) {
+    return (
+      node.type === 'InterfaceDeclaration' &&
+      node.extends.length === 1 &&
+      node.extends[0].type === 'InterfaceExtends' &&
+      node.extends[0].id.name === 'TurboModule'
+    );
+  }
+  isGenericTypeAnnotation(type) {
+    return type === 'GenericTypeAnnotation';
+  }
+  extractAnnotatedElement(typeAnnotation, types) {
+    return types[typeAnnotation.typeParameters.params[0].id.name];
+  }
+
+  /**
+   * This FlowFixMe is supposed to refer to an InterfaceDeclaration or TypeAlias
+   * declaration type. Unfortunately, we don't have those types, because flow-parser
+   * generates them, and flow-parser is not type-safe. In the future, we should find
+   * a way to get these types from our flow parser library.
+   *
+   * TODO(T71778680): Flow type AST Nodes
+   */
+
+  getTypes(ast) {
+    return ast.body.reduce((types, node) => {
+      if (
+        node.type === 'ExportNamedDeclaration' &&
+        node.exportKind === 'type'
+      ) {
+        if (
+          node.declaration != null &&
+          (node.declaration.type === 'TypeAlias' ||
+            node.declaration.type === 'OpaqueType' ||
+            node.declaration.type === 'InterfaceDeclaration')
+        ) {
+          types[node.declaration.id.name] = node.declaration;
+        }
+      } else if (
+        node.type === 'ExportNamedDeclaration' &&
+        node.exportKind === 'value' &&
+        node.declaration &&
+        node.declaration.type === 'EnumDeclaration'
+      ) {
+        types[node.declaration.id.name] = node.declaration;
+      } else if (
+        node.type === 'TypeAlias' ||
+        node.type === 'OpaqueType' ||
+        node.type === 'InterfaceDeclaration' ||
+        node.type === 'EnumDeclaration'
+      ) {
+        types[node.id.name] = node;
+      }
+      return types;
+    }, {});
+  }
+  callExpressionTypeParameters(callExpression) {
+    return callExpression.typeArguments || null;
+  }
+  computePartialProperties(
+    properties,
+    hasteModuleName,
+    types,
+    aliasMap,
+    enumMap,
+    tryParse,
+    cxxOnly,
+  ) {
+    return properties.map(prop => {
+      return {
+        name: prop.key.name,
+        optional: true,
+        typeAnnotation: flowTranslateTypeAnnotation(
+          hasteModuleName,
+          prop.value,
+          types,
+          aliasMap,
+          enumMap,
+          tryParse,
+          cxxOnly,
+          this,
+        ),
+      };
+    });
+  }
+  functionTypeAnnotation(propertyValueType) {
+    return propertyValueType === 'FunctionTypeAnnotation';
+  }
+  getTypeArgumentParamsFromDeclaration(declaration) {
+    return declaration.typeArguments.params;
+  }
+
+  /**
+   * This FlowFixMe is supposed to refer to typeArgumentParams and
+   * funcArgumentParams of generated AST.
+   */
+  getNativeComponentType(typeArgumentParams, funcArgumentParams) {
+    return {
+      propsTypeName: typeArgumentParams[0].id.name,
+      componentName: funcArgumentParams[0].value,
+    };
+  }
+  getAnnotatedElementProperties(annotatedElement) {
+    return annotatedElement.right.properties;
+  }
+  bodyProperties(typeAlias) {
+    return typeAlias.body.properties;
+  }
+  convertKeywordToTypeAnnotation(keyword) {
+    return keyword;
+  }
+  argumentForProp(prop) {
+    return prop.argument;
+  }
+  nameForArgument(prop) {
+    return prop.argument.id.name;
+  }
+  isOptionalProperty(property) {
+    return (
+      property.value.type === 'NullableTypeAnnotation' || property.optional
+    );
+  }
+  getGetSchemaInfoFN() {
+    return getSchemaInfo;
+  }
+  getTypeAnnotationFromProperty(property) {
+    return property.value.type === 'NullableTypeAnnotation'
+      ? property.value.typeAnnotation
+      : property.value;
+  }
+  getGetTypeAnnotationFN() {
+    return getTypeAnnotation;
+  }
+  getResolvedTypeAnnotation(typeAnnotation, types, parser) {
+    invariant(
+      typeAnnotation != null,
+      'resolveTypeAnnotation(): typeAnnotation cannot be null',
+    );
+    let node = typeAnnotation;
+    let nullable = false;
+    let typeResolutionStatus = {
+      successful: false,
+    };
+    for (;;) {
+      if (node.type === 'NullableTypeAnnotation') {
+        nullable = true;
+        node = node.typeAnnotation;
+        continue;
+      }
+      if (node.type !== 'GenericTypeAnnotation') {
+        break;
+      }
+      const typeAnnotationName = this.getTypeAnnotationName(node);
+      const resolvedTypeAnnotation = types[typeAnnotationName];
+      if (resolvedTypeAnnotation == null) {
+        break;
+      }
+      const {typeAnnotation: typeAnnotationNode, typeResolutionStatus: status} =
+        handleGenericTypeAnnotation(node, resolvedTypeAnnotation, this);
+      typeResolutionStatus = status;
+      node = typeAnnotationNode;
+    }
+    return {
+      nullable: nullable,
+      typeAnnotation: node,
+      typeResolutionStatus,
+    };
+  }
+  getResolveTypeAnnotationFN() {
+    return (typeAnnotation, types, parser) =>
+      this.getResolvedTypeAnnotation(typeAnnotation, types, parser);
+  }
+  extendsForProp(prop, types, parser) {
+    const argument = this.argumentForProp(prop);
+    if (!argument) {
+      console.log('null', prop);
+    }
+    const name = parser.nameForArgument(prop);
+    if (types[name] != null) {
+      // This type is locally defined in the file
+      return null;
+    }
+    switch (name) {
+      case 'ViewProps':
+        return {
+          type: 'ReactNativeBuiltInType',
+          knownTypeName: 'ReactNativeCoreViewProps',
+        };
+      default: {
+        throw new Error(`Unable to handle prop spread: ${name}`);
+      }
+    }
+  }
+  removeKnownExtends(typeDefinition, types) {
+    return typeDefinition.filter(
+      prop =>
+        prop.type !== 'ObjectTypeSpreadProperty' ||
+        this.extendsForProp(prop, types, this) === null,
+    );
+  }
+  getExtendsProps(typeDefinition, types) {
+    return typeDefinition
+      .filter(prop => prop.type === 'ObjectTypeSpreadProperty')
+      .map(prop => this.extendsForProp(prop, types, this))
+      .filter(Boolean);
+  }
+  getProps(typeDefinition, types) {
+    const nonExtendsProps = this.removeKnownExtends(typeDefinition, types);
+    const props = flattenProperties(nonExtendsProps, types, this)
+      .map(property => buildPropSchema(property, types, this))
+      .filter(Boolean);
+    return {
+      props,
+      extendsProps: this.getExtendsProps(typeDefinition, types),
+    };
+  }
+  getProperties(typeName, types) {
+    const typeAlias = types[typeName];
+    try {
+      return typeAlias.right.typeParameters.params[0].properties;
+    } catch (e) {
+      throw new Error(
+        `Failed to find type definition for "${typeName}", please check that you have a valid codegen flow file`,
+      );
+    }
+  }
+  nextNodeForTypeAlias(typeAnnotation) {
+    if (typeAnnotation.type === 'OpaqueType') {
+      return typeAnnotation.impltype;
+    }
+    return typeAnnotation.right;
+  }
+  nextNodeForEnum(typeAnnotation) {
+    return typeAnnotation.body;
+  }
+  genericTypeAnnotationErrorMessage(typeAnnotation) {
+    return `A non GenericTypeAnnotation must be a type declaration ('${this.typeAlias}') or enum ('${this.enumDeclaration}'). Instead, got the unsupported ${typeAnnotation.type}.`;
+  }
+  extractTypeFromTypeAnnotation(typeAnnotation) {
+    return typeAnnotation.type === 'GenericTypeAnnotation'
+      ? typeAnnotation.id.name
+      : typeAnnotation.type;
+  }
+  getObjectProperties(typeAnnotation) {
+    return typeAnnotation.properties;
+  }
+  getLiteralValue(option) {
+    return option.value;
+  }
+  getPaperTopLevelNameDeprecated(typeAnnotation) {
+    return typeAnnotation.typeParameters.params.length > 1
+      ? typeAnnotation.typeParameters.params[1].value
+      : null;
+  }
+}
+module.exports = {
+  FlowParser,
+};

node_modules/@react-native/codegen/lib/parsers/flow/parser.js.flow

@@ -0,0 +1,586 @@
+/**
+ * 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 {
+  ExtendsPropsShape,
+  NamedShape,
+  NativeModuleAliasMap,
+  NativeModuleEnumMap,
+  NativeModuleEnumMember,
+  NativeModuleEnumMemberType,
+  NativeModuleParamTypeAnnotation,
+  Nullable,
+  PropTypeAnnotation,
+  SchemaType,
+  UnionTypeAnnotationMemberType,
+} from '../../CodegenSchema';
+import type {ParserType} from '../errors';
+import type {
+  GetSchemaInfoFN,
+  GetTypeAnnotationFN,
+  Parser,
+  ResolveTypeAnnotationFN,
+} from '../parser';
+import type {
+  ParserErrorCapturer,
+  PropAST,
+  TypeDeclarationMap,
+  TypeResolutionStatus,
+} from '../utils';
+
+const {
+  UnsupportedObjectPropertyTypeAnnotationParserError,
+} = require('../errors');
+const {
+  buildModuleSchema,
+  buildPropSchema,
+  buildSchema,
+  handleGenericTypeAnnotation,
+} = require('../parsers-commons');
+const {Visitor} = require('../parsers-primitives');
+const {wrapComponentSchema} = require('../schema.js');
+const {buildComponentSchema} = require('./components');
+const {
+  flattenProperties,
+  getSchemaInfo,
+  getTypeAnnotation,
+} = require('./components/componentsUtils');
+const {flowTranslateTypeAnnotation} = require('./modules');
+const {parseFlowAndThrowErrors} = require('./parseFlowAndThrowErrors');
+const fs = require('fs');
+const invariant = require('invariant');
+
+type ExtendsForProp = null | {
+  type: 'ReactNativeBuiltInType',
+  knownTypeName: 'ReactNativeCoreViewProps',
+};
+
+class FlowParser implements Parser {
+  typeParameterInstantiation: string = 'TypeParameterInstantiation';
+  typeAlias: string = 'TypeAlias';
+  enumDeclaration: string = 'EnumDeclaration';
+  interfaceDeclaration: string = 'InterfaceDeclaration';
+  nullLiteralTypeAnnotation: string = 'NullLiteralTypeAnnotation';
+  undefinedLiteralTypeAnnotation: string = 'VoidLiteralTypeAnnotation';
+
+  isProperty(property: $FlowFixMe): boolean {
+    return property.type === 'ObjectTypeProperty';
+  }
+
+  getKeyName(property: $FlowFixMe, hasteModuleName: string): string {
+    if (!this.isProperty(property)) {
+      throw new UnsupportedObjectPropertyTypeAnnotationParserError(
+        hasteModuleName,
+        property,
+        property.type,
+        this.language(),
+      );
+    }
+    return property.key.name;
+  }
+
+  language(): ParserType {
+    return 'Flow';
+  }
+
+  getTypeAnnotationName(typeAnnotation: $FlowFixMe): string {
+    if (typeAnnotation?.id?.type === 'QualifiedTypeIdentifier') {
+      return typeAnnotation.id.id.name;
+    }
+
+    return typeAnnotation?.id?.name;
+  }
+
+  checkIfInvalidModule(typeArguments: $FlowFixMe): boolean {
+    return (
+      typeArguments.type !== 'TypeParameterInstantiation' ||
+      typeArguments.params.length !== 1 ||
+      typeArguments.params[0].type !== 'GenericTypeAnnotation' ||
+      typeArguments.params[0].id.name !== 'Spec'
+    );
+  }
+
+  remapUnionTypeAnnotationMemberNames(
+    membersTypes: $FlowFixMe[],
+  ): UnionTypeAnnotationMemberType[] {
+    const remapLiteral = (item: $FlowFixMe) => {
+      return item.type
+        .replace('NumberLiteralTypeAnnotation', 'NumberTypeAnnotation')
+        .replace('StringLiteralTypeAnnotation', 'StringTypeAnnotation');
+    };
+
+    return [...new Set(membersTypes.map(remapLiteral))];
+  }
+
+  getStringLiteralUnionTypeAnnotationStringLiterals(
+    membersTypes: $FlowFixMe[],
+  ): string[] {
+    return membersTypes.map((item: $FlowFixMe) => item.value);
+  }
+
+  parseFile(filename: string): SchemaType {
+    const contents = fs.readFileSync(filename, 'utf8');
+
+    return this.parseString(contents, filename);
+  }
+
+  parseString(contents: string, filename: ?string): SchemaType {
+    return buildSchema(
+      contents,
+      filename,
+      wrapComponentSchema,
+      buildComponentSchema,
+      buildModuleSchema,
+      Visitor,
+      this,
+      flowTranslateTypeAnnotation,
+    );
+  }
+
+  parseModuleFixture(filename: string): SchemaType {
+    const contents = fs.readFileSync(filename, 'utf8');
+
+    return this.parseString(contents, 'path/NativeSampleTurboModule.js');
+  }
+
+  getAst(contents: string, filename?: ?string): $FlowFixMe {
+    return parseFlowAndThrowErrors(contents, {filename});
+  }
+
+  getFunctionTypeAnnotationParameters(
+    functionTypeAnnotation: $FlowFixMe,
+  ): $ReadOnlyArray<$FlowFixMe> {
+    return functionTypeAnnotation.params;
+  }
+
+  getFunctionNameFromParameter(
+    parameter: NamedShape<Nullable<NativeModuleParamTypeAnnotation>>,
+  ): $FlowFixMe {
+    return parameter.name;
+  }
+
+  getParameterName(parameter: $FlowFixMe): string {
+    return parameter.name.name;
+  }
+
+  getParameterTypeAnnotation(parameter: $FlowFixMe): $FlowFixMe {
+    return parameter.typeAnnotation;
+  }
+
+  getFunctionTypeAnnotationReturnType(
+    functionTypeAnnotation: $FlowFixMe,
+  ): $FlowFixMe {
+    return functionTypeAnnotation.returnType;
+  }
+
+  parseEnumMembersType(typeAnnotation: $FlowFixMe): NativeModuleEnumMemberType {
+    const enumMembersType: ?NativeModuleEnumMemberType =
+      typeAnnotation.type === 'EnumStringBody'
+        ? 'StringTypeAnnotation'
+        : typeAnnotation.type === 'EnumNumberBody'
+          ? 'NumberTypeAnnotation'
+          : null;
+    if (!enumMembersType) {
+      throw new Error(
+        `Unknown enum type annotation type. Got: ${typeAnnotation.type}. Expected: EnumStringBody or EnumNumberBody.`,
+      );
+    }
+    return enumMembersType;
+  }
+
+  validateEnumMembersSupported(
+    typeAnnotation: $FlowFixMe,
+    enumMembersType: NativeModuleEnumMemberType,
+  ): void {
+    if (!typeAnnotation.members || typeAnnotation.members.length === 0) {
+      // passing mixed members to flow would result in a flow error
+      // if the tool is launched ignoring that error, the enum would appear like not having enums
+      throw new Error(
+        'Enums should have at least one member and member values can not be mixed- they all must be either blank, number, or string values.',
+      );
+    }
+
+    typeAnnotation.members.forEach(member => {
+      if (
+        enumMembersType === 'StringTypeAnnotation' &&
+        (!member.init || typeof member.init.value === 'string')
+      ) {
+        return;
+      }
+
+      if (
+        enumMembersType === 'NumberTypeAnnotation' &&
+        member.init &&
+        typeof member.init.value === 'number'
+      ) {
+        return;
+      }
+
+      throw new Error(
+        'Enums can not be mixed- they all must be either blank, number, or string values.',
+      );
+    });
+  }
+
+  parseEnumMembers(
+    typeAnnotation: $FlowFixMe,
+  ): $ReadOnlyArray<NativeModuleEnumMember> {
+    return typeAnnotation.members.map(member => {
+      const value =
+        typeof member.init?.value === 'number'
+          ? {
+              type: 'NumberLiteralTypeAnnotation',
+              value: member.init.value,
+            }
+          : typeof member.init?.value === 'string'
+            ? {
+                type: 'StringLiteralTypeAnnotation',
+                value: member.init.value,
+              }
+            : {
+                type: 'StringLiteralTypeAnnotation',
+                value: member.id.name,
+              };
+
+      return {
+        name: member.id.name,
+        value: value,
+      };
+    });
+  }
+
+  isModuleInterface(node: $FlowFixMe): boolean {
+    return (
+      node.type === 'InterfaceDeclaration' &&
+      node.extends.length === 1 &&
+      node.extends[0].type === 'InterfaceExtends' &&
+      node.extends[0].id.name === 'TurboModule'
+    );
+  }
+
+  isGenericTypeAnnotation(type: $FlowFixMe): boolean {
+    return type === 'GenericTypeAnnotation';
+  }
+
+  extractAnnotatedElement(
+    typeAnnotation: $FlowFixMe,
+    types: TypeDeclarationMap,
+  ): $FlowFixMe {
+    return types[typeAnnotation.typeParameters.params[0].id.name];
+  }
+
+  /**
+   * This FlowFixMe is supposed to refer to an InterfaceDeclaration or TypeAlias
+   * declaration type. Unfortunately, we don't have those types, because flow-parser
+   * generates them, and flow-parser is not type-safe. In the future, we should find
+   * a way to get these types from our flow parser library.
+   *
+   * TODO(T71778680): Flow type AST Nodes
+   */
+
+  getTypes(ast: $FlowFixMe): TypeDeclarationMap {
+    return ast.body.reduce((types, node) => {
+      if (
+        node.type === 'ExportNamedDeclaration' &&
+        node.exportKind === 'type'
+      ) {
+        if (
+          node.declaration != null &&
+          (node.declaration.type === 'TypeAlias' ||
+            node.declaration.type === 'OpaqueType' ||
+            node.declaration.type === 'InterfaceDeclaration')
+        ) {
+          types[node.declaration.id.name] = node.declaration;
+        }
+      } else if (
+        node.type === 'ExportNamedDeclaration' &&
+        node.exportKind === 'value' &&
+        node.declaration &&
+        node.declaration.type === 'EnumDeclaration'
+      ) {
+        types[node.declaration.id.name] = node.declaration;
+      } else if (
+        node.type === 'TypeAlias' ||
+        node.type === 'OpaqueType' ||
+        node.type === 'InterfaceDeclaration' ||
+        node.type === 'EnumDeclaration'
+      ) {
+        types[node.id.name] = node;
+      }
+      return types;
+    }, {});
+  }
+
+  callExpressionTypeParameters(callExpression: $FlowFixMe): $FlowFixMe | null {
+    return callExpression.typeArguments || null;
+  }
+
+  computePartialProperties(
+    properties: Array<$FlowFixMe>,
+    hasteModuleName: string,
+    types: TypeDeclarationMap,
+    aliasMap: {...NativeModuleAliasMap},
+    enumMap: {...NativeModuleEnumMap},
+    tryParse: ParserErrorCapturer,
+    cxxOnly: boolean,
+  ): Array<$FlowFixMe> {
+    return properties.map(prop => {
+      return {
+        name: prop.key.name,
+        optional: true,
+        typeAnnotation: flowTranslateTypeAnnotation(
+          hasteModuleName,
+          prop.value,
+          types,
+          aliasMap,
+          enumMap,
+          tryParse,
+          cxxOnly,
+          this,
+        ),
+      };
+    });
+  }
+
+  functionTypeAnnotation(propertyValueType: string): boolean {
+    return propertyValueType === 'FunctionTypeAnnotation';
+  }
+
+  getTypeArgumentParamsFromDeclaration(declaration: $FlowFixMe): $FlowFixMe {
+    return declaration.typeArguments.params;
+  }
+
+  /**
+   * This FlowFixMe is supposed to refer to typeArgumentParams and
+   * funcArgumentParams of generated AST.
+   */
+  getNativeComponentType(
+    typeArgumentParams: $FlowFixMe,
+    funcArgumentParams: $FlowFixMe,
+  ): {[string]: string} {
+    return {
+      propsTypeName: typeArgumentParams[0].id.name,
+      componentName: funcArgumentParams[0].value,
+    };
+  }
+
+  getAnnotatedElementProperties(annotatedElement: $FlowFixMe): $FlowFixMe {
+    return annotatedElement.right.properties;
+  }
+
+  bodyProperties(typeAlias: $FlowFixMe): $ReadOnlyArray<$FlowFixMe> {
+    return typeAlias.body.properties;
+  }
+
+  convertKeywordToTypeAnnotation(keyword: string): string {
+    return keyword;
+  }
+
+  argumentForProp(prop: PropAST): $FlowFixMe {
+    return prop.argument;
+  }
+
+  nameForArgument(prop: PropAST): $FlowFixMe {
+    return prop.argument.id.name;
+  }
+
+  isOptionalProperty(property: $FlowFixMe): boolean {
+    return (
+      property.value.type === 'NullableTypeAnnotation' || property.optional
+    );
+  }
+
+  getGetSchemaInfoFN(): GetSchemaInfoFN {
+    return getSchemaInfo;
+  }
+
+  getTypeAnnotationFromProperty(property: PropAST): $FlowFixMe {
+    return property.value.type === 'NullableTypeAnnotation'
+      ? property.value.typeAnnotation
+      : property.value;
+  }
+
+  getGetTypeAnnotationFN(): GetTypeAnnotationFN {
+    return getTypeAnnotation;
+  }
+
+  getResolvedTypeAnnotation(
+    typeAnnotation: $FlowFixMe,
+    types: TypeDeclarationMap,
+    parser: Parser,
+  ): {
+    nullable: boolean,
+    typeAnnotation: $FlowFixMe,
+    typeResolutionStatus: TypeResolutionStatus,
+  } {
+    invariant(
+      typeAnnotation != null,
+      'resolveTypeAnnotation(): typeAnnotation cannot be null',
+    );
+
+    let node = typeAnnotation;
+    let nullable = false;
+    let typeResolutionStatus: TypeResolutionStatus = {
+      successful: false,
+    };
+
+    for (;;) {
+      if (node.type === 'NullableTypeAnnotation') {
+        nullable = true;
+        node = node.typeAnnotation;
+        continue;
+      }
+
+      if (node.type !== 'GenericTypeAnnotation') {
+        break;
+      }
+
+      const typeAnnotationName = this.getTypeAnnotationName(node);
+      const resolvedTypeAnnotation = types[typeAnnotationName];
+      if (resolvedTypeAnnotation == null) {
+        break;
+      }
+      const {typeAnnotation: typeAnnotationNode, typeResolutionStatus: status} =
+        handleGenericTypeAnnotation(node, resolvedTypeAnnotation, this);
+      typeResolutionStatus = status;
+      node = typeAnnotationNode;
+    }
+
+    return {
+      nullable: nullable,
+      typeAnnotation: node,
+      typeResolutionStatus,
+    };
+  }
+
+  getResolveTypeAnnotationFN(): ResolveTypeAnnotationFN {
+    return (typeAnnotation, types, parser) =>
+      this.getResolvedTypeAnnotation(typeAnnotation, types, parser);
+  }
+  extendsForProp(
+    prop: PropAST,
+    types: TypeDeclarationMap,
+    parser: Parser,
+  ): ExtendsForProp {
+    const argument = this.argumentForProp(prop);
+    if (!argument) {
+      console.log('null', prop);
+    }
+    const name = parser.nameForArgument(prop);
+
+    if (types[name] != null) {
+      // This type is locally defined in the file
+      return null;
+    }
+
+    switch (name) {
+      case 'ViewProps':
+        return {
+          type: 'ReactNativeBuiltInType',
+          knownTypeName: 'ReactNativeCoreViewProps',
+        };
+      default: {
+        throw new Error(`Unable to handle prop spread: ${name}`);
+      }
+    }
+  }
+
+  removeKnownExtends(
+    typeDefinition: $ReadOnlyArray<PropAST>,
+    types: TypeDeclarationMap,
+  ): $ReadOnlyArray<PropAST> {
+    return typeDefinition.filter(
+      prop =>
+        prop.type !== 'ObjectTypeSpreadProperty' ||
+        this.extendsForProp(prop, types, this) === null,
+    );
+  }
+
+  getExtendsProps(
+    typeDefinition: $ReadOnlyArray<PropAST>,
+    types: TypeDeclarationMap,
+  ): $ReadOnlyArray<ExtendsPropsShape> {
+    return typeDefinition
+      .filter(prop => prop.type === 'ObjectTypeSpreadProperty')
+      .map(prop => this.extendsForProp(prop, types, this))
+      .filter(Boolean);
+  }
+
+  getProps(
+    typeDefinition: $ReadOnlyArray<PropAST>,
+    types: TypeDeclarationMap,
+  ): {
+    props: $ReadOnlyArray<NamedShape<PropTypeAnnotation>>,
+    extendsProps: $ReadOnlyArray<ExtendsPropsShape>,
+  } {
+    const nonExtendsProps = this.removeKnownExtends(typeDefinition, types);
+    const props = flattenProperties(nonExtendsProps, types, this)
+      .map(property => buildPropSchema(property, types, this))
+      .filter(Boolean);
+
+    return {
+      props,
+      extendsProps: this.getExtendsProps(typeDefinition, types),
+    };
+  }
+
+  getProperties(typeName: string, types: TypeDeclarationMap): $FlowFixMe {
+    const typeAlias = types[typeName];
+    try {
+      return typeAlias.right.typeParameters.params[0].properties;
+    } catch (e) {
+      throw new Error(
+        `Failed to find type definition for "${typeName}", please check that you have a valid codegen flow file`,
+      );
+    }
+  }
+
+  nextNodeForTypeAlias(typeAnnotation: $FlowFixMe): $FlowFixMe {
+    if (typeAnnotation.type === 'OpaqueType') {
+      return typeAnnotation.impltype;
+    }
+
+    return typeAnnotation.right;
+  }
+
+  nextNodeForEnum(typeAnnotation: $FlowFixMe): $FlowFixMe {
+    return typeAnnotation.body;
+  }
+
+  genericTypeAnnotationErrorMessage(typeAnnotation: $FlowFixMe): string {
+    return `A non GenericTypeAnnotation must be a type declaration ('${this.typeAlias}') or enum ('${this.enumDeclaration}'). Instead, got the unsupported ${typeAnnotation.type}.`;
+  }
+
+  extractTypeFromTypeAnnotation(typeAnnotation: $FlowFixMe): string {
+    return typeAnnotation.type === 'GenericTypeAnnotation'
+      ? typeAnnotation.id.name
+      : typeAnnotation.type;
+  }
+
+  getObjectProperties(typeAnnotation: $FlowFixMe): $FlowFixMe {
+    return typeAnnotation.properties;
+  }
+
+  getLiteralValue(option: $FlowFixMe): $FlowFixMe {
+    return option.value;
+  }
+
+  getPaperTopLevelNameDeprecated(typeAnnotation: $FlowFixMe): $FlowFixMe {
+    return typeAnnotation.typeParameters.params.length > 1
+      ? typeAnnotation.typeParameters.params[1].value
+      : null;
+  }
+}
+
+module.exports = {
+  FlowParser,
+};

node_modules/@react-native/codegen/lib/parsers/flow/utils.js

@@ -0,0 +1,21 @@
+/**
+ * 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 getValueFromTypes(value, types) {
+  if (value.type === 'GenericTypeAnnotation' && types[value.id.name]) {
+    return getValueFromTypes(types[value.id.name].right, types);
+  }
+  return value;
+}
+module.exports = {
+  getValueFromTypes,
+};

node_modules/@react-native/codegen/lib/parsers/flow/utils.js.flow

@@ -0,0 +1,24 @@
+/**
+ * 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 {ASTNode, TypeDeclarationMap} from '../utils';
+
+function getValueFromTypes(value: ASTNode, types: TypeDeclarationMap): ASTNode {
+  if (value.type === 'GenericTypeAnnotation' && types[value.id.name]) {
+    return getValueFromTypes(types[value.id.name].right, types);
+  }
+  return value;
+}
+
+module.exports = {
+  getValueFromTypes,
+};