@react-native/codegen 0.73.0 → 0.74.0-nightly-20231003-5dedf277c

package/lib/parsers/error-utils.js.flow

@@ -298,6 +298,59 @@ function throwIfMoreThanOneCodegenNativecommands(
   }
 }
 
+function throwIfConfigNotfound(foundConfigs: Array<{[string]: string}>) {
+  if (foundConfigs.length === 0) {
+    throw new Error('Could not find component config for native component');
+  }
+}
+
+function throwIfMoreThanOneConfig(foundConfigs: Array<{[string]: string}>) {
+  if (foundConfigs.length > 1) {
+    throw new Error('Only one component is supported per file');
+  }
+}
+
+function throwIfEventHasNoName(typeAnnotation: $FlowFixMe, parser: Parser) {
+  const name =
+    parser.language() === 'Flow' ? typeAnnotation.id : typeAnnotation.typeName;
+
+  if (!name) {
+    throw new Error("typeAnnotation of event doesn't have a name");
+  }
+}
+
+function throwIfBubblingTypeIsNull(
+  bubblingType: ?('direct' | 'bubble'),
+  eventName: string,
+): 'direct' | 'bubble' {
+  if (!bubblingType) {
+    throw new Error(
+      `Unable to determine event bubbling type for "${eventName}"`,
+    );
+  }
+
+  return bubblingType;
+}
+
+function throwIfArgumentPropsAreNull(
+  argumentProps: ?$ReadOnlyArray<$FlowFixMe>,
+  eventName: string,
+): $ReadOnlyArray<$FlowFixMe> {
+  if (!argumentProps) {
+    throw new Error(`Unable to determine event arguments for "${eventName}"`);
+  }
+
+  return argumentProps;
+}
+
+function throwIfTypeAliasIsNotInterface(typeAlias: $FlowFixMe, parser: Parser) {
+  if (typeAlias.type !== parser.interfaceDeclaration) {
+    throw new Error(
+      `The type argument for codegenNativeCommands must be an interface, received ${typeAlias.type}`,
+    );
+  }
+}
+
 module.exports = {
   throwIfModuleInterfaceIsMisnamed,
   throwIfUnsupportedFunctionReturnTypeAnnotationParserError,
@@ -316,4 +369,10 @@ module.exports = {
   throwIfPartialNotAnnotatingTypeParameter,
   throwIfPartialWithMoreParameter,
   throwIfMoreThanOneCodegenNativecommands,
+  throwIfConfigNotfound,
+  throwIfMoreThanOneConfig,
+  throwIfEventHasNoName,
+  throwIfBubblingTypeIsNull,
+  throwIfArgumentPropsAreNull,
+  throwIfTypeAliasIsNotInterface,
 };

package/lib/parsers/errors.js

@@ -84,9 +84,7 @@ class UnsupportedTypeAnnotationParserError extends ParserError {
 class UnsupportedGenericParserError extends ParserError {
   // +genericName: string;
   constructor(nativeModuleName, genericTypeAnnotation, parser) {
-    const genericName = parser.nameForGenericTypeAnnotation(
-      genericTypeAnnotation,
-    );
+    const genericName = parser.getTypeAnnotationName(genericTypeAnnotation);
     super(
       nativeModuleName,
       genericTypeAnnotation,
@@ -99,9 +97,7 @@ class UnsupportedGenericParserError extends ParserError {
 
 class MissingTypeParameterGenericParserError extends ParserError {
   constructor(nativeModuleName, genericTypeAnnotation, parser) {
-    const genericName = parser.nameForGenericTypeAnnotation(
-      genericTypeAnnotation,
-    );
+    const genericName = parser.getTypeAnnotationName(genericTypeAnnotation);
     super(
       nativeModuleName,
       genericTypeAnnotation,
@@ -111,9 +107,7 @@ class MissingTypeParameterGenericParserError extends ParserError {
 }
 class MoreThanOneTypeParameterGenericParserError extends ParserError {
   constructor(nativeModuleName, genericTypeAnnotation, parser) {
-    const genericName = parser.nameForGenericTypeAnnotation(
-      genericTypeAnnotation,
-    );
+    const genericName = parser.getTypeAnnotationName(genericTypeAnnotation);
     super(
       nativeModuleName,
       genericTypeAnnotation,

package/lib/parsers/errors.js.flow

@@ -117,9 +117,7 @@ class UnsupportedGenericParserError extends ParserError {
     genericTypeAnnotation: $FlowFixMe,
     parser: Parser,
   ) {
-    const genericName = parser.nameForGenericTypeAnnotation(
-      genericTypeAnnotation,
-    );
+    const genericName = parser.getTypeAnnotationName(genericTypeAnnotation);
     super(
       nativeModuleName,
       genericTypeAnnotation,
@@ -136,9 +134,7 @@ class MissingTypeParameterGenericParserError extends ParserError {
     genericTypeAnnotation: $FlowFixMe,
     parser: Parser,
   ) {
-    const genericName = parser.nameForGenericTypeAnnotation(
-      genericTypeAnnotation,
-    );
+    const genericName = parser.getTypeAnnotationName(genericTypeAnnotation);
 
     super(
       nativeModuleName,
@@ -154,9 +150,7 @@ class MoreThanOneTypeParameterGenericParserError extends ParserError {
     genericTypeAnnotation: $FlowFixMe,
     parser: Parser,
   ) {
-    const genericName = parser.nameForGenericTypeAnnotation(
-      genericTypeAnnotation,
-    );
+    const genericName = parser.getTypeAnnotationName(genericTypeAnnotation);
 
     super(
       nativeModuleName,

package/lib/parsers/flow/components/__test_fixtures__/fixtures.js

@@ -84,6 +84,57 @@ const EVENT_DEFINITION = `
   object_readonly_optional_both?: ?$ReadOnly<{
     int32_optional_both?: ?Int32,
   }>,
+
+  boolean_array_required: $ReadOnlyArray<boolean>,
+  boolean_array_optional_key?: boolean[],
+  boolean_array_optional_value: ?$ReadOnlyArray<boolean>,
+  boolean_array_optional_both?: ?boolean[],
+
+  string_array_required: $ReadOnlyArray<string>,
+  string_array_optional_key?: string[],
+  string_array_optional_value: ?$ReadOnlyArray<string>,
+  string_array_optional_both?: ?string[],
+
+  double_array_required: $ReadOnlyArray<Double>,
+  double_array_optional_key?: Double[],
+  double_array_optional_value: ?$ReadOnlyArray<Double>,
+  double_array_optional_both?: ?Double[],
+
+  float_array_required: $ReadOnlyArray<Float>,
+  float_array_optional_key?: Float[],
+  float_array_optional_value: ?$ReadOnlyArray<Float>,
+  float_array_optional_both?: ?Float[],
+
+  int32_array_required: $ReadOnlyArray<Int32>,
+  int32_array_optional_key?: Int32[],
+  int32_array_optional_value: ?$ReadOnlyArray<Int32>,
+  int32_array_optional_both?: ?Int32[],
+
+  enum_array_required: $ReadOnlyArray<('small' | 'large')>,
+  enum_array_optional_key?: ('small' | 'large')[],
+  enum_array_optional_value: ?$ReadOnlyArray<('small' | 'large')>,
+  enum_array_optional_both?: ?('small' | 'large')[],
+
+  object_array_required: $ReadOnlyArray<{
+    boolean_required: boolean,
+  }>,
+
+  object_array_optional_key?: {
+    string_optional_key?: string,
+  }[],
+
+  object_array_optional_value: ?$ReadOnlyArray<{
+    float_optional_value: ?Float,
+  }>,
+
+  object_array_optional_both?: ?{
+    int32_optional_both?: ?Int32,
+  }[],
+
+  int32_array_array_required: $ReadOnlyArray<$ReadOnlyArray<Int32>>,
+  int32_array_array_optional_key?: Int32[][],
+  int32_array_array_optional_value: ?$ReadOnlyArray<$ReadOnlyArray<Int32>>,
+  int32_array_array_optional_both?: ?Int32[][],
 `;
 const ONE_OF_EACH_PROP_EVENT_DEFAULT_AND_OPTIONS = `
 /**

package/lib/parsers/flow/components/__test_fixtures__/fixtures.js.flow

@@ -84,6 +84,57 @@ const EVENT_DEFINITION = `
   object_readonly_optional_both?: ?$ReadOnly<{
     int32_optional_both?: ?Int32,
   }>,
+
+  boolean_array_required: $ReadOnlyArray<boolean>,
+  boolean_array_optional_key?: boolean[],
+  boolean_array_optional_value: ?$ReadOnlyArray<boolean>,
+  boolean_array_optional_both?: ?boolean[],
+
+  string_array_required: $ReadOnlyArray<string>,
+  string_array_optional_key?: string[],
+  string_array_optional_value: ?$ReadOnlyArray<string>,
+  string_array_optional_both?: ?string[],
+
+  double_array_required: $ReadOnlyArray<Double>,
+  double_array_optional_key?: Double[],
+  double_array_optional_value: ?$ReadOnlyArray<Double>,
+  double_array_optional_both?: ?Double[],
+
+  float_array_required: $ReadOnlyArray<Float>,
+  float_array_optional_key?: Float[],
+  float_array_optional_value: ?$ReadOnlyArray<Float>,
+  float_array_optional_both?: ?Float[],
+
+  int32_array_required: $ReadOnlyArray<Int32>,
+  int32_array_optional_key?: Int32[],
+  int32_array_optional_value: ?$ReadOnlyArray<Int32>,
+  int32_array_optional_both?: ?Int32[],
+
+  enum_array_required: $ReadOnlyArray<('small' | 'large')>,
+  enum_array_optional_key?: ('small' | 'large')[],
+  enum_array_optional_value: ?$ReadOnlyArray<('small' | 'large')>,
+  enum_array_optional_both?: ?('small' | 'large')[],
+
+  object_array_required: $ReadOnlyArray<{
+    boolean_required: boolean,
+  }>,
+
+  object_array_optional_key?: {
+    string_optional_key?: string,
+  }[],
+
+  object_array_optional_value: ?$ReadOnlyArray<{
+    float_optional_value: ?Float,
+  }>,
+
+  object_array_optional_both?: ?{
+    int32_optional_both?: ?Int32,
+  }[],
+
+  int32_array_array_required: $ReadOnlyArray<$ReadOnlyArray<Int32>>,
+  int32_array_array_optional_key?: Int32[][],
+  int32_array_array_optional_value: ?$ReadOnlyArray<$ReadOnlyArray<Int32>>,
+  int32_array_array_optional_both?: ?Int32[][],
 `;
 
 const ONE_OF_EACH_PROP_EVENT_DEFAULT_AND_OPTIONS = `

package/lib/parsers/flow/components/componentsUtils.js

@@ -12,21 +12,15 @@
 
 const _require = require('../utils.js'),
   getValueFromTypes = _require.getValueFromTypes;
-function 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`,
-    );
-  }
-}
+const _require2 = require('../../parsers-commons'),
+  verifyPropNotAlreadyDefined = _require2.verifyPropNotAlreadyDefined;
+// $FlowFixMe[unsupported-variance-annotation]
 function getTypeAnnotationForArray(
   name,
   typeAnnotation,
   defaultValue,
   types,
+  parser,
   buildSchema,
 ) {
   const extractedTypeAnnotation = getValueFromTypes(typeAnnotation, types);
@@ -37,7 +31,7 @@ function getTypeAnnotationForArray(
   }
   if (
     extractedTypeAnnotation.type === 'GenericTypeAnnotation' &&
-    extractedTypeAnnotation.id.name === 'WithDefault'
+    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>"',
@@ -52,8 +46,9 @@ function getTypeAnnotationForArray(
         properties: flattenProperties(
           objectType.typeParameters.params[0].properties,
           types,
+          parser,
         )
-          .map(prop => buildSchema(prop, types))
+          .map(prop => buildSchema(prop, types, parser))
           .filter(Boolean),
       };
     }
@@ -71,8 +66,9 @@ function getTypeAnnotationForArray(
           properties: flattenProperties(
             nestedObjectType.typeParameters.params[0].properties,
             types,
+            parser,
           )
-            .map(prop => buildSchema(prop, types))
+            .map(prop => buildSchema(prop, types, parser))
             .filter(Boolean),
         },
       };
@@ -80,7 +76,7 @@ function getTypeAnnotationForArray(
   }
   const type =
     extractedTypeAnnotation.type === 'GenericTypeAnnotation'
-      ? extractedTypeAnnotation.id.name
+      ? parser.getTypeAnnotationName(extractedTypeAnnotation)
       : extractedTypeAnnotation.type;
   switch (type) {
     case 'ImageSource':
@@ -165,19 +161,19 @@ function getTypeAnnotationForArray(
         );
       }
     default:
-      type;
       throw new Error(`Unknown property type for "${name}": ${type}`);
   }
 }
-function flattenProperties(typeDefinition, types) {
+function flattenProperties(typeDefinition, types, parser) {
   return typeDefinition
     .map(property => {
       if (property.type === 'ObjectTypeProperty') {
         return property;
       } else if (property.type === 'ObjectTypeSpreadProperty') {
         return flattenProperties(
-          getProperties(property.argument.id.name, types),
+          parser.getProperties(property.argument.id.name, types),
           types,
+          parser,
         );
       }
     })
@@ -195,25 +191,21 @@ function flattenProperties(typeDefinition, types) {
     }, [])
     .filter(Boolean);
 }
-function verifyPropNotAlreadyDefined(props, needleProp) {
-  const propName = needleProp.key.name;
-  const foundProp = props.some(prop => prop.key.name === propName);
-  if (foundProp) {
-    throw new Error(`A prop was already defined with the name ${propName}`);
-  }
-}
+
+// $FlowFixMe[unsupported-variance-annotation]
 function getTypeAnnotation(
   name,
   annotation,
   defaultValue,
   withNullDefault,
   types,
+  parser,
   buildSchema,
 ) {
   const typeAnnotation = getValueFromTypes(annotation, types);
   if (
     typeAnnotation.type === 'GenericTypeAnnotation' &&
-    typeAnnotation.id.name === '$ReadOnlyArray'
+    parser.getTypeAnnotationName(typeAnnotation) === '$ReadOnlyArray'
   ) {
     return {
       type: 'ArrayTypeAnnotation',
@@ -222,27 +214,29 @@ function getTypeAnnotation(
         typeAnnotation.typeParameters.params[0],
         defaultValue,
         types,
+        parser,
         buildSchema,
       ),
     };
   }
   if (
     typeAnnotation.type === 'GenericTypeAnnotation' &&
-    typeAnnotation.id.name === '$ReadOnly'
+    parser.getTypeAnnotationName(typeAnnotation) === '$ReadOnly'
   ) {
     return {
       type: 'ObjectTypeAnnotation',
       properties: flattenProperties(
         typeAnnotation.typeParameters.params[0].properties,
         types,
+        parser,
       )
-        .map(prop => buildSchema(prop, types))
+        .map(prop => buildSchema(prop, types, parser))
         .filter(Boolean),
     };
   }
   const type =
     typeAnnotation.type === 'GenericTypeAnnotation'
-      ? typeAnnotation.id.name
+      ? parser.getTypeAnnotationName(typeAnnotation)
       : typeAnnotation.type;
   switch (type) {
     case 'ImageSource':
@@ -369,7 +363,6 @@ function getTypeAnnotation(
         type: 'MixedTypeAnnotation',
       };
     default:
-      type;
       throw new Error(
         `Unknown property type for "${name}": "${type}" in the State`,
       );
@@ -449,11 +442,7 @@ function getSchemaInfo(property, types) {
     withNullDefault,
   };
 }
-
-// $FlowFixMe[unclear-type] there's no flowtype for ASTs
-
 module.exports = {
-  getProperties,
   getSchemaInfo,
   getTypeAnnotation,
   flattenProperties,

package/lib/parsers/flow/components/componentsUtils.js.flow

@@ -10,31 +10,19 @@
 
 'use strict';
 
-import type {ASTNode} from '../utils';
-import type {NamedShape} from '../../../CodegenSchema.js';
 const {getValueFromTypes} = require('../utils.js');
-import type {TypeDeclarationMap} from '../../utils';
-
-function 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`,
-    );
-  }
-}
+const {verifyPropNotAlreadyDefined} = require('../../parsers-commons');
+import type {TypeDeclarationMap, PropAST, ASTNode} from '../../utils';
+import type {BuildSchemaFN, Parser} from '../../parser';
 
+// $FlowFixMe[unsupported-variance-annotation]
 function getTypeAnnotationForArray<+T>(
   name: string,
   typeAnnotation: $FlowFixMe,
   defaultValue: $FlowFixMe | null,
   types: TypeDeclarationMap,
-  buildSchema: (property: PropAST, types: TypeDeclarationMap) => ?NamedShape<T>,
+  parser: Parser,
+  buildSchema: BuildSchemaFN<T>,
 ): $FlowFixMe {
   const extractedTypeAnnotation = getValueFromTypes(typeAnnotation, types);
   if (extractedTypeAnnotation.type === 'NullableTypeAnnotation') {
@@ -45,7 +33,7 @@ function getTypeAnnotationForArray<+T>(
 
   if (
     extractedTypeAnnotation.type === 'GenericTypeAnnotation' &&
-    extractedTypeAnnotation.id.name === 'WithDefault'
+    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>"',
@@ -62,8 +50,9 @@ function getTypeAnnotationForArray<+T>(
         properties: flattenProperties(
           objectType.typeParameters.params[0].properties,
           types,
+          parser,
         )
-          .map(prop => buildSchema(prop, types))
+          .map(prop => buildSchema(prop, types, parser))
           .filter(Boolean),
       };
     }
@@ -83,8 +72,9 @@ function getTypeAnnotationForArray<+T>(
           properties: flattenProperties(
             nestedObjectType.typeParameters.params[0].properties,
             types,
+            parser,
           )
-            .map(prop => buildSchema(prop, types))
+            .map(prop => buildSchema(prop, types, parser))
             .filter(Boolean),
         },
       };
@@ -93,7 +83,7 @@ function getTypeAnnotationForArray<+T>(
 
   const type =
     extractedTypeAnnotation.type === 'GenericTypeAnnotation'
-      ? extractedTypeAnnotation.id.name
+      ? parser.getTypeAnnotationName(extractedTypeAnnotation)
       : extractedTypeAnnotation.type;
 
   switch (type) {
@@ -181,7 +171,6 @@ function getTypeAnnotationForArray<+T>(
         );
       }
     default:
-      (type: empty);
       throw new Error(`Unknown property type for "${name}": ${type}`);
   }
 }
@@ -189,6 +178,7 @@ function getTypeAnnotationForArray<+T>(
 function flattenProperties(
   typeDefinition: $ReadOnlyArray<PropAST>,
   types: TypeDeclarationMap,
+  parser: Parser,
 ): $ReadOnlyArray<PropAST> {
   return typeDefinition
     .map(property => {
@@ -196,8 +186,9 @@ function flattenProperties(
         return property;
       } else if (property.type === 'ObjectTypeSpreadProperty') {
         return flattenProperties(
-          getProperties(property.argument.id.name, types),
+          parser.getProperties(property.argument.id.name, types),
           types,
+          parser,
         );
       }
     })
@@ -216,30 +207,21 @@ function flattenProperties(
     .filter(Boolean);
 }
 
-function verifyPropNotAlreadyDefined(
-  props: $ReadOnlyArray<PropAST>,
-  needleProp: PropAST,
-) {
-  const propName = needleProp.key.name;
-  const foundProp = props.some(prop => prop.key.name === propName);
-  if (foundProp) {
-    throw new Error(`A prop was already defined with the name ${propName}`);
-  }
-}
-
+// $FlowFixMe[unsupported-variance-annotation]
 function getTypeAnnotation<+T>(
   name: string,
   annotation: $FlowFixMe | ASTNode,
   defaultValue: $FlowFixMe | null,
   withNullDefault: boolean,
   types: TypeDeclarationMap,
-  buildSchema: (property: PropAST, types: TypeDeclarationMap) => ?NamedShape<T>,
+  parser: Parser,
+  buildSchema: BuildSchemaFN<T>,
 ): $FlowFixMe {
   const typeAnnotation = getValueFromTypes(annotation, types);
 
   if (
     typeAnnotation.type === 'GenericTypeAnnotation' &&
-    typeAnnotation.id.name === '$ReadOnlyArray'
+    parser.getTypeAnnotationName(typeAnnotation) === '$ReadOnlyArray'
   ) {
     return {
       type: 'ArrayTypeAnnotation',
@@ -248,6 +230,7 @@ function getTypeAnnotation<+T>(
         typeAnnotation.typeParameters.params[0],
         defaultValue,
         types,
+        parser,
         buildSchema,
       ),
     };
@@ -255,22 +238,23 @@ function getTypeAnnotation<+T>(
 
   if (
     typeAnnotation.type === 'GenericTypeAnnotation' &&
-    typeAnnotation.id.name === '$ReadOnly'
+    parser.getTypeAnnotationName(typeAnnotation) === '$ReadOnly'
   ) {
     return {
       type: 'ObjectTypeAnnotation',
       properties: flattenProperties(
         typeAnnotation.typeParameters.params[0].properties,
         types,
+        parser,
       )
-        .map(prop => buildSchema(prop, types))
+        .map(prop => buildSchema(prop, types, parser))
         .filter(Boolean),
     };
   }
 
   const type =
     typeAnnotation.type === 'GenericTypeAnnotation'
-      ? typeAnnotation.id.name
+      ? parser.getTypeAnnotationName(typeAnnotation)
       : typeAnnotation.type;
 
   switch (type) {
@@ -396,7 +380,6 @@ function getTypeAnnotation<+T>(
         type: 'MixedTypeAnnotation',
       };
     default:
-      (type: empty);
       throw new Error(
         `Unknown property type for "${name}": "${type}" in the State`,
       );
@@ -499,11 +482,7 @@ function getSchemaInfo(
   };
 }
 
-// $FlowFixMe[unclear-type] there's no flowtype for ASTs
-type PropAST = Object;
-
 module.exports = {
-  getProperties,
   getSchemaInfo,
   getTypeAnnotation,
   flattenProperties,