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

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

@@ -10,97 +10,165 @@
 
 'use strict';
 
+const _require = require('../../error-utils'),
+  throwIfEventHasNoName = _require.throwIfEventHasNoName,
+  throwIfBubblingTypeIsNull = _require.throwIfBubblingTypeIsNull,
+  throwIfArgumentPropsAreNull = _require.throwIfArgumentPropsAreNull;
+const _require2 = require('../../parsers-commons'),
+  getEventArgument = _require2.getEventArgument,
+  buildPropertiesForEvent = _require2.buildPropertiesForEvent,
+  handleEventHandler = _require2.handleEventHandler,
+  emitBuildEventSchema = _require2.emitBuildEventSchema;
+const _require3 = require('../../parsers-primitives'),
+  emitBoolProp = _require3.emitBoolProp,
+  emitDoubleProp = _require3.emitDoubleProp,
+  emitFloatProp = _require3.emitFloatProp,
+  emitMixedProp = _require3.emitMixedProp,
+  emitStringProp = _require3.emitStringProp,
+  emitInt32Prop = _require3.emitInt32Prop,
+  emitObjectProp = _require3.emitObjectProp,
+  emitUnionProp = _require3.emitUnionProp;
 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 =
-    typeAnnotation.type === 'GenericTypeAnnotation'
-      ? typeAnnotation.id.name
-      : typeAnnotation.type;
+  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: {
-          type: 'BooleanTypeAnnotation',
-        },
+        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 {
-        name,
-        optional,
-        typeAnnotation: {
-          type: 'StringTypeAnnotation',
-        },
+        type: 'StringTypeAnnotation',
       };
     case 'Int32':
       return {
-        name,
-        optional,
-        typeAnnotation: {
-          type: 'Int32TypeAnnotation',
-        },
+        type: 'Int32TypeAnnotation',
       };
+    case 'Float':
+      return {
+        type: 'FloatTypeAnnotation',
+      };
+    case 'NumberTypeAnnotation':
     case 'Double':
       return {
-        name,
-        optional,
-        typeAnnotation: {
-          type: 'DoubleTypeAnnotation',
-        },
+        type: 'DoubleTypeAnnotation',
       };
-    case 'Float':
+    case 'UnionTypeAnnotation':
       return {
-        name,
-        optional,
-        typeAnnotation: {
-          type: 'FloatTypeAnnotation',
-        },
+        type: 'StringEnumTypeAnnotation',
+        options: typeAnnotation.types.map(option =>
+          parser.getLiteralValue(option),
+        ),
+      };
+    case 'UnsafeMixed':
+      return {
+        type: 'MixedTypeAnnotation',
       };
-    case '$ReadOnly':
-      return getPropertyType(
-        name,
-        optional,
-        typeAnnotation.typeParameters.params[0],
-      );
     case 'ObjectTypeAnnotation':
       return {
-        name,
-        optional,
-        typeAnnotation: {
-          type: 'ObjectTypeAnnotation',
-          properties: typeAnnotation.properties.map(buildPropertiesForEvent),
-        },
+        type: 'ObjectTypeAnnotation',
+        properties: parser
+          .getObjectProperties(typeAnnotation)
+          .map(member =>
+            buildPropertiesForEvent(member, parser, getPropertyType),
+          ),
       };
-    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;
-      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) {
+  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,
 ) {
-  if (!typeAnnotation.id) {
-    throw new Error("typeAnnotation of event doesn't have a name");
-  }
-  const name = typeAnnotation.id.name;
+  throwIfEventHasNoName(typeAnnotation, parser);
+  const name = parser.getTypeAnnotationName(typeAnnotation);
   if (name === '$ReadOnly') {
     return {
       argumentProps: typeAnnotation.typeParameters.params[0].properties,
@@ -108,29 +176,16 @@ function findEventArgumentsAndType(
       bubblingType,
     };
   } else if (name === 'BubblingEventHandler' || name === 'DirectEventHandler') {
-    const eventType = name === 'BubblingEventHandler' ? 'bubble' : 'direct';
-    const paperTopLevelNameDeprecated =
-      typeAnnotation.typeParameters.params.length > 1
-        ? typeAnnotation.typeParameters.params[1].value
-        : null;
-    if (
-      typeAnnotation.typeParameters.params[0].type ===
-      'NullLiteralTypeAnnotation'
-    ) {
-      return {
-        argumentProps: [],
-        bubblingType: eventType,
-        paperTopLevelNameDeprecated,
-      };
-    }
-    return findEventArgumentsAndType(
-      typeAnnotation.typeParameters.params[0],
+    return handleEventHandler(
+      name,
+      typeAnnotation,
+      parser,
       types,
-      eventType,
-      paperTopLevelNameDeprecated,
+      findEventArgumentsAndType,
     );
   } else if (types[name]) {
     return findEventArgumentsAndType(
+      parser,
       types[name].right,
       types,
       bubblingType,
@@ -144,29 +199,7 @@ 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) {
-  const name = property.key.name;
-  const optional =
-    property.value.type === 'NullableTypeAnnotation' || property.optional;
-  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) {
-  return {
-    type: 'ObjectTypeAnnotation',
-    properties: argumentProps.map(buildPropertiesForEvent),
-  };
-}
-function buildEventSchema(types, property) {
+function buildEventSchema(types, property, parser) {
   const name = property.key.name;
   const optional =
     property.optional || property.value.type === 'NullableTypeAnnotation';
@@ -176,12 +209,13 @@ function buildEventSchema(types, property) {
       : property.value;
   if (
     typeAnnotation.type !== 'GenericTypeAnnotation' ||
-    (typeAnnotation.id.name !== 'BubblingEventHandler' &&
-      typeAnnotation.id.name !== 'DirectEventHandler')
+    (parser.getTypeAnnotationName(typeAnnotation) !== 'BubblingEventHandler' &&
+      parser.getTypeAnnotationName(typeAnnotation) !== 'DirectEventHandler')
   ) {
     return null;
   }
   const _findEventArgumentsAn = findEventArgumentsAndType(
+      parser,
       typeAnnotation,
       types,
     ),
@@ -189,45 +223,34 @@ function buildEventSchema(types, property) {
     bubblingType = _findEventArgumentsAn.bubblingType,
     paperTopLevelNameDeprecated =
       _findEventArgumentsAn.paperTopLevelNameDeprecated;
-  if (bubblingType && argumentProps) {
-    if (paperTopLevelNameDeprecated != null) {
-      return {
-        name,
-        optional,
-        bubblingType,
-        paperTopLevelNameDeprecated,
-        typeAnnotation: {
-          type: 'EventTypeAnnotation',
-          argument: getEventArgument(argumentProps, name),
-        },
-      };
-    }
-    return {
-      name,
-      optional,
-      bubblingType,
-      typeAnnotation: {
-        type: 'EventTypeAnnotation',
-        argument: getEventArgument(argumentProps, name),
-      },
-    };
-  }
-  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}"`);
-  }
+  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) {
+function getEvents(eventTypeAST, types, parser) {
   return eventTypeAST
     .filter(property => property.type === 'ObjectTypeProperty')
-    .map(property => buildEventSchema(types, property))
+    .map(property => buildEventSchema(types, property, parser))
     .filter(Boolean);
 }
 module.exports = {
   getEvents,
+  extractArrayElementType,
 };