Support for intersection types (#482)

Author: rklfss

src/lib/converter/plugins/TypePlugin.ts

@@ -1,5 +1,5 @@
 import {Reflection, ReflectionKind, Decorator, DeclarationReflection, DeclarationHierarchy} from '../../models/reflections/index';
-import {Type, ReferenceType, TupleType, UnionType} from '../../models/types/index';
+import {Type, ReferenceType, TupleType, UnionType, IntersectionType} from '../../models/types/index';
 import {Component, ConverterComponent} from '../components';
 import {Converter} from '../converter';
 import {Context} from '../context';
@@ -108,10 +108,10 @@ export class TypePlugin extends ConverterComponent {
                 for (let index = 0, count = tupleType.elements.length; index < count; index++) {
                     resolveType(reflection, tupleType.elements[index]);
                 }
-            } else if (type instanceof UnionType) {
-                const unionType: UnionType = <UnionType> type;
-                for (let index = 0, count = unionType.types.length; index < count; index++) {
-                    resolveType(reflection, unionType.types[index]);
+            } else if (type instanceof UnionType || type instanceof IntersectionType) {
+                const unionOrIntersectionType: UnionType | IntersectionType = <UnionType | IntersectionType> type;
+                for (let index = 0, count = unionOrIntersectionType.types.length; index < count; index++) {
+                    resolveType(reflection, unionOrIntersectionType.types[index]);
                 }
             }
         }

src/lib/converter/types/index.ts

@@ -9,5 +9,5 @@ export {ReferenceConverter} from './reference';
 export {ThisConverter} from './this';
 export {TupleConverter} from './tuple';
 export {TypeParameterConverter} from './type-parameter';
-export {UnionConverter} from './union';
+export {UnionOrIntersectionConverter} from './union-or-intersection';
 export {UnknownConverter} from './unknown';

src/lib/converter/types/union.ts renamed to src/lib/converter/types/union-or-intersection.ts

@@ -1,47 +1,47 @@
 import * as ts from 'typescript';
 
-import {Type, UnionType} from '../../models/types/index';
+import {Type, UnionType, IntersectionType} from '../../models/types/index';
 import {Component, ConverterTypeComponent, TypeConverter} from '../components';
 import {Context} from '../context';
 
-@Component({name: 'type:union'})
-export class UnionConverter extends ConverterTypeComponent implements TypeConverter<ts.UnionType, ts.UnionTypeNode> {
+@Component({name: 'type:union-or-intersection'})
+export class UnionOrIntersectionConverter extends ConverterTypeComponent implements TypeConverter<ts.UnionOrIntersectionType, ts.UnionOrIntersectionTypeNode> {
     /**
      * Test whether this converter can handle the given TypeScript node.
      */
-    supportsNode(context: Context, node: ts.UnionTypeNode): boolean {
-        return node.kind === ts.SyntaxKind.UnionType;
+    supportsNode(context: Context, node: ts.UnionOrIntersectionTypeNode): boolean {
+        return node.kind === ts.SyntaxKind.UnionType || node.kind === ts.SyntaxKind.IntersectionType;
     }
 
     /**
      * Test whether this converter can handle the given TypeScript type.
      */
-    supportsType(context: Context, type: ts.UnionType): boolean {
-        return !!(type.flags & ts.TypeFlags.Union);
+    supportsType(context: Context, type: ts.UnionOrIntersectionType): boolean {
+        return !!(type.flags & ts.TypeFlags.UnionOrIntersection);
     }
 
     /**
      * Convert the given union type node to its type reflection.
      *
-     * This is a node based converter, see [[convertUnionType]] for the type equivalent.
+     * This is a node based converter, see [[convertType]] for the type equivalent.
      *
      * ```
      * let someValue: string|number;
      * ```
      *
      * @param context  The context object describing the current state the converter is in.
-     * @param node  The union type node that should be converted.
+     * @param node  The union or intersection type node that should be converted.
      * @returns The type reflection representing the given union type node.
      */
-    convertNode(context: Context, node: ts.UnionTypeNode): UnionType {
+    convertNode(context: Context, node: ts.UnionOrIntersectionTypeNode): UnionType | IntersectionType {
         let types: Type[] = [];
         if (node.types) {
             types = node.types.map((n) => this.owner.convertType(context, n));
         } else {
             types = [];
         }
 
-        return new UnionType(types);
+        return node.kind === ts.SyntaxKind.IntersectionType ? new IntersectionType(types) : new UnionType(types);
     }
 
     /**
@@ -57,14 +57,14 @@ export class UnionConverter extends ConverterTypeComponent implements TypeConver
      * @param type  The union type that should be converted.
      * @returns The type reflection representing the given union type.
      */
-    convertType(context: Context, type: ts.UnionType): UnionType {
+    convertType(context: Context, type: ts.UnionOrIntersectionType): UnionType | IntersectionType {
         let types: Type[];
         if (type && type.types) {
             types = type.types.map((t) => this.owner.convertType(context, null, t));
         } else {
             types = [];
         }
 
-        return new UnionType(types);
+        return !!(type.flags & ts.TypeFlags.Intersection) ? new IntersectionType(types) : new UnionType(types);
     }
 }

src/lib/models/types/abstract.ts

@@ -9,6 +9,11 @@ export abstract class Type {
      */
     isArray = false;
 
+    /**
+     * The type name identifier.
+     */
+    readonly type: string = 'void';
+
     /**
      * Clone this type.
      *
@@ -31,7 +36,7 @@ export abstract class Type {
      */
     toObject(): any {
         let result: any = {};
-        result.type = 'void';
+        result.type = this.type;
 
         if (this.isArray) {
             result.isArray = this.isArray;

src/lib/models/types/index.ts

@@ -1,5 +1,6 @@
 export {Type} from './abstract';
 export {IntrinsicType} from './intrinsic';
+export {IntersectionType} from './intersection';
 export {ReferenceType} from './reference';
 export {ReflectionType} from './reflection';
 export {StringLiteralType} from './string-literal';

src/lib/models/types/intersection.ts

@@ -0,0 +1,82 @@
+import {Type} from './abstract';
+
+/**
+ * Represents an intersection type.
+ *
+ * ~~~
+ * let value: A & B;
+ * ~~~
+ */
+export class IntersectionType extends Type {
+    /**
+     * The types this union consists of.
+     */
+    types: Type[];
+
+    /**
+     * The type name identifier.
+     */
+    readonly type: string = 'intersection';
+
+    /**
+     * Create a new TupleType instance.
+     *
+     * @param types  The types this union consists of.
+     */
+    constructor(types: Type[]) {
+        super();
+        this.types = types;
+    }
+
+    /**
+     * Clone this type.
+     *
+     * @return A clone of this type.
+     */
+    clone(): Type {
+        const clone = new IntersectionType(this.types);
+        clone.isArray = this.isArray;
+        return clone;
+    }
+
+    /**
+     * Test whether this type equals the given type.
+     *
+     * @param type  The type that should be checked for equality.
+     * @returns TRUE if the given type equals this type, FALSE otherwise.
+     */
+    equals(type: IntersectionType): boolean {
+        if (!(type instanceof IntersectionType)) {
+            return false;
+        }
+        if (type.isArray !== this.isArray) {
+            return false;
+        }
+        return Type.isTypeListSimiliar(type.types, this.types);
+    }
+
+    /**
+     * Return a raw object representation of this type.
+     */
+    toObject(): any {
+        const result: any = super.toObject();
+
+        if (this.types && this.types.length) {
+            result.types = this.types.map((e) => e.toObject());
+        }
+
+        return result;
+    }
+
+    /**
+     * Return a string representation of this type.
+     */
+    toString() {
+        const names: string[] = [];
+        this.types.forEach((element) => {
+            names.push(element.toString());
+        });
+
+        return names.join(' & ');
+    }
+}

src/lib/models/types/intrinsic.ts

@@ -13,6 +13,11 @@ export class IntrinsicType extends Type {
      */
     name: string;
 
+    /**
+     * The type name identifier.
+     */
+    readonly type: string = 'instrinct'; // TODO: Is there any change to correct this typo?
+
     /**
      * Create a new instance of IntrinsicType.
      *
@@ -51,7 +56,6 @@ export class IntrinsicType extends Type {
      */
     toObject(): any {
         const result: any = super.toObject();
-        result.type = 'instrinct';
         result.name = this.name;
         return result;
     }

src/lib/models/types/reference.ts

@@ -9,6 +9,11 @@ import {Type} from './abstract';
  * ~~~
  */
 export class ReferenceType extends Type {
+    /**
+     * The type name identifier.
+     */
+    readonly type: string = 'reference';
+
     /**
      * The name of the referenced type.
      *
@@ -90,7 +95,6 @@ export class ReferenceType extends Type {
      */
     toObject(): any {
         const result: any = super.toObject();
-        result.type = 'reference';
         result.name = this.name;
 
         if (this.reflection) {

src/lib/models/types/reflection.ts

@@ -14,6 +14,11 @@ export class ReflectionType extends Type {
      */
     declaration: DeclarationReflection;
 
+    /**
+     * The type name identifier.
+     */
+    readonly type: string = 'reflection';
+
     /**
      * Create a new instance of ReflectionType.
      *
@@ -50,7 +55,6 @@ export class ReflectionType extends Type {
      */
     toObject(): any {
         const result: any = super.toObject();
-        result.type = 'reflection';
 
         if (this.declaration) {
             result.declaration = this.declaration.toObject();

src/lib/models/types/string-literal.ts

@@ -13,6 +13,11 @@ export class StringLiteralType extends Type {
      */
     value: string;
 
+    /**
+     * The type name identifier.
+     */
+    readonly type: string = 'stringLiteral';
+
     /**
      * Create a new instance of StringLiteralType.
      *
@@ -51,7 +56,6 @@ export class StringLiteralType extends Type {
      */
     toObject(): any {
         const result: any = super.toObject();
-        result.type = 'stringLiteral';
         result.value = this.value;
         return result;
     }