typedoc 0.28.1 → 0.28.3

package/dist/lib/models/types.js

@@ -1,7 +1,41 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
 import { ReflectionSymbolId } from "./ReflectionSymbolId.js";
 import { ReflectionKind } from "./kind.js";
 import { Comment } from "./Comment.js";
-import { i18n, joinArray } from "#utils";
+import { i18n, joinArray, NonEnumerable } from "#utils";
 /**
  * Base class of all type definitions.
  * @category Types
@@ -658,227 +692,241 @@ export class QueryType extends Type {
  * ```
  * @category Types
  */
-export class ReferenceType extends Type {
-    type = "reference";
-    /**
-     * The name of the referenced type.
-     *
-     * If the symbol cannot be found because it's not part of the documentation this
-     * can be used to represent the type.
-     */
-    name;
-    /**
-     * The type arguments of this reference.
-     */
-    typeArguments;
-    /**
-     * The resolved reflection.
-     */
-    get reflection() {
-        if (typeof this._target === "number") {
-            return this._project?.getReflectionById(this._target);
-        }
-        const resolvePotential = this._project?.getReflectionsFromSymbolId(this._target);
-        if (!resolvePotential?.length) {
-            return;
-        }
-        const kind = this.preferValues
-            ? ReflectionKind.ValueReferenceTarget
-            : ReflectionKind.TypeReferenceTarget;
-        const resolved = resolvePotential.find((refl) => refl.kindOf(kind)) ||
-            resolvePotential.find((refl) => refl.kindOf(~kind));
-        // Do not mark the type as resolved at this point so that if it
-        // points to a member which is removed (e.g. by typedoc-plugin-zod)
-        // and then replaced it still ends up pointing at the right reflection.
-        // We will lock type reference resolution when serializing to JSON.
-        // this._target = resolved.id;
-        return resolved;
-    }
-    /**
-     * Sometimes a few properties are more important than the rest
-     * of the properties within a type. This occurs most often with
-     * object parameters, where users want to specify `@param foo.bar`
-     * to highlight something about the `bar` property.
-     *
-     * Does NOT support nested properties.
-     */
-    highlightedProperties;
-    /**
-     * If not resolved, the symbol id of the reflection, otherwise undefined.
-     */
-    get symbolId() {
-        if (!this.reflection && typeof this._target === "object") {
-            return this._target;
+let ReferenceType = (() => {
+    let _classSuper = Type;
+    let __project_decorators;
+    let __project_initializers = [];
+    let __project_extraInitializers = [];
+    return class ReferenceType extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __project_decorators = [NonEnumerable];
+            __esDecorate(null, null, __project_decorators, { kind: "field", name: "_project", static: false, private: false, access: { has: obj => "_project" in obj, get: obj => obj._project, set: (obj, value) => { obj._project = value; } }, metadata: _metadata }, __project_initializers, __project_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
-    }
-    /**
-     * Checks if this type is a reference type because it uses a name, but is intentionally not pointing
-     * to a reflection. This happens for type parameters and when representing a mapped type.
-     */
-    isIntentionallyBroken() {
-        if (typeof this._target === "object" &&
-            this._project?.symbolIdHasBeenRemoved(this._target)) {
-            return true;
-        }
-        return this._target === -1 || this.refersToTypeParameter;
-    }
-    /**
-     * Convert this reference type to a declaration reference used for resolution of external types.
-     */
-    toDeclarationReference() {
-        return {
-            resolutionStart: "global",
-            moduleSource: this.package,
-            symbolReference: {
-                path: this.qualifiedName
-                    .split(".")
-                    .map((p) => ({ path: p, navigation: "." })),
-            },
-        };
-    }
-    /**
-     * The fully qualified name of the referenced type, relative to the file it is defined in.
-     * This will usually be the same as `name`, unless namespaces are used.
-     */
-    qualifiedName;
-    /**
-     * The package that this type is referencing.
-     */
-    package;
-    /**
-     * If this reference type refers to a reflection defined by a project not being rendered,
-     * points to the url that this type should be linked to.
-     */
-    externalUrl;
-    /**
-     * If set, no warnings about something not being exported should be created
-     * since this may be referring to a type created with `infer X` which will not
-     * be registered on the project.
-     */
-    refersToTypeParameter = false;
-    /**
-     * If set, will prefer reflections with {@link ReflectionKind | ReflectionKinds} which represent
-     * values rather than those which represent types.
-     */
-    preferValues = false;
-    _target;
-    _project;
-    constructor(name, target, project, qualifiedName) {
-        super();
-        this.name = name;
-        if (typeof target === "number") {
-            this._target = target;
+        type = "reference";
+        /**
+         * The name of the referenced type.
+         *
+         * If the symbol cannot be found because it's not part of the documentation this
+         * can be used to represent the type.
+         */
+        name;
+        /**
+         * The type arguments of this reference.
+         */
+        typeArguments;
+        /**
+         * The resolved reflection.
+         */
+        get reflection() {
+            if (typeof this._target === "number") {
+                return this._project?.getReflectionById(this._target);
+            }
+            const resolvePotential = this._project?.getReflectionsFromSymbolId(this._target);
+            if (!resolvePotential?.length) {
+                return;
+            }
+            const kind = this.preferValues
+                ? ReflectionKind.ValueReferenceTarget
+                : ReflectionKind.TypeReferenceTarget;
+            const resolved = resolvePotential.find((refl) => refl.kindOf(kind)) ||
+                resolvePotential.find((refl) => refl.kindOf(~kind));
+            // Do not mark the type as resolved at this point so that if it
+            // points to a member which is removed (e.g. by typedoc-plugin-zod)
+            // and then replaced it still ends up pointing at the right reflection.
+            // We will lock type reference resolution when serializing to JSON.
+            // this._target = resolved.id;
+            return resolved;
         }
-        else {
-            this._target = "variant" in target ? target.id : target;
+        /**
+         * Sometimes a few properties are more important than the rest
+         * of the properties within a type. This occurs most often with
+         * object parameters, where users want to specify `@param foo.bar`
+         * to highlight something about the `bar` property.
+         *
+         * Does NOT support nested properties.
+         */
+        highlightedProperties;
+        /**
+         * If not resolved, the symbol id of the reflection, otherwise undefined.
+         */
+        get symbolId() {
+            if (!this.reflection && typeof this._target === "object") {
+                return this._target;
+            }
         }
-        this._project = project;
-        this.qualifiedName = qualifiedName;
-    }
-    static createUnresolvedReference(name, target, project, qualifiedName) {
-        return new ReferenceType(name, target, project, qualifiedName);
-    }
-    static createResolvedReference(name, target, project) {
-        return new ReferenceType(name, target, project, name);
-    }
-    /**
-     * This is used for type parameters, which don't actually point to something,
-     * and also for temporary references which will be cleaned up with real references
-     * later during conversion.
-     * @internal
-     */
-    static createBrokenReference(name, project) {
-        return new ReferenceType(name, -1, project, name);
-    }
-    getTypeString() {
-        const name = this.reflection ? this.reflection.name : this.name;
-        let typeArgs = "";
-        if (this.typeArguments && this.typeArguments.length > 0) {
-            typeArgs += "<";
-            typeArgs += this.typeArguments
-                .map((arg) => arg.stringify(TypeContext.referenceTypeArgument))
-                .join(", ");
-            typeArgs += ">";
+        /**
+         * Checks if this type is a reference type because it uses a name, but is intentionally not pointing
+         * to a reflection. This happens for type parameters and when representing a mapped type.
+         */
+        isIntentionallyBroken() {
+            if (typeof this._target === "object" &&
+                this._project?.symbolIdHasBeenRemoved(this._target)) {
+                return true;
+            }
+            return this._target === -1 || this.refersToTypeParameter;
         }
-        return name + typeArgs;
-    }
-    needsParenthesis() {
-        return false;
-    }
-    toObject(serializer) {
-        let target;
-        if (typeof this._target === "number") {
-            target = this._target;
+        /**
+         * Convert this reference type to a declaration reference used for resolution of external types.
+         */
+        toDeclarationReference() {
+            return {
+                resolutionStart: "global",
+                moduleSource: this.package,
+                symbolReference: {
+                    path: this.qualifiedName
+                        .split(".")
+                        .map((p) => ({ path: p, navigation: "." })),
+                },
+            };
         }
-        else if (this._project?.symbolIdHasBeenRemoved(this._target)) {
-            target = -1;
+        /**
+         * The fully qualified name of the referenced type, relative to the file it is defined in.
+         * This will usually be the same as `name`, unless namespaces are used.
+         */
+        qualifiedName;
+        /**
+         * The package that this type is referencing.
+         */
+        package;
+        /**
+         * If this reference type refers to a reflection defined by a project not being rendered,
+         * points to the url that this type should be linked to.
+         */
+        externalUrl;
+        /**
+         * If set, no warnings about something not being exported should be created
+         * since this may be referring to a type created with `infer X` which will not
+         * be registered on the project.
+         */
+        refersToTypeParameter = false;
+        /**
+         * If set, will prefer reflections with {@link ReflectionKind | ReflectionKinds} which represent
+         * values rather than those which represent types.
+         */
+        preferValues = false;
+        _target;
+        _project = __runInitializers(this, __project_initializers, void 0);
+        constructor(name, target, project, qualifiedName) {
+            super();
+            __runInitializers(this, __project_extraInitializers);
+            this.name = name;
+            if (typeof target === "number") {
+                this._target = target;
+            }
+            else {
+                this._target = "variant" in target ? target.id : target;
+            }
+            this._project = project;
+            this.qualifiedName = qualifiedName;
         }
-        else if (this.reflection) {
-            target = this.reflection.id;
+        static createUnresolvedReference(name, target, project, qualifiedName) {
+            return new ReferenceType(name, target, project, qualifiedName);
         }
-        else {
-            target = this._target.toObject();
+        static createResolvedReference(name, target, project) {
+            return new ReferenceType(name, target, project, name);
         }
-        const result = {
-            type: this.type,
-            target,
-            typeArguments: serializer.toObjectsOptional(this.typeArguments),
-            name: this.name,
-            package: this.package,
-            externalUrl: this.externalUrl,
-        };
-        if (this.name !== this.qualifiedName) {
-            result.qualifiedName = this.qualifiedName;
+        /**
+         * This is used for type parameters, which don't actually point to something,
+         * and also for temporary references which will be cleaned up with real references
+         * later during conversion.
+         * @internal
+         */
+        static createBrokenReference(name, project) {
+            return new ReferenceType(name, -1, project, name);
         }
-        if (this.refersToTypeParameter) {
-            result.refersToTypeParameter = true;
+        getTypeString() {
+            const name = this.reflection ? this.reflection.name : this.name;
+            let typeArgs = "";
+            if (this.typeArguments && this.typeArguments.length > 0) {
+                typeArgs += "<";
+                typeArgs += this.typeArguments
+                    .map((arg) => arg.stringify(TypeContext.referenceTypeArgument))
+                    .join(", ");
+                typeArgs += ">";
+            }
+            return name + typeArgs;
         }
-        if (typeof target !== "number" && this.preferValues) {
-            result.preferValues = true;
+        needsParenthesis() {
+            return false;
         }
-        if (this.highlightedProperties) {
-            result.highlightedProperties = Object.fromEntries(Array.from(this.highlightedProperties.entries(), ([key, parts]) => {
-                return [
-                    key,
-                    Comment.serializeDisplayParts(parts),
-                ];
-            }));
+        toObject(serializer) {
+            let target;
+            if (typeof this._target === "number") {
+                target = this._target;
+            }
+            else if (this._project?.symbolIdHasBeenRemoved(this._target)) {
+                target = -1;
+            }
+            else if (this.reflection) {
+                target = this.reflection.id;
+            }
+            else {
+                target = this._target.toObject();
+            }
+            const result = {
+                type: this.type,
+                target,
+                typeArguments: serializer.toObjectsOptional(this.typeArguments),
+                name: this.name,
+                package: this.package,
+                externalUrl: this.externalUrl,
+            };
+            if (this.name !== this.qualifiedName) {
+                result.qualifiedName = this.qualifiedName;
+            }
+            if (this.refersToTypeParameter) {
+                result.refersToTypeParameter = true;
+            }
+            if (typeof target !== "number" && this.preferValues) {
+                result.preferValues = true;
+            }
+            if (this.highlightedProperties) {
+                result.highlightedProperties = Object.fromEntries(Array.from(this.highlightedProperties.entries(), ([key, parts]) => {
+                    return [
+                        key,
+                        Comment.serializeDisplayParts(parts),
+                    ];
+                }));
+            }
+            return result;
         }
-        return result;
-    }
-    fromObject(de, obj) {
-        this.typeArguments = de.reviveMany(obj.typeArguments, (t) => de.constructType(t));
-        if (typeof obj.target === "number" && obj.target !== -1) {
-            de.defer((project) => {
-                const target = project.getReflectionById(de.oldIdToNewId[obj.target] ?? -1);
-                if (target) {
-                    this._project = project;
-                    this._target = target.id;
-                }
-                else {
-                    de.logger.warn(i18n.serialized_project_referenced_0_not_part_of_project(JSON.stringify(obj.target)));
+        fromObject(de, obj) {
+            this.typeArguments = de.reviveMany(obj.typeArguments, (t) => de.constructType(t));
+            if (typeof obj.target === "number" && obj.target !== -1) {
+                de.defer((project) => {
+                    const target = project.getReflectionById(de.oldIdToNewId[obj.target] ?? -1);
+                    if (target) {
+                        this._project = project;
+                        this._target = target.id;
+                    }
+                    else {
+                        de.logger.warn(i18n.serialized_project_referenced_0_not_part_of_project(JSON.stringify(obj.target)));
+                    }
+                });
+            }
+            else if (obj.target === -1) {
+                this._target = -1;
+            }
+            else {
+                this._project = de.project;
+                this._target = new ReflectionSymbolId(obj.target);
+            }
+            this.qualifiedName = obj.qualifiedName ?? obj.name;
+            this.package = obj.package;
+            this.refersToTypeParameter = !!obj.refersToTypeParameter;
+            this.preferValues = !!obj.preferValues;
+            if (obj.highlightedProperties) {
+                this.highlightedProperties = new Map();
+                for (const [key, parts] of Object.entries(obj.highlightedProperties)) {
+                    this.highlightedProperties.set(key, Comment.deserializeDisplayParts(de, parts));
                 }
-            });
-        }
-        else if (obj.target === -1) {
-            this._target = -1;
-        }
-        else {
-            this._project = de.project;
-            this._target = new ReflectionSymbolId(obj.target);
-        }
-        this.qualifiedName = obj.qualifiedName ?? obj.name;
-        this.package = obj.package;
-        this.refersToTypeParameter = !!obj.refersToTypeParameter;
-        this.preferValues = !!obj.preferValues;
-        if (obj.highlightedProperties) {
-            this.highlightedProperties = new Map();
-            for (const [key, parts] of Object.entries(obj.highlightedProperties)) {
-                this.highlightedProperties.set(key, Comment.deserializeDisplayParts(de, parts));
             }
         }
-    }
-}
+    };
+})();
+export { ReferenceType };
 /**
  * Represents a type which has it's own reflection like literal types.
  * This type will likely go away at some point and be replaced by a dedicated
@@ -899,17 +947,17 @@ export class ReflectionType extends Type {
     }
     getTypeString() {
         const parts = [];
-        const sigs = this.declaration.getAllSignatures();
+        const sigs = this.declaration.getNonIndexSignatures();
         for (const sig of sigs) {
             parts.push(sigStr(sig, ": "));
         }
-        if (this.declaration.children) {
-            for (const p of this.declaration.children) {
-                parts.push(`${p.name}${propertySep(p)} ${typeStr(p.type)}`);
-            }
-            return `{ ${parts.join("; ")} }`;
+        for (const p of this.declaration.children || []) {
+            parts.push(`${p.name}${propertySep(p)} ${typeStr(p.type)}`);
+        }
+        for (const s of this.declaration.indexSignatures || []) {
+            parts.push(sigStr(s, ": ", "[]"));
         }
-        if (sigs.length === 1) {
+        if (sigs.length === 1 && parts.length === 1) {
             return sigStr(sigs[0], " => ");
         }
         if (parts.length === 0) {
@@ -1238,7 +1286,7 @@ function propertySep(refl) {
 function typeStr(type) {
     return type?.toString() ?? "any";
 }
-function sigStr(sig, sep) {
+function sigStr(sig, sep, brackets = "()") {
     const params = joinArray(sig.parameters, ", ", (p) => `${p.name}${propertySep(p)} ${typeStr(p.type)}`);
-    return `(${params})${sep}${typeStr(sig.type)}`;
+    return `${brackets[0]}${params}${brackets[1]}${sep}${typeStr(sig.type)}`;
 }

package/dist/lib/output/renderer.d.ts

@@ -115,7 +115,7 @@ export interface RendererEvents {
  *    an instance of {@link IndexEvent}.
  *
  * @summary Writes HTML output from TypeDoc's models
- * @group Common
+ * @group None
  */
 export declare class Renderer extends AbstractComponent<Application, RendererEvents> {
     private routers;
@@ -189,12 +189,16 @@ export declare class Renderer extends AbstractComponent<Application, RendererEve
      * @param theme
      */
     defineTheme(name: string, theme: new (renderer: Renderer) => Theme): void;
+    /** @internal intended for test usage only */
+    removeTheme(name: string): void;
     /**
      * Define a new router that can be used to determine the output structure.
      * @param name
      * @param router
      */
     defineRouter(name: string, router: new (app: Application) => Router): void;
+    /** @internal intended for test usage only */
+    removeRouter(name: string): void;
     /**
      * Render the given project reflection to the specified output directory.
      *

package/dist/lib/output/renderer.js

@@ -79,7 +79,7 @@ import { CategoryRouter, GroupRouter, KindDirRouter, KindRouter, StructureDirRou
  *    an instance of {@link IndexEvent}.
  *
  * @summary Writes HTML output from TypeDoc's models
- * @group Common
+ * @group None
  */
 let Renderer = (() => {
     let _classSuper = AbstractComponent;
@@ -231,6 +231,10 @@ let Renderer = (() => {
             }
             this.themes.set(name, theme);
         }
+        /** @internal intended for test usage only */
+        removeTheme(name) {
+            this.themes.delete(name);
+        }
         /**
          * Define a new router that can be used to determine the output structure.
          * @param name
@@ -242,6 +246,10 @@ let Renderer = (() => {
             }
             this.routers.set(name, router);
         }
+        /** @internal intended for test usage only */
+        removeRouter(name) {
+            this.routers.delete(name);
+        }
         /**
          * Render the given project reflection to the specified output directory.
          *

package/dist/lib/output/router.js

@@ -166,6 +166,16 @@ let BaseRouter = (() => {
                 // an own document.
                 from = from.parent;
             }
+            let toPage = to;
+            while (!this.hasOwnDocument(toPage)) {
+                toPage = toPage.parent;
+            }
+            // We unfortunately have to special case ProjectReflection as it is
+            // the model used twice for rendering. This should be changed in a
+            // future version to remove this hackery.
+            if (from === toPage && !(to instanceof ProjectReflection)) {
+                return to === toPage ? "" : `#${this.getAnchor(to)}`;
+            }
             const fromUrl = this.getFullUrl(from);
             const toUrl = this.getFullUrl(to);
             let equal = true;
@@ -181,12 +191,14 @@ let BaseRouter = (() => {
                     }
                 }
             }
-            if (equal && !(to instanceof ProjectReflection)) {
-                if (fromUrl === toUrl) {
-                    return "";
-                }
-                return `#${this.getAnchor(to)}`;
+            // If equal is still set, we're going to a page either in
+            // the same directory as this page, or a lower directory,
+            // don't bother going up directories just to come back down.
+            if (equal) {
+                return toUrl.substring(start);
             }
+            // Otherwise, go up until we get to the common directory
+            // and then back down to the target path.
             return "../".repeat(slashes) + toUrl.substring(start);
         }
         baseRelativeUrl(from, target) {

package/dist/lib/output/themes/MarkedPlugin.js

@@ -177,7 +177,7 @@ let MarkedPlugin = (() => {
                                     let url;
                                     let kindClass;
                                     if (typeof part.target === "string") {
-                                        url = part.target;
+                                        url = part.target === "#" ? undefined : part.target;
                                     }
                                     else if ("id" in part.target) {
                                         // No point in trying to resolve a ReflectionSymbolId at this point, we've already
@@ -204,6 +204,11 @@ let MarkedPlugin = (() => {
                                                     .reflection_0_links_to_1_with_text_2_but_resolved_to_3(page.model.getFriendlyFullName(), part.target.getFriendlyFullName(), part.text, target.getFriendlyFullName()));
                                             }
                                         }
+                                        // If the url goes to this page, render as `#`
+                                        // to go to the top of the page.
+                                        if (url == "") {
+                                            url = "#";
+                                        }
                                     }
                                     if (useHtml) {
                                         const text = part.tag === "@linkcode" ? `<code>${part.text}</code>` : part.text;