@react-native/codegen 0.72.5 → 0.73.0-nightly-20230605-5062553c6

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

@@ -15,6 +15,21 @@ import type {
   NamedShape,
   EventTypeAnnotation,
 } from '../../../CodegenSchema.js';
+import type {Parser} from '../../parser';
+
+const {
+  throwIfEventHasNoName,
+  throwIfBubblingTypeIsNull,
+  throwIfArgumentPropsAreNull,
+} = require('../../error-utils');
+const {getEventArgument} = require('../../parsers-commons');
+const {
+  emitBoolProp,
+  emitDoubleProp,
+  emitFloatProp,
+  emitStringProp,
+  emitInt32Prop,
+} = require('../../parsers-primitives');
 
 function getPropertyType(
   /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
@@ -22,84 +37,146 @@ function getPropertyType(
   name,
   optional: boolean,
   typeAnnotation: $FlowFixMe,
+  parser: Parser,
 ): NamedShape<EventTypeAnnotation> {
-  const type =
-    typeAnnotation.type === 'GenericTypeAnnotation'
-      ? typeAnnotation.id.name
-      : typeAnnotation.type;
+  const type = extractTypeFromTypeAnnotation(typeAnnotation);
 
   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 {
         name,
         optional,
         typeAnnotation: {
-          type: 'BooleanTypeAnnotation',
+          type: 'ObjectTypeAnnotation',
+          properties: typeAnnotation.properties.map(member =>
+            buildPropertiesForEvent(member, parser),
+          ),
         },
       };
-    case 'StringTypeAnnotation':
+    case 'UnionTypeAnnotation':
       return {
         name,
         optional,
         typeAnnotation: {
-          type: 'StringTypeAnnotation',
+          type: 'StringEnumTypeAnnotation',
+          options: typeAnnotation.types.map(option => option.value),
         },
       };
-    case 'Int32':
+    case 'UnsafeMixed':
       return {
         name,
         optional,
         typeAnnotation: {
-          type: 'Int32TypeAnnotation',
+          type: 'MixedTypeAnnotation',
         },
       };
-    case 'Double':
+    case 'ArrayTypeAnnotation':
+    case '$ReadOnlyArray':
       return {
         name,
         optional,
-        typeAnnotation: {
-          type: 'DoubleTypeAnnotation',
-        },
+        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);
+
+  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 {
-        name,
-        optional,
-        typeAnnotation: {
-          type: 'FloatTypeAnnotation',
-        },
+        type: 'DoubleTypeAnnotation',
       };
-    case '$ReadOnly':
-      return getPropertyType(
-        name,
-        optional,
-        typeAnnotation.typeParameters.params[0],
-      );
+    case 'UnionTypeAnnotation':
+      return {
+        type: 'StringEnumTypeAnnotation',
+        options: typeAnnotation.types.map(option => option.value),
+      };
+    case 'UnsafeMixed':
+      return {type: 'MixedTypeAnnotation'};
     case 'ObjectTypeAnnotation':
       return {
-        name,
-        optional,
-        typeAnnotation: {
-          type: 'ObjectTypeAnnotation',
-          properties: typeAnnotation.properties.map(buildPropertiesForEvent),
-        },
+        type: 'ObjectTypeAnnotation',
+        properties: typeAnnotation.properties.map(member =>
+          buildPropertiesForEvent(member, parser),
+        ),
       };
-    case 'UnionTypeAnnotation':
+    case 'ArrayTypeAnnotation':
       return {
-        name,
-        optional,
-        typeAnnotation: {
-          type: 'StringEnumTypeAnnotation',
-          options: typeAnnotation.types.map(option => option.value),
-        },
+        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:
-      (type: empty);
-      throw new Error(`Unable to determine event type for "${name}": ${type}`);
+      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): string {
+  return typeAnnotation.type === 'GenericTypeAnnotation'
+    ? typeAnnotation.id.name
+    : typeAnnotation.type;
+}
+
 function findEventArgumentsAndType(
+  parser: Parser,
   typeAnnotation: $FlowFixMe,
   types: TypeMap,
   bubblingType: void | 'direct' | 'bubble',
@@ -109,9 +186,7 @@ function findEventArgumentsAndType(
   bubblingType: ?('direct' | 'bubble'),
   paperTopLevelNameDeprecated: ?$FlowFixMe,
 } {
-  if (!typeAnnotation.id) {
-    throw new Error("typeAnnotation of event doesn't have a name");
-  }
+  throwIfEventHasNoName(typeAnnotation, parser);
   const name = typeAnnotation.id.name;
   if (name === '$ReadOnly') {
     return {
@@ -127,7 +202,7 @@ function findEventArgumentsAndType(
         : null;
     if (
       typeAnnotation.typeParameters.params[0].type ===
-      'NullLiteralTypeAnnotation'
+      parser.nullLiteralTypeAnnotation
     ) {
       return {
         argumentProps: [],
@@ -136,6 +211,7 @@ function findEventArgumentsAndType(
       };
     }
     return findEventArgumentsAndType(
+      parser,
       typeAnnotation.typeParameters.params[0],
       types,
       eventType,
@@ -143,6 +219,7 @@ function findEventArgumentsAndType(
     );
   } else if (types[name]) {
     return findEventArgumentsAndType(
+      parser,
       types[name].right,
       types,
       bubblingType,
@@ -157,32 +234,26 @@ function findEventArgumentsAndType(
   }
 }
 
-/* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
- * LTI update could not be added via codemod */
-function buildPropertiesForEvent(property): NamedShape<EventTypeAnnotation> {
+function buildPropertiesForEvent(
+  /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
+   * LTI update could not be added via codemod */
+  property,
+  parser: Parser,
+): NamedShape<EventTypeAnnotation> {
   const name = property.key.name;
-  const optional =
-    property.value.type === 'NullableTypeAnnotation' || property.optional;
+  const optional = parser.isOptionalProperty(property);
   let typeAnnotation =
     property.value.type === 'NullableTypeAnnotation'
       ? property.value.typeAnnotation
       : property.value;
 
-  return getPropertyType(name, optional, typeAnnotation);
-}
-
-/* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
- * LTI update could not be added via codemod */
-function getEventArgument(argumentProps, name: $FlowFixMe) {
-  return {
-    type: 'ObjectTypeAnnotation',
-    properties: argumentProps.map(buildPropertiesForEvent),
-  };
+  return getPropertyType(name, optional, typeAnnotation, parser);
 }
 
 function buildEventSchema(
   types: TypeMap,
   property: EventTypeAST,
+  parser: Parser,
 ): ?EventTypeShape {
   const name = property.key.name;
   const optional =
@@ -202,40 +273,44 @@ function buildEventSchema(
   }
 
   const {argumentProps, bubblingType, paperTopLevelNameDeprecated} =
-    findEventArgumentsAndType(typeAnnotation, types);
+    findEventArgumentsAndType(parser, typeAnnotation, types);
 
-  if (bubblingType && argumentProps) {
-    if (paperTopLevelNameDeprecated != null) {
-      return {
-        name,
-        optional,
-        bubblingType,
-        paperTopLevelNameDeprecated,
-        typeAnnotation: {
-          type: 'EventTypeAnnotation',
-          argument: getEventArgument(argumentProps, name),
-        },
-      };
-    }
+  const nonNullableArgumentProps = throwIfArgumentPropsAreNull(
+    argumentProps,
+    name,
+  );
+  const nonNullableBubblingType = throwIfBubblingTypeIsNull(bubblingType, name);
 
+  if (paperTopLevelNameDeprecated != null) {
     return {
       name,
       optional,
-      bubblingType,
+      bubblingType: nonNullableBubblingType,
+      paperTopLevelNameDeprecated,
       typeAnnotation: {
         type: 'EventTypeAnnotation',
-        argument: getEventArgument(argumentProps, name),
+        argument: getEventArgument(
+          nonNullableArgumentProps,
+          buildPropertiesForEvent,
+          parser,
+        ),
       },
     };
   }
 
-  if (argumentProps === null) {
-    throw new Error(`Unable to determine event arguments for "${name}"`);
-  }
-
-  if (bubblingType === null) {
-    throw new Error(`Unable to determine event arguments for "${name}"`);
-  }
+  return {
+    name,
+    optional,
+    bubblingType: nonNullableBubblingType,
+    typeAnnotation: {
+      type: 'EventTypeAnnotation',
+      argument: getEventArgument(
+        nonNullableArgumentProps,
+        buildPropertiesForEvent,
+        parser,
+      ),
+    },
+  };
 }
 
 // $FlowFixMe[unclear-type] there's no flowtype for ASTs
@@ -250,10 +325,11 @@ type TypeMap = {
 function getEvents(
   eventTypeAST: $ReadOnlyArray<EventTypeAST>,
   types: TypeMap,
+  parser: Parser,
 ): $ReadOnlyArray<EventTypeShape> {
   return eventTypeAST
     .filter(property => property.type === 'ObjectTypeProperty')
-    .map(property => buildEventSchema(types, property))
+    .map(property => buildEventSchema(types, property, parser))
     .filter(Boolean);
 }
 

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

@@ -14,144 +14,25 @@ const _require = require('./commands'),
   getCommands = _require.getCommands;
 const _require2 = require('./events'),
   getEvents = _require2.getEvents;
-const _require3 = require('./extends'),
-  getExtendsProps = _require3.getExtendsProps,
-  removeKnownExtends = _require3.removeKnownExtends;
-const _require4 = require('./props'),
-  getProps = _require4.getProps;
-const _require5 = require('./componentsUtils.js'),
-  getProperties = _require5.getProperties;
-const _require6 = require('../../error-utils'),
-  throwIfMoreThanOneCodegenNativecommands =
-    _require6.throwIfMoreThanOneCodegenNativecommands;
-const _require7 = require('../../parsers-commons'),
-  createComponentConfig = _require7.createComponentConfig,
-  findNativeComponentType = _require7.findNativeComponentType,
-  getCommandOptions = _require7.getCommandOptions,
-  getOptions = _require7.getOptions;
-
-// $FlowFixMe[signature-verification-failure] there's no flowtype for AST
-function findComponentConfig(ast, parser) {
-  const foundConfigs = [];
-  const defaultExports = ast.body.filter(
-    node => node.type === 'ExportDefaultDeclaration',
-  );
-  defaultExports.forEach(statement => {
-    findNativeComponentType(statement, foundConfigs, parser);
-  });
-  if (foundConfigs.length === 0) {
-    throw new Error('Could not find component config for native component');
-  }
-  if (foundConfigs.length > 1) {
-    throw new Error('Only one component is supported per file');
-  }
-  const foundConfig = foundConfigs[0];
-  const namedExports = ast.body.filter(
-    node => node.type === 'ExportNamedDeclaration',
-  );
-  const commandsTypeNames = namedExports
-    .map(statement => {
-      let callExpression;
-      let calleeName;
-      try {
-        callExpression = statement.declaration.declarations[0].init;
-        calleeName = callExpression.callee.name;
-      } catch (e) {
-        return;
-      }
-      if (calleeName !== 'codegenNativeCommands') {
-        return;
-      }
-
-      // const statement.declaration.declarations[0].init
-      if (callExpression.arguments.length !== 1) {
-        throw new Error(
-          'codegenNativeCommands must be passed options including the supported commands',
-        );
-      }
-      const typeArgumentParam = callExpression.typeArguments.params[0];
-      if (typeArgumentParam.type !== 'GenericTypeAnnotation') {
-        throw new Error(
-          "codegenNativeCommands doesn't support inline definitions. Specify a file local type alias",
-        );
-      }
-      return {
-        commandTypeName: typeArgumentParam.id.name,
-        commandOptionsExpression: callExpression.arguments[0],
-      };
-    })
-    .filter(Boolean);
-  throwIfMoreThanOneCodegenNativecommands(commandsTypeNames);
-  return createComponentConfig(foundConfig, commandsTypeNames);
-}
-function getCommandProperties(
-  /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
-   * LTI update could not be added via codemod */
-  commandTypeName,
-  types,
-  commandOptions,
-) {
-  if (commandTypeName == null) {
-    return [];
-  }
-  const typeAlias = types[commandTypeName];
-  if (typeAlias.type !== 'InterfaceDeclaration') {
-    throw new Error(
-      `The type argument for codegenNativeCommands must be an interface, received ${typeAlias.type}`,
-    );
-  }
-  let properties;
-  try {
-    properties = typeAlias.body.properties;
-  } catch (e) {
-    throw new Error(
-      `Failed to find type definition for "${commandTypeName}", please check that you have a valid codegen flow file`,
-    );
-  }
-  const flowPropertyNames = properties
-    .map(property => property && property.key && property.key.name)
-    .filter(Boolean);
-  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 _findComponentConfig = findComponentConfig(ast, parser),
     componentName = _findComponentConfig.componentName,
     propsTypeName = _findComponentConfig.propsTypeName,
-    commandTypeName = _findComponentConfig.commandTypeName,
-    commandOptionsExpression = _findComponentConfig.commandOptionsExpression,
     optionsExpression = _findComponentConfig.optionsExpression;
   const types = parser.getTypes(ast);
-  const propProperties = getProperties(propsTypeName, types);
-  const commandOptions = getCommandOptions(commandOptionsExpression);
-  const commandProperties = getCommandProperties(
-    commandTypeName,
-    types,
-    commandOptions,
-  );
-  const extendsProps = getExtendsProps(propProperties, types);
+  const propProperties = parser.getProperties(propsTypeName, types);
+  const commandProperties = getCommandProperties(ast, parser);
+  const _parser$getProps = parser.getProps(propProperties, types),
+    extendsProps = _parser$getProps.extendsProps,
+    props = _parser$getProps.props;
   const options = getOptions(optionsExpression);
-  const nonExtendsProps = removeKnownExtends(propProperties, types);
-  const props = getProps(nonExtendsProps, types);
-  const events = getEvents(propProperties, types);
+  const events = getEvents(propProperties, types, parser);
   const commands = getCommands(commandProperties, types);
   return {
     filename: componentName,