@react-native/codegen 0.72.4 → 0.73.0-nightly-20230603-fd9e295be

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

@@ -14,6 +14,17 @@ const _require = require('./componentsUtils'),
   flattenProperties = _require.flattenProperties;
 const _require2 = require('../parseTopLevelType'),
   parseTopLevelType = _require2.parseTopLevelType;
+const _require3 = require('../../error-utils'),
+  throwIfEventHasNoName = _require3.throwIfEventHasNoName,
+  throwIfBubblingTypeIsNull = _require3.throwIfBubblingTypeIsNull,
+  throwIfArgumentPropsAreNull = _require3.throwIfArgumentPropsAreNull;
+const _require4 = require('../../parsers-commons'),
+  getEventArgument = _require4.getEventArgument;
+const _require5 = require('../../parsers-primitives'),
+  emitBoolProp = _require5.emitBoolProp,
+  emitDoubleProp = _require5.emitDoubleProp,
+  emitFloatProp = _require5.emitFloatProp,
+  emitStringProp = _require5.emitStringProp;
 function getPropertyType(
   /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
    * LTI update could not be added via codemod */
@@ -22,6 +33,7 @@ function getPropertyType(
   /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
    * LTI update could not be added via codemod */
   annotation,
+  parser,
 ) {
   const topLevelType = parseTopLevelType(annotation);
   const typeAnnotation = topLevelType.type;
@@ -32,21 +44,9 @@ function getPropertyType(
       : typeAnnotation.type;
   switch (type) {
     case 'TSBooleanKeyword':
-      return {
-        name,
-        optional,
-        typeAnnotation: {
-          type: 'BooleanTypeAnnotation',
-        },
-      };
+      return emitBoolProp(name, optional);
     case 'TSStringKeyword':
-      return {
-        name,
-        optional,
-        typeAnnotation: {
-          type: 'StringTypeAnnotation',
-        },
-      };
+      return emitStringProp(name, optional);
     case 'Int32':
       return {
         name,
@@ -56,45 +56,116 @@ function getPropertyType(
         },
       };
     case 'Double':
+      return emitDoubleProp(name, optional);
+    case 'Float':
+      return emitFloatProp(name, optional);
+    case 'TSTypeLiteral':
       return {
         name,
         optional,
         typeAnnotation: {
-          type: 'DoubleTypeAnnotation',
+          type: 'ObjectTypeAnnotation',
+          properties: typeAnnotation.members.map(member =>
+            buildPropertiesForEvent(member, parser),
+          ),
         },
       };
-    case 'Float':
+    case 'TSUnionType':
       return {
         name,
         optional,
         typeAnnotation: {
-          type: 'FloatTypeAnnotation',
+          type: 'StringEnumTypeAnnotation',
+          options: typeAnnotation.types.map(option => option.literal.value),
         },
       };
-    case 'TSTypeLiteral':
+    case 'UnsafeMixed':
       return {
         name,
         optional,
         typeAnnotation: {
-          type: 'ObjectTypeAnnotation',
-          properties: typeAnnotation.members.map(buildPropertiesForEvent),
+          type: 'MixedTypeAnnotation',
         },
       };
-    case 'TSUnionType':
+    case 'TSArrayType':
       return {
         name,
         optional,
-        typeAnnotation: {
-          type: 'StringEnumTypeAnnotation',
-          options: typeAnnotation.types.map(option => option.literal.value),
-        },
+        typeAnnotation: extractArrayElementType(typeAnnotation, name, parser),
       };
     default:
       type;
       throw new Error(`Unable to determine event type for "${name}": ${type}`);
   }
 }
+function extractArrayElementType(typeAnnotation, name, parser) {
+  const type = extractTypeFromTypeAnnotation(typeAnnotation);
+  switch (type) {
+    case 'TSParenthesizedType':
+      return extractArrayElementType(
+        typeAnnotation.typeAnnotation,
+        name,
+        parser,
+      );
+    case 'TSBooleanKeyword':
+      return {
+        type: 'BooleanTypeAnnotation',
+      };
+    case 'TSStringKeyword':
+      return {
+        type: 'StringTypeAnnotation',
+      };
+    case 'Float':
+      return {
+        type: 'FloatTypeAnnotation',
+      };
+    case 'Int32':
+      return {
+        type: 'Int32TypeAnnotation',
+      };
+    case 'TSNumberKeyword':
+    case 'Double':
+      return {
+        type: 'DoubleTypeAnnotation',
+      };
+    case 'TSUnionType':
+      return {
+        type: 'StringEnumTypeAnnotation',
+        options: typeAnnotation.types.map(option => option.literal.value),
+      };
+    case 'TSTypeLiteral':
+      return {
+        type: 'ObjectTypeAnnotation',
+        properties: typeAnnotation.members.map(member =>
+          buildPropertiesForEvent(member, parser),
+        ),
+      };
+    case 'TSArrayType':
+      return {
+        type: 'ArrayTypeAnnotation',
+        elementType: extractArrayElementType(
+          typeAnnotation.elementType,
+          name,
+          parser,
+        ),
+      };
+    default:
+      throw new Error(
+        `Unrecognized ${type} for Array ${name} in events.\n${JSON.stringify(
+          typeAnnotation,
+          null,
+          2,
+        )}`,
+      );
+  }
+}
+function extractTypeFromTypeAnnotation(typeAnnotation) {
+  return typeAnnotation.type === 'TSTypeReference'
+    ? typeAnnotation.typeName.name
+    : typeAnnotation.type;
+}
 function findEventArgumentsAndType(
+  parser,
   typeAnnotation,
   types,
   bubblingType,
@@ -114,12 +185,11 @@ function findEventArgumentsAndType(
       bubblingType,
     };
   }
-  if (!typeAnnotation.typeName) {
-    throw new Error("typeAnnotation of event doesn't have a name");
-  }
+  throwIfEventHasNoName(typeAnnotation, parser);
   const name = typeAnnotation.typeName.name;
   if (name === 'Readonly') {
     return findEventArgumentsAndType(
+      parser,
       typeAnnotation.typeParameters.params[0],
       types,
       bubblingType,
@@ -132,8 +202,8 @@ function findEventArgumentsAndType(
         ? typeAnnotation.typeParameters.params[1].literal.value
         : null;
     switch (typeAnnotation.typeParameters.params[0].type) {
-      case 'TSNullKeyword':
-      case 'TSUndefinedKeyword':
+      case parser.nullLiteralTypeAnnotation:
+      case parser.undefinedLiteralTypeAnnotation:
         return {
           argumentProps: [],
           bubblingType: eventType,
@@ -141,6 +211,7 @@ function findEventArgumentsAndType(
         };
       default:
         return findEventArgumentsAndType(
+          parser,
           typeAnnotation.typeParameters.params[0],
           types,
           eventType,
@@ -153,6 +224,7 @@ function findEventArgumentsAndType(
       elementType = elementType.typeAnnotation;
     }
     return findEventArgumentsAndType(
+      parser,
       elementType,
       types,
       bubblingType,
@@ -166,28 +238,21 @@ 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) {
+function buildPropertiesForEvent(
+  /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
+   * LTI update could not be added via codemod */
+  property,
+  parser,
+) {
   const name = property.key.name;
-  const optional = property.optional || false;
+  const optional = parser.isOptionalProperty(property);
   let typeAnnotation = property.typeAnnotation.typeAnnotation;
-  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),
-  };
+  return getPropertyType(name, optional, typeAnnotation, parser);
 }
 
 // $FlowFixMe[unclear-type] TODO(T108222691): Use flow-types for @babel/parser
 
-function buildEventSchema(types, property) {
+function buildEventSchema(types, property, parser) {
   // unpack WithDefault, (T) or T|U
   const topLevelType = parseTopLevelType(
     property.typeAnnotation.typeAnnotation,
@@ -197,6 +262,7 @@ function buildEventSchema(types, property) {
   const typeAnnotation = topLevelType.type;
   const optional = property.optional || topLevelType.optional;
   const _findEventArgumentsAn = findEventArgumentsAndType(
+      parser,
       typeAnnotation,
       types,
     ),
@@ -204,36 +270,45 @@ function buildEventSchema(types, property) {
     bubblingType = _findEventArgumentsAn.bubblingType,
     paperTopLevelNameDeprecated =
       _findEventArgumentsAn.paperTopLevelNameDeprecated;
-  if (!argumentProps) {
-    throw new Error(`Unable to determine event arguments for "${name}"`);
-  } else if (!bubblingType) {
-    throw new Error(`Unable to determine event bubbling type for "${name}"`);
-  } else {
-    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,
+        ),
       },
     };
   }
+  return {
+    name,
+    optional,
+    bubblingType: nonNullableBubblingType,
+    typeAnnotation: {
+      type: 'EventTypeAnnotation',
+      argument: getEventArgument(
+        nonNullableArgumentProps,
+        buildPropertiesForEvent,
+        parser,
+      ),
+    },
+  };
 }
-function getEvents(eventTypeAST, types) {
-  return eventTypeAST.map(property => buildEventSchema(types, property));
+function getEvents(eventTypeAST, types, parser) {
+  return eventTypeAST
+    .map(property => buildEventSchema(types, property, parser))
+    .filter(Boolean);
 }
 module.exports = {
   getEvents,

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

@@ -16,9 +16,21 @@ import type {
   EventTypeAnnotation,
 } from '../../../CodegenSchema.js';
 import type {TypeDeclarationMap} from '../../utils';
+import type {Parser} from '../../parser';
 const {flattenProperties} = require('./componentsUtils');
 const {parseTopLevelType} = require('../parseTopLevelType');
-
+const {
+  throwIfEventHasNoName,
+  throwIfBubblingTypeIsNull,
+  throwIfArgumentPropsAreNull,
+} = require('../../error-utils');
+const {getEventArgument} = require('../../parsers-commons');
+const {
+  emitBoolProp,
+  emitDoubleProp,
+  emitFloatProp,
+  emitStringProp,
+} = require('../../parsers-primitives');
 function getPropertyType(
   /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
    * LTI update could not be added via codemod */
@@ -27,6 +39,7 @@ function getPropertyType(
   /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
    * LTI update could not be added via codemod */
   annotation,
+  parser: Parser,
 ): NamedShape<EventTypeAnnotation> {
   const topLevelType = parseTopLevelType(annotation);
   const typeAnnotation = topLevelType.type;
@@ -38,21 +51,9 @@ function getPropertyType(
 
   switch (type) {
     case 'TSBooleanKeyword':
-      return {
-        name,
-        optional,
-        typeAnnotation: {
-          type: 'BooleanTypeAnnotation',
-        },
-      };
+      return emitBoolProp(name, optional);
     case 'TSStringKeyword':
-      return {
-        name,
-        optional,
-        typeAnnotation: {
-          type: 'StringTypeAnnotation',
-        },
-      };
+      return emitStringProp(name, optional);
     case 'Int32':
       return {
         name,
@@ -62,39 +63,42 @@ function getPropertyType(
         },
       };
     case 'Double':
+      return emitDoubleProp(name, optional);
+    case 'Float':
+      return emitFloatProp(name, optional);
+    case 'TSTypeLiteral':
       return {
         name,
         optional,
         typeAnnotation: {
-          type: 'DoubleTypeAnnotation',
+          type: 'ObjectTypeAnnotation',
+          properties: typeAnnotation.members.map(member =>
+            buildPropertiesForEvent(member, parser),
+          ),
         },
       };
-    case 'Float':
+    case 'TSUnionType':
       return {
         name,
         optional,
         typeAnnotation: {
-          type: 'FloatTypeAnnotation',
+          type: 'StringEnumTypeAnnotation',
+          options: typeAnnotation.types.map(option => option.literal.value),
         },
       };
-    case 'TSTypeLiteral':
+    case 'UnsafeMixed':
       return {
         name,
         optional,
         typeAnnotation: {
-          type: 'ObjectTypeAnnotation',
-          properties: typeAnnotation.members.map(buildPropertiesForEvent),
+          type: 'MixedTypeAnnotation',
         },
       };
-
-    case 'TSUnionType':
+    case 'TSArrayType':
       return {
         name,
         optional,
-        typeAnnotation: {
-          type: 'StringEnumTypeAnnotation',
-          options: typeAnnotation.types.map(option => option.literal.value),
-        },
+        typeAnnotation: extractArrayElementType(typeAnnotation, name, parser),
       };
     default:
       (type: empty);
@@ -102,7 +106,77 @@ function getPropertyType(
   }
 }
 
+function extractArrayElementType(
+  typeAnnotation: $FlowFixMe,
+  name: string,
+  parser: Parser,
+): EventTypeAnnotation {
+  const type = extractTypeFromTypeAnnotation(typeAnnotation);
+
+  switch (type) {
+    case 'TSParenthesizedType':
+      return extractArrayElementType(
+        typeAnnotation.typeAnnotation,
+        name,
+        parser,
+      );
+    case 'TSBooleanKeyword':
+      return {type: 'BooleanTypeAnnotation'};
+    case 'TSStringKeyword':
+      return {type: 'StringTypeAnnotation'};
+    case 'Float':
+      return {
+        type: 'FloatTypeAnnotation',
+      };
+    case 'Int32':
+      return {
+        type: 'Int32TypeAnnotation',
+      };
+    case 'TSNumberKeyword':
+    case 'Double':
+      return {
+        type: 'DoubleTypeAnnotation',
+      };
+    case 'TSUnionType':
+      return {
+        type: 'StringEnumTypeAnnotation',
+        options: typeAnnotation.types.map(option => option.literal.value),
+      };
+    case 'TSTypeLiteral':
+      return {
+        type: 'ObjectTypeAnnotation',
+        properties: typeAnnotation.members.map(member =>
+          buildPropertiesForEvent(member, parser),
+        ),
+      };
+    case 'TSArrayType':
+      return {
+        type: 'ArrayTypeAnnotation',
+        elementType: extractArrayElementType(
+          typeAnnotation.elementType,
+          name,
+          parser,
+        ),
+      };
+    default:
+      throw new Error(
+        `Unrecognized ${type} for Array ${name} in events.\n${JSON.stringify(
+          typeAnnotation,
+          null,
+          2,
+        )}`,
+      );
+  }
+}
+
+function extractTypeFromTypeAnnotation(typeAnnotation: $FlowFixMe): string {
+  return typeAnnotation.type === 'TSTypeReference'
+    ? typeAnnotation.typeName.name
+    : typeAnnotation.type;
+}
+
 function findEventArgumentsAndType(
+  parser: Parser,
   typeAnnotation: $FlowFixMe,
   types: TypeDeclarationMap,
   bubblingType: void | 'direct' | 'bubble',
@@ -128,12 +202,11 @@ function findEventArgumentsAndType(
     };
   }
 
-  if (!typeAnnotation.typeName) {
-    throw new Error("typeAnnotation of event doesn't have a name");
-  }
+  throwIfEventHasNoName(typeAnnotation, parser);
   const name = typeAnnotation.typeName.name;
   if (name === 'Readonly') {
     return findEventArgumentsAndType(
+      parser,
       typeAnnotation.typeParameters.params[0],
       types,
       bubblingType,
@@ -147,8 +220,8 @@ function findEventArgumentsAndType(
         : null;
 
     switch (typeAnnotation.typeParameters.params[0].type) {
-      case 'TSNullKeyword':
-      case 'TSUndefinedKeyword':
+      case parser.nullLiteralTypeAnnotation:
+      case parser.undefinedLiteralTypeAnnotation:
         return {
           argumentProps: [],
           bubblingType: eventType,
@@ -156,6 +229,7 @@ function findEventArgumentsAndType(
         };
       default:
         return findEventArgumentsAndType(
+          parser,
           typeAnnotation.typeParameters.params[0],
           types,
           eventType,
@@ -168,6 +242,7 @@ function findEventArgumentsAndType(
       elementType = elementType.typeAnnotation;
     }
     return findEventArgumentsAndType(
+      parser,
       elementType,
       types,
       bubblingType,
@@ -182,23 +257,17 @@ 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.optional || false;
+  const optional = parser.isOptionalProperty(property);
   let typeAnnotation = property.typeAnnotation.typeAnnotation;
 
-  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);
 }
 
 // $FlowFixMe[unclear-type] TODO(T108222691): Use flow-types for @babel/parser
@@ -207,7 +276,8 @@ type EventTypeAST = Object;
 function buildEventSchema(
   types: TypeDeclarationMap,
   property: EventTypeAST,
-): EventTypeShape {
+  parser: Parser,
+): ?EventTypeShape {
   // unpack WithDefault, (T) or T|U
   const topLevelType = parseTopLevelType(
     property.typeAnnotation.typeAnnotation,
@@ -218,43 +288,54 @@ function buildEventSchema(
   const typeAnnotation = topLevelType.type;
   const optional = property.optional || topLevelType.optional;
   const {argumentProps, bubblingType, paperTopLevelNameDeprecated} =
-    findEventArgumentsAndType(typeAnnotation, types);
+    findEventArgumentsAndType(parser, typeAnnotation, types);
 
-  if (!argumentProps) {
-    throw new Error(`Unable to determine event arguments for "${name}"`);
-  } else if (!bubblingType) {
-    throw new Error(`Unable to determine event bubbling type for "${name}"`);
-  } else {
-    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,
+        ),
       },
     };
   }
+
+  return {
+    name,
+    optional,
+    bubblingType: nonNullableBubblingType,
+    typeAnnotation: {
+      type: 'EventTypeAnnotation',
+      argument: getEventArgument(
+        nonNullableArgumentProps,
+        buildPropertiesForEvent,
+        parser,
+      ),
+    },
+  };
 }
 
 function getEvents(
   eventTypeAST: $ReadOnlyArray<EventTypeAST>,
   types: TypeDeclarationMap,
+  parser: Parser,
 ): $ReadOnlyArray<EventTypeShape> {
-  return eventTypeAST.map(property => buildEventSchema(types, property));
+  return eventTypeAST
+    .map(property => buildEventSchema(types, property, parser))
+    .filter(Boolean);
 }
 
 module.exports = {