typedoc 0.22.13 → 0.22.16

package/dist/lib/models/reflections/declaration.d.ts

@@ -68,6 +68,8 @@ export declare class DeclarationReflection extends ContainerReflection {
      * The default value of this reflection.
      *
      * Applies to function parameters.
+     *
+     * Note: Using this for enum members is DEPRECATED and will be removed in 0.23.
      */
     defaultValue?: string;
     /**

package/dist/lib/models/reflections/declaration.js

@@ -45,7 +45,7 @@ class DeclarationReflection extends container_1.ContainerReflection {
      */
     traverse(callback) {
         var _a, _b;
-        for (const parameter of (_a = this.typeParameters) !== null && _a !== void 0 ? _a : []) {
+        for (const parameter of ((_a = this.typeParameters) === null || _a === void 0 ? void 0 : _a.slice()) || []) {
             if (callback(parameter, abstract_1.TraverseProperty.TypeParameter) === false) {
                 return;
             }
@@ -55,7 +55,7 @@ class DeclarationReflection extends container_1.ContainerReflection {
                 return;
             }
         }
-        for (const signature of (_b = this.signatures) !== null && _b !== void 0 ? _b : []) {
+        for (const signature of ((_b = this.signatures) === null || _b === void 0 ? void 0 : _b.slice()) || []) {
             if (callback(signature, abstract_1.TraverseProperty.Signatures) === false) {
                 return;
             }

package/dist/lib/models/reflections/index.d.ts

@@ -8,5 +8,5 @@ export { ParameterReflection } from "./parameter";
 export { ProjectReflection } from "./project";
 export { ReferenceReflection } from "./reference";
 export { SignatureReflection } from "./signature";
-export { TypeParameterReflection } from "./type-parameter";
+export { TypeParameterReflection, VarianceModifier } from "./type-parameter";
 export { splitUnquotedString } from "./utils";

package/dist/lib/models/reflections/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.splitUnquotedString = exports.TypeParameterReflection = exports.SignatureReflection = exports.ReferenceReflection = exports.ProjectReflection = exports.ParameterReflection = exports.ReflectionKind = exports.DeclarationReflection = exports.ContainerReflection = exports.TraverseProperty = exports.ReflectionFlags = exports.ReflectionFlag = exports.Reflection = void 0;
+exports.splitUnquotedString = exports.VarianceModifier = exports.TypeParameterReflection = exports.SignatureReflection = exports.ReferenceReflection = exports.ProjectReflection = exports.ParameterReflection = exports.ReflectionKind = exports.DeclarationReflection = exports.ContainerReflection = exports.TraverseProperty = exports.ReflectionFlags = exports.ReflectionFlag = exports.Reflection = void 0;
 var abstract_1 = require("./abstract");
 Object.defineProperty(exports, "Reflection", { enumerable: true, get: function () { return abstract_1.Reflection; } });
 Object.defineProperty(exports, "ReflectionFlag", { enumerable: true, get: function () { return abstract_1.ReflectionFlag; } });
@@ -22,5 +22,6 @@ var signature_1 = require("./signature");
 Object.defineProperty(exports, "SignatureReflection", { enumerable: true, get: function () { return signature_1.SignatureReflection; } });
 var type_parameter_1 = require("./type-parameter");
 Object.defineProperty(exports, "TypeParameterReflection", { enumerable: true, get: function () { return type_parameter_1.TypeParameterReflection; } });
+Object.defineProperty(exports, "VarianceModifier", { enumerable: true, get: function () { return type_parameter_1.VarianceModifier; } });
 var utils_1 = require("./utils");
 Object.defineProperty(exports, "splitUnquotedString", { enumerable: true, get: function () { return utils_1.splitUnquotedString; } });

package/dist/lib/models/reflections/signature.js

@@ -25,12 +25,12 @@ class SignatureReflection extends abstract_1.Reflection {
                 return;
             }
         }
-        for (const parameter of (_a = this.typeParameters) !== null && _a !== void 0 ? _a : []) {
+        for (const parameter of ((_a = this.typeParameters) === null || _a === void 0 ? void 0 : _a.slice()) || []) {
             if (callback(parameter, abstract_1.TraverseProperty.TypeParameter) === false) {
                 return;
             }
         }
-        for (const parameter of (_b = this.parameters) !== null && _b !== void 0 ? _b : []) {
+        for (const parameter of ((_b = this.parameters) === null || _b === void 0 ? void 0 : _b.slice()) || []) {
             if (callback(parameter, abstract_1.TraverseProperty.Parameters) === false) {
                 return;
             }

package/dist/lib/models/reflections/type-parameter.d.ts

@@ -1,12 +1,20 @@
 import type { Type } from "../types";
 import { Reflection } from "./abstract";
 import type { DeclarationReflection } from "./declaration";
+/**
+ * Modifier flags for type parameters, added in TS 4.7
+ * @enum
+ */
+export declare const VarianceModifier: {
+    readonly in: "in";
+    readonly out: "out";
+    readonly inOut: "in out";
+};
+export declare type VarianceModifier = typeof VarianceModifier[keyof typeof VarianceModifier];
 export declare class TypeParameterReflection extends Reflection {
     parent?: DeclarationReflection;
     type?: Type;
     default?: Type;
-    /**
-     * Create a new TypeParameterReflection instance.
-     */
-    constructor(name: string, constraint?: Type, defaultType?: Type, parent?: Reflection);
+    varianceModifier?: VarianceModifier;
+    constructor(name: string, constraint: Type | undefined, defaultType: Type | undefined, parent: Reflection, varianceModifier: VarianceModifier | undefined);
 }

package/dist/lib/models/reflections/type-parameter.js

@@ -1,16 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeParameterReflection = void 0;
+exports.TypeParameterReflection = exports.VarianceModifier = void 0;
 const abstract_1 = require("./abstract");
 const kind_1 = require("./kind");
+/**
+ * Modifier flags for type parameters, added in TS 4.7
+ * @enum
+ */
+exports.VarianceModifier = {
+    in: "in",
+    out: "out",
+    inOut: "in out",
+};
 class TypeParameterReflection extends abstract_1.Reflection {
-    /**
-     * Create a new TypeParameterReflection instance.
-     */
-    constructor(name, constraint, defaultType, parent) {
+    constructor(name, constraint, defaultType, parent, varianceModifier) {
         super(name, kind_1.ReflectionKind.TypeParameter, parent);
         this.type = constraint;
         this.default = defaultType;
+        this.varianceModifier = varianceModifier;
     }
 }
 exports.TypeParameterReflection = TypeParameterReflection;

package/dist/lib/models/types.d.ts

@@ -14,12 +14,19 @@ export declare abstract class Type {
     /**
      * Return a string representation of this type.
      */
-    abstract toString(): string;
+    toString(): string;
     /**
      * Visit this type, returning the value returned by the visitor.
      */
     visit<T>(visitor: TypeVisitor<T>): T;
     visit<T>(visitor: Partial<TypeVisitor<T>>): T | undefined;
+    stringify(context: TypeContext): string;
+    abstract needsParenthesis(context: TypeContext): boolean;
+    /**
+     * Implementation method for `toString`. `needsParenthesis` will be used to determine if
+     * the returned string should be wrapped in parenthesis.
+     */
+    protected abstract getTypeString(): string;
 }
 export interface TypeKindMap {
     array: ArrayType;
@@ -49,6 +56,37 @@ export declare type TypeVisitor<T = void> = {
 export declare function makeRecursiveVisitor(visitor: Partial<TypeVisitor>): TypeVisitor;
 export declare type TypeKind = keyof TypeKindMap;
 export declare type SomeType = TypeKindMap[keyof TypeKindMap];
+/**
+ * Enumeration that can be used when traversing types to track the location of recursion.
+ * Used by TypeDoc internally to track when to output parenthesis when rendering.
+ * @enum
+ */
+export declare const TypeContext: {
+    readonly none: "none";
+    readonly templateLiteralElement: "templateLiteralElement";
+    readonly arrayElement: "arrayElement";
+    readonly indexedAccessElement: "indexedAccessElement";
+    readonly conditionalCheck: "conditionalCheck";
+    readonly conditionalExtends: "conditionalExtends";
+    readonly conditionalTrue: "conditionalTrue";
+    readonly conditionalFalse: "conditionalFalse";
+    readonly indexedIndex: "indexedIndex";
+    readonly indexedObject: "indexedObject";
+    readonly inferredConstraint: "inferredConstraint";
+    readonly intersectionElement: "intersectionElement";
+    readonly mappedName: "mappedName";
+    readonly mappedParameter: "mappedParameter";
+    readonly mappedTemplate: "mappedTemplate";
+    readonly optionalElement: "optionalElement";
+    readonly predicateTarget: "predicateTarget";
+    readonly queryTypeTarget: "queryTypeTarget";
+    readonly typeOperatorTarget: "typeOperatorTarget";
+    readonly referenceTypeArgument: "referenceTypeArgument";
+    readonly restElement: "restElement";
+    readonly tupleElement: "tupleElement";
+    readonly unionElement: "unionElement";
+};
+export declare type TypeContext = typeof TypeContext[keyof typeof TypeContext];
 /**
  * Represents an array type.
  *
@@ -63,7 +101,8 @@ export declare class ArrayType extends Type {
      */
     elementType: Type;
     constructor(elementType: Type);
-    toString(): string;
+    protected getTypeString(): string;
+    needsParenthesis(): boolean;
 }
 /**
  * Represents a conditional type.
@@ -79,7 +118,8 @@ export declare class ConditionalType extends Type {
     falseType: Type;
     readonly type = "conditional";
     constructor(checkType: Type, extendsType: Type, trueType: Type, falseType: Type);
-    toString(): string;
+    protected getTypeString(): string;
+    needsParenthesis(context: TypeContext): boolean;
 }
 /**
  * Represents an indexed access type.
@@ -89,7 +129,8 @@ export declare class IndexedAccessType extends Type {
     indexType: Type;
     readonly type = "indexedAccess";
     constructor(objectType: Type, indexType: Type);
-    toString(): string;
+    protected getTypeString(): string;
+    needsParenthesis(): boolean;
 }
 /**
  * Represents an inferred type, U in the example below.
@@ -100,9 +141,11 @@ export declare class IndexedAccessType extends Type {
  */
 export declare class InferredType extends Type {
     name: string;
+    constraint?: SomeType | undefined;
     readonly type = "inferred";
-    constructor(name: string);
-    toString(): string;
+    constructor(name: string, constraint?: SomeType | undefined);
+    protected getTypeString(): string;
+    needsParenthesis(context: TypeContext): boolean;
 }
 /**
  * Represents an intersection type.
@@ -115,7 +158,8 @@ export declare class IntersectionType extends Type {
     types: Type[];
     readonly type = "intersection";
     constructor(types: Type[]);
-    toString(): string;
+    protected getTypeString(): string;
+    needsParenthesis(context: TypeContext): boolean;
 }
 /**
  * Represents an intrinsic type like `string` or `boolean`.
@@ -128,7 +172,8 @@ export declare class IntrinsicType extends Type {
     name: string;
     readonly type = "intrinsic";
     constructor(name: string);
-    toString(): string;
+    protected getTypeString(): string;
+    needsParenthesis(): boolean;
 }
 /**
  * Represents a literal type.
@@ -145,13 +190,14 @@ export declare class LiteralType extends Type {
     /**
      * Return a string representation of this type.
      */
-    toString(): string;
+    protected getTypeString(): string;
+    needsParenthesis(): boolean;
 }
 /**
  * Represents a mapped type.
  *
  * ```ts
- * { -readonly [K in keyof U & string as `a${K}`]?: Foo }
+ * { -readonly [K in Parameter as Name]?: Template }
  * ```
  */
 export declare class MappedType extends Type {
@@ -163,7 +209,8 @@ export declare class MappedType extends Type {
     nameType?: Type | undefined;
     readonly type = "mapped";
     constructor(parameter: string, parameterType: Type, templateType: Type, readonlyModifier?: "-" | "+" | undefined, optionalModifier?: "-" | "+" | undefined, nameType?: Type | undefined);
-    toString(): string;
+    protected getTypeString(): string;
+    needsParenthesis(): boolean;
 }
 /**
  * Represents an optional type
@@ -176,7 +223,8 @@ export declare class OptionalType extends Type {
     readonly type = "optional";
     elementType: Type;
     constructor(elementType: Type);
-    toString(): string;
+    protected getTypeString(): string;
+    needsParenthesis(): boolean;
 }
 /**
  * Represents a type predicate.
@@ -210,7 +258,8 @@ export declare class PredicateType extends Type {
     /**
      * Return a string representation of this type.
      */
-    toString(): string;
+    protected getTypeString(): string;
+    needsParenthesis(): boolean;
 }
 /**
  * Represents a type that is constructed by querying the type of a reflection.
@@ -223,7 +272,14 @@ export declare class QueryType extends Type {
     readonly queryType: ReferenceType;
     readonly type = "query";
     constructor(reference: ReferenceType);
-    toString(): string;
+    protected getTypeString(): string;
+    /**
+     * @privateRemarks
+     * An argument could be made that this ought to return true for indexedObject
+     * since precedence is different than on the value side... if someone really cares
+     * they can easily use a custom theme to change this.
+     */
+    needsParenthesis(): boolean;
 }
 /**
  * Represents a type that refers to another reflection like a class, interface or enum.
@@ -274,7 +330,8 @@ export declare class ReferenceType extends Type {
     static createSymbolReference(symbol: ts.Symbol, context: Context, name?: string): ReferenceType;
     /** @internal this is used for type parameters, which don't actually point to something */
     static createBrokenReference(name: string, project: ProjectReflection): ReferenceType;
-    toString(): string;
+    protected getTypeString(): string;
+    needsParenthesis(): boolean;
 }
 /**
  * Represents a type which has it's own reflection like literal types.
@@ -290,7 +347,8 @@ export declare class ReflectionType extends Type {
     readonly type = "reflection";
     declaration: DeclarationReflection;
     constructor(declaration: DeclarationReflection);
-    toString(): "Function" | "Object";
+    protected getTypeString(): "Function" | "Object";
+    needsParenthesis(): boolean;
 }
 /**
  * Represents a rest type
@@ -303,7 +361,8 @@ export declare class RestType extends Type {
     elementType: Type;
     readonly type = "rest";
     constructor(elementType: Type);
-    toString(): string;
+    protected getTypeString(): string;
+    needsParenthesis(): boolean;
 }
 /**
  * TS 4.1 template literal types
@@ -316,7 +375,8 @@ export declare class TemplateLiteralType extends Type {
     tail: [Type, string][];
     readonly type = "template-literal";
     constructor(head: string, tail: [Type, string][]);
-    toString(): string;
+    protected getTypeString(): string;
+    needsParenthesis(): boolean;
 }
 /**
  * Represents a tuple type.
@@ -332,7 +392,8 @@ export declare class TupleType extends Type {
      */
     elements: Type[];
     constructor(elements: Type[]);
-    toString(): string;
+    protected getTypeString(): string;
+    needsParenthesis(): boolean;
 }
 /**
  * Represents a named member of a tuple type.
@@ -350,7 +411,8 @@ export declare class NamedTupleMember extends Type {
     /**
      * Return a string representation of this type.
      */
-    toString(): string;
+    protected getTypeString(): string;
+    needsParenthesis(): boolean;
 }
 /**
  * Represents a type operator type.
@@ -365,7 +427,8 @@ export declare class TypeOperatorType extends Type {
     operator: "keyof" | "unique" | "readonly";
     readonly type = "typeOperator";
     constructor(target: Type, operator: "keyof" | "unique" | "readonly");
-    toString(): string;
+    protected getTypeString(): string;
+    needsParenthesis(context: TypeContext): boolean;
 }
 /**
  * Represents an union type.
@@ -378,7 +441,8 @@ export declare class UnionType extends Type {
     types: SomeType[];
     readonly type = "union";
     constructor(types: SomeType[]);
-    toString(): string;
+    protected getTypeString(): string;
+    needsParenthesis(context: TypeContext): boolean;
     private normalize;
 }
 /**
@@ -391,5 +455,10 @@ export declare class UnknownType extends Type {
      */
     name: string;
     constructor(name: string);
-    toString(): string;
+    protected getTypeString(): string;
+    /**
+     * Always returns true if not at the root level, we have no idea what's in here, so wrap it in parenthesis
+     * to be extra safe.
+     */
+    needsParenthesis(context: TypeContext): boolean;
 }