@react-native/codegen 0.74.0 → 0.75.0-nightly-20240221-a1171f79f

package/lib/parsers/error-utils.js

@@ -11,33 +11,33 @@
 'use strict';
 
 const _require = require('./errors'),
+  IncorrectModuleRegistryCallArgumentTypeParserError =
+    _require.IncorrectModuleRegistryCallArgumentTypeParserError,
+  IncorrectModuleRegistryCallArityParserError =
+    _require.IncorrectModuleRegistryCallArityParserError,
+  IncorrectModuleRegistryCallTypeParameterParserError =
+    _require.IncorrectModuleRegistryCallTypeParameterParserError,
   MisnamedModuleInterfaceParserError =
     _require.MisnamedModuleInterfaceParserError,
-  UnsupportedFunctionReturnTypeAnnotationParserError =
-    _require.UnsupportedFunctionReturnTypeAnnotationParserError,
   ModuleInterfaceNotFoundParserError =
     _require.ModuleInterfaceNotFoundParserError,
+  MoreThanOneModuleInterfaceParserError =
+    _require.MoreThanOneModuleInterfaceParserError,
   MoreThanOneModuleRegistryCallsParserError =
     _require.MoreThanOneModuleRegistryCallsParserError,
-  UnusedModuleInterfaceParserError = _require.UnusedModuleInterfaceParserError,
-  IncorrectModuleRegistryCallArityParserError =
-    _require.IncorrectModuleRegistryCallArityParserError,
-  IncorrectModuleRegistryCallTypeParameterParserError =
-    _require.IncorrectModuleRegistryCallTypeParameterParserError,
-  IncorrectModuleRegistryCallArgumentTypeParserError =
-    _require.IncorrectModuleRegistryCallArgumentTypeParserError,
+  UnsupportedArrayElementTypeAnnotationParserError =
+    _require.UnsupportedArrayElementTypeAnnotationParserError,
+  UnsupportedFunctionParamTypeAnnotationParserError =
+    _require.UnsupportedFunctionParamTypeAnnotationParserError,
+  UnsupportedFunctionReturnTypeAnnotationParserError =
+    _require.UnsupportedFunctionReturnTypeAnnotationParserError,
+  UnsupportedModulePropertyParserError =
+    _require.UnsupportedModulePropertyParserError,
   UnsupportedObjectPropertyValueTypeAnnotationParserError =
     _require.UnsupportedObjectPropertyValueTypeAnnotationParserError,
   UntypedModuleRegistryCallParserError =
     _require.UntypedModuleRegistryCallParserError,
-  UnsupportedModulePropertyParserError =
-    _require.UnsupportedModulePropertyParserError,
-  MoreThanOneModuleInterfaceParserError =
-    _require.MoreThanOneModuleInterfaceParserError,
-  UnsupportedFunctionParamTypeAnnotationParserError =
-    _require.UnsupportedFunctionParamTypeAnnotationParserError,
-  UnsupportedArrayElementTypeAnnotationParserError =
-    _require.UnsupportedArrayElementTypeAnnotationParserError;
+  UnusedModuleInterfaceParserError = _require.UnusedModuleInterfaceParserError;
 function throwIfModuleInterfaceIsMisnamed(
   nativeModuleName,
   moduleSpecId,

package/lib/parsers/error-utils.js.flow

@@ -11,25 +11,25 @@
 'use strict';
 
 import type {NativeModuleTypeAnnotation} from '../CodegenSchema';
+import type {TypeDeclarationMap} from '../parsers/utils';
 import type {ParserType} from './errors';
 import type {Parser} from './parser';
-import type {TypeDeclarationMap} from '../parsers/utils';
 
 const {
+  IncorrectModuleRegistryCallArgumentTypeParserError,
+  IncorrectModuleRegistryCallArityParserError,
+  IncorrectModuleRegistryCallTypeParameterParserError,
   MisnamedModuleInterfaceParserError,
-  UnsupportedFunctionReturnTypeAnnotationParserError,
   ModuleInterfaceNotFoundParserError,
+  MoreThanOneModuleInterfaceParserError,
   MoreThanOneModuleRegistryCallsParserError,
-  UnusedModuleInterfaceParserError,
-  IncorrectModuleRegistryCallArityParserError,
-  IncorrectModuleRegistryCallTypeParameterParserError,
-  IncorrectModuleRegistryCallArgumentTypeParserError,
+  UnsupportedArrayElementTypeAnnotationParserError,
+  UnsupportedFunctionParamTypeAnnotationParserError,
+  UnsupportedFunctionReturnTypeAnnotationParserError,
+  UnsupportedModulePropertyParserError,
   UnsupportedObjectPropertyValueTypeAnnotationParserError,
   UntypedModuleRegistryCallParserError,
-  UnsupportedModulePropertyParserError,
-  MoreThanOneModuleInterfaceParserError,
-  UnsupportedFunctionParamTypeAnnotationParserError,
-  UnsupportedArrayElementTypeAnnotationParserError,
+  UnusedModuleInterfaceParserError,
 } = require('./errors');
 
 function throwIfModuleInterfaceIsMisnamed(

package/lib/parsers/errors.js

@@ -165,6 +165,15 @@ class UnsupportedObjectPropertyValueTypeAnnotationParserError extends ParserErro
     );
   }
 }
+class UnsupportedObjectDirectRecursivePropertyParserError extends ParserError {
+  constructor(propertyName, propertyValueAST, nativeModuleName) {
+    super(
+      nativeModuleName,
+      propertyValueAST,
+      `Object property '${propertyName}' is direct recursive and must be nullable.`,
+    );
+  }
+}
 
 /**
  * Function parsing errors
@@ -315,6 +324,7 @@ module.exports = {
   UnsupportedModulePropertyParserError,
   UnsupportedObjectPropertyTypeAnnotationParserError,
   UnsupportedObjectPropertyValueTypeAnnotationParserError,
+  UnsupportedObjectDirectRecursivePropertyParserError,
   UnusedModuleInterfaceParserError,
   MoreThanOneModuleRegistryCallsParserError,
   UntypedModuleRegistryCallParserError,

package/lib/parsers/errors.js.flow

@@ -11,7 +11,6 @@
 'use strict';
 
 import type {UnionTypeAnnotationMemberType} from '../CodegenSchema';
-
 import type {Parser} from './parser';
 export type ParserType = 'Flow' | 'TypeScript';
 
@@ -218,6 +217,20 @@ class UnsupportedObjectPropertyValueTypeAnnotationParserError extends ParserErro
   }
 }
 
+class UnsupportedObjectDirectRecursivePropertyParserError extends ParserError {
+  constructor(
+    propertyName: string,
+    propertyValueAST: $FlowFixMe,
+    nativeModuleName: string,
+  ) {
+    super(
+      nativeModuleName,
+      propertyValueAST,
+      `Object property '${propertyName}' is direct recursive and must be nullable.`,
+    );
+  }
+}
+
 /**
  * Function parsing errors
  */
@@ -406,6 +419,7 @@ module.exports = {
   UnsupportedModulePropertyParserError,
   UnsupportedObjectPropertyTypeAnnotationParserError,
   UnsupportedObjectPropertyValueTypeAnnotationParserError,
+  UnsupportedObjectDirectRecursivePropertyParserError,
   UnusedModuleInterfaceParserError,
   MoreThanOneModuleRegistryCallsParserError,
   UntypedModuleRegistryCallParserError,

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

@@ -988,10 +988,16 @@ export type ScrollTo = (
 
 interface NativeCommands {
   +scrollTo: ScrollTo;
+  +addOverlays: (
+    viewRef: React.ElementRef<NativeType>,
+    overlayColorsReadOnly: $ReadOnlyArray<string>,
+    overlayColorsArray: Array<string>,
+    overlayColorsArrayAnnotation: string[],
+  ) => void;
 }
 
 export const Commands = codegenNativeCommands<NativeCommands>({
-  supportedCommands: ['scrollTo'],
+  supportedCommands: ['scrollTo', 'addOverlays'],
 });
 
 export default (codegenNativeComponent<ModuleProps>(

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

@@ -1001,10 +1001,16 @@ export type ScrollTo = (
 
 interface NativeCommands {
   +scrollTo: ScrollTo;
+  +addOverlays: (
+    viewRef: React.ElementRef<NativeType>,
+    overlayColorsReadOnly: $ReadOnlyArray<string>,
+    overlayColorsArray: Array<string>,
+    overlayColorsArrayAnnotation: string[],
+  ) => void;
 }
 
 export const Commands = codegenNativeCommands<NativeCommands>({
-  supportedCommands: ['scrollTo'],
+  supportedCommands: ['scrollTo', 'addOverlays'],
 });
 
 export default (codegenNativeComponent<ModuleProps>(

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

@@ -72,6 +72,30 @@ function buildCommandSchema(property, types) {
           type: 'StringTypeAnnotation',
         };
         break;
+      case 'Array':
+      case '$ReadOnlyArray':
+        if (!paramValue.type === 'GenericTypeAnnotation') {
+          throw new Error(
+            'Array and $ReadOnlyArray are GenericTypeAnnotation for array',
+          );
+        }
+        returnType = {
+          type: 'ArrayTypeAnnotation',
+          elementType: {
+            // TODO: T172453752 support complex type annotation for array element
+            type: paramValue.typeParameters.params[0].type,
+          },
+        };
+        break;
+      case 'ArrayTypeAnnotation':
+        returnType = {
+          type: 'ArrayTypeAnnotation',
+          elementType: {
+            // TODO: T172453752 support complex type annotation for array element
+            type: paramValue.elementType.type,
+          },
+        };
+        break;
       default:
         type;
         throw new Error(

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

@@ -11,8 +11,9 @@
 'use strict';
 
 import type {
-  NamedShape,
+  CommandParamTypeAnnotation,
   CommandTypeAnnotation,
+  NamedShape,
 } from '../../../CodegenSchema.js';
 import type {TypeDeclarationMap} from '../../utils';
 
@@ -21,7 +22,24 @@ const {getValueFromTypes} = require('../utils.js');
 // $FlowFixMe[unclear-type] there's no flowtype for ASTs
 type EventTypeAST = Object;
 
-function buildCommandSchema(property: EventTypeAST, types: TypeDeclarationMap) {
+function buildCommandSchema(
+  property: EventTypeAST,
+  types: TypeDeclarationMap,
+): $ReadOnly<{
+  name: string,
+  optional: boolean,
+  typeAnnotation: {
+    type: 'FunctionTypeAnnotation',
+    params: $ReadOnlyArray<{
+      name: string,
+      optional: boolean,
+      typeAnnotation: CommandParamTypeAnnotation,
+    }>,
+    returnTypeAnnotation: {
+      type: 'VoidTypeAnnotation',
+    },
+  },
+}> {
   const name = property.key.name;
   const optional = property.optional;
   const value = getValueFromTypes(property.value, types);
@@ -48,7 +66,7 @@ function buildCommandSchema(property: EventTypeAST, types: TypeDeclarationMap) {
       paramValue.type === 'GenericTypeAnnotation'
         ? paramValue.id.name
         : paramValue.type;
-    let returnType;
+    let returnType: CommandParamTypeAnnotation;
 
     switch (type) {
       case 'RootTag':
@@ -82,6 +100,30 @@ function buildCommandSchema(property: EventTypeAST, types: TypeDeclarationMap) {
           type: 'StringTypeAnnotation',
         };
         break;
+      case 'Array':
+      case '$ReadOnlyArray':
+        if (!paramValue.type === 'GenericTypeAnnotation') {
+          throw new Error(
+            'Array and $ReadOnlyArray are GenericTypeAnnotation for array',
+          );
+        }
+        returnType = {
+          type: 'ArrayTypeAnnotation',
+          elementType: {
+            // TODO: T172453752 support complex type annotation for array element
+            type: paramValue.typeParameters.params[0].type,
+          },
+        };
+        break;
+      case 'ArrayTypeAnnotation':
+        returnType = {
+          type: 'ArrayTypeAnnotation',
+          elementType: {
+            // TODO: T172453752 support complex type annotation for array element
+            type: paramValue.elementType.type,
+          },
+        };
+        break;
       default:
         (type: empty);
         throw new Error(

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

@@ -10,10 +10,11 @@
 
 'use strict';
 
-const _require = require('../utils.js'),
-  getValueFromTypes = _require.getValueFromTypes;
-const _require2 = require('../../parsers-commons'),
-  verifyPropNotAlreadyDefined = _require2.verifyPropNotAlreadyDefined;
+const _require = require('../../parsers-commons'),
+  verifyPropNotAlreadyDefined = _require.verifyPropNotAlreadyDefined;
+const _require2 = require('../utils.js'),
+  getValueFromTypes = _require2.getValueFromTypes;
+
 // $FlowFixMe[unsupported-variance-annotation]
 function getTypeAnnotationForArray(
   name,

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

@@ -10,10 +10,11 @@
 
 'use strict';
 
-const {getValueFromTypes} = require('../utils.js');
-const {verifyPropNotAlreadyDefined} = require('../../parsers-commons');
-import type {TypeDeclarationMap, PropAST, ASTNode} from '../../utils';
 import type {BuildSchemaFN, Parser} from '../../parser';
+import type {ASTNode, PropAST, TypeDeclarationMap} from '../../utils';
+
+const {verifyPropNotAlreadyDefined} = require('../../parsers-commons');
+const {getValueFromTypes} = require('../utils.js');
 
 // $FlowFixMe[unsupported-variance-annotation]
 function getTypeAnnotationForArray<+T>(

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

@@ -11,22 +11,22 @@
 'use strict';
 
 const _require = require('../../error-utils'),
-  throwIfEventHasNoName = _require.throwIfEventHasNoName,
+  throwIfArgumentPropsAreNull = _require.throwIfArgumentPropsAreNull,
   throwIfBubblingTypeIsNull = _require.throwIfBubblingTypeIsNull,
-  throwIfArgumentPropsAreNull = _require.throwIfArgumentPropsAreNull;
+  throwIfEventHasNoName = _require.throwIfEventHasNoName;
 const _require2 = require('../../parsers-commons'),
-  getEventArgument = _require2.getEventArgument,
   buildPropertiesForEvent = _require2.buildPropertiesForEvent,
-  handleEventHandler = _require2.handleEventHandler,
-  emitBuildEventSchema = _require2.emitBuildEventSchema;
+  emitBuildEventSchema = _require2.emitBuildEventSchema,
+  getEventArgument = _require2.getEventArgument,
+  handleEventHandler = _require2.handleEventHandler;
 const _require3 = require('../../parsers-primitives'),
   emitBoolProp = _require3.emitBoolProp,
   emitDoubleProp = _require3.emitDoubleProp,
   emitFloatProp = _require3.emitFloatProp,
-  emitMixedProp = _require3.emitMixedProp,
-  emitStringProp = _require3.emitStringProp,
   emitInt32Prop = _require3.emitInt32Prop,
+  emitMixedProp = _require3.emitMixedProp,
   emitObjectProp = _require3.emitObjectProp,
+  emitStringProp = _require3.emitStringProp,
   emitUnionProp = _require3.emitUnionProp;
 function getPropertyType(
   /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's

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

@@ -11,32 +11,32 @@
 'use strict';
 
 import type {
+  EventTypeAnnotation,
   EventTypeShape,
   NamedShape,
-  EventTypeAnnotation,
 } from '../../../CodegenSchema.js';
 import type {Parser} from '../../parser';
 import type {EventArgumentReturnType} from '../../parsers-commons';
 
 const {
-  throwIfEventHasNoName,
-  throwIfBubblingTypeIsNull,
   throwIfArgumentPropsAreNull,
+  throwIfBubblingTypeIsNull,
+  throwIfEventHasNoName,
 } = require('../../error-utils');
 const {
-  getEventArgument,
   buildPropertiesForEvent,
-  handleEventHandler,
   emitBuildEventSchema,
+  getEventArgument,
+  handleEventHandler,
 } = require('../../parsers-commons');
 const {
   emitBoolProp,
   emitDoubleProp,
   emitFloatProp,
-  emitMixedProp,
-  emitStringProp,
   emitInt32Prop,
+  emitMixedProp,
   emitObjectProp,
+  emitStringProp,
   emitUnionProp,
 } = require('../../parsers-primitives');
 

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

@@ -10,14 +10,14 @@
 
 'use strict';
 
-const _require = require('./commands'),
-  getCommands = _require.getCommands;
-const _require2 = require('./events'),
-  getEvents = _require2.getEvents;
-const _require3 = require('../../parsers-commons'),
-  getOptions = _require3.getOptions,
-  findComponentConfig = _require3.findComponentConfig,
-  getCommandProperties = _require3.getCommandProperties;
+const _require = require('../../parsers-commons'),
+  findComponentConfig = _require.findComponentConfig,
+  getCommandProperties = _require.getCommandProperties,
+  getOptions = _require.getOptions;
+const _require2 = require('./commands'),
+  getCommands = _require2.getCommands;
+const _require3 = require('./events'),
+  getEvents = _require3.getEvents;
 
 // $FlowFixMe[signature-verification-failure] there's no flowtype for AST
 function buildComponentSchema(ast, parser) {

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

@@ -12,13 +12,13 @@
 import type {Parser} from '../../parser';
 import type {ComponentSchemaBuilderConfig} from '../../schema.js';
 
-const {getCommands} = require('./commands');
-const {getEvents} = require('./events');
 const {
-  getOptions,
   findComponentConfig,
   getCommandProperties,
+  getOptions,
 } = require('../../parsers-commons');
+const {getCommands} = require('./commands');
+const {getEvents} = require('./events');
 
 // $FlowFixMe[signature-verification-failure] there's no flowtype for AST
 function buildComponentSchema(

package/lib/parsers/flow/modules/__test_fixtures__/fixtures.js

@@ -708,10 +708,23 @@ export enum StringOptions {
   Three = 'three',
 }
 
+export type BinaryTreeNode = {
+  left?: BinaryTreeNode,
+  value: number,
+  right?: BinaryTreeNode,
+};
+
+export type GraphNode = {
+  label: string,
+  neighbors?: Array<GraphNode>,
+};
+
 export interface Spec extends TurboModule {
   +getCallback: () => () => void;
   +getMixed: (arg: mixed) => mixed;
   +getEnums: (quality: Quality, resolution?: Resolution, floppy: Floppy, stringOptions: StringOptions) => string;
+  +getBinaryTreeNode: (arg: BinaryTreeNode) => BinaryTreeNode;
+  +getGraphNode: (arg: GraphNode) => GraphNode;
   +getMap: (arg: {[a: string]: ?number}) => {[b: string]: ?number};
   +getAnotherMap: (arg: {[string]: string}) => {[string]: string};
   +getUnion: (chooseInt: ChooseInt, chooseFloat: ChooseFloat, chooseObject: ChooseObject, chooseString: ChooseString) => ChooseObject;

package/lib/parsers/flow/modules/__test_fixtures__/fixtures.js.flow

@@ -731,10 +731,23 @@ export enum StringOptions {
   Three = 'three',
 }
 
+export type BinaryTreeNode = {
+  left?: BinaryTreeNode,
+  value: number,
+  right?: BinaryTreeNode,
+};
+
+export type GraphNode = {
+  label: string,
+  neighbors?: Array<GraphNode>,
+};
+
 export interface Spec extends TurboModule {
   +getCallback: () => () => void;
   +getMixed: (arg: mixed) => mixed;
   +getEnums: (quality: Quality, resolution?: Resolution, floppy: Floppy, stringOptions: StringOptions) => string;
+  +getBinaryTreeNode: (arg: BinaryTreeNode) => BinaryTreeNode;
+  +getGraphNode: (arg: GraphNode) => GraphNode;
   +getMap: (arg: {[a: string]: ?number}) => {[b: string]: ?number};
   +getAnotherMap: (arg: {[string]: string}) => {[string]: string};
   +getUnion: (chooseInt: ChooseInt, chooseFloat: ChooseFloat, chooseObject: ChooseObject, chooseString: ChooseString) => ChooseObject;

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

@@ -78,26 +78,26 @@ function _iterableToArrayLimit(arr, i) {
 function _arrayWithHoles(arr) {
   if (Array.isArray(arr)) return arr;
 }
-const _require = require('../../parsers-commons'),
-  unwrapNullable = _require.unwrapNullable,
-  wrapNullable = _require.wrapNullable,
-  assertGenericTypeAnnotationHasExactlyOneTypeParameter =
-    _require.assertGenericTypeAnnotationHasExactlyOneTypeParameter,
-  parseObjectProperty = _require.parseObjectProperty;
-const _require2 = require('../../parsers-primitives'),
-  emitArrayType = _require2.emitArrayType,
-  emitFunction = _require2.emitFunction,
-  emitDictionary = _require2.emitDictionary,
-  emitPromise = _require2.emitPromise,
-  emitRootTag = _require2.emitRootTag,
-  emitUnion = _require2.emitUnion,
-  emitCommonTypes = _require2.emitCommonTypes,
-  typeAliasResolution = _require2.typeAliasResolution,
-  typeEnumResolution = _require2.typeEnumResolution;
-const _require3 = require('../../errors'),
+const _require = require('../../errors'),
+  UnsupportedGenericParserError = _require.UnsupportedGenericParserError,
   UnsupportedTypeAnnotationParserError =
-    _require3.UnsupportedTypeAnnotationParserError,
-  UnsupportedGenericParserError = _require3.UnsupportedGenericParserError;
+    _require.UnsupportedTypeAnnotationParserError;
+const _require2 = require('../../parsers-commons'),
+  assertGenericTypeAnnotationHasExactlyOneTypeParameter =
+    _require2.assertGenericTypeAnnotationHasExactlyOneTypeParameter,
+  parseObjectProperty = _require2.parseObjectProperty,
+  unwrapNullable = _require2.unwrapNullable,
+  wrapNullable = _require2.wrapNullable;
+const _require3 = require('../../parsers-primitives'),
+  emitArrayType = _require3.emitArrayType,
+  emitCommonTypes = _require3.emitCommonTypes,
+  emitDictionary = _require3.emitDictionary,
+  emitFunction = _require3.emitFunction,
+  emitPromise = _require3.emitPromise,
+  emitRootTag = _require3.emitRootTag,
+  emitUnion = _require3.emitUnion,
+  typeAliasResolution = _require3.typeAliasResolution,
+  typeEnumResolution = _require3.typeEnumResolution;
 function translateTypeAnnotation(
   hasteModuleName,
   /**
@@ -231,6 +231,7 @@ function translateTypeAnnotation(
           .map(property => {
             return tryParse(() => {
               return parseObjectProperty(
+                flowTypeAnnotation,
                 property,
                 hasteModuleName,
                 types,

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

@@ -13,38 +13,36 @@
 import type {
   NamedShape,
   NativeModuleAliasMap,
-  NativeModuleEnumMap,
   NativeModuleBaseTypeAnnotation,
+  NativeModuleEnumMap,
   NativeModuleTypeAnnotation,
   Nullable,
 } from '../../../CodegenSchema';
-
 import type {Parser} from '../../parser';
 import type {ParserErrorCapturer, TypeDeclarationMap} from '../../utils';
 
 const {
-  unwrapNullable,
-  wrapNullable,
+  UnsupportedGenericParserError,
+  UnsupportedTypeAnnotationParserError,
+} = require('../../errors');
+const {
   assertGenericTypeAnnotationHasExactlyOneTypeParameter,
   parseObjectProperty,
+  unwrapNullable,
+  wrapNullable,
 } = require('../../parsers-commons');
 const {
   emitArrayType,
-  emitFunction,
+  emitCommonTypes,
   emitDictionary,
+  emitFunction,
   emitPromise,
   emitRootTag,
   emitUnion,
-  emitCommonTypes,
   typeAliasResolution,
   typeEnumResolution,
 } = require('../../parsers-primitives');
 
-const {
-  UnsupportedTypeAnnotationParserError,
-  UnsupportedGenericParserError,
-} = require('../../errors');
-
 function translateTypeAnnotation(
   hasteModuleName: string,
   /**
@@ -178,6 +176,7 @@ function translateTypeAnnotation(
             property => {
               return tryParse(() => {
                 return parseObjectProperty(
+                  flowTypeAnnotation,
                   property,
                   hasteModuleName,
                   types,