Handle type aliases better

src/models/node.ts

@@ -1,5 +1,5 @@
 export interface TypeNode {
 	readonly kind: string;
 	name: string | undefined;
-	parentNamespaces: string[];
+	parentNamespaces: string[] | undefined;
 }

src/models/types/intersection.ts

@@ -7,14 +7,16 @@ export class IntersectionNode implements TypeNode {
 
 	constructor(
 		public name: string | undefined,
-		public parentNamespaces: string[],
+		parentNamespaces: string[],
 		types: TypeNode[],
 		public properties: PropertyNode[],
 	) {
 		const flatTypes = flattenTypes(types, IntersectionNode);
 		sortMemberTypes(flatTypes);
 		this.types = deduplicateMemberTypes(flatTypes);
+		this.parentNamespaces = name ? parentNamespaces : undefined;
 	}
 
 	types: readonly TypeNode[];
+	parentNamespaces: string[] | undefined;
 }

src/models/types/union.ts

@@ -8,16 +8,18 @@ export class UnionNode implements TypeNode {
 
 	constructor(
 		public name: string | undefined,
-		public parentNamespaces: string[],
+		parentNamespaces: string[],
 		types: TypeNode[],
 	) {
 		const flatTypes = flattenTypes(types, UnionNode);
 		sanitizeBooleanLiterals(flatTypes);
 		sortMemberTypes(flatTypes);
 		this.types = deduplicateMemberTypes(flatTypes);
+		this.parentNamespaces = name ? parentNamespaces : undefined;
 	}
 
 	types: readonly TypeNode[];
+	parentNamespaces: string[] | undefined;
 }
 
 /**

src/parsers/exportParser.ts

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

src/parsers/functionParser.ts

@@ -75,11 +75,7 @@ function parseFunctionSignature(
 		parseParameter(parameterSymbol, context, skipResolvingComplexTypes),
 	);
 
-	const returnValueType = resolveType(
-		signature.getReturnType(),
-		signature.getDeclaration().name?.getText() || '',
-		context,
-	);
+	const returnValueType = resolveType(signature.getReturnType(), context);
 
 	return new CallSignature(parameters, returnValueType);
 }
@@ -94,10 +90,11 @@ function parseParameter(
 
 	try {
 		const parameterDeclaration = parameterSymbol.valueDeclaration as ts.ParameterDeclaration;
+
 		const parameterType = resolveType(
 			checker.getTypeOfSymbolAtLocation(parameterSymbol, parameterSymbol.valueDeclaration!),
-			parameterSymbol.getName(),
 			context,
+			parameterDeclaration.type,
 			skipResolvingComplexTypes,
 		);
 

src/parsers/objectParser.ts

@@ -2,32 +2,31 @@ import ts from 'typescript';
 import { parseProperty } from './propertyParser';
 import { ParserContext } from '../parser';
 import { ObjectNode } from '../models';
-import { getTypeNamespaces } from './typeResolver';
+import { getTypeName, getTypeNamespaces } from './typeResolver';
 
 export function parseObjectType(
 	type: ts.Type,
-	name: string,
 	context: ParserContext,
 	skipResolvingComplexTypes: boolean,
 ): ObjectNode | undefined {
-	const { shouldInclude, shouldResolveObject, typeStack, includeExternalTypes } = context;
+	const { shouldInclude, shouldResolveObject, typeStack, includeExternalTypes, checker } = context;
 
 	const properties = type
 		.getProperties()
 		.filter((property) => includeExternalTypes || !isPropertyExternal(property));
 
-	const typeSymbol = type.aliasSymbol ?? type.getSymbol();
-	let typeName = typeSymbol?.getName();
-	if (typeName === '__type') {
-		typeName = undefined;
-	}
+	const typeName = getTypeName(type, undefined, checker, false);
 
 	if (properties.length) {
 		if (
 			!skipResolvingComplexTypes &&
-			shouldResolveObject({ name, propertyCount: properties.length, depth: typeStack.length })
+			shouldResolveObject({
+				name: typeName ?? '',
+				propertyCount: properties.length,
+				depth: typeStack.length,
+			})
 		) {
-			const filtered = properties.filter((property) => {
+			const filteredProperties = properties.filter((property) => {
 				const declaration =
 					property.valueDeclaration ??
 					(property.declarations?.[0] as ts.PropertySignature | undefined);
@@ -37,11 +36,11 @@ export function parseObjectType(
 					shouldInclude({ name: property.getName(), depth: typeStack.length + 1 })
 				);
 			});
-			if (filtered.length > 0) {
+			if (filteredProperties.length > 0) {
 				return new ObjectNode(
 					typeName,
 					getTypeNamespaces(type),
-					filtered.map((property) => {
+					filteredProperties.map((property) => {
 						return parseProperty(
 							property,
 							property.valueDeclaration as ts.PropertySignature,

src/parsers/propertyParser.ts

@@ -16,11 +16,12 @@ export function parseProperty(
 
 	try {
 		let type: ts.Type;
+
 		if (propertySignature) {
-			if (!propertySignature.type) {
-				type = checker.getAnyType();
-			} else {
+			if (propertySignature.type) {
 				type = checker.getTypeOfSymbolAtLocation(propertySymbol, propertySignature.type);
+			} else {
+				type = checker.getAnyType();
 			}
 		} else {
 			type = checker.getTypeOfSymbol(propertySymbol);
@@ -36,7 +37,12 @@ export function parseProperty(
 			parsedType = new IntrinsicNode('any');
 			isOptional = Boolean(propertySignature.questionToken);
 		} else {
-			parsedType = resolveType(type, propertySymbol.getName(), context, skipResolvingComplexTypes);
+			parsedType = resolveType(
+				type,
+				context,
+				isTypeParameterLike(type) ? undefined : propertySignature?.type,
+				skipResolvingComplexTypes,
+			);
 			isOptional = Boolean(propertySymbol.flags & ts.SymbolFlags.Optional);
 		}
 
@@ -58,3 +64,25 @@ export function parseProperty(
 		parsedSymbolStack.pop();
 	}
 }
+
+function isTypeParameterLike(type: ts.Type): boolean {
+	// Check if the type is a type parameter
+	return (
+		(type.flags & ts.TypeFlags.TypeParameter) !== 0 ||
+		((type.flags & ts.TypeFlags.Union) !== 0 && isOptionalTypeParameter(type as ts.UnionType))
+	);
+}
+
+function isOptionalTypeParameter(type: ts.UnionType): boolean {
+	// Check if the type is defined as
+	// foo?: T
+	// where T is a type parameter
+
+	return (
+		type.types.length === 2 &&
+		type.types.some((t) => t.flags & ts.TypeFlags.Undefined) &&
+		type.types.some(
+			(t) => 'objectFlags' in t && ((t.objectFlags as number) & ts.ObjectFlags.Instantiated) !== 0,
+		)
+	);
+}