@react-native/codegen 0.73.0-nightly-20230603-fd9e295be → 0.73.0-nightly-20230606-396cdac62

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

@@ -12,16 +12,6 @@
 
 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`,
-    );
-  }
-}
 function getTypeAnnotationForArray(
   name,
   typeAnnotation,
@@ -53,6 +43,7 @@ function getTypeAnnotationForArray(
         properties: flattenProperties(
           objectType.typeParameters.params[0].properties,
           types,
+          parser,
         )
           .map(prop => buildSchema(prop, types, parser))
           .filter(Boolean),
@@ -72,6 +63,7 @@ function getTypeAnnotationForArray(
           properties: flattenProperties(
             nestedObjectType.typeParameters.params[0].properties,
             types,
+            parser,
           )
             .map(prop => buildSchema(prop, types, parser))
             .filter(Boolean),
@@ -170,15 +162,16 @@ function getTypeAnnotationForArray(
       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,
         );
       }
     })
@@ -238,6 +231,7 @@ function getTypeAnnotation(
       properties: flattenProperties(
         typeAnnotation.typeParameters.params[0].properties,
         types,
+        parser,
       )
         .map(prop => buildSchema(prop, types, parser))
         .filter(Boolean),
@@ -453,7 +447,6 @@ function getSchemaInfo(property, types) {
   };
 }
 module.exports = {
-  getProperties,
   getSchemaInfo,
   getTypeAnnotation,
   flattenProperties,

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

@@ -10,25 +10,10 @@
 
 'use strict';
 
-import type {NamedShape} from '../../../CodegenSchema.js';
 const {getValueFromTypes} = require('../utils.js');
 import type {TypeDeclarationMap, PropAST, ASTNode} from '../../utils';
 import type {BuildSchemaFN, Parser} from '../../parser';
 
-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`,
-    );
-  }
-}
-
 function getTypeAnnotationForArray<+T>(
   name: string,
   typeAnnotation: $FlowFixMe,
@@ -63,6 +48,7 @@ function getTypeAnnotationForArray<+T>(
         properties: flattenProperties(
           objectType.typeParameters.params[0].properties,
           types,
+          parser,
         )
           .map(prop => buildSchema(prop, types, parser))
           .filter(Boolean),
@@ -84,6 +70,7 @@ function getTypeAnnotationForArray<+T>(
           properties: flattenProperties(
             nestedObjectType.typeParameters.params[0].properties,
             types,
+            parser,
           )
             .map(prop => buildSchema(prop, types, parser))
             .filter(Boolean),
@@ -190,6 +177,7 @@ function getTypeAnnotationForArray<+T>(
 function flattenProperties(
   typeDefinition: $ReadOnlyArray<PropAST>,
   types: TypeDeclarationMap,
+  parser: Parser,
 ): $ReadOnlyArray<PropAST> {
   return typeDefinition
     .map(property => {
@@ -197,8 +185,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,
         );
       }
     })
@@ -265,6 +254,7 @@ function getTypeAnnotation<+T>(
       properties: flattenProperties(
         typeAnnotation.typeParameters.params[0].properties,
         types,
+        parser,
       )
         .map(prop => buildSchema(prop, types, parser))
         .filter(Boolean),
@@ -503,7 +493,6 @@ function getSchemaInfo(
 }
 
 module.exports = {
-  getProperties,
   getSchemaInfo,
   getTypeAnnotation,
   flattenProperties,

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

@@ -20,7 +20,9 @@ const _require3 = require('../../parsers-primitives'),
   emitBoolProp = _require3.emitBoolProp,
   emitDoubleProp = _require3.emitDoubleProp,
   emitFloatProp = _require3.emitFloatProp,
-  emitStringProp = _require3.emitStringProp;
+  emitMixedProp = _require3.emitMixedProp,
+  emitStringProp = _require3.emitStringProp,
+  emitInt32Prop = _require3.emitInt32Prop;
 function getPropertyType(
   /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
    * LTI update could not be added via codemod */
@@ -36,13 +38,7 @@ function getPropertyType(
     case 'StringTypeAnnotation':
       return emitStringProp(name, optional);
     case 'Int32':
-      return {
-        name,
-        optional,
-        typeAnnotation: {
-          type: 'Int32TypeAnnotation',
-        },
-      };
+      return emitInt32Prop(name, optional);
     case 'Double':
       return emitDoubleProp(name, optional);
     case 'Float':
@@ -75,13 +71,7 @@ function getPropertyType(
         },
       };
     case 'UnsafeMixed':
-      return {
-        name,
-        optional,
-        typeAnnotation: {
-          type: 'MixedTypeAnnotation',
-        },
-      };
+      return emitMixedProp(name, optional);
     case 'ArrayTypeAnnotation':
     case '$ReadOnlyArray':
       return {
@@ -233,10 +223,7 @@ function buildPropertiesForEvent(
 ) {
   const name = property.key.name;
   const optional = parser.isOptionalProperty(property);
-  let typeAnnotation =
-    property.value.type === 'NullableTypeAnnotation'
-      ? property.value.typeAnnotation
-      : property.value;
+  const typeAnnotation = parser.getTypeAnnotationFromProperty(property);
   return getPropertyType(name, optional, typeAnnotation, parser);
 }
 function buildEventSchema(types, property, parser) {

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

@@ -27,7 +27,9 @@ const {
   emitBoolProp,
   emitDoubleProp,
   emitFloatProp,
+  emitMixedProp,
   emitStringProp,
+  emitInt32Prop,
 } = require('../../parsers-primitives');
 
 function getPropertyType(
@@ -46,13 +48,7 @@ function getPropertyType(
     case 'StringTypeAnnotation':
       return emitStringProp(name, optional);
     case 'Int32':
-      return {
-        name,
-        optional,
-        typeAnnotation: {
-          type: 'Int32TypeAnnotation',
-        },
-      };
+      return emitInt32Prop(name, optional);
     case 'Double':
       return emitDoubleProp(name, optional);
     case 'Float':
@@ -85,13 +81,7 @@ function getPropertyType(
         },
       };
     case 'UnsafeMixed':
-      return {
-        name,
-        optional,
-        typeAnnotation: {
-          type: 'MixedTypeAnnotation',
-        },
-      };
+      return emitMixedProp(name, optional);
     case 'ArrayTypeAnnotation':
     case '$ReadOnlyArray':
       return {
@@ -247,10 +237,7 @@ function buildPropertiesForEvent(
 ): NamedShape<EventTypeAnnotation> {
   const name = property.key.name;
   const optional = parser.isOptionalProperty(property);
-  let typeAnnotation =
-    property.value.type === 'NullableTypeAnnotation'
-      ? property.value.typeAnnotation
-      : property.value;
+  const typeAnnotation = parser.getTypeAnnotationFromProperty(property);
 
   return getPropertyType(name, optional, typeAnnotation, parser);
 }

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

@@ -14,61 +14,19 @@ const _require = require('./commands'),
   getCommands = _require.getCommands;
 const _require2 = require('./events'),
   getEvents = _require2.getEvents;
-const _require3 = require('./componentsUtils.js'),
-  getProperties = _require3.getProperties;
-const _require4 = require('../../error-utils'),
-  throwIfTypeAliasIsNotInterface = _require4.throwIfTypeAliasIsNotInterface;
-const _require5 = require('../../parsers-commons'),
-  propertyNames = _require5.propertyNames,
-  getCommandOptions = _require5.getCommandOptions,
-  getOptions = _require5.getOptions,
-  findComponentConfig = _require5.findComponentConfig;
-function getCommandProperties(ast, parser) {
-  const _findComponentConfig = findComponentConfig(ast, parser),
-    commandTypeName = _findComponentConfig.commandTypeName,
-    commandOptionsExpression = _findComponentConfig.commandOptionsExpression;
-  if (commandTypeName == null) {
-    return [];
-  }
-  const types = parser.getTypes(ast);
-  const typeAlias = types[commandTypeName];
-  throwIfTypeAliasIsNotInterface(typeAlias, parser);
-  const properties = parser.bodyProperties(typeAlias);
-  if (!properties) {
-    throw new Error(
-      `Failed to find type definition for "${commandTypeName}", please check that you have a valid codegen flow file`,
-    );
-  }
-  const flowPropertyNames = propertyNames(properties);
-  const commandOptions = getCommandOptions(commandOptionsExpression);
-  if (commandOptions == null || commandOptions.supportedCommands == null) {
-    throw new Error(
-      'codegenNativeCommands must be given an options object with supportedCommands array',
-    );
-  }
-  if (
-    commandOptions.supportedCommands.length !== flowPropertyNames.length ||
-    !commandOptions.supportedCommands.every(supportedCommand =>
-      flowPropertyNames.includes(supportedCommand),
-    )
-  ) {
-    throw new Error(
-      `codegenNativeCommands expected the same supportedCommands specified in the ${commandTypeName} interface: ${flowPropertyNames.join(
-        ', ',
-      )}`,
-    );
-  }
-  return properties;
-}
+const _require3 = require('../../parsers-commons'),
+  getOptions = _require3.getOptions,
+  findComponentConfig = _require3.findComponentConfig,
+  getCommandProperties = _require3.getCommandProperties;
 
 // $FlowFixMe[signature-verification-failure] there's no flowtype for AST
 function buildComponentSchema(ast, parser) {
-  const _findComponentConfig2 = findComponentConfig(ast, parser),
-    componentName = _findComponentConfig2.componentName,
-    propsTypeName = _findComponentConfig2.propsTypeName,
-    optionsExpression = _findComponentConfig2.optionsExpression;
+  const _findComponentConfig = findComponentConfig(ast, parser),
+    componentName = _findComponentConfig.componentName,
+    propsTypeName = _findComponentConfig.propsTypeName,
+    optionsExpression = _findComponentConfig.optionsExpression;
   const types = parser.getTypes(ast);
-  const propProperties = getProperties(propsTypeName, types);
+  const propProperties = parser.getProperties(propsTypeName, types);
   const commandProperties = getCommandProperties(ast, parser);
   const _parser$getProps = parser.getProps(propProperties, types),
     extendsProps = _parser$getProps.extendsProps,

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

@@ -14,63 +14,12 @@ import type {ComponentSchemaBuilderConfig} from '../../schema.js';
 
 const {getCommands} = require('./commands');
 const {getEvents} = require('./events');
-const {getProperties} = require('./componentsUtils.js');
-const {throwIfTypeAliasIsNotInterface} = require('../../error-utils');
 const {
-  propertyNames,
-  getCommandOptions,
   getOptions,
   findComponentConfig,
+  getCommandProperties,
 } = require('../../parsers-commons');
 
-function getCommandProperties(ast: $FlowFixMe, parser: Parser) {
-  const {commandTypeName, commandOptionsExpression} = findComponentConfig(
-    ast,
-    parser,
-  );
-
-  if (commandTypeName == null) {
-    return [];
-  }
-  const types = parser.getTypes(ast);
-
-  const typeAlias = types[commandTypeName];
-
-  throwIfTypeAliasIsNotInterface(typeAlias, parser);
-
-  const properties = parser.bodyProperties(typeAlias);
-  if (!properties) {
-    throw new Error(
-      `Failed to find type definition for "${commandTypeName}", please check that you have a valid codegen flow file`,
-    );
-  }
-
-  const flowPropertyNames = propertyNames(properties);
-
-  const commandOptions = getCommandOptions(commandOptionsExpression);
-
-  if (commandOptions == null || commandOptions.supportedCommands == null) {
-    throw new Error(
-      'codegenNativeCommands must be given an options object with supportedCommands array',
-    );
-  }
-
-  if (
-    commandOptions.supportedCommands.length !== flowPropertyNames.length ||
-    !commandOptions.supportedCommands.every(supportedCommand =>
-      flowPropertyNames.includes(supportedCommand),
-    )
-  ) {
-    throw new Error(
-      `codegenNativeCommands expected the same supportedCommands specified in the ${commandTypeName} interface: ${flowPropertyNames.join(
-        ', ',
-      )}`,
-    );
-  }
-
-  return properties;
-}
-
 // $FlowFixMe[signature-verification-failure] there's no flowtype for AST
 function buildComponentSchema(
   ast: $FlowFixMe,
@@ -83,7 +32,7 @@ function buildComponentSchema(
 
   const types = parser.getTypes(ast);
 
-  const propProperties = getProperties(propsTypeName, types);
+  const propProperties = parser.getProperties(propsTypeName, types);
   const commandProperties = getCommandProperties(ast, parser);
   const {extendsProps, props} = parser.getProps(propProperties, types);
 

package/lib/parsers/flow/parser.js

@@ -50,19 +50,19 @@ const _require2 = require('./modules'),
 const flowParser = require('flow-parser');
 const _require3 = require('../parsers-commons'),
   buildSchema = _require3.buildSchema,
-  buildPropSchema = _require3.buildPropSchema;
+  buildPropSchema = _require3.buildPropSchema,
+  buildModuleSchema = _require3.buildModuleSchema,
+  handleGenericTypeAnnotation = _require3.handleGenericTypeAnnotation;
 const _require4 = require('../parsers-primitives'),
   Visitor = _require4.Visitor;
 const _require5 = require('./components'),
   buildComponentSchema = _require5.buildComponentSchema;
 const _require6 = require('../schema.js'),
   wrapComponentSchema = _require6.wrapComponentSchema;
-const _require7 = require('../parsers-commons.js'),
-  buildModuleSchema = _require7.buildModuleSchema;
 const fs = require('fs');
-const _require8 = require('../errors'),
+const _require7 = require('../errors'),
   UnsupportedObjectPropertyTypeAnnotationParserError =
-    _require8.UnsupportedObjectPropertyTypeAnnotationParserError;
+    _require7.UnsupportedObjectPropertyTypeAnnotationParserError;
 class FlowParser {
   constructor() {
     _defineProperty(
@@ -345,6 +345,11 @@ class FlowParser {
   getGetSchemaInfoFN() {
     return getSchemaInfo;
   }
+  getTypeAnnotationFromProperty(property) {
+    return property.value.type === 'NullableTypeAnnotation'
+      ? property.value.typeAnnotation
+      : property.value;
+  }
   getGetTypeAnnotationFN() {
     return getTypeAnnotation;
   }
@@ -367,35 +372,20 @@ class FlowParser {
       if (node.type !== 'GenericTypeAnnotation') {
         break;
       }
-      const resolvedTypeAnnotation = types[node.id.name];
+      const typeAnnotationName = this.nameForGenericTypeAnnotation(node);
+      const resolvedTypeAnnotation = types[typeAnnotationName];
       if (resolvedTypeAnnotation == null) {
         break;
       }
-      switch (resolvedTypeAnnotation.type) {
-        case parser.typeAlias: {
-          typeResolutionStatus = {
-            successful: true,
-            type: 'alias',
-            name: node.id.name,
-          };
-          node = resolvedTypeAnnotation.right;
-          break;
-        }
-        case parser.enumDeclaration: {
-          typeResolutionStatus = {
-            successful: true,
-            type: 'enum',
-            name: node.id.name,
-          };
-          node = resolvedTypeAnnotation.body;
-          break;
-        }
-        default: {
-          throw new TypeError(
-            `A non GenericTypeAnnotation must be a type declaration ('${parser.typeAlias}') or enum ('${parser.enumDeclaration}'). Instead, got the unsupported ${resolvedTypeAnnotation.type}.`,
-          );
-        }
-      }
+      const _handleGenericTypeAnn = handleGenericTypeAnnotation(
+          node,
+          resolvedTypeAnnotation,
+          this,
+        ),
+        typeAnnotationNode = _handleGenericTypeAnn.typeAnnotation,
+        status = _handleGenericTypeAnn.typeResolutionStatus;
+      typeResolutionStatus = status;
+      node = typeAnnotationNode;
     }
     return {
       nullable: nullable,
@@ -443,7 +433,7 @@ class FlowParser {
   }
   getProps(typeDefinition, types) {
     const nonExtendsProps = this.removeKnownExtends(typeDefinition, types);
-    const props = flattenProperties(nonExtendsProps, types)
+    const props = flattenProperties(nonExtendsProps, types, this)
       .map(property => buildPropSchema(property, types, this))
       .filter(Boolean);
     return {
@@ -451,6 +441,25 @@ class FlowParser {
       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) {
+    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}.`;
+  }
 }
 module.exports = {
   FlowParser,

package/lib/parsers/flow/parser.js.flow

@@ -55,11 +55,15 @@ const {flowTranslateTypeAnnotation} = require('./modules');
 // $FlowFixMe[untyped-import] there's no flowtype flow-parser
 const flowParser = require('flow-parser');
 
-const {buildSchema, buildPropSchema} = require('../parsers-commons');
+const {
+  buildSchema,
+  buildPropSchema,
+  buildModuleSchema,
+  handleGenericTypeAnnotation,
+} = require('../parsers-commons');
 const {Visitor} = require('../parsers-primitives');
 const {buildComponentSchema} = require('./components');
 const {wrapComponentSchema} = require('../schema.js');
-const {buildModuleSchema} = require('../parsers-commons.js');
 
 const fs = require('fs');
 
@@ -376,6 +380,12 @@ class FlowParser implements Parser {
     return getSchemaInfo;
   }
 
+  getTypeAnnotationFromProperty(property: PropAST): $FlowFixMe {
+    return property.value.type === 'NullableTypeAnnotation'
+      ? property.value.typeAnnotation
+      : property.value;
+  }
+
   getGetTypeAnnotationFN(): GetTypeAnnotationFN {
     return getTypeAnnotation;
   }
@@ -411,36 +421,16 @@ class FlowParser implements Parser {
         break;
       }
 
-      const resolvedTypeAnnotation = types[node.id.name];
+      const typeAnnotationName = this.nameForGenericTypeAnnotation(node);
+      const resolvedTypeAnnotation = types[typeAnnotationName];
       if (resolvedTypeAnnotation == null) {
         break;
       }
 
-      switch (resolvedTypeAnnotation.type) {
-        case parser.typeAlias: {
-          typeResolutionStatus = {
-            successful: true,
-            type: 'alias',
-            name: node.id.name,
-          };
-          node = resolvedTypeAnnotation.right;
-          break;
-        }
-        case parser.enumDeclaration: {
-          typeResolutionStatus = {
-            successful: true,
-            type: 'enum',
-            name: node.id.name,
-          };
-          node = resolvedTypeAnnotation.body;
-          break;
-        }
-        default: {
-          throw new TypeError(
-            `A non GenericTypeAnnotation must be a type declaration ('${parser.typeAlias}') or enum ('${parser.enumDeclaration}'). Instead, got the unsupported ${resolvedTypeAnnotation.type}.`,
-          );
-        }
-      }
+      const {typeAnnotation: typeAnnotationNode, typeResolutionStatus: status} =
+        handleGenericTypeAnnotation(node, resolvedTypeAnnotation, this);
+      typeResolutionStatus = status;
+      node = typeAnnotationNode;
     }
 
     return {
@@ -511,7 +501,7 @@ class FlowParser implements Parser {
     extendsProps: $ReadOnlyArray<ExtendsPropsShape>,
   } {
     const nonExtendsProps = this.removeKnownExtends(typeDefinition, types);
-    const props = flattenProperties(nonExtendsProps, types)
+    const props = flattenProperties(nonExtendsProps, types, this)
       .map(property => buildPropSchema(property, types, this))
       .filter(Boolean);
 
@@ -520,6 +510,29 @@ class FlowParser implements Parser {
       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 {
+    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}.`;
+  }
 }
 
 module.exports = {

package/lib/parsers/parser.js.flow

@@ -357,6 +357,13 @@ export interface Parser {
 
   getGetSchemaInfoFN(): GetSchemaInfoFN;
 
+  /**
+   * Given a property return the type annotation.
+   * @parameter property
+   * @returns: the annotation for a type in the AST.
+   */
+  getTypeAnnotationFromProperty(property: PropAST): $FlowFixMe;
+
   getResolvedTypeAnnotation(
     typeAnnotation: $FlowFixMe,
     types: TypeDeclarationMap,
@@ -376,4 +383,21 @@ export interface Parser {
     props: $ReadOnlyArray<NamedShape<PropTypeAnnotation>>,
     extendsProps: $ReadOnlyArray<ExtendsPropsShape>,
   };
+
+  getProperties(typeName: string, types: TypeDeclarationMap): $FlowFixMe;
+
+  /**
+   * Given a typeAlias, it returns the next node.
+   */
+  nextNodeForTypeAlias(typeAnnotation: $FlowFixMe): $FlowFixMe;
+
+  /**
+   * Given an enum Declaration, it returns the next node.
+   */
+  nextNodeForEnum(typeAnnotation: $FlowFixMe): $FlowFixMe;
+
+  /**
+   * Given a unsupported typeAnnotation, returns an error message.
+   */
+  genericTypeAnnotationErrorMessage(typeAnnotation: $FlowFixMe): string;
 }