Refactoring and cleaning up

Author: michaldudak

src/parsers/exportParser.ts

@@ -149,7 +149,7 @@ export function parseExport(
 		type: ts.Type,
 		parentNamespaces: string[],
 	) {
-		const parsedType = resolveType(type, parserContext);
+		const parsedType = resolveType(type, undefined, parserContext);
 		if (parsedType) {
 			// Patch parentNamespaces if the type supports it
 			if (parsedType && 'parentNamespaces' in parsedType) {

src/parsers/functionParser.ts

@@ -75,7 +75,7 @@ function parseFunctionSignature(
 		parseParameter(parameterSymbol, context, skipResolvingComplexTypes),
 	);
 
-	const returnValueType = resolveType(signature.getReturnType(), context);
+	const returnValueType = resolveType(signature.getReturnType(), undefined, context);
 
 	return new CallSignature(parameters, returnValueType);
 }
@@ -93,8 +93,8 @@ function parseParameter(
 
 		const parameterType = resolveType(
 			checker.getTypeOfSymbolAtLocation(parameterSymbol, parameterSymbol.valueDeclaration!),
-			context,
 			parameterDeclaration.type,
+			context,
 			skipResolvingComplexTypes,
 		);
 

src/parsers/propertyParser.ts

@@ -31,8 +31,8 @@ export function parseProperty(
 
 		const parsedType = resolveType(
 			type,
-			context,
 			isTypeParameterLike(type) ? undefined : propertySignature?.type,
+			context,
 			skipResolvingComplexTypes,
 		);
 

src/parsers/typeResolver.ts

@@ -19,10 +19,17 @@ import {
 import { resolveUnionType } from './unionTypeResolver';
 import { getTypeName } from './common';
 
+/**
+ *
+ * @param type TypeScript type to resolve
+ * @param typeNode TypeScript TypeNode associated with the type, if available. It can be used to preserve the authored type name.
+ * @param context Parser context containing TypeScript checker and other utilities.
+ * @param skipResolvingComplexTypes If true, complex types like functions and objects will be resolved to their intrinsic types (e.g., 'function', 'object').
+ */
 export function resolveType(
 	type: ts.Type,
+	typeNode: ts.TypeNode | undefined,
 	context: ParserContext,
-	typeNode?: ts.TypeNode,
 	skipResolvingComplexTypes: boolean = false,
 ): TypeNode {
 	const { checker, typeStack, includeExternalTypes } = context;
@@ -73,15 +80,19 @@ export function resolveType(
 				namespaces,
 				declaration?.constraint?.getText(),
 				declaration?.default
-					? resolveType(checker.getTypeAtLocation(declaration.default), context)
+					? resolveType(checker.getTypeAtLocation(declaration.default), undefined, context)
 					: undefined,
 			);
 		}
 
 		if (checker.isArrayType(type)) {
 			// @ts-expect-error - Private method
 			const arrayType: ts.Type = checker.getElementTypeOfArrayType(type);
-			return new ArrayNode(type.aliasSymbol?.name, namespaces, resolveType(arrayType, context));
+			return new ArrayNode(
+				type.aliasSymbol?.name,
+				namespaces,
+				resolveType(arrayType, undefined, context),
+			);
 		}
 
 		if (!includeExternalTypes && isTypeExternal(type, checker)) {
@@ -126,7 +137,7 @@ export function resolveType(
 			const typeName = getTypeName(type, typeSymbol, checker, false);
 
 			for (const memberType of type.types) {
-				memberTypes.push(resolveType(memberType, context));
+				memberTypes.push(resolveType(memberType, undefined, context));
 			}
 
 			if (memberTypes.length === 0) {
@@ -160,7 +171,7 @@ export function resolveType(
 			return new TupleNode(
 				typeSymbol?.name ?? type.aliasSymbol?.name,
 				namespaces,
-				(type as ts.TupleType).typeArguments?.map((x) => resolveType(x, context)) ?? [],
+				(type as ts.TupleType).typeArguments?.map((x) => resolveType(x, undefined, context)) ?? [],
 			);
 		}
 
@@ -235,14 +246,15 @@ export function resolveType(
 					undefined,
 					[],
 					[
-						resolveType((type as ts.ConditionalType).resolvedTrueType!, context),
-						resolveType((type as ts.ConditionalType).resolvedFalseType!, context),
+						// TODO: Pass TypeNode here to resolve aliases correctly
+						resolveType((type as ts.ConditionalType).resolvedTrueType!, undefined, context),
+						resolveType((type as ts.ConditionalType).resolvedFalseType!, undefined, context),
 					],
 				);
 			} else if (conditionalType.resolvedTrueType) {
-				return resolveType(conditionalType.resolvedTrueType, context);
+				return resolveType(conditionalType.resolvedTrueType, undefined, context);
 			} else if (conditionalType.resolvedFalseType) {
-				return resolveType(conditionalType.resolvedFalseType, context);
+				return resolveType(conditionalType.resolvedFalseType, undefined, context);
 			}
 		}
 

src/parsers/unionTypeResolver.ts

@@ -60,7 +60,7 @@ export function resolveUnionType(
 				memberTypeNode = typeNode.types[index];
 			}
 
-			result.push(resolveType(memberType, context, memberTypeNode || typeNode));
+			result.push(resolveType(memberType, memberTypeNode || typeNode, context));
 		}
 	} else {
 		// Type is an union type, but TypeNode is not.
@@ -74,11 +74,11 @@ export function resolveUnionType(
 			// In such case propagate the parent TypeNode to the member types.
 			// It will help to resolve T correctly and won't have any effect on the `undefined` type.
 			for (const memberType of memberTypes) {
-				result.push(resolveType(memberType, context, typeNode));
+				result.push(resolveType(memberType, typeNode, context));
 			}
 		} else {
 			for (const memberType of memberTypes) {
-				result.push(resolveType(memberType, context));
+				result.push(resolveType(memberType, undefined, context));
 			}
 		}
 	}