@depup/typedoc 0.28.17-depup.0

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

@@ -0,0 +1,367 @@
+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 { Theme } from "../../theme.js";
+import { ReferenceReflection, ReflectionCategory, ReflectionGroup, ReflectionKind, } from "../../../models/index.js";
+import { DefaultThemeRenderContext } from "./DefaultThemeRenderContext.js";
+import { getIcons } from "./partials/icon.js";
+import { filterMap, JSX } from "#utils";
+import { classNames, getDisplayName, toStyleClass } from "../lib.js";
+import { PageKind } from "../../router.js";
+import { loadHighlighter, Option } from "#node-utils";
+let DefaultTheme = (() => {
+    let _classSuper = Theme;
+    let _lightTheme_decorators;
+    let _lightTheme_initializers = [];
+    let _lightTheme_extraInitializers = [];
+    let _darkTheme_decorators;
+    let _darkTheme_initializers = [];
+    let _darkTheme_extraInitializers = [];
+    let _highlightLanguages_decorators;
+    let _highlightLanguages_initializers = [];
+    let _highlightLanguages_extraInitializers = [];
+    let _ignoredHighlightLanguages_decorators;
+    let _ignoredHighlightLanguages_initializers = [];
+    let _ignoredHighlightLanguages_extraInitializers = [];
+    return class DefaultTheme extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _lightTheme_decorators = [Option("lightHighlightTheme")];
+            _darkTheme_decorators = [Option("darkHighlightTheme")];
+            _highlightLanguages_decorators = [Option("highlightLanguages")];
+            _ignoredHighlightLanguages_decorators = [Option("ignoredHighlightLanguages")];
+            __esDecorate(this, null, _lightTheme_decorators, { kind: "accessor", name: "lightTheme", static: false, private: false, access: { has: obj => "lightTheme" in obj, get: obj => obj.lightTheme, set: (obj, value) => { obj.lightTheme = value; } }, metadata: _metadata }, _lightTheme_initializers, _lightTheme_extraInitializers);
+            __esDecorate(this, null, _darkTheme_decorators, { kind: "accessor", name: "darkTheme", static: false, private: false, access: { has: obj => "darkTheme" in obj, get: obj => obj.darkTheme, set: (obj, value) => { obj.darkTheme = value; } }, metadata: _metadata }, _darkTheme_initializers, _darkTheme_extraInitializers);
+            __esDecorate(this, null, _highlightLanguages_decorators, { kind: "accessor", name: "highlightLanguages", static: false, private: false, access: { has: obj => "highlightLanguages" in obj, get: obj => obj.highlightLanguages, set: (obj, value) => { obj.highlightLanguages = value; } }, metadata: _metadata }, _highlightLanguages_initializers, _highlightLanguages_extraInitializers);
+            __esDecorate(this, null, _ignoredHighlightLanguages_decorators, { kind: "accessor", name: "ignoredHighlightLanguages", static: false, private: false, access: { has: obj => "ignoredHighlightLanguages" in obj, get: obj => obj.ignoredHighlightLanguages, set: (obj, value) => { obj.ignoredHighlightLanguages = value; } }, metadata: _metadata }, _ignoredHighlightLanguages_initializers, _ignoredHighlightLanguages_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        // Note: This will always contain lowercased names to avoid issues with
+        // case-insensitive file systems.
+        usedFileNames = new Set();
+        /** @internal */
+        markedPlugin;
+        router;
+        /**
+         * The icons which will actually be rendered. The source of truth lives on the theme, and
+         * the {@link DefaultThemeRenderContext.icons} member will produce references to these.
+         *
+         * These icons will be written twice. Once to an `icons.svg` file in the assets directory
+         * which will be referenced by icons on the context, and once to an `icons.js` file so that
+         * references to the icons can be dynamically embedded within the page for use by the search
+         * dropdown and when loading the page on `file://` urls.
+         *
+         * Custom themes may overwrite this entire object or individual properties on it to customize
+         * the icons used within the page, however TypeDoc currently assumes that all icons are svg
+         * elements, so custom themes must also use svg elements.
+         */
+        icons;
+        ContextClass = DefaultThemeRenderContext;
+        #lightTheme_accessor_storage = __runInitializers(this, _lightTheme_initializers, void 0);
+        get lightTheme() { return this.#lightTheme_accessor_storage; }
+        set lightTheme(value) { this.#lightTheme_accessor_storage = value; }
+        #darkTheme_accessor_storage = (__runInitializers(this, _lightTheme_extraInitializers), __runInitializers(this, _darkTheme_initializers, void 0));
+        get darkTheme() { return this.#darkTheme_accessor_storage; }
+        set darkTheme(value) { this.#darkTheme_accessor_storage = value; }
+        #highlightLanguages_accessor_storage = (__runInitializers(this, _darkTheme_extraInitializers), __runInitializers(this, _highlightLanguages_initializers, void 0));
+        get highlightLanguages() { return this.#highlightLanguages_accessor_storage; }
+        set highlightLanguages(value) { this.#highlightLanguages_accessor_storage = value; }
+        #ignoredHighlightLanguages_accessor_storage = (__runInitializers(this, _highlightLanguages_extraInitializers), __runInitializers(this, _ignoredHighlightLanguages_initializers, void 0));
+        get ignoredHighlightLanguages() { return this.#ignoredHighlightLanguages_accessor_storage; }
+        set ignoredHighlightLanguages(value) { this.#ignoredHighlightLanguages_accessor_storage = value; }
+        getRenderContext(pageEvent) {
+            return new this.ContextClass(this.router, this, pageEvent, this.application.options);
+        }
+        documentTemplate = (__runInitializers(this, _ignoredHighlightLanguages_extraInitializers), (pageEvent) => {
+            return this.getRenderContext(pageEvent).documentTemplate(pageEvent);
+        });
+        reflectionTemplate = (pageEvent) => {
+            return this.getRenderContext(pageEvent).reflectionTemplate(pageEvent);
+        };
+        indexTemplate = (pageEvent) => {
+            return this.getRenderContext(pageEvent).indexTemplate(pageEvent);
+        };
+        hierarchyTemplate = (pageEvent) => {
+            return this.getRenderContext(pageEvent).hierarchyTemplate(pageEvent);
+        };
+        defaultLayoutTemplate = (pageEvent, template) => {
+            return this.getRenderContext(pageEvent).defaultLayout(template, pageEvent);
+        };
+        getReflectionClasses(reflection) {
+            const filters = this.application.options.getValue("visibilityFilters");
+            return getReflectionClasses(reflection, filters);
+        }
+        /**
+         * This is used so that themes may define multiple icons for modified icons (e.g. method, and inherited method)
+         */
+        getReflectionIcon(reflection) {
+            return reflection.kind;
+        }
+        /**
+         * Create a new DefaultTheme instance.
+         *
+         * @param renderer  The renderer this theme is attached to.
+         */
+        constructor(renderer) {
+            super(renderer);
+            this.icons = getIcons();
+            this.markedPlugin = renderer.markedPlugin;
+            this.router = renderer.router;
+        }
+        render(page) {
+            const templateMapping = {
+                [PageKind.Index]: this.indexTemplate,
+                [PageKind.Document]: this.documentTemplate,
+                [PageKind.Hierarchy]: this.hierarchyTemplate,
+                [PageKind.Reflection]: this.reflectionTemplate,
+            };
+            const template = templateMapping[page.pageKind];
+            if (!template) {
+                throw new Error(`TypeDoc's DefaultTheme does not support the page kind ${page.pageKind}`);
+            }
+            if (!page.isReflectionEvent()) {
+                throw new Error(`TypeDoc's DefaultTheme requires that a page model be a reflection when rendering ${page.pageKind}`);
+            }
+            const templateOutput = this.defaultLayoutTemplate(page, template);
+            return "<!DOCTYPE html>" + JSX.renderElement(templateOutput) + "\n";
+        }
+        async preRender(_event) {
+            await loadHighlighter(this.lightTheme, this.darkTheme, 
+            // Checked in option validation
+            this.highlightLanguages, this.ignoredHighlightLanguages);
+        }
+        _navigationCache;
+        /**
+         * If implementing a custom theme, it is recommended to override {@link buildNavigation} instead.
+         */
+        getNavigation(project) {
+            // This is ok because currently TypeDoc wipes out the theme after each render.
+            // Might need to change in the future, but it's fine for now.
+            if (this._navigationCache) {
+                return this._navigationCache;
+            }
+            return (this._navigationCache = this.buildNavigation(project));
+        }
+        buildNavigation(project) {
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const theme = this;
+            const router = this.router;
+            const opts = this.application.options.getValue("navigation");
+            const leaves = this.application.options.getValue("navigationLeaves");
+            return getNavigationElements(project) || [];
+            function toNavigation(element) {
+                if (opts.excludeReferences && element instanceof ReferenceReflection) {
+                    return;
+                }
+                const children = getNavigationElements(element);
+                if (element instanceof ReflectionCategory || element instanceof ReflectionGroup) {
+                    if (!children?.length) {
+                        return;
+                    }
+                    return {
+                        text: element.title,
+                        children,
+                    };
+                }
+                const icon = theme.getReflectionIcon(element) === element.kind
+                    ? undefined
+                    : theme.getReflectionIcon(element);
+                return {
+                    text: getDisplayName(element),
+                    path: router.getFullUrl(element),
+                    kind: element.kind & ReflectionKind.Project ? undefined : element.kind,
+                    class: classNames({ deprecated: element.isDeprecated() }, theme.getReflectionClasses(element)),
+                    children: children?.length ? children : undefined,
+                    icon,
+                };
+            }
+            function getNavigationElements(parent) {
+                if (parent instanceof ReflectionCategory) {
+                    return filterMap(parent.children, toNavigation);
+                }
+                if (parent instanceof ReflectionGroup) {
+                    if (shouldShowCategories(parent.owningReflection, opts) && parent.categories) {
+                        return filterMap(parent.categories, toNavigation);
+                    }
+                    return filterMap(parent.children, toNavigation);
+                }
+                if (leaves.includes(parent.getFullName())) {
+                    return;
+                }
+                if (!parent.kindOf(ReflectionKind.MayContainDocuments)) {
+                    return;
+                }
+                if (parent.isDocument()) {
+                    return filterMap(parent.children, toNavigation);
+                }
+                if (!parent.kindOf(ReflectionKind.SomeModule | ReflectionKind.Project)) {
+                    // Tricky: Non-module children don't show up in the navigation pane,
+                    //   but any documents added by them should.
+                    return filterMap(parent.documents, toNavigation);
+                }
+                if (parent.categories && shouldShowCategories(parent, opts)) {
+                    return filterMapWithNoneCollection(parent.categories);
+                }
+                if (parent.groups && shouldShowGroups(parent, opts)) {
+                    return filterMapWithNoneCollection(parent.groups);
+                }
+                if (opts.includeFolders && parent.childrenIncludingDocuments?.some((child) => child.name.includes("/"))) {
+                    return deriveModuleFolders(parent.childrenIncludingDocuments);
+                }
+                return filterMap(parent.childrenIncludingDocuments, toNavigation);
+            }
+            function filterMapWithNoneCollection(reflection) {
+                const none = reflection.find((x) => x.title.toLocaleLowerCase() === "none");
+                const others = reflection.filter((x) => x.title.toLocaleLowerCase() !== "none");
+                const mappedOthers = filterMap(others, toNavigation);
+                if (none) {
+                    const noneMappedChildren = filterMap(none.children, toNavigation);
+                    return [...noneMappedChildren, ...mappedOthers];
+                }
+                return mappedOthers;
+            }
+            function deriveModuleFolders(children) {
+                const result = [];
+                const resolveOrCreateParents = (path, root = result) => {
+                    if (path.length > 1) {
+                        const inner = root.find((el) => el.text === path[0]);
+                        if (inner) {
+                            inner.children ||= [];
+                            return resolveOrCreateParents(path.slice(1), inner.children);
+                        }
+                        else {
+                            root.push({
+                                text: path[0],
+                                children: [],
+                            });
+                            return resolveOrCreateParents(path.slice(1), root[root.length - 1].children);
+                        }
+                    }
+                    return root;
+                };
+                // Note: This might end up putting a module within another module if we document
+                // both foo/index.ts and foo/bar.ts.
+                for (const child of children.filter((c) => router.hasOwnDocument(c))) {
+                    const nav = toNavigation(child);
+                    if (nav) {
+                        const parts = child.name.split("/");
+                        const collection = resolveOrCreateParents(parts);
+                        nav.text = parts[parts.length - 1];
+                        collection.push(nav);
+                    }
+                }
+                // Now merge single-possible-paths together so we don't have folders in our navigation
+                // which contain only another single folder.
+                if (opts.compactFolders) {
+                    const queue = [...result];
+                    while (queue.length) {
+                        const review = queue.shift();
+                        queue.push(...(review.children || []));
+                        if (review.kind || review.path)
+                            continue;
+                        if (review.children?.length === 1) {
+                            const copyFrom = review.children[0];
+                            const fullName = `${review.text}/${copyFrom.text}`;
+                            delete review.children;
+                            Object.assign(review, copyFrom);
+                            review.text = fullName;
+                            queue.push(review);
+                        }
+                    }
+                }
+                return result;
+            }
+        }
+    };
+})();
+export { DefaultTheme };
+function getReflectionClasses(reflection, filters) {
+    const classes = new Set();
+    // Filter classes should match up with the settings function in
+    // partials/navigation.tsx.
+    for (const key of Object.keys(filters)) {
+        if (key === "inherited") {
+            if (reflection.flags.isInherited) {
+                classes.add("tsd-is-inherited");
+            }
+        }
+        else if (key === "protected") {
+            if (reflection.flags.isProtected) {
+                classes.add("tsd-is-protected");
+            }
+        }
+        else if (key === "private") {
+            if (reflection.flags.isPrivate) {
+                classes.add("tsd-is-private");
+            }
+        }
+        else if (key === "external") {
+            if (reflection.flags.isExternal) {
+                classes.add("tsd-is-external");
+            }
+        }
+        else if (key.startsWith("@")) {
+            if (key === "@deprecated") {
+                if (reflection.isDeprecated()) {
+                    classes.add(toStyleClass(`tsd-is-${key.substring(1)}`));
+                }
+            }
+            else if (reflection.comment?.hasModifier(key) ||
+                reflection.comment?.getTag(key)) {
+                classes.add(toStyleClass(`tsd-is-${key.substring(1)}`));
+            }
+            else if (reflection.isDeclaration()) {
+                const ownSignatures = reflection.getNonIndexSignatures();
+                // Check methods and accessors, find common tags, elevate
+                if (ownSignatures.length &&
+                    ownSignatures.every((refl) => refl.comment?.hasModifier(key) || refl.comment?.getTag(key))) {
+                    classes.add(toStyleClass(`tsd-is-${key.substring(1)}`));
+                }
+            }
+        }
+    }
+    return Array.from(classes).join(" ");
+}
+function shouldShowCategories(reflection, opts) {
+    if (opts.includeCategories) {
+        return !reflection.comment?.hasModifier("@hideCategories");
+    }
+    return reflection.comment?.hasModifier("@showCategories") === true;
+}
+function shouldShowGroups(reflection, opts) {
+    if (opts.includeGroups) {
+        return !reflection.comment?.hasModifier("@hideGroups");
+    }
+    return reflection.comment?.hasModifier("@showGroups") === true;
+}

package/dist/lib/output/themes/default/DefaultThemeRenderContext.d.ts

@@ -0,0 +1,105 @@
+import type { PageEvent, Renderer } from "../../index.js";
+import type { CommentDisplayPart, Reflection } from "../../../models/index.js";
+import { type Options } from "../../../utils/index.js";
+import type { DefaultTheme } from "./DefaultTheme.js";
+import { type Icons } from "./partials/icon.js";
+import type { Router } from "../../router.js";
+import type { JSX, NeverIfInternal } from "#utils";
+export declare class DefaultThemeRenderContext {
+    readonly router: Router;
+    readonly theme: DefaultTheme;
+    page: PageEvent<Reflection>;
+    private _refIcons;
+    options: Options;
+    model: Reflection;
+    constructor(router: Router, theme: DefaultTheme, page: PageEvent<Reflection>, options: Options);
+    /**
+     * Icons available for use within the page.
+     * When getting an icon for a reflection, {@link reflectionIcon} should be used so
+     * that themes which define multiple icon variants can correctly specify which icon
+     * they want to be used.
+     *
+     * Note: This creates a reference to icons declared by {@link DefaultTheme.icons},
+     * to customize icons, that object must be modified instead.
+     */
+    get icons(): Readonly<Icons>;
+    /**
+     * Do not override this method, override {@link DefaultTheme.getReflectionIcon} instead.
+     */
+    reflectionIcon: (reflection: Reflection) => JSX.Element;
+    get slugger(): import("./Slugger.js").Slugger;
+    hook: Renderer["hooks"]["emit"];
+    /** Avoid this in favor of urlTo if possible */
+    relativeURL: (url: string, cacheBust?: boolean) => string;
+    getAnchor: (reflection: Reflection) => string | undefined;
+    urlTo: (reflection: Reflection) => string | undefined;
+    markdown: (md: readonly CommentDisplayPart[] | NeverIfInternal<string | undefined>) => string;
+    /** Renders user comment markdown wrapped in a tsd-comment div */
+    displayParts: (parts: readonly CommentDisplayPart[] | undefined) => JSX.Element | undefined;
+    getNavigation: () => import("./DefaultTheme.js").NavigationElement[];
+    getReflectionClasses: (refl: Reflection) => string;
+    documentTemplate: (props: PageEvent<import("../../../models/DocumentReflection.js").DocumentReflection>) => JSX.Element;
+    reflectionTemplate: (props: PageEvent<import("../../../models/ContainerReflection.js").ContainerReflection>) => JSX.Element;
+    indexTemplate: (props: PageEvent<import("../../../models/ProjectReflection.js").ProjectReflection>) => JSX.Element;
+    hierarchyTemplate: (props: PageEvent<import("../../../models/ProjectReflection.js").ProjectReflection>) => JSX.Element;
+    defaultLayout: (template: import("./DefaultTheme.js").RenderTemplate<PageEvent<Reflection>>, props: PageEvent<Reflection>) => JSX.Element;
+    /**
+     * Rendered just after the description for a reflection.
+     * This can be used to render a shortened type display of a reflection that the
+     * rest of the page expands on.
+     *
+     * Note: Will not be called for variables/type aliases, as they are summarized
+     * by their type declaration, which is already rendered by {@link DefaultThemeRenderContext.memberDeclaration}
+     */
+    reflectionPreview: (props: Reflection) => JSX.Element | undefined;
+    /**
+     * Used to render additional details about a type. This is used to implement
+     * the `@expand` tag, comments on union members, comments on object type members...
+     */
+    typeDetails: (reflectionOwningType: Reflection, type: import("../../../models/types.js").SomeType, renderAnchors: boolean) => JSX.Children;
+    /**
+     * Should call the {@link typeDetails} helper if rendering additional details
+     * about the type will provide the user with more information about the type.
+     */
+    typeDetailsIfUseful: (reflectionOwningType: Reflection, type: import("../../../models/types.js").SomeType | undefined) => JSX.Children;
+    /**
+     * Wrapper around {@link typeDetails} which checks if it is useful
+     * and includes a "Type Declaration" header.
+     */
+    typeDeclaration: (reflectionOwningType: Reflection, type: import("../../../models/types.js").SomeType) => JSX.Children;
+    breadcrumbs: (props: Reflection) => JSX.Element;
+    commentShortSummary: (props: Reflection) => JSX.Element | undefined;
+    commentSummary: (props: Reflection) => JSX.Element | undefined;
+    commentTags: (props: Reflection) => JSX.Element | undefined;
+    reflectionFlags: (props: Reflection) => JSX.Element;
+    footer: () => JSX.Element;
+    header: (props: PageEvent<Reflection>) => JSX.Element;
+    hierarchy: (typeHierarchy: import("../../../models/DeclarationReflection.js").DeclarationHierarchy | undefined) => JSX.Element | undefined;
+    index: (props: import("../../../models/ContainerReflection.js").ContainerReflection) => JSX.Element;
+    member: (props: import("../../../models/DocumentReflection.js").DocumentReflection | import("../../../models/DeclarationReflection.js").DeclarationReflection) => JSX.Element;
+    moduleReflection: (mod: import("../../../models/DeclarationReflection.js").DeclarationReflection | import("../../../models/ProjectReflection.js").ProjectReflection) => JSX.Element;
+    moduleMemberSummary: (member: import("../../../models/DocumentReflection.js").DocumentReflection | import("../../../models/DeclarationReflection.js").DeclarationReflection) => JSX.Element;
+    memberDeclaration: (props: import("../../../models/DeclarationReflection.js").DeclarationReflection) => JSX.Element;
+    memberGetterSetter: (props: import("../../../models/DeclarationReflection.js").DeclarationReflection) => JSX.Element;
+    memberSignatureBody: (props: import("../../../models/SignatureReflection.js").SignatureReflection, r_1?: {
+        hideSources?: boolean;
+    } | undefined) => JSX.Element;
+    memberSignatureTitle: (props: import("../../../models/SignatureReflection.js").SignatureReflection, options?: {
+        hideName?: boolean;
+    } | undefined) => JSX.Element;
+    memberSignatures: (props: import("../../../models/DeclarationReflection.js").DeclarationReflection) => JSX.Element;
+    memberSources: (props: import("../../../models/DeclarationReflection.js").DeclarationReflection | import("../../../models/SignatureReflection.js").SignatureReflection) => JSX.Element;
+    members: (props: import("../../../models/ContainerReflection.js").ContainerReflection) => JSX.Element;
+    sidebar: (props: PageEvent<Reflection>) => JSX.Element;
+    pageSidebar: (props: PageEvent<Reflection>) => JSX.Element;
+    sidebarLinks: () => JSX.Element | null;
+    settings: () => JSX.Element;
+    navigation: (props: PageEvent<Reflection>) => JSX.Element;
+    pageNavigation: (props: PageEvent<Reflection>) => JSX.Element;
+    toolbar: (props: PageEvent<Reflection>) => JSX.Element;
+    type: (type: import("../../../models/types.js").SomeType | undefined, options?: {
+        topLevelLinks: boolean;
+    } | undefined) => JSX.Element;
+    typeAndParent: (props: import("../../../models/types.js").Type) => JSX.Element;
+    typeParameters: (typeParameters: import("../../../models/TypeParameterReflection.js").TypeParameterReflection[]) => JSX.Element;
+}

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

@@ -0,0 +1,151 @@
+import {} from "../../../utils/index.js";
+import { defaultLayout } from "./layouts/default.js";
+import { index } from "./partials/index.js";
+import { breadcrumbs } from "./partials/breadcrumb.js";
+import { commentShortSummary, commentSummary, commentTags, reflectionFlags, renderDisplayParts, } from "./partials/comment.js";
+import { footer } from "./partials/footer.js";
+import { header } from "./partials/header.js";
+import { hierarchy } from "./partials/hierarchy.js";
+import { buildRefIcons } from "./partials/icon.js";
+import { member } from "./partials/member.js";
+import { memberDeclaration } from "./partials/member.declaration.js";
+import { memberGetterSetter } from "./partials/member.getterSetter.js";
+import { memberSignatureBody } from "./partials/member.signature.body.js";
+import { memberSignatureTitle } from "./partials/member.signature.title.js";
+import { memberSignatures } from "./partials/member.signatures.js";
+import { memberSources } from "./partials/member.sources.js";
+import { members } from "./partials/members.js";
+import { navigation, pageNavigation, pageSidebar, settings, sidebar, sidebarLinks } from "./partials/navigation.js";
+import { reflectionPreview } from "./partials/reflectionPreview.js";
+import { toolbar } from "./partials/toolbar.js";
+import { type } from "./partials/type.js";
+import { typeAndParent } from "./partials/typeAndParent.js";
+import { typeParameters } from "./partials/typeParameters.js";
+import { indexTemplate } from "./templates/index.js";
+import { documentTemplate } from "./templates/document.js";
+import { hierarchyTemplate } from "./templates/hierarchy.js";
+import { reflectionTemplate } from "./templates/reflection.js";
+import { typeDeclaration, typeDetails, typeDetailsIfUseful } from "./partials/typeDetails.js";
+import { moduleMemberSummary, moduleReflection } from "./partials/moduleReflection.js";
+function bind(fn, first) {
+    return (...r) => fn(first, ...r);
+}
+export class DefaultThemeRenderContext {
+    router;
+    theme;
+    page;
+    _refIcons;
+    options;
+    model;
+    constructor(router, theme, page, options) {
+        this.router = router;
+        this.theme = theme;
+        this.page = page;
+        this._refIcons = buildRefIcons(theme.icons, this);
+        this.options = options;
+        this.model = page.model;
+    }
+    /**
+     * Icons available for use within the page.
+     * When getting an icon for a reflection, {@link reflectionIcon} should be used so
+     * that themes which define multiple icon variants can correctly specify which icon
+     * they want to be used.
+     *
+     * Note: This creates a reference to icons declared by {@link DefaultTheme.icons},
+     * to customize icons, that object must be modified instead.
+     */
+    get icons() {
+        return this._refIcons;
+    }
+    /**
+     * Do not override this method, override {@link DefaultTheme.getReflectionIcon} instead.
+     */
+    reflectionIcon = (reflection) => {
+        return this.icons[this.theme.getReflectionIcon(reflection)]();
+    };
+    get slugger() {
+        return this.router.getSlugger(this.page.model);
+    }
+    hook = (...params) => {
+        return this.theme.owner.hooks.emit(...params);
+    };
+    /** Avoid this in favor of urlTo if possible */
+    relativeURL = (url, cacheBust = false) => {
+        const result = this.router.baseRelativeUrl(this.page.model, url);
+        if (cacheBust && this.theme.owner.cacheBust) {
+            return result + `?cache=${this.theme.owner.renderStartTime}`;
+        }
+        return result;
+    };
+    getAnchor = (reflection) => {
+        return this.router.getAnchor(reflection);
+    };
+    urlTo = (reflection) => {
+        return this.router.relativeUrl(this.page.model, reflection);
+    };
+    markdown = (md) => {
+        return this.theme.markedPlugin.parseMarkdown(md || "", this.page, this);
+    };
+    /** Renders user comment markdown wrapped in a tsd-comment div */
+    displayParts = bind(renderDisplayParts, this);
+    getNavigation = () => this.theme.getNavigation(this.page.project);
+    getReflectionClasses = (refl) => this.theme.getReflectionClasses(refl);
+    documentTemplate = bind(documentTemplate, this);
+    reflectionTemplate = bind(reflectionTemplate, this);
+    indexTemplate = bind(indexTemplate, this);
+    hierarchyTemplate = bind(hierarchyTemplate, this);
+    defaultLayout = bind(defaultLayout, this);
+    /**
+     * Rendered just after the description for a reflection.
+     * This can be used to render a shortened type display of a reflection that the
+     * rest of the page expands on.
+     *
+     * Note: Will not be called for variables/type aliases, as they are summarized
+     * by their type declaration, which is already rendered by {@link DefaultThemeRenderContext.memberDeclaration}
+     */
+    reflectionPreview = bind(reflectionPreview, this);
+    /**
+     * Used to render additional details about a type. This is used to implement
+     * the `@expand` tag, comments on union members, comments on object type members...
+     */
+    typeDetails = bind(typeDetails, this);
+    /**
+     * Should call the {@link typeDetails} helper if rendering additional details
+     * about the type will provide the user with more information about the type.
+     */
+    typeDetailsIfUseful = bind(typeDetailsIfUseful, this);
+    /**
+     * Wrapper around {@link typeDetails} which checks if it is useful
+     * and includes a "Type Declaration" header.
+     */
+    typeDeclaration = bind(typeDeclaration, this);
+    breadcrumbs = bind(breadcrumbs, this);
+    commentShortSummary = bind(commentShortSummary, this);
+    commentSummary = bind(commentSummary, this);
+    commentTags = bind(commentTags, this);
+    reflectionFlags = bind(reflectionFlags, this);
+    footer = bind(footer, this);
+    header = bind(header, this);
+    hierarchy = bind(hierarchy, this);
+    index = bind(index, this);
+    member = bind(member, this);
+    moduleReflection = bind(moduleReflection, this);
+    moduleMemberSummary = bind(moduleMemberSummary, this);
+    memberDeclaration = bind(memberDeclaration, this);
+    memberGetterSetter = bind(memberGetterSetter, this);
+    memberSignatureBody = bind(memberSignatureBody, this);
+    memberSignatureTitle = bind(memberSignatureTitle, this);
+    memberSignatures = bind(memberSignatures, this);
+    memberSources = bind(memberSources, this);
+    members = bind(members, this);
+    sidebar = bind(sidebar, this);
+    pageSidebar = bind(pageSidebar, this);
+    sidebarLinks = bind(sidebarLinks, this);
+    settings = bind(settings, this);
+    navigation = bind(navigation, this);
+    pageNavigation = bind(pageNavigation, this);
+    toolbar = bind(toolbar, this);
+    type = bind(type, this);
+    typeAndParent = bind(typeAndParent, this);
+    typeParameters = bind(typeParameters, this);
+}

package/dist/lib/output/themes/default/Slugger.d.ts

@@ -0,0 +1,13 @@
+import type { TypeDocOptionMap } from "#node-utils";
+/**
+ * Responsible for getting a unique anchor for elements within a page.
+ */
+export declare class Slugger {
+    private options;
+    private seen;
+    private serialize;
+    constructor(options: TypeDocOptionMap["sluggerConfiguration"]);
+    slug(value: string): string;
+    hasAnchor(anchor: string): boolean;
+    getSimilarAnchors(anchor: string): string[];
+}