@react-native/codegen 0.74.0-nightly-20231203-385473522 → 0.74.0-nightly-20231204-e9b80971c

package/lib/generators/modules/GenerateModuleH.js

@@ -88,7 +88,9 @@ const _require3 = require('../Utils'),
 const _require4 = require('./Utils'),
   createAliasResolver = _require4.createAliasResolver,
   getAreEnumMembersInteger = _require4.getAreEnumMembersInteger,
-  getModules = _require4.getModules;
+  getModules = _require4.getModules,
+  isArrayRecursiveMember = _require4.isArrayRecursiveMember,
+  isDirectRecursiveMember = _require4.isDirectRecursiveMember;
 const ModuleClassDeclarationTemplate = ({
   hasteModuleName,
   moduleProperties,
@@ -165,6 +167,7 @@ ${modules.join('\n\n')}
 };
 function translatePrimitiveJSTypeToCpp(
   moduleName,
+  parentObjectAliasName,
   nullableTypeAnnotation,
   optional,
   createErrorMessage,
@@ -176,12 +179,16 @@ function translatePrimitiveJSTypeToCpp(
     typeAnnotation = _unwrapNullable2[0],
     nullable = _unwrapNullable2[1];
   const isRequired = !optional && !nullable;
+  const isRecursiveType = isDirectRecursiveMember(
+    parentObjectAliasName,
+    nullableTypeAnnotation,
+  );
   let realTypeAnnotation = typeAnnotation;
   if (realTypeAnnotation.type === 'TypeAliasTypeAnnotation') {
     realTypeAnnotation = resolveAlias(realTypeAnnotation.name);
   }
   function wrap(type) {
-    return isRequired ? type : `std::optional<${type}>`;
+    return isRequired || isRecursiveType ? type : `std::optional<${type}>`;
   }
   switch (realTypeAnnotation.type) {
     case 'ReservedTypeAnnotation':
@@ -248,9 +255,10 @@ function translatePrimitiveJSTypeToCpp(
   }
 }
 function createStructsString(moduleName, aliasMap, resolveAlias, enumMap) {
-  const getCppType = v =>
+  const getCppType = (parentObjectAlias, v) =>
     translatePrimitiveJSTypeToCpp(
       moduleName,
+      parentObjectAlias,
       v.typeAnnotation,
       false,
       typeName => `Unsupported type for param "${v.name}". Found: ${typeName}`,
@@ -276,7 +284,7 @@ function createStructsString(moduleName, aliasMap, resolveAlias, enumMap) {
           .join(', ');
         const debugParameterConversion = value.properties
           .map(
-            (v, i) => `  static ${getCppType(v)} ${
+            (v, i) => `  static ${getCppType(alias, v)} ${
               v.name
             }ToJs(jsi::Runtime &rt, P${i} value) {
     return bridging::toJs(rt, value);
@@ -347,12 +355,39 @@ ${value.properties
           return '';
         }
         const structName = `${moduleName}${alias}`;
-        const templateParameterWithTypename = value.properties
+        const templateParameter = value.properties.filter(
+          v =>
+            !isDirectRecursiveMember(alias, v.typeAnnotation) &&
+            !isArrayRecursiveMember(alias, v.typeAnnotation),
+        );
+        const templateParameterWithTypename = templateParameter
           .map((v, i) => `typename P${i}`)
           .join(', ');
+        const templateParameterWithoutTypename = templateParameter
+          .map((v, i) => `P${i}`)
+          .join(', ');
+        let i = -1;
+        const templateMemberTypes = value.properties.map(v => {
+          if (isDirectRecursiveMember(alias, v.typeAnnotation)) {
+            return `std::unique_ptr<${structName}<${templateParameterWithoutTypename}>> ${v.name}`;
+          } else if (isArrayRecursiveMember(alias, v.typeAnnotation)) {
+            const _unwrapNullable3 = unwrapNullable(v.typeAnnotation),
+              _unwrapNullable4 = _slicedToArray(_unwrapNullable3, 1),
+              nullable = _unwrapNullable4[0];
+            return (
+              (nullable
+                ? `std::optional<std::vector<${structName}<${templateParameterWithoutTypename}>>>`
+                : `std::vector<${structName}<${templateParameterWithoutTypename}>>`) +
+              ` ${v.name}`
+            );
+          } else {
+            i++;
+            return `P${i} ${v.name}`;
+          }
+        });
         const debugParameterConversion = value.properties
           .map(
-            (v, i) => `  static ${getCppType(v)} ${
+            v => `  static ${getCppType(alias, v)} ${
               v.name
             }ToJs(jsi::Runtime &rt, decltype(types.${v.name}) value) {
     return bridging::toJs(rt, value);
@@ -364,7 +399,7 @@ ${value.properties
 
 template <${templateParameterWithTypename}>
 struct ${structName} {
-${value.properties.map((v, i) => '  P' + i + ' ' + v.name).join(';\n')};
+${templateMemberTypes.map(v => '  ' + v).join(';\n')};
   bool operator==(const ${structName} &other) const {
     return ${value.properties
       .map(v => `${v.name} == other.${v.name}`)
@@ -382,10 +417,13 @@ struct ${structName}Bridging {
       const std::shared_ptr<CallInvoker> &jsInvoker) {
     T result{
 ${value.properties
-  .map(
-    (v, i) =>
-      `      bridging::fromJs<decltype(types.${v.name})>(rt, value.getProperty(rt, "${v.name}"), jsInvoker)`,
-  )
+  .map(v => {
+    if (isDirectRecursiveMember(alias, v.typeAnnotation)) {
+      return `      value.hasProperty(rt, "${v.name}") ? std::make_unique<T>(bridging::fromJs<T>(rt, value.getProperty(rt, "${v.name}"), jsInvoker)) : nullptr`;
+    } else {
+      return `      bridging::fromJs<decltype(types.${v.name})>(rt, value.getProperty(rt, "${v.name}"), jsInvoker)`;
+    }
+  })
   .join(',\n')}};
     return result;
   }
@@ -400,8 +438,12 @@ ${debugParameterConversion}
       const std::shared_ptr<CallInvoker> &jsInvoker) {
     auto result = facebook::jsi::Object(rt);
 ${value.properties
-  .map((v, i) => {
-    if (v.optional) {
+  .map(v => {
+    if (isDirectRecursiveMember(alias, v.typeAnnotation)) {
+      return `    if (value.${v.name}) {
+        result.setProperty(rt, "${v.name}", bridging::toJs(rt, *value.${v.name}, jsInvoker));
+      }`;
+    } else if (v.optional) {
       return `    if (value.${v.name}) {
       result.setProperty(rt, "${v.name}", bridging::toJs(rt, value.${v.name}.value(), jsInvoker));
     }`;
@@ -521,15 +563,16 @@ function translatePropertyToCpp(
   enumMap,
   abstract = false,
 ) {
-  const _unwrapNullable3 = unwrapNullable(prop.typeAnnotation),
-    _unwrapNullable4 = _slicedToArray(_unwrapNullable3, 1),
-    propTypeAnnotation = _unwrapNullable4[0];
+  const _unwrapNullable5 = unwrapNullable(prop.typeAnnotation),
+    _unwrapNullable6 = _slicedToArray(_unwrapNullable5, 1),
+    propTypeAnnotation = _unwrapNullable6[0];
   const params = propTypeAnnotation.params.map(
     param => `std::move(${param.name})`,
   );
   const paramTypes = propTypeAnnotation.params.map(param => {
     const translatedParam = translatePrimitiveJSTypeToCpp(
       moduleName,
+      null,
       param.typeAnnotation,
       param.optional,
       typeName =>
@@ -541,6 +584,7 @@ function translatePropertyToCpp(
   });
   const returnType = translatePrimitiveJSTypeToCpp(
     moduleName,
+    null,
     propTypeAnnotation.returnTypeAnnotation,
     false,
     typeName => `Unsupported return type for ${prop.name}. Found: ${typeName}`,

package/lib/generators/modules/GenerateModuleH.js.flow

@@ -33,6 +33,8 @@ const {
   createAliasResolver,
   getAreEnumMembersInteger,
   getModules,
+  isArrayRecursiveMember,
+  isDirectRecursiveMember,
 } = require('./Utils');
 
 type FilesOutput = Map<string, string>;
@@ -129,6 +131,7 @@ ${modules.join('\n\n')}
 
 function translatePrimitiveJSTypeToCpp(
   moduleName: string,
+  parentObjectAliasName: ?string,
   nullableTypeAnnotation: Nullable<NativeModuleTypeAnnotation>,
   optional: boolean,
   createErrorMessage: (typeName: string) => string,
@@ -139,6 +142,10 @@ function translatePrimitiveJSTypeToCpp(
     nullableTypeAnnotation,
   );
   const isRequired = !optional && !nullable;
+  const isRecursiveType = isDirectRecursiveMember(
+    parentObjectAliasName,
+    nullableTypeAnnotation,
+  );
 
   let realTypeAnnotation = typeAnnotation;
   if (realTypeAnnotation.type === 'TypeAliasTypeAnnotation') {
@@ -146,7 +153,7 @@ function translatePrimitiveJSTypeToCpp(
   }
 
   function wrap(type: string) {
-    return isRequired ? type : `std::optional<${type}>`;
+    return isRequired || isRecursiveType ? type : `std::optional<${type}>`;
   }
 
   switch (realTypeAnnotation.type) {
@@ -221,10 +228,12 @@ function createStructsString(
   enumMap: NativeModuleEnumMap,
 ): string {
   const getCppType = (
+    parentObjectAlias: string,
     v: NamedShape<Nullable<NativeModuleBaseTypeAnnotation>>,
   ) =>
     translatePrimitiveJSTypeToCpp(
       moduleName,
+      parentObjectAlias,
       v.typeAnnotation,
       false,
       typeName => `Unsupported type for param "${v.name}". Found: ${typeName}`,
@@ -250,7 +259,7 @@ function createStructsString(
           .join(', ');
         const debugParameterConversion = value.properties
           .map(
-            (v, i) => `  static ${getCppType(v)} ${
+            (v, i) => `  static ${getCppType(alias, v)} ${
               v.name
             }ToJs(jsi::Runtime &rt, P${i} value) {
     return bridging::toJs(rt, value);
@@ -321,12 +330,39 @@ ${value.properties
           return '';
         }
         const structName = `${moduleName}${alias}`;
-        const templateParameterWithTypename = value.properties
+        const templateParameter = value.properties.filter(
+          v =>
+            !isDirectRecursiveMember(alias, v.typeAnnotation) &&
+            !isArrayRecursiveMember(alias, v.typeAnnotation),
+        );
+        const templateParameterWithTypename = templateParameter
           .map((v, i) => `typename P${i}`)
           .join(', ');
+        const templateParameterWithoutTypename = templateParameter
+          .map((v, i) => `P${i}`)
+          .join(', ');
+        let i = -1;
+        const templateMemberTypes = value.properties.map(v => {
+          if (isDirectRecursiveMember(alias, v.typeAnnotation)) {
+            return `std::unique_ptr<${structName}<${templateParameterWithoutTypename}>> ${v.name}`;
+          } else if (isArrayRecursiveMember(alias, v.typeAnnotation)) {
+            const [nullable] = unwrapNullable<NativeModuleTypeAnnotation>(
+              v.typeAnnotation,
+            );
+            return (
+              (nullable
+                ? `std::optional<std::vector<${structName}<${templateParameterWithoutTypename}>>>`
+                : `std::vector<${structName}<${templateParameterWithoutTypename}>>`) +
+              ` ${v.name}`
+            );
+          } else {
+            i++;
+            return `P${i} ${v.name}`;
+          }
+        });
         const debugParameterConversion = value.properties
           .map(
-            (v, i) => `  static ${getCppType(v)} ${
+            v => `  static ${getCppType(alias, v)} ${
               v.name
             }ToJs(jsi::Runtime &rt, decltype(types.${v.name}) value) {
     return bridging::toJs(rt, value);
@@ -338,7 +374,7 @@ ${value.properties
 
 template <${templateParameterWithTypename}>
 struct ${structName} {
-${value.properties.map((v, i) => '  P' + i + ' ' + v.name).join(';\n')};
+${templateMemberTypes.map(v => '  ' + v).join(';\n')};
   bool operator==(const ${structName} &other) const {
     return ${value.properties
       .map(v => `${v.name} == other.${v.name}`)
@@ -356,10 +392,13 @@ struct ${structName}Bridging {
       const std::shared_ptr<CallInvoker> &jsInvoker) {
     T result{
 ${value.properties
-  .map(
-    (v, i) =>
-      `      bridging::fromJs<decltype(types.${v.name})>(rt, value.getProperty(rt, "${v.name}"), jsInvoker)`,
-  )
+  .map(v => {
+    if (isDirectRecursiveMember(alias, v.typeAnnotation)) {
+      return `      value.hasProperty(rt, "${v.name}") ? std::make_unique<T>(bridging::fromJs<T>(rt, value.getProperty(rt, "${v.name}"), jsInvoker)) : nullptr`;
+    } else {
+      return `      bridging::fromJs<decltype(types.${v.name})>(rt, value.getProperty(rt, "${v.name}"), jsInvoker)`;
+    }
+  })
   .join(',\n')}};
     return result;
   }
@@ -374,8 +413,12 @@ ${debugParameterConversion}
       const std::shared_ptr<CallInvoker> &jsInvoker) {
     auto result = facebook::jsi::Object(rt);
 ${value.properties
-  .map((v, i) => {
-    if (v.optional) {
+  .map(v => {
+    if (isDirectRecursiveMember(alias, v.typeAnnotation)) {
+      return `    if (value.${v.name}) {
+        result.setProperty(rt, "${v.name}", bridging::toJs(rt, *value.${v.name}, jsInvoker));
+      }`;
+    } else if (v.optional) {
       return `    if (value.${v.name}) {
       result.setProperty(rt, "${v.name}", bridging::toJs(rt, value.${v.name}.value(), jsInvoker));
     }`;
@@ -528,6 +571,7 @@ function translatePropertyToCpp(
   const paramTypes = propTypeAnnotation.params.map(param => {
     const translatedParam = translatePrimitiveJSTypeToCpp(
       moduleName,
+      null,
       param.typeAnnotation,
       param.optional,
       typeName =>
@@ -540,6 +584,7 @@ function translatePropertyToCpp(
 
   const returnType = translatePrimitiveJSTypeToCpp(
     moduleName,
+    null,
     propTypeAnnotation.returnTypeAnnotation,
     false,
     typeName => `Unsupported return type for ${prop.name}. Found: ${typeName}`,

package/lib/generators/modules/Utils.js

@@ -10,6 +10,76 @@
 
 'use strict';
 
+function _slicedToArray(arr, i) {
+  return (
+    _arrayWithHoles(arr) ||
+    _iterableToArrayLimit(arr, i) ||
+    _unsupportedIterableToArray(arr, i) ||
+    _nonIterableRest()
+  );
+}
+function _nonIterableRest() {
+  throw new TypeError(
+    'Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.',
+  );
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === 'string') return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === 'Object' && o.constructor) n = o.constructor.name;
+  if (n === 'Map' || n === 'Set') return Array.from(o);
+  if (n === 'Arguments' || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+    return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _iterableToArrayLimit(arr, i) {
+  var _i =
+    null == arr
+      ? null
+      : ('undefined' != typeof Symbol && arr[Symbol.iterator]) ||
+        arr['@@iterator'];
+  if (null != _i) {
+    var _s,
+      _e,
+      _x,
+      _r,
+      _arr = [],
+      _n = !0,
+      _d = !1;
+    try {
+      if (((_x = (_i = _i.call(arr)).next), 0 === i)) {
+        if (Object(_i) !== _i) return;
+        _n = !1;
+      } else
+        for (
+          ;
+          !(_n = (_s = _x.call(_i)).done) &&
+          (_arr.push(_s.value), _arr.length !== i);
+          _n = !0
+        );
+    } catch (err) {
+      (_d = !0), (_e = err);
+    } finally {
+      try {
+        if (!_n && null != _i.return && ((_r = _i.return()), Object(_r) !== _r))
+          return;
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+    return _arr;
+  }
+}
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+const _require = require('../../parsers/parsers-commons'),
+  unwrapNullable = _require.unwrapNullable;
 const invariant = require('invariant');
 function createAliasResolver(aliasMap) {
   return aliasName => {
@@ -28,6 +98,32 @@ function getModules(schema) {
     return modules;
   }, {});
 }
+function isDirectRecursiveMember(
+  parentObjectAliasName,
+  nullableTypeAnnotation,
+) {
+  const _unwrapNullable = unwrapNullable(nullableTypeAnnotation),
+    _unwrapNullable2 = _slicedToArray(_unwrapNullable, 1),
+    typeAnnotation = _unwrapNullable2[0];
+  return (
+    parentObjectAliasName !== undefined &&
+    typeAnnotation.name === parentObjectAliasName
+  );
+}
+function isArrayRecursiveMember(parentObjectAliasName, nullableTypeAnnotation) {
+  var _typeAnnotation$eleme;
+  const _unwrapNullable3 = unwrapNullable(nullableTypeAnnotation),
+    _unwrapNullable4 = _slicedToArray(_unwrapNullable3, 1),
+    typeAnnotation = _unwrapNullable4[0];
+  return (
+    parentObjectAliasName !== undefined &&
+    typeAnnotation.type === 'ArrayTypeAnnotation' &&
+    ((_typeAnnotation$eleme = typeAnnotation.elementType) === null ||
+    _typeAnnotation$eleme === void 0
+      ? void 0
+      : _typeAnnotation$eleme.name) === parentObjectAliasName
+  );
+}
 function getAreEnumMembersInteger(members) {
   return !members.some(m => `${m.value}`.includes('.'));
 }
@@ -35,4 +131,6 @@ module.exports = {
   createAliasResolver,
   getModules,
   getAreEnumMembersInteger,
+  isDirectRecursiveMember,
+  isArrayRecursiveMember,
 };

package/lib/generators/modules/Utils.js.flow

@@ -15,9 +15,12 @@ import type {
   NativeModuleEnumMembers,
   NativeModuleObjectTypeAnnotation,
   NativeModuleSchema,
+  NativeModuleTypeAnnotation,
+  Nullable,
   SchemaType,
 } from '../../CodegenSchema';
 
+const {unwrapNullable} = require('../../parsers/parsers-commons');
 const invariant = require('invariant');
 
 export type AliasResolver = (
@@ -48,6 +51,33 @@ function getModules(
   );
 }
 
+function isDirectRecursiveMember(
+  parentObjectAliasName: ?string,
+  nullableTypeAnnotation: Nullable<NativeModuleTypeAnnotation>,
+): boolean {
+  const [typeAnnotation] = unwrapNullable<NativeModuleTypeAnnotation>(
+    nullableTypeAnnotation,
+  );
+  return (
+    parentObjectAliasName !== undefined &&
+    typeAnnotation.name === parentObjectAliasName
+  );
+}
+
+function isArrayRecursiveMember(
+  parentObjectAliasName: ?string,
+  nullableTypeAnnotation: Nullable<NativeModuleTypeAnnotation>,
+): boolean {
+  const [typeAnnotation] = unwrapNullable<NativeModuleTypeAnnotation>(
+    nullableTypeAnnotation,
+  );
+  return (
+    parentObjectAliasName !== undefined &&
+    typeAnnotation.type === 'ArrayTypeAnnotation' &&
+    typeAnnotation.elementType?.name === parentObjectAliasName
+  );
+}
+
 function getAreEnumMembersInteger(members: NativeModuleEnumMembers): boolean {
   return !members.some(m => `${m.value}`.includes('.'));
 }
@@ -56,4 +86,6 @@ module.exports = {
   createAliasResolver,
   getModules,
   getAreEnumMembersInteger,
+  isDirectRecursiveMember,
+  isArrayRecursiveMember,
 };

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

@@ -231,6 +231,7 @@ function translateTypeAnnotation(
           .map(property => {
             return tryParse(() => {
               return parseObjectProperty(
+                flowTypeAnnotation,
                 property,
                 hasteModuleName,
                 types,

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

@@ -176,6 +176,7 @@ function translateTypeAnnotation(
             property => {
               return tryParse(() => {
                 return parseObjectProperty(
+                  flowTypeAnnotation,
                   property,
                   hasteModuleName,
                   types,

package/lib/parsers/parsers-commons.js

@@ -247,6 +247,7 @@ function isObjectProperty(property, language) {
   }
 }
 function parseObjectProperty(
+  parentObject,
   property,
   hasteModuleName,
   types,
@@ -266,6 +267,44 @@ function parseObjectProperty(
     language === 'TypeScript'
       ? property.typeAnnotation.typeAnnotation
       : property.value;
+
+  // Handle recursive types
+  if (parentObject) {
+    var _languageTypeAnnotati, _languageTypeAnnotati2;
+    const propertyType = parser.getResolveTypeAnnotationFN()(
+      languageTypeAnnotation,
+      types,
+      parser,
+    );
+    if (
+      propertyType.typeResolutionStatus.successful === true &&
+      propertyType.typeResolutionStatus.type === 'alias' &&
+      (language === 'TypeScript'
+        ? parentObject.typeName &&
+          parentObject.typeName.name ===
+            ((_languageTypeAnnotati = languageTypeAnnotation.typeName) ===
+              null || _languageTypeAnnotati === void 0
+              ? void 0
+              : _languageTypeAnnotati.name)
+        : parentObject.id &&
+          parentObject.id.name ===
+            ((_languageTypeAnnotati2 = languageTypeAnnotation.id) === null ||
+            _languageTypeAnnotati2 === void 0
+              ? void 0
+              : _languageTypeAnnotati2.name))
+    ) {
+      return {
+        name,
+        optional,
+        typeAnnotation: {
+          type: 'TypeAliasTypeAnnotation',
+          name: propertyType.typeResolutionStatus.name,
+        },
+      };
+    }
+  }
+
+  // Handle non-recursive types
   const _unwrapNullable = unwrapNullable(
       translateTypeAnnotation(
         hasteModuleName,

package/lib/parsers/parsers-commons.js.flow

@@ -171,6 +171,7 @@ function isObjectProperty(property: $FlowFixMe, language: ParserType): boolean {
 }
 
 function parseObjectProperty(
+  parentObject?: $FlowFixMe,
   property: $FlowFixMe,
   hasteModuleName: string,
   types: TypeDeclarationMap,
@@ -191,6 +192,34 @@ function parseObjectProperty(
       ? property.typeAnnotation.typeAnnotation
       : property.value;
 
+  // Handle recursive types
+  if (parentObject) {
+    const propertyType = parser.getResolveTypeAnnotationFN()(
+      languageTypeAnnotation,
+      types,
+      parser,
+    );
+    if (
+      propertyType.typeResolutionStatus.successful === true &&
+      propertyType.typeResolutionStatus.type === 'alias' &&
+      (language === 'TypeScript'
+        ? parentObject.typeName &&
+          parentObject.typeName.name === languageTypeAnnotation.typeName?.name
+        : parentObject.id &&
+          parentObject.id.name === languageTypeAnnotation.id?.name)
+    ) {
+      return {
+        name,
+        optional,
+        typeAnnotation: {
+          type: 'TypeAliasTypeAnnotation',
+          name: propertyType.typeResolutionStatus.name,
+        },
+      };
+    }
+  }
+
+  // Handle non-recursive types
   const [propertyTypeAnnotation, isPropertyNullable] =
     unwrapNullable<$FlowFixMe>(
       translateTypeAnnotation(

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

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

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

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

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

@@ -36,6 +36,7 @@ function translateObjectTypeAnnotation(
   /**
    * TODO(T108222691): Use flow-types for @babel/parser
    */
+  typeScriptTypeAnnotation,
   nullable,
   objectMembers,
   typeResolutionStatus,
@@ -52,6 +53,7 @@ function translateObjectTypeAnnotation(
     .map(property => {
       return tryParse(() => {
         return parseObjectProperty(
+          typeScriptTypeAnnotation,
           property,
           hasteModuleName,
           types,
@@ -259,6 +261,7 @@ function translateTypeAnnotation(
       }
       return translateObjectTypeAnnotation(
         hasteModuleName,
+        typeScriptTypeAnnotation,
         nullable,
         flattenProperties([typeAnnotation], types, parser),
         typeResolutionStatus,
@@ -274,6 +277,7 @@ function translateTypeAnnotation(
     case 'TSIntersectionType': {
       return translateObjectTypeAnnotation(
         hasteModuleName,
+        typeScriptTypeAnnotation,
         nullable,
         flattenProperties(
           flattenIntersectionType(typeAnnotation, types),
@@ -316,6 +320,7 @@ function translateTypeAnnotation(
       }
       return translateObjectTypeAnnotation(
         hasteModuleName,
+        typeScriptTypeAnnotation,
         nullable,
         typeAnnotation.members,
         typeResolutionStatus,

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

@@ -50,6 +50,7 @@ function translateObjectTypeAnnotation(
   /**
    * TODO(T108222691): Use flow-types for @babel/parser
    */
+  typeScriptTypeAnnotation: $FlowFixMe,
   nullable: boolean,
   objectMembers: $ReadOnlyArray<$FlowFixMe>,
   typeResolutionStatus: TypeResolutionStatus,
@@ -66,6 +67,7 @@ function translateObjectTypeAnnotation(
     .map<?NamedShape<Nullable<NativeModuleBaseTypeAnnotation>>>(property => {
       return tryParse(() => {
         return parseObjectProperty(
+          typeScriptTypeAnnotation,
           property,
           hasteModuleName,
           types,
@@ -266,6 +268,7 @@ function translateTypeAnnotation(
 
       return translateObjectTypeAnnotation(
         hasteModuleName,
+        typeScriptTypeAnnotation,
         nullable,
         flattenProperties([typeAnnotation], types, parser),
         typeResolutionStatus,
@@ -281,6 +284,7 @@ function translateTypeAnnotation(
     case 'TSIntersectionType': {
       return translateObjectTypeAnnotation(
         hasteModuleName,
+        typeScriptTypeAnnotation,
         nullable,
         flattenProperties(
           flattenIntersectionType(typeAnnotation, types),
@@ -324,6 +328,7 @@ function translateTypeAnnotation(
 
       return translateObjectTypeAnnotation(
         hasteModuleName,
+        typeScriptTypeAnnotation,
         nullable,
         typeAnnotation.members,
         typeResolutionStatus,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native/codegen",
-  "version": "0.74.0-nightly-20231203-385473522",
+  "version": "0.74.0-nightly-20231204-e9b80971c",
   "description": "Code generation tools for React Native",
   "license": "MIT",
   "repository": {