typedoc 0.28.2 → 0.28.4

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;
-        }
-    }
-    /**
-     * 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;
+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 });
         }
-        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

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

@@ -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;

package/dist/lib/output/themes/default/partials/icon.d.ts

@@ -7,6 +7,7 @@ export interface Icons extends Record<ReflectionKind, () => JSX.Element> {
     checkbox(): JSX.Element;
     menu(): JSX.Element;
     search(): JSX.Element;
+    /** @deprecated */
     chevronSmall(): JSX.Element;
     anchor(): JSX.Element;
     folder(): JSX.Element;

package/dist/lib/output/themes/default/partials/index.js

@@ -18,7 +18,7 @@ export function index(context, props) {
             JSX.createElement("section", { class: "tsd-panel tsd-index-panel" },
                 JSX.createElement("details", { class: "tsd-index-content tsd-accordion", open: true },
                     JSX.createElement("summary", { class: "tsd-accordion-summary tsd-index-summary" },
-                        context.icons.chevronSmall(),
+                        context.icons.chevronDown(),
                         JSX.createElement("h5", { class: "tsd-index-heading uppercase" }, i18n.theme_index())),
                     JSX.createElement("div", { class: "tsd-accordion-details" }, sections.map(s => renderSection(context, s))))))));
 }

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

@@ -31,17 +31,14 @@ export function getKindClass(refl) {
  * @return The original string containing ``<wbr>`` tags where possible.
  */
 export function wbr(str) {
-    // TODO surely there is a better way to do this, but I'm tired.
-    const ret = [];
-    const re = /[\s\S]*?(?:[^_-][_-](?=[^_-])|[^A-Z](?=[A-Z][^A-Z]))/g;
-    let match;
-    let i = 0;
-    while ((match = re.exec(str))) {
-        ret.push(match[0], JSX.createElement("wbr", null));
-        i += match[0].length;
-    }
-    ret.push(str.slice(i));
-    return ret;
+    // Keep this in sync with the same helper in Navigation.ts
+    // We use lookahead/lookbehind to indicate where the string should
+    // be split without consuming a character.
+    // (?<=[^A-Z])(?=[A-Z]) -- regular camel cased text
+    // (?<=[A-Z])(?=[A-Z][a-z]) -- acronym
+    // (?<=[_-])(?=[^_-]) -- snake
+    const parts = str.split(/(?<=[^A-Z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|(?<=[_-])(?=[^_-])/);
+    return parts.flatMap(p => [p, JSX.createElement("wbr", null)]).slice(0, -1);
 }
 export function join(joiner, list, cb) {
     const result = [];

package/dist/lib/utils/entry-point.js

@@ -231,9 +231,6 @@ function expandGlobs(globs, exclude, logger) {
             // #2918 - do not pass entry through nicePath here in case it contains
             // windows path separators which should cause additional warnings.
             logger.warn(i18n.glob_0_did_not_match_any_files(entry));
-            if (entry.includes("\\") && !entry.includes("/")) {
-                logger.info(i18n.glob_should_use_posix_slash());
-            }
         }
         else if (filtered.length === 0) {
             logger.warn(i18n.entry_point_0_did_not_match_any_files_after_exclude(entry));

package/dist/lib/utils/highlighter.js

@@ -1,7 +1,8 @@
 import * as shiki from "@gerrit0/mini-shiki";
 import { JSX, unique } from "#utils";
 import assert from "assert";
-const aliases = new Map();
+const tsAliases = [["mts", "typescript"], ["cts", "typescript"]];
+const aliases = new Map(tsAliases);
 for (const lang of shiki.bundledLanguagesInfo) {
     for (const alias of lang.aliases || []) {
         aliases.set(alias, lang.id);
@@ -131,7 +132,7 @@ export function getSupportedThemes() {
     return supportedThemes;
 }
 export function isLoadedLanguage(lang) {
-    return (plaintextLanguages.includes(lang) || ignoredLanguages?.includes(lang) || highlighter?.supports(lang) || false);
+    return (isSupportedLanguage(lang) || highlighter?.supports(lang) || false);
 }
 export function highlight(code, lang) {
     assert(highlighter, "Tried to highlight with an uninitialized highlighter");

package/dist/lib/utils/options/declaration.js

@@ -199,7 +199,17 @@ const converters = {
         return resolved;
     },
     [ParameterType.GlobArray](value, option, configPath) {
-        const toGlobString = (v) => createGlobString(configPath, String(v));
+        const toGlobString = (v) => {
+            const s = String(v);
+            // If the string tries to escape a character which isn't a special
+            // glob character, the user probably provided a Windows style path
+            // by accident due to shell completion, tell them to either remove
+            // the useless escape or switch to Unix path separators.
+            if (/\\[^?*()[\]\\{}]/.test(s)) {
+                throw new Error(i18n.glob_0_should_use_posix_slash(s));
+            }
+            return createGlobString(configPath, s);
+        };
         const globs = Array.isArray(value) ? value.map(toGlobString) : [toGlobString(value)];
         option.validate?.(globs);
         return globs;

package/dist/lib/utils/options/readers/arguments.d.ts

@@ -8,6 +8,8 @@ export declare class ArgumentsReader implements OptionsReader {
     readonly order: number;
     readonly supportsPackages = false;
     private args;
+    private skipErrorReporting;
     constructor(priority: number, args?: string[]);
+    ignoreErrors(): this;
     read(container: Options, logger: Logger): void;
 }