feat: Upgrade to TS 4.0

Partial fix for #1357

package.json

@@ -32,7 +32,7 @@
     "typedoc-default-themes": "^0.11.0"
   },
   "peerDependencies": {
-    "typescript": ">=3.8.3"
+    "typescript": ">=4.0.2"
   },
   "devDependencies": {
     "@types/fs-extra": "^9.0.1",
@@ -48,7 +48,7 @@
     "mockery": "^2.1.0",
     "nyc": "^15.1.0",
     "tslint": "^5.20.1",
-    "typescript": "^3.8.3"
+    "typescript": "^4.0.2"
   },
   "files": [
     "bin",

src/lib/converter/types/tuple.ts

@@ -1,15 +1,16 @@
 import * as ts from 'typescript';
 
 import { Type, TupleType } from '../../models/types/index';
-import { Component, ConverterTypeComponent, TypeConverter } from '../components';
+import { Component, ConverterTypeComponent, TypeConverter, TypeNodeConverter } from '../components';
 import { Context } from '../context';
+import { NamedTupleMember } from '../../models/types/tuple';
 
 @Component({name: 'type:tuple'})
 export class TupleConverter extends ConverterTypeComponent implements TypeConverter<ts.TypeReference, ts.TupleTypeNode> {
     /**
      * Test whether this converter can handle the given TypeScript node.
      */
-    supportsNode(context: Context, node: ts.TupleTypeNode): boolean {
+    supportsNode(_context: Context, node: ts.TupleTypeNode): boolean {
         return node.kind === ts.SyntaxKind.TupleType;
     }
 
@@ -46,7 +47,7 @@ export class TupleConverter extends ConverterTypeComponent implements TypeConver
      * @returns The type reflection representing the given tuple type node.
      */
     convertNode(context: Context, node: ts.TupleTypeNode): TupleType {
-        const elements: Type[] = this.owner.convertTypes(context, node.elementTypes);
+        const elements: Type[] = this.owner.convertTypes(context, node.elements);
         return new TupleType(elements);
     }
 
@@ -64,7 +65,24 @@ export class TupleConverter extends ConverterTypeComponent implements TypeConver
      * @returns The type reflection representing the given tuple type.
      */
     convertType(context: Context, type: ts.TypeReference): TupleType {
+        // TODO: We might be able to have named tuple elements here.
         const elements: Type[] = this.owner.convertTypes(context, undefined, type.typeArguments);
         return new TupleType(elements);
     }
 }
+
+@Component({ name: 'type:named-tuple-member' })
+export class NamedTupleMemberConverter extends ConverterTypeComponent implements TypeNodeConverter<ts.Type, ts.NamedTupleMember> {
+    supportsNode(_context: Context, node: ts.Node) {
+        return ts.isNamedTupleMember(node);
+    }
+
+    convertNode(context: Context, node: ts.NamedTupleMember): NamedTupleMember | undefined {
+        const innerType = this.owner.convertType(context, node.type);
+        if (!innerType) {
+            return;
+        }
+
+        return new NamedTupleMember(node.name.getText(), !!node.questionToken, innerType);
+    }
+}

src/lib/models/types/index.ts

@@ -10,7 +10,7 @@ export { PredicateType } from './predicate';
 export { ReferenceType } from './reference';
 export { ReflectionType } from './reflection';
 export { StringLiteralType } from './string-literal';
-export { TupleType } from './tuple';
+export { TupleType, NamedTupleMember } from './tuple';
 export { TypeOperatorType } from './type-operator';
 export { TypeParameterType } from './type-parameter';
 export { UnionType } from './union';

src/lib/models/types/tuple.ts

@@ -62,3 +62,40 @@ export class TupleType extends Type {
         return '[' + names.join(', ') + ']';
     }
 }
+
+export class NamedTupleMember extends Type {
+    readonly type = 'named-tuple-member';
+
+    constructor(public name: string, public isOptional: boolean, public element: Type) {
+        super();
+    }
+
+        /**
+     * Clone this type.
+     *
+     * @return A clone of this type.
+     */
+    clone(): Type {
+        return new NamedTupleMember(this.name, this.isOptional, this.element.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: Type): boolean {
+        if (!(type instanceof NamedTupleMember)) {
+            return false;
+        }
+        return this.isOptional === type.isOptional && this.element.equals(type.element);
+    }
+
+    /**
+     * Return a string representation of this type.
+     */
+    toString() {
+        return `${this.name}${this.isOptional ? '?' : ''}: ${this.element}`;
+    }
+}

src/lib/serialization/schema.ts

@@ -219,6 +219,12 @@ export interface TupleType extends Type, S<M.TupleType, 'type'> {
     elements?: ModelToObject<M.TupleType['elements']>;
 }
 
+export interface NamedTupleMemberType extends Type, S<M.NamedTupleMember, 'type'> {
+    name: string;
+    isOptional: boolean;
+    element: ModelToObject<M.NamedTupleMember['element']>;
+}
+
 export interface TypeOperatorType extends Type, S<M.TypeOperatorType, 'type' | 'operator' | 'target'> {
 }
 

src/lib/serialization/serializer.ts

@@ -121,6 +121,7 @@ const serializerComponents: (new (owner: Serializer) => SerializerComponent<any>
     S.ReflectionTypeSerializer,
     S.StringLiteralTypeSerializer,
     S.TupleTypeSerializer,
+    S.NamedTupleMemberTypeSerializer,
     S.TypeOperatorTypeSerializer,
     S.TypeParameterTypeSerializer,
     S.UnionTypeSerializer,

src/lib/serialization/serializers/types/tuple.ts

@@ -1,7 +1,11 @@
 import { TupleType } from '../../../models';
+import { NamedTupleMember } from '../../../models/types/tuple';
 
 import { TypeSerializerComponent } from '../../components';
-import { TupleType as JSONTupleType } from '../../schema';
+import {
+    TupleType as JSONTupleType,
+    NamedTupleMemberType as JSONNamedTupleMemberType
+} from '../../schema';
 
 export class TupleTypeSerializer extends TypeSerializerComponent<TupleType> {
     supports(t: unknown) {
@@ -18,3 +22,18 @@ export class TupleTypeSerializer extends TypeSerializerComponent<TupleType> {
         return result;
     }
 }
+
+export class NamedTupleMemberTypeSerializer extends TypeSerializerComponent<NamedTupleMember> {
+    supports(t: unknown) {
+        return t instanceof NamedTupleMember;
+    }
+
+    toObject(tuple: NamedTupleMember, obj: Pick<JSONNamedTupleMemberType, 'type'>): JSONNamedTupleMemberType {
+        return {
+            ...obj,
+            name: tuple.name,
+            isOptional: tuple.isOptional,
+            element: this.owner.toObject(tuple.element)
+        };
+    }
+}