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

package/lib/parsers/parsers-primitives.js.flow

@@ -14,7 +14,9 @@ import type {
   Nullable,
   BooleanTypeAnnotation,
   DoubleTypeAnnotation,
+  EventTypeAnnotation,
   Int32TypeAnnotation,
+  NamedShape,
   NativeModuleAliasMap,
   NativeModuleEnumMap,
   NativeModuleBaseTypeAnnotation,
@@ -74,6 +76,19 @@ function emitInt32(nullable: boolean): Nullable<Int32TypeAnnotation> {
   });
 }
 
+function emitInt32Prop(
+  name: string,
+  optional: boolean,
+): NamedShape<Int32TypeAnnotation> {
+  return {
+    name,
+    optional,
+    typeAnnotation: {
+      type: 'Int32TypeAnnotation',
+    },
+  };
+}
+
 function emitNumber(
   nullable: boolean,
 ): Nullable<NativeModuleNumberTypeAnnotation> {
@@ -95,6 +110,19 @@ function emitDouble(nullable: boolean): Nullable<DoubleTypeAnnotation> {
   });
 }
 
+function emitDoubleProp(
+  name: string,
+  optional: boolean,
+): NamedShape<DoubleTypeAnnotation> {
+  return {
+    name,
+    optional,
+    typeAnnotation: {
+      type: 'DoubleTypeAnnotation',
+    },
+  };
+}
+
 function emitVoid(nullable: boolean): Nullable<VoidTypeAnnotation> {
   return wrapNullable(nullable, {
     type: 'VoidTypeAnnotation',
@@ -148,6 +176,19 @@ function emitString(nullable: boolean): Nullable<StringTypeAnnotation> {
   });
 }
 
+function emitStringProp(
+  name: string,
+  optional: boolean,
+): NamedShape<StringTypeAnnotation> {
+  return {
+    name,
+    optional,
+    typeAnnotation: {
+      type: 'StringTypeAnnotation',
+    },
+  };
+}
+
 function typeAliasResolution(
   typeResolution: TypeResolutionStatus,
   objectTypeAnnotation: ObjectTypeAnnotation<
@@ -309,6 +350,16 @@ function emitGenericObject(
   });
 }
 
+function emitDictionary(
+  nullable: boolean,
+  valueType: Nullable<NativeModuleTypeAnnotation>,
+): Nullable<NativeModuleGenericObjectTypeAnnotation> {
+  return wrapNullable(nullable, {
+    type: 'GenericObjectTypeAnnotation',
+    dictionaryValueType: valueType,
+  });
+}
+
 function emitObject(
   nullable: boolean,
   properties: Array<$FlowFixMe>,
@@ -327,6 +378,19 @@ function emitFloat(
   });
 }
 
+function emitFloatProp(
+  name: string,
+  optional: boolean,
+): NamedShape<EventTypeAnnotation> {
+  return {
+    name,
+    optional,
+    typeAnnotation: {
+      type: 'FloatTypeAnnotation',
+    },
+  };
+}
+
 function emitUnion(
   nullable: boolean,
   hasteModuleName: string,
@@ -547,7 +611,7 @@ function emitCommonTypes(
   }
 
   const genericTypeAnnotationName =
-    parser.nameForGenericTypeAnnotation(typeAnnotation);
+    parser.getTypeAnnotationName(typeAnnotation);
 
   const emitter = typeMap[genericTypeAnnotationName];
   if (!emitter) {
@@ -567,21 +631,90 @@ function emitCommonTypes(
   );
 }
 
+function emitBoolProp(
+  name: string,
+  optional: boolean,
+): NamedShape<EventTypeAnnotation> {
+  return {
+    name,
+    optional,
+    typeAnnotation: {
+      type: 'BooleanTypeAnnotation',
+    },
+  };
+}
+
+function emitMixedProp(
+  name: string,
+  optional: boolean,
+): NamedShape<EventTypeAnnotation> {
+  return {
+    name,
+    optional,
+    typeAnnotation: {
+      type: 'MixedTypeAnnotation',
+    },
+  };
+}
+
+function emitObjectProp(
+  name: string,
+  optional: boolean,
+  parser: Parser,
+  typeAnnotation: $FlowFixMe,
+  extractArrayElementType: (
+    typeAnnotation: $FlowFixMe,
+    name: string,
+    parser: Parser,
+  ) => EventTypeAnnotation,
+): NamedShape<EventTypeAnnotation> {
+  return {
+    name,
+    optional,
+    typeAnnotation: extractArrayElementType(typeAnnotation, name, parser),
+  };
+}
+
+function emitUnionProp(
+  name: string,
+  optional: boolean,
+  parser: Parser,
+  typeAnnotation: $FlowFixMe,
+): NamedShape<EventTypeAnnotation> {
+  return {
+    name,
+    optional,
+    typeAnnotation: {
+      type: 'StringEnumTypeAnnotation',
+      options: typeAnnotation.types.map(option =>
+        parser.getLiteralValue(option),
+      ),
+    },
+  };
+}
+
 module.exports = {
   emitArrayType,
   emitBoolean,
+  emitBoolProp,
   emitDouble,
+  emitDoubleProp,
   emitFloat,
+  emitFloatProp,
   emitFunction,
   emitInt32,
+  emitInt32Prop,
+  emitMixedProp,
   emitNumber,
   emitGenericObject,
+  emitDictionary,
   emitObject,
   emitPromise,
   emitRootTag,
   emitVoid,
   emitString,
   emitStringish,
+  emitStringProp,
   emitMixed,
   emitUnion,
   emitPartial,
@@ -590,4 +723,6 @@ module.exports = {
   typeEnumResolution,
   translateArrayTypeAnnotation,
   Visitor,
+  emitObjectProp,
+  emitUnionProp,
 };

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

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

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

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

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

@@ -13,37 +13,8 @@
 const _require = require('../parseTopLevelType'),
   parseTopLevelType = _require.parseTopLevelType,
   flattenIntersectionType = _require.flattenIntersectionType;
-function getProperties(typeName, types) {
-  const alias = types[typeName];
-  if (!alias) {
-    throw new Error(
-      `Failed to find definition for "${typeName}", please check that you have a valid codegen typescript file`,
-    );
-  }
-  const aliasKind =
-    alias.type === 'TSInterfaceDeclaration' ? 'interface' : 'type';
-  try {
-    if (aliasKind === 'interface') {
-      var _alias$extends;
-      return [
-        ...((_alias$extends = alias.extends) !== null &&
-        _alias$extends !== void 0
-          ? _alias$extends
-          : []),
-        ...alias.body.body,
-      ];
-    }
-    return (
-      alias.typeAnnotation.members ||
-      alias.typeAnnotation.typeParameters.params[0].members ||
-      alias.typeAnnotation.typeParameters.params
-    );
-  } catch (e) {
-    throw new Error(
-      `Failed to find ${aliasKind} definition for "${typeName}", please check that you have a valid codegen typescript file`,
-    );
-  }
-}
+const _require2 = require('../../parsers-commons'),
+  verifyPropNotAlreadyDefined = _require2.verifyPropNotAlreadyDefined;
 function getUnionOfLiterals(name, forArray, elementTypes, defaultValue, types) {
   var _elementTypes$0$liter, _elementTypes$0$liter2;
   elementTypes.reduce((lastType, currType) => {
@@ -109,6 +80,7 @@ function detectArrayType(
   typeAnnotation,
   defaultValue,
   types,
+  parser,
   buildSchema,
 ) {
   // Covers: readonly T[]
@@ -124,6 +96,7 @@ function detectArrayType(
         typeAnnotation.typeAnnotation.elementType,
         defaultValue,
         types,
+        parser,
         buildSchema,
       ),
     };
@@ -138,6 +111,7 @@ function detectArrayType(
         typeAnnotation.elementType,
         defaultValue,
         types,
+        parser,
         buildSchema,
       ),
     };
@@ -146,8 +120,8 @@ function detectArrayType(
   // Covers: Array<T> and ReadonlyArray<T>
   if (
     typeAnnotation.type === 'TSTypeReference' &&
-    (typeAnnotation.typeName.name === 'ReadonlyArray' ||
-      typeAnnotation.typeName.name === 'Array')
+    (parser.getTypeAnnotationName(typeAnnotation) === 'ReadonlyArray' ||
+      parser.getTypeAnnotationName(typeAnnotation) === 'Array')
   ) {
     return {
       type: 'ArrayTypeAnnotation',
@@ -156,16 +130,17 @@ function detectArrayType(
         typeAnnotation.typeParameters.params[0],
         defaultValue,
         types,
+        parser,
         buildSchema,
       ),
     };
   }
   return null;
 }
-function buildObjectType(rawProperties, types, buildSchema) {
-  const flattenedProperties = flattenProperties(rawProperties, types);
+function buildObjectType(rawProperties, types, parser, buildSchema) {
+  const flattenedProperties = flattenProperties(rawProperties, types, parser);
   const properties = flattenedProperties
-    .map(prop => buildSchema(prop, types))
+    .map(prop => buildSchema(prop, types, parser))
     .filter(Boolean);
   return {
     type: 'ObjectTypeAnnotation',
@@ -179,17 +154,24 @@ function getCommonTypeAnnotation(
   typeAnnotation,
   defaultValue,
   types,
+  parser,
   buildSchema,
 ) {
   switch (type) {
     case 'TSTypeLiteral':
-      return buildObjectType(typeAnnotation.members, types, buildSchema);
+      return buildObjectType(
+        typeAnnotation.members,
+        types,
+        parser,
+        buildSchema,
+      );
     case 'TSInterfaceDeclaration':
-      return buildObjectType([typeAnnotation], types, buildSchema);
+      return buildObjectType([typeAnnotation], types, parser, buildSchema);
     case 'TSIntersectionType':
       return buildObjectType(
         flattenIntersectionType(typeAnnotation, types),
         types,
+        parser,
         buildSchema,
       );
     case 'ImageSource':
@@ -265,6 +247,7 @@ function getTypeAnnotationForArray(
   typeAnnotation,
   defaultValue,
   types,
+  parser,
   buildSchema,
 ) {
   var _extractedTypeAnnotat, _extractedTypeAnnotat2;
@@ -286,6 +269,7 @@ function getTypeAnnotationForArray(
     extractedTypeAnnotation,
     defaultValue,
     types,
+    parser,
     buildSchema,
   );
   if (arrayType) {
@@ -315,6 +299,7 @@ function getTypeAnnotationForArray(
     extractedTypeAnnotation,
     defaultValue,
     types,
+    parser,
     buildSchema,
   );
   if (common) {
@@ -348,7 +333,16 @@ function setDefaultValue(common, defaultValue) {
       break;
   }
 }
-function getTypeAnnotation(name, annotation, defaultValue, types, buildSchema) {
+function getTypeAnnotation(
+  name,
+  annotation,
+  defaultValue,
+  withNullDefault,
+  // Just to make `getTypeAnnotation` signature match with the one from Flow
+  types,
+  parser,
+  buildSchema,
+) {
   // unpack WithDefault, (T) or T|U
   const topLevelType = parseTopLevelType(annotation, types);
   const typeAnnotation = topLevelType.type;
@@ -357,6 +351,7 @@ function getTypeAnnotation(name, annotation, defaultValue, types, buildSchema) {
     typeAnnotation,
     defaultValue,
     types,
+    parser,
     buildSchema,
   );
   if (arrayType) {
@@ -365,7 +360,7 @@ function getTypeAnnotation(name, annotation, defaultValue, types, buildSchema) {
   const type =
     typeAnnotation.type === 'TSTypeReference' ||
     typeAnnotation.type === 'TSTypeAliasDeclaration'
-      ? typeAnnotation.typeName.name
+      ? parser.getTypeAnnotationName(typeAnnotation)
       : typeAnnotation.type;
   const common = getCommonTypeAnnotation(
     name,
@@ -374,6 +369,7 @@ function getTypeAnnotation(name, annotation, defaultValue, types, buildSchema) {
     typeAnnotation,
     defaultValue,
     types,
+    parser,
     buildSchema,
   );
   if (common) {
@@ -398,7 +394,6 @@ function getTypeAnnotation(name, annotation, defaultValue, types, buildSchema) {
         `Cannot use "${type}" type annotation for "${name}": must use a specific function type like BubblingEventHandler, or DirectEventHandler`,
       );
     default:
-      type;
       throw new Error(`Unknown prop type for "${name}": "${type}"`);
   }
 }
@@ -419,42 +414,40 @@ function getSchemaInfo(property, types) {
     optional: property.optional || topLevelType.optional,
     typeAnnotation: topLevelType.type,
     defaultValue: topLevelType.defaultValue,
+    withNullDefault: false, // Just to make `getTypeAnnotation` signature match with the one from Flow
   };
 }
 
-// $FlowFixMe[unclear-type] TODO(T108222691): Use flow-types for @babel/parser
-
-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}`);
-  }
-}
-function flattenProperties(typeDefinition, types) {
+function flattenProperties(typeDefinition, types, parser) {
   return typeDefinition
     .map(property => {
       if (property.type === 'TSPropertySignature') {
         return property;
       } else if (property.type === 'TSTypeReference') {
         return flattenProperties(
-          getProperties(property.typeName.name, types),
+          parser.getProperties(property.typeName.name, types),
           types,
+          parser,
         );
       } else if (
         property.type === 'TSExpressionWithTypeArguments' ||
         property.type === 'TSInterfaceHeritage'
       ) {
         return flattenProperties(
-          getProperties(property.expression.name, types),
+          parser.getProperties(property.expression.name, types),
           types,
+          parser,
         );
       } else if (property.type === 'TSTypeLiteral') {
-        return flattenProperties(property.members, types);
+        return flattenProperties(property.members, types, parser);
       } else if (property.type === 'TSInterfaceDeclaration') {
-        return flattenProperties(getProperties(property.id.name, types), types);
+        return flattenProperties(
+          parser.getProperties(property.id.name, types),
+          types,
+          parser,
+        );
       } else if (property.type === 'TSIntersectionType') {
-        return flattenProperties(property.types, types);
+        return flattenProperties(property.types, types, parser);
       } else {
         throw new Error(
           `${property.type} is not a supported object literal type.`,
@@ -477,7 +470,6 @@ function flattenProperties(typeDefinition, types) {
     .filter(Boolean);
 }
 module.exports = {
-  getProperties,
   getSchemaInfo,
   getTypeAnnotation,
   flattenProperties,