Resolve recursive named unions correctly

Author: michaldudak

src/parsers/typeResolver.ts

@@ -25,15 +25,17 @@ export function resolveType(
 ): TypeNode {
 	const { checker, typeStack, includeExternalTypes } = context;
 
+	const typeId = getTypeId(type);
+
 	// If the typeStack contains type.id we're dealing with an object that references itself.
 	// To prevent getting stuck in an infinite loop we just set it to an objectNode
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	if (typeStack.includes((type as any).id)) {
+	if (typeId !== undefined && typeStack.includes(typeId)) {
 		return new ObjectNode(undefined, [], undefined);
 	}
 
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	typeStack.push((type as any).id);
+	if (typeId !== undefined) {
+		typeStack.push(typeId);
+	}
 
 	try {
 		if (type.flags & ts.TypeFlags.TypeParameter && type.symbol) {
@@ -97,7 +99,9 @@ export function resolveType(
 			// @ts-expect-error - Internal API
 			if (type.origin?.isUnion()) {
 				// @ts-expect-error - Internal API
-				return resolveType(type.origin, name, context);
+				for (const memberType of type.origin.types) {
+					memberTypes.push(resolveType(memberType, memberType.getSymbol()?.name || '', context));
+				}
 			} else {
 				for (const memberType of type.types) {
 					memberTypes.push(resolveType(memberType, memberType.getSymbol()?.name || '', context));
@@ -243,6 +247,9 @@ export function resolveType(
 		);
 
 		return new IntrinsicNode('any');
+	} catch (error) {
+		console.error(error);
+		throw error;
 	} finally {
 		typeStack.pop();
 	}
@@ -319,3 +326,8 @@ function getTypeName(type: ts.Type, checker: ts.TypeChecker): string {
 function hasFlag(typeFlags: number, flag: number) {
 	return (typeFlags & flag) === flag;
 }
+
+function getTypeId(type: ts.Type): number | undefined {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	return (type as any).id;
+}

test/literal-unions/input.tsx

@@ -6,6 +6,7 @@ export function test2(
 	referencedStringUnion: StringUnion,
 	referencedNumberUnion: NumberUnion,
 	unionOfUnions: StringUnion | NumberUnion,
+	indirectUnion: IndirectStringUnion | undefined,
 ) {}
 
 export function test3(prop: keyof Params) {}
@@ -17,8 +18,9 @@ export interface Params {
 	referencedNumberUnion: NumberUnion;
 	callback: (ref: StringUnion | undefined) => void;
 	unionOfUnions: StringUnion | NumberUnion;
-	unionAndLiteral: StringUnion | 'qux';
+	indirectUnion: IndirectStringUnion | undefined;
 }
 
 type StringUnion = 'foo' | 'bar' | 'baz';
+type IndirectStringUnion = StringUnion | 'qux';
 type NumberUnion = 1 | 2 | 3;

test/literal-unions/output.json

@@ -196,31 +196,41 @@
 											"optional": false
 										},
 										{
-											"name": "unionAndLiteral",
+											"name": "indirectUnion",
 											"type": {
 												"kind": "union",
 												"types": [
 													{
 														"kind": "union",
-														"name": "StringUnion",
+														"name": "IndirectStringUnion",
 														"types": [
 															{
-																"kind": "literal",
-																"value": "\"foo\""
-															},
-															{
-																"kind": "literal",
-																"value": "\"bar\""
+																"kind": "union",
+																"name": "StringUnion",
+																"types": [
+																	{
+																		"kind": "literal",
+																		"value": "\"foo\""
+																	},
+																	{
+																		"kind": "literal",
+																		"value": "\"bar\""
+																	},
+																	{
+																		"kind": "literal",
+																		"value": "\"baz\""
+																	}
+																]
 															},
 															{
 																"kind": "literal",
-																"value": "\"baz\""
+																"value": "\"qux\""
 															}
 														]
 													},
 													{
-														"kind": "literal",
-														"value": "\"qux\""
+														"kind": "intrinsic",
+														"name": "undefined"
 													}
 												]
 											},
@@ -376,6 +386,47 @@
 										}
 									]
 								}
+							},
+							{
+								"nodeType": "parameter",
+								"name": "indirectUnion",
+								"type": {
+									"kind": "union",
+									"types": [
+										{
+											"kind": "union",
+											"name": "IndirectStringUnion",
+											"types": [
+												{
+													"kind": "union",
+													"name": "StringUnion",
+													"types": [
+														{
+															"kind": "literal",
+															"value": "\"foo\""
+														},
+														{
+															"kind": "literal",
+															"value": "\"bar\""
+														},
+														{
+															"kind": "literal",
+															"value": "\"baz\""
+														}
+													]
+												},
+												{
+													"kind": "literal",
+													"value": "\"qux\""
+												}
+											]
+										},
+										{
+											"kind": "intrinsic",
+											"name": "undefined"
+										}
+									]
+								}
 							}
 						],
 						"returnValueType": {
@@ -426,7 +477,7 @@
 										},
 										{
 											"kind": "literal",
-											"value": "\"unionAndLiteral\""
+											"value": "\"indirectUnion\""
 										}
 									]
 								}