Update the API, handle type names differently

Author: michaldudak

src/models/export.ts

@@ -1,10 +1,10 @@
 import { Documentation } from './documentation';
-import { TypeNode } from './node';
+import { AnyType } from './node';
 
 export class ExportNode {
 	constructor(
 		public name: string,
-		public type: TypeNode,
+		public type: AnyType,
 		public documentation: Documentation | undefined,
 	) {}
 

src/models/node.ts

@@ -1,5 +1,32 @@
+import { TypeName } from './typeName';
+import { ArrayNode } from './types/array';
+import { ComponentNode } from './types/component';
+import { EnumNode } from './types/enum';
+import { ExternalTypeNode } from './types/external';
+import { FunctionNode } from './types/function';
+import { IntersectionNode } from './types/intersection';
+import { IntrinsicNode } from './types/intrinsic';
+import { LiteralNode } from './types/literal';
+import { ObjectNode } from './types/object';
+import { TupleNode } from './types/tuple';
+import { TypeParameterNode } from './types/typeParameter';
+import { UnionNode } from './types/union';
+
 export interface TypeNode {
 	readonly kind: string;
-	name: string | undefined;
-	parentNamespaces: string[] | undefined;
+	typeName: TypeName | undefined;
 }
+
+export type AnyType =
+	| ArrayNode
+	| ComponentNode
+	| EnumNode
+	| ExternalTypeNode
+	| FunctionNode
+	| IntersectionNode
+	| IntrinsicNode
+	| LiteralNode
+	| ObjectNode
+	| TupleNode
+	| TypeParameterNode
+	| UnionNode;

src/models/property.ts

@@ -1,10 +1,10 @@
 import { Documentation } from './documentation';
-import { TypeNode } from './node';
+import { AnyType } from './node';
 
 export class PropertyNode {
 	constructor(
 		public name: string,
-		public type: TypeNode,
+		public type: AnyType,
 		public documentation: Documentation | undefined,
 		public optional: boolean,
 	) {}

src/models/typeName.ts

@@ -0,0 +1,21 @@
+export class TypeName {
+	public readonly name: string | undefined;
+	public readonly namespaces: readonly string[] | undefined;
+
+	constructor(name: string | undefined, namespaces: readonly string[] | undefined = undefined) {
+		this.name = name;
+		this.namespaces = namespaces;
+	}
+
+	toString(): string {
+		if (!this.name) {
+			return '';
+		}
+
+		if (!this.namespaces || this.namespaces.length === 0) {
+			return this.name;
+		}
+
+		return `${this.namespaces.join('.')}.${this.name}`;
+	}
+}

src/models/types/array.ts

@@ -1,10 +1,13 @@
-import { TypeNode } from '../node';
+import { AnyType, TypeNode } from '../node';
+import { TypeName } from '../typeName';
 
 export class ArrayNode implements TypeNode {
-	kind = 'array';
-	constructor(
-		public name: string | undefined,
-		public parentNamespaces: string[],
-		public elementType: TypeNode,
-	) {}
+	readonly kind = 'array';
+	public typeName: TypeName | undefined;
+	public elementType: AnyType;
+
+	constructor(typeName: TypeName | undefined, elementType: AnyType) {
+		this.typeName = typeName?.name ? typeName : undefined;
+		this.elementType = elementType;
+	}
 }

src/models/types/component.ts

@@ -1,12 +1,14 @@
 import { PropertyNode } from '../property';
 import { TypeNode } from '../node';
+import { TypeName } from '../typeName';
 
 export class ComponentNode implements TypeNode {
-	kind = 'component';
+	readonly kind = 'component';
+	public typeName: TypeName | undefined;
+	public props: PropertyNode[];
 
-	constructor(
-		public name: string | undefined,
-		public parentNamespaces: string[],
-		public props: PropertyNode[],
-	) {}
+	constructor(typeName: TypeName | undefined, props: PropertyNode[]) {
+		this.props = props;
+		this.typeName = typeName?.name ? typeName : undefined;
+	}
 }

src/models/types/compoundTypeUtils.ts

@@ -2,18 +2,18 @@ import { uniqBy } from 'lodash';
 import { IntrinsicNode } from './intrinsic';
 import { LiteralNode } from './literal';
 import { ExternalTypeNode } from './external';
-import { TypeNode } from '../node';
+import { AnyType } from '../node';
 import { IntersectionNode } from './intersection';
 import { UnionNode } from './union';
 import { TypeParameterNode } from './typeParameter';
 
 export function flattenTypes(
-	nodes: readonly TypeNode[],
+	nodes: readonly AnyType[],
 	nodeToProcess: typeof UnionNode | typeof IntersectionNode,
-): TypeNode[] {
-	let flatTypes: TypeNode[] = [];
+): AnyType[] {
+	let flatTypes: AnyType[] = [];
 	nodes.forEach((node) => {
-		if (node instanceof nodeToProcess && !node.name) {
+		if (node instanceof nodeToProcess && !node.typeName) {
 			flatTypes = flatTypes.concat(flattenTypes(node.types, nodeToProcess));
 		} else {
 			flatTypes.push(node);
@@ -23,25 +23,29 @@ export function flattenTypes(
 	return flatTypes;
 }
 
-export function deduplicateMemberTypes(types: TypeNode[]): TypeNode[] {
+export function deduplicateMemberTypes(types: AnyType[]): AnyType[] {
 	return uniqBy(types, (x) => {
 		if (x instanceof LiteralNode) {
 			return x.value;
 		}
 
-		if (x instanceof ExternalTypeNode || x instanceof TypeParameterNode) {
+		if (x instanceof ExternalTypeNode) {
+			return x.typeName;
+		}
+
+		if (x instanceof TypeParameterNode) {
 			return x.name;
 		}
 
 		if (x instanceof IntrinsicNode) {
-			return x.name ?? x.intrinsic;
+			return x.typeName ?? x.intrinsic;
 		}
 
 		return x;
 	});
 }
 
-export function sortMemberTypes(members: TypeNode[]) {
+export function sortMemberTypes(members: AnyType[]) {
 	// move undefined and null to the end
 
 	const nullIndex = members.findIndex((x) => x instanceof IntrinsicNode && x.intrinsic === 'null');

src/models/types/enum.ts

@@ -1,12 +1,12 @@
 import { Documentation } from '../documentation';
 import { TypeNode } from '../node';
+import { TypeName } from '../typeName';
 
 export class EnumNode implements TypeNode {
-	kind = 'enum';
+	readonly kind = 'enum';
 
 	constructor(
-		public name: string,
-		public parentNamespaces: string[],
+		public typeName: TypeName,
 		public members: EnumMember[],
 		public documentation: Documentation | undefined,
 	) {}

src/models/types/external.ts

@@ -1,10 +1,8 @@
 import { TypeNode } from '../node';
+import { TypeName } from '../typeName';
 
 export class ExternalTypeNode implements TypeNode {
-	kind = 'external';
+	readonly kind = 'external';
 
-	constructor(
-		public name: string,
-		public parentNamespaces: string[],
-	) {}
+	constructor(public typeName: TypeName) {}
 }

src/models/types/function.ts

@@ -1,29 +1,29 @@
 import { Documentation } from '../documentation';
-import { TypeNode } from '../node';
+import { AnyType, TypeNode } from '../node';
+import { TypeName } from '../typeName';
 
 export class FunctionNode implements TypeNode {
-	kind = 'function';
-	name: string | undefined;
+	readonly kind = 'function';
+	typeName: TypeName | undefined;
+	callSignatures: CallSignature[];
 
-	constructor(
-		name: string | undefined,
-		public parentNamespaces: string[],
-		public callSignatures: CallSignature[],
-	) {
-		this.name = name === '__function' ? undefined : name;
+	constructor(typeName: TypeName | undefined, callSignatures: CallSignature[]) {
+		this.typeName =
+			typeName?.name === '__function' || typeName?.name === undefined ? undefined : typeName;
+		this.callSignatures = callSignatures;
 	}
 }
 
 export class CallSignature {
 	constructor(
 		public parameters: Parameter[],
-		public returnValueType: TypeNode,
+		public returnValueType: AnyType,
 	) {}
 }
 
 export class Parameter {
 	constructor(
-		public type: TypeNode,
+		public type: AnyType,
 		public name: string,
 		public documentation: Documentation | undefined,
 		public optional: boolean,