style: format

src/AnnotationsReader/ExtendedAnnotationsReader.ts

@@ -5,7 +5,10 @@ import { symbolAtNode } from "../Utils/symbolAtNode";
 import { BasicAnnotationsReader } from "./BasicAnnotationsReader";
 
 export class ExtendedAnnotationsReader extends BasicAnnotationsReader {
-    public constructor(private typeChecker: ts.TypeChecker, extraTags?: Set<string>) {
+    public constructor(
+        private typeChecker: ts.TypeChecker,
+        extraTags?: Set<string>
+    ) {
         super(extraTags);
     }
 

src/ChainNodeParser.ts

@@ -9,7 +9,10 @@ import { ReferenceType } from "./Type/ReferenceType";
 export class ChainNodeParser implements SubNodeParser, MutableParser {
     protected readonly typeCaches = new WeakMap<ts.Node, Map<string, BaseType>>();
 
-    public constructor(protected typeChecker: ts.TypeChecker, protected nodeParsers: SubNodeParser[]) {}
+    public constructor(
+        protected typeChecker: ts.TypeChecker,
+        protected nodeParsers: SubNodeParser[]
+    ) {}
 
     public addNodeParser(nodeParser: SubNodeParser): this {
         this.nodeParsers.push(nodeParser);

src/Error/UnknownNodeError.ts

@@ -2,7 +2,10 @@ import ts from "typescript";
 import { BaseError } from "./BaseError";
 
 export class UnknownNodeError extends BaseError {
-    public constructor(private node: ts.Node, private reference?: ts.Node) {
+    public constructor(
+        private node: ts.Node,
+        private reference?: ts.Node
+    ) {
         super(
             `Unknown node "${node.getSourceFile() ? node.getFullText() : "<unknown>"}" of kind "${
                 ts.SyntaxKind[node.kind]

src/NodeParser/AnnotatedNodeParser.ts

@@ -12,7 +12,10 @@ import { UnionType } from "../Type/UnionType";
 import { AnyType } from "../Type/AnyType";
 
 export class AnnotatedNodeParser implements SubNodeParser {
-    public constructor(protected childNodeParser: SubNodeParser, protected annotationsReader: AnnotationsReader) {}
+    public constructor(
+        protected childNodeParser: SubNodeParser,
+        protected annotationsReader: AnnotationsReader
+    ) {}
 
     public supportsNode(node: ts.Node): boolean {
         return this.childNodeParser.supportsNode(node);

src/NodeParser/CallExpressionParser.ts

@@ -8,7 +8,10 @@ import { LiteralType } from "../Type/LiteralType";
 import { SymbolType } from "../Type/SymbolType";
 
 export class CallExpressionParser implements SubNodeParser {
-    public constructor(protected typeChecker: ts.TypeChecker, protected childNodeParser: NodeParser) {}
+    public constructor(
+        protected typeChecker: ts.TypeChecker,
+        protected childNodeParser: NodeParser
+    ) {}
 
     public supportsNode(node: ts.CallExpression): boolean {
         return node.kind === ts.SyntaxKind.CallExpression;

src/NodeParser/ConditionalTypeNodeParser.ts

@@ -8,11 +8,17 @@ import { UnionType } from "../Type/UnionType";
 import { NeverType } from "../Type/NeverType";
 
 class CheckType {
-    constructor(public parameterName: string, public type: BaseType) {}
+    constructor(
+        public parameterName: string,
+        public type: BaseType
+    ) {}
 }
 
 export class ConditionalTypeNodeParser implements SubNodeParser {
-    public constructor(protected typeChecker: ts.TypeChecker, protected childNodeParser: NodeParser) {}
+    public constructor(
+        protected typeChecker: ts.TypeChecker,
+        protected childNodeParser: NodeParser
+    ) {}
 
     public supportsNode(node: ts.ConditionalTypeNode): boolean {
         return node.kind === ts.SyntaxKind.ConditionalType;

src/NodeParser/ExpressionWithTypeArgumentsNodeParser.ts

@@ -4,7 +4,10 @@ import { SubNodeParser } from "../SubNodeParser";
 import { BaseType } from "../Type/BaseType";
 
 export class ExpressionWithTypeArgumentsNodeParser implements SubNodeParser {
-    public constructor(protected typeChecker: ts.TypeChecker, protected childNodeParser: NodeParser) {}
+    public constructor(
+        protected typeChecker: ts.TypeChecker,
+        protected childNodeParser: NodeParser
+    ) {}
 
     public supportsNode(node: ts.ExpressionWithTypeArguments): boolean {
         return node.kind === ts.SyntaxKind.ExpressionWithTypeArguments;

src/NodeParser/IndexedAccessTypeNodeParser.ts

@@ -14,7 +14,10 @@ import { derefType } from "../Utils/derefType";
 import { getTypeByKey } from "../Utils/typeKeys";
 
 export class IndexedAccessTypeNodeParser implements SubNodeParser {
-    public constructor(protected typeChecker: ts.TypeChecker, protected childNodeParser: NodeParser) {}
+    public constructor(
+        protected typeChecker: ts.TypeChecker,
+        protected childNodeParser: NodeParser
+    ) {}
 
     public supportsNode(node: ts.TypeNode): boolean {
         return node.kind === ts.SyntaxKind.IndexedAccessType;

src/NodeParser/InferTypeNodeParser.ts

@@ -5,7 +5,10 @@ import { BaseType } from "../Type/BaseType";
 import { InferType } from "../Type/InferType";
 
 export class InferTypeNodeParser implements SubNodeParser {
-    public constructor(protected typeChecker: ts.TypeChecker, protected childNodeParser: NodeParser) {}
+    public constructor(
+        protected typeChecker: ts.TypeChecker,
+        protected childNodeParser: NodeParser
+    ) {}
 
     public supportsNode(node: ts.InferTypeNode): boolean {
         return node.kind === ts.SyntaxKind.InferType;

src/NodeParser/InterfaceAndClassNodeParser.ts

@@ -108,17 +108,20 @@ export class InterfaceAndClassNodeParser implements SubNodeParser {
         let hasRequiredNever = false;
 
         const properties = (node.members as ts.NodeArray<ts.TypeElement | ts.ClassElement>)
-            .reduce((members, member) => {
-                if (ts.isConstructorDeclaration(member)) {
-                    const params = member.parameters.filter((param) =>
-                        ts.isParameterPropertyDeclaration(param, param.parent)
-                    ) as ts.ParameterPropertyDeclaration[];
-                    members.push(...params);
-                } else if (ts.isPropertySignature(member) || ts.isPropertyDeclaration(member)) {
-                    members.push(member);
-                }
-                return members;
-            }, [] as (ts.PropertyDeclaration | ts.PropertySignature | ts.ParameterPropertyDeclaration)[])
+            .reduce(
+                (members, member) => {
+                    if (ts.isConstructorDeclaration(member)) {
+                        const params = member.parameters.filter((param) =>
+                            ts.isParameterPropertyDeclaration(param, param.parent)
+                        ) as ts.ParameterPropertyDeclaration[];
+                        members.push(...params);
+                    } else if (ts.isPropertySignature(member) || ts.isPropertyDeclaration(member)) {
+                        members.push(member);
+                    }
+                    return members;
+                },
+                [] as (ts.PropertyDeclaration | ts.PropertySignature | ts.ParameterPropertyDeclaration)[]
+            )
             .filter((member) => isPublic(member) && !isStatic(member) && !isNodeHidden(member))
             .reduce((entries, member) => {
                 let memberType: ts.Node | undefined = member.type;

src/NodeParser/IntersectionNodeParser.ts

@@ -11,7 +11,10 @@ import { UndefinedType } from "../Type/UndefinedType";
 import { NeverType } from "../Type/NeverType";
 
 export class IntersectionNodeParser implements SubNodeParser {
-    public constructor(protected typeChecker: ts.TypeChecker, protected childNodeParser: NodeParser) {}
+    public constructor(
+        protected typeChecker: ts.TypeChecker,
+        protected childNodeParser: NodeParser
+    ) {}
 
     public supportsNode(node: ts.IntersectionTypeNode): boolean {
         return node.kind === ts.SyntaxKind.IntersectionType;

src/NodeParser/MappedTypeNodeParser.ts

@@ -20,7 +20,10 @@ import { preserveAnnotation } from "../Utils/preserveAnnotation";
 import { removeUndefined } from "../Utils/removeUndefined";
 
 export class MappedTypeNodeParser implements SubNodeParser {
-    public constructor(protected childNodeParser: NodeParser, protected readonly additionalProperties: boolean) {}
+    public constructor(
+        protected childNodeParser: NodeParser,
+        protected readonly additionalProperties: boolean
+    ) {}
 
     public supportsNode(node: ts.MappedTypeNode): boolean {
         return node.kind === ts.SyntaxKind.MappedType;

src/NodeParser/PropertyAccessExpressionParser.ts

@@ -4,7 +4,10 @@ import { SubNodeParser } from "../SubNodeParser";
 import { BaseType } from "../Type/BaseType";
 
 export class PropertyAccessExpressionParser implements SubNodeParser {
-    public constructor(protected typeChecker: ts.TypeChecker, protected childNodeParser: NodeParser) {}
+    public constructor(
+        protected typeChecker: ts.TypeChecker,
+        protected childNodeParser: NodeParser
+    ) {}
 
     public supportsNode(node: ts.PropertyAccessExpression): boolean {
         return node.kind === ts.SyntaxKind.PropertyAccessExpression;

src/NodeParser/TupleNodeParser.ts

@@ -5,7 +5,10 @@ import { BaseType } from "../Type/BaseType";
 import { TupleType } from "../Type/TupleType";
 
 export class TupleNodeParser implements SubNodeParser {
-    public constructor(protected typeChecker: ts.TypeChecker, protected childNodeParser: NodeParser) {}
+    public constructor(
+        protected typeChecker: ts.TypeChecker,
+        protected childNodeParser: NodeParser
+    ) {}
 
     public supportsNode(node: ts.TupleTypeNode): boolean {
         return node.kind === ts.SyntaxKind.TupleType;

src/NodeParser/TypeAliasNodeParser.ts

@@ -8,7 +8,10 @@ import { ReferenceType } from "../Type/ReferenceType";
 import { getKey } from "../Utils/nodeKey";
 
 export class TypeAliasNodeParser implements SubNodeParser {
-    public constructor(protected typeChecker: ts.TypeChecker, protected childNodeParser: NodeParser) {}
+    public constructor(
+        protected typeChecker: ts.TypeChecker,
+        protected childNodeParser: NodeParser
+    ) {}
 
     public supportsNode(node: ts.TypeAliasDeclaration): boolean {
         return node.kind === ts.SyntaxKind.TypeAliasDeclaration;

src/NodeParser/TypeReferenceNodeParser.ts

@@ -14,7 +14,10 @@ const invalidTypes: Record<number, boolean> = {
 };
 
 export class TypeReferenceNodeParser implements SubNodeParser {
-    public constructor(protected typeChecker: ts.TypeChecker, protected childNodeParser: NodeParser) {}
+    public constructor(
+        protected typeChecker: ts.TypeChecker,
+        protected childNodeParser: NodeParser
+    ) {}
 
     public supportsNode(node: ts.TypeReferenceNode): boolean {
         return node.kind === ts.SyntaxKind.TypeReference;

src/NodeParser/TypeofNodeParser.ts

@@ -10,7 +10,10 @@ import { LiteralType } from "../Type/LiteralType";
 import { UnknownType } from "../Type/UnknownType";
 
 export class TypeofNodeParser implements SubNodeParser {
-    public constructor(protected typeChecker: ts.TypeChecker, protected childNodeParser: NodeParser) {}
+    public constructor(
+        protected typeChecker: ts.TypeChecker,
+        protected childNodeParser: NodeParser
+    ) {}
 
     public supportsNode(node: ts.TypeQueryNode): boolean {
         return node.kind === ts.SyntaxKind.TypeQuery;

src/NodeParser/UnionNodeParser.ts

@@ -7,7 +7,10 @@ import { notNever } from "../Utils/notNever";
 import { NeverType } from "../Type/NeverType";
 
 export class UnionNodeParser implements SubNodeParser {
-    public constructor(protected typeChecker: ts.TypeChecker, protected childNodeParser: NodeParser) {}
+    public constructor(
+        protected typeChecker: ts.TypeChecker,
+        protected childNodeParser: NodeParser
+    ) {}
 
     public supportsNode(node: ts.UnionTypeNode): boolean {
         return node.kind === ts.SyntaxKind.UnionType;

src/Type/AliasType.ts

@@ -1,7 +1,10 @@
 import { BaseType } from "./BaseType";
 
 export class AliasType extends BaseType {
-    public constructor(private id: string, private type: BaseType) {
+    public constructor(
+        private id: string,
+        private type: BaseType
+    ) {
         super();
     }
 

src/Type/AnnotatedType.ts

@@ -6,7 +6,11 @@ export interface Annotations {
 }
 
 export class AnnotatedType extends BaseType {
-    public constructor(private type: BaseType, private annotations: Annotations, private nullable: boolean) {
+    public constructor(
+        private type: BaseType,
+        private annotations: Annotations,
+        private nullable: boolean
+    ) {
         super();
     }
 

src/Type/DefinitionType.ts

@@ -1,7 +1,10 @@
 import { BaseType } from "./BaseType";
 
 export class DefinitionType extends BaseType {
-    public constructor(private name: string | undefined, private type: BaseType) {
+    public constructor(
+        private name: string | undefined,
+        private type: BaseType
+    ) {
         super();
     }
 

src/Type/EnumType.ts

@@ -7,7 +7,10 @@ export type EnumValue = string | boolean | number | null;
 export class EnumType extends BaseType {
     private types: BaseType[];
 
-    public constructor(private id: string, private values: readonly EnumValue[]) {
+    public constructor(
+        private id: string,
+        private values: readonly EnumValue[]
+    ) {
         super();
         this.types = values.map((value) => (value == null ? new NullType() : new LiteralType(value)));
     }

src/Type/ObjectType.ts

@@ -2,7 +2,11 @@ import { BaseType } from "./BaseType";
 import { strip } from "../Utils/String";
 
 export class ObjectProperty {
-    public constructor(private name: string, private type: BaseType, private required: boolean) {}
+    public constructor(
+        private name: string,
+        private type: BaseType,
+        private required: boolean
+    ) {}
 
     public getName(): string {
         return strip(this.name);

src/Type/RestType.ts

@@ -4,7 +4,10 @@ import { InferType } from "./InferType";
 import { TupleType } from "./TupleType";
 
 export class RestType extends BaseType {
-    public constructor(private item: ArrayType | InferType | TupleType, private title: string | null = null) {
+    public constructor(
+        private item: ArrayType | InferType | TupleType,
+        private title: string | null = null
+    ) {
         super();
     }
 

src/TypeFormatter/DefinitionTypeFormatter.ts

@@ -6,7 +6,10 @@ import { TypeFormatter } from "../TypeFormatter";
 import { uniqueArray } from "../Utils/uniqueArray";
 
 export class DefinitionTypeFormatter implements SubTypeFormatter {
-    public constructor(protected childTypeFormatter: TypeFormatter, protected encodeRefs: boolean) {}
+    public constructor(
+        protected childTypeFormatter: TypeFormatter,
+        protected encodeRefs: boolean
+    ) {}
 
     public supportsType(type: DefinitionType): boolean {
         return type instanceof DefinitionType;

src/TypeFormatter/ReferenceTypeFormatter.ts

@@ -6,7 +6,10 @@ import { ReferenceType } from "../Type/ReferenceType";
 import { TypeFormatter } from "../TypeFormatter";
 
 export class ReferenceTypeFormatter implements SubTypeFormatter {
-    public constructor(protected childTypeFormatter: TypeFormatter, protected encodeRefs: boolean) {}
+    public constructor(
+        protected childTypeFormatter: TypeFormatter,
+        protected encodeRefs: boolean
+    ) {}
 
     public supportsType(type: ReferenceType): boolean {
         return type instanceof ReferenceType;

src/TypeFormatter/UnionTypeFormatter.ts

@@ -13,7 +13,10 @@ import { uniqueArray } from "../Utils/uniqueArray";
 type DiscriminatorType = "json-schema" | "open-api";
 
 export class UnionTypeFormatter implements SubTypeFormatter {
-    public constructor(protected childTypeFormatter: TypeFormatter, private discriminatorType?: DiscriminatorType) {}
+    public constructor(
+        protected childTypeFormatter: TypeFormatter,
+        private discriminatorType?: DiscriminatorType
+    ) {}
 
     public supportsType(type: UnionType): boolean {
         return type instanceof UnionType;