@depup/typedoc 0.28.17-depup.0

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

@@ -0,0 +1,14 @@
+import type { Application } from "../application.js";
+import type { ProjectReflection } from "../models/index.js";
+import { type OutputSpecification } from "../utils/options/declaration.js";
+export declare class Outputs {
+    readonly application: Application;
+    private outputs;
+    private defaultOutput;
+    constructor(application: Application);
+    addOutput(name: string, output: (path: string, project: ProjectReflection) => Promise<void>): void;
+    setDefaultOutputName(name: string): void;
+    getOutputSpecs(): OutputSpecification[];
+    writeOutputs(project: ProjectReflection): Promise<void>;
+    writeOutput(output: OutputSpecification, project: ProjectReflection): Promise<void>;
+}

package/dist/lib/output/output.js

@@ -0,0 +1,92 @@
+import { i18n } from "#utils";
+import { ParameterType } from "../utils/options/declaration.js";
+import { nicePath } from "../utils/paths.js";
+export class Outputs {
+    application;
+    outputs = new Map();
+    defaultOutput = "html";
+    constructor(application) {
+        this.application = application;
+    }
+    addOutput(name, output) {
+        if (this.outputs.has(name)) {
+            throw new Error(`Output type '${name}' has already been defined`);
+        }
+        this.outputs.set(name, output);
+    }
+    setDefaultOutputName(name) {
+        this.defaultOutput = name;
+    }
+    getOutputSpecs() {
+        const options = this.application.options;
+        let outputs = [];
+        const outputShortcuts = options
+            .getDeclarations()
+            .filter((decl) => decl.type === ParameterType.Path && decl.outputShortcut);
+        // --out is a special case. It isn't marked as a shortcut as what it is
+        // a shortcut for may be modified by plugins. However, it is effectively
+        // treated as an output shortcut, so check it here.
+        if (options.isSet("out")) {
+            outputs.push({
+                name: this.defaultOutput,
+                path: options.getValue("out"),
+            });
+        }
+        for (const shortcut of outputShortcuts) {
+            if (options.isSet(shortcut.name)) {
+                outputs.push({
+                    name: shortcut.outputShortcut,
+                    path: options.getValue(shortcut.name),
+                });
+            }
+        }
+        // If no shortcuts have been defined, use the dedicated outputs option
+        if (outputs.length === 0) {
+            outputs = options.getValue("outputs") || [];
+        }
+        // If no outputs have been defined, just write the default output.
+        if (!outputs.length) {
+            outputs.push({
+                name: this.defaultOutput,
+                path: options.getValue("out"),
+            });
+        }
+        return outputs;
+    }
+    async writeOutputs(project) {
+        const outputs = this.getOutputSpecs();
+        for (const output of outputs) {
+            await this.writeOutput(output, project);
+        }
+    }
+    async writeOutput(output, project) {
+        const options = this.application.options;
+        const snap = options.snapshot();
+        const writer = this.outputs.get(output.name);
+        if (!writer) {
+            this.application.logger.error(i18n.specified_output_0_has_not_been_defined(output.name));
+            return;
+        }
+        if (!this.application.setOptions(output.options || {}, true)) {
+            options.restore(snap);
+            return;
+        }
+        const preErrors = this.application.logger.errorCount;
+        const start = Date.now();
+        try {
+            await writer(output.path, project);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.application.logger.error(message);
+        }
+        if (this.application.logger.errorCount === preErrors) {
+            this.application.logger.info(i18n.output_0_generated_at_1(output.name, nicePath(output.path)));
+        }
+        else {
+            this.application.logger.error(i18n.output_0_could_not_be_generated(output.name));
+        }
+        this.application.logger.verbose(`${output.name} took ${Date.now() - start}ms`);
+        options.restore(snap);
+    }
+}

package/dist/lib/output/plugins/AssetsPlugin.d.ts

@@ -0,0 +1,20 @@
+import { RendererComponent } from "../components.js";
+import type { Renderer } from "../index.js";
+/**
+ * A plugin that copies the subdirectory ´assets´ from the current themes
+ * source folder to the output directory.
+ */
+export declare class AssetsPlugin extends RendererComponent {
+    private accessor favicon;
+    private accessor customCss;
+    private accessor customJs;
+    constructor(owner: Renderer);
+    getTranslatedStrings(): Record<string, string>;
+    private onRenderBegin;
+    /**
+     * Triggered before the renderer starts rendering a project.
+     *
+     * @param event  An event object describing the current render operation.
+     */
+    private onRenderEnd;
+}

package/dist/lib/output/plugins/AssetsPlugin.js

@@ -0,0 +1,160 @@
+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 { RendererComponent } from "../components.js";
+import { RendererEvent } from "../events.js";
+import { copySync, isFile, readFile, writeFileSync } from "../../utils/fs.js";
+import { DefaultTheme } from "../themes/default/DefaultTheme.js";
+import { getStyles } from "../../utils/highlighter.js";
+import { getEnumKeys, i18n } from "#utils";
+import { existsSync } from "fs";
+import { extname, join } from "path";
+import { fileURLToPath } from "url";
+import { ReflectionKind } from "../../models/index.js";
+import { Option } from "../../utils/index.js";
+/**
+ * A plugin that copies the subdirectory ´assets´ from the current themes
+ * source folder to the output directory.
+ */
+let AssetsPlugin = (() => {
+    let _classSuper = RendererComponent;
+    let _favicon_decorators;
+    let _favicon_initializers = [];
+    let _favicon_extraInitializers = [];
+    let _customCss_decorators;
+    let _customCss_initializers = [];
+    let _customCss_extraInitializers = [];
+    let _customJs_decorators;
+    let _customJs_initializers = [];
+    let _customJs_extraInitializers = [];
+    return class AssetsPlugin extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _favicon_decorators = [Option("favicon")];
+            _customCss_decorators = [Option("customCss")];
+            _customJs_decorators = [Option("customJs")];
+            __esDecorate(this, null, _favicon_decorators, { kind: "accessor", name: "favicon", static: false, private: false, access: { has: obj => "favicon" in obj, get: obj => obj.favicon, set: (obj, value) => { obj.favicon = value; } }, metadata: _metadata }, _favicon_initializers, _favicon_extraInitializers);
+            __esDecorate(this, null, _customCss_decorators, { kind: "accessor", name: "customCss", static: false, private: false, access: { has: obj => "customCss" in obj, get: obj => obj.customCss, set: (obj, value) => { obj.customCss = value; } }, metadata: _metadata }, _customCss_initializers, _customCss_extraInitializers);
+            __esDecorate(this, null, _customJs_decorators, { kind: "accessor", name: "customJs", static: false, private: false, access: { has: obj => "customJs" in obj, get: obj => obj.customJs, set: (obj, value) => { obj.customJs = value; } }, metadata: _metadata }, _customJs_initializers, _customJs_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        #favicon_accessor_storage = __runInitializers(this, _favicon_initializers, void 0);
+        get favicon() { return this.#favicon_accessor_storage; }
+        set favicon(value) { this.#favicon_accessor_storage = value; }
+        #customCss_accessor_storage = (__runInitializers(this, _favicon_extraInitializers), __runInitializers(this, _customCss_initializers, void 0));
+        get customCss() { return this.#customCss_accessor_storage; }
+        set customCss(value) { this.#customCss_accessor_storage = value; }
+        #customJs_accessor_storage = (__runInitializers(this, _customCss_extraInitializers), __runInitializers(this, _customJs_initializers, void 0));
+        get customJs() { return this.#customJs_accessor_storage; }
+        set customJs(value) { this.#customJs_accessor_storage = value; }
+        constructor(owner) {
+            super(owner);
+            __runInitializers(this, _customJs_extraInitializers);
+            this.owner.on(RendererEvent.BEGIN, this.onRenderBegin.bind(this));
+            this.owner.on(RendererEvent.END, this.onRenderEnd.bind(this));
+        }
+        getTranslatedStrings() {
+            const translations = {
+                copy: i18n.theme_copy(),
+                copied: i18n.theme_copied(),
+                normally_hidden: i18n.theme_normally_hidden(),
+                hierarchy_expand: i18n.theme_hierarchy_expand(),
+                hierarchy_collapse: i18n.theme_hierarchy_collapse(),
+                folder: i18n.theme_folder(),
+                search_index_not_available: i18n.theme_search_index_not_available(),
+                search_no_results_found_for_0: i18n.theme_search_no_results_found_for_0("{0}"),
+            };
+            for (const key of getEnumKeys(ReflectionKind)) {
+                const kind = ReflectionKind[key];
+                translations[`kind_${kind}`] = ReflectionKind.singularString(kind);
+            }
+            return translations;
+        }
+        onRenderBegin(event) {
+            const dest = join(event.outputDirectory, "assets");
+            if (!/^https?:\/\//i.test(this.favicon) &&
+                [".ico", ".png", ".svg"].includes(extname(this.favicon))) {
+                copySync(this.favicon, join(dest, "favicon" + extname(this.favicon)));
+            }
+            if (this.customCss) {
+                this.application.watchFile(this.customCss);
+                if (existsSync(this.customCss)) {
+                    copySync(this.customCss, join(dest, "custom.css"));
+                }
+                else {
+                    this.application.logger.error(i18n.custom_css_file_0_does_not_exist(this.customCss));
+                }
+            }
+            if (this.customJs) {
+                this.application.watchFile(this.customJs);
+                if (existsSync(this.customJs)) {
+                    copySync(this.customJs, join(dest, "custom.js"));
+                }
+                else {
+                    this.application.logger.error(i18n.custom_js_file_0_does_not_exist(this.customJs));
+                }
+            }
+        }
+        /**
+         * Triggered before the renderer starts rendering a project.
+         *
+         * @param event  An event object describing the current render operation.
+         */
+        onRenderEnd(event) {
+            if (this.owner.theme instanceof DefaultTheme) {
+                const src = join(fileURLToPath(import.meta.url), "../../../../../static");
+                const dest = join(event.outputDirectory, "assets");
+                copySync(join(src, "style.css"), join(dest, "style.css"));
+                const mainJs = readFile(join(src, "main.js"));
+                writeFileSync(join(dest, "main.js"), [
+                    '"use strict";',
+                    `window.translations=${JSON.stringify(this.getTranslatedStrings())};`,
+                    mainJs,
+                ].join("\n"));
+                writeFileSync(join(dest, "highlight.css"), getStyles());
+                const media = join(event.outputDirectory, "media");
+                const toCopy = event.project.files.getNameToAbsoluteMap();
+                for (const [fileName, absolute] of toCopy.entries()) {
+                    if (isFile(absolute)) {
+                        copySync(absolute, join(media, fileName));
+                    }
+                    else {
+                        this.application.logger.warn(i18n.relative_path_0_is_not_a_file_and_will_not_be_copied_to_output(absolute));
+                    }
+                }
+            }
+        }
+    };
+})();
+export { AssetsPlugin };

package/dist/lib/output/plugins/HierarchyPlugin.d.ts

@@ -0,0 +1,7 @@
+import { RendererComponent } from "../components.js";
+import type { Renderer } from "../index.js";
+export declare class HierarchyPlugin extends RendererComponent {
+    constructor(renderer: Renderer);
+    private onRendererBegin;
+    private buildHierarchy;
+}

package/dist/lib/output/plugins/HierarchyPlugin.js

@@ -0,0 +1,65 @@
+import * as Path from "path";
+import { RendererComponent } from "../components.js";
+import { RendererEvent } from "../events.js";
+import { writeFile } from "../../utils/index.js";
+import { DefaultTheme } from "../themes/default/DefaultTheme.js";
+import { getHierarchyRoots, getKindClass, getUniquePath } from "../themes/lib.js";
+import { compressJson } from "../../utils/compress.js";
+export class HierarchyPlugin extends RendererComponent {
+    constructor(renderer) {
+        super(renderer);
+        this.owner.on(RendererEvent.BEGIN, this.onRendererBegin.bind(this));
+    }
+    onRendererBegin(_event) {
+        if (!(this.owner.theme instanceof DefaultTheme)) {
+            return;
+        }
+        this.owner.preRenderAsyncJobs.push((event) => this.buildHierarchy(event));
+    }
+    async buildHierarchy(event) {
+        const project = event.project;
+        const hierarchy = {
+            roots: getHierarchyRoots(project).map((refl) => refl.id),
+            reflections: {},
+        };
+        const queue = [...hierarchy.roots];
+        while (queue.length) {
+            const id = queue.pop();
+            const refl = project.getReflectionById(id);
+            if (id in hierarchy.reflections)
+                continue;
+            const url = this.owner.router.getFullUrl(refl);
+            if (!url)
+                continue;
+            const jsonRecord = {
+                name: refl.name,
+                kind: refl.kind,
+                url,
+                class: getKindClass(refl),
+            };
+            const path = getUniquePath(refl);
+            if (path.length > 1) {
+                jsonRecord.uniqueNameParents = path
+                    .slice(0, -1)
+                    .map((r) => r.id);
+                queue.push(...jsonRecord.uniqueNameParents);
+            }
+            const children = [
+                ...(refl.implementedBy || []),
+                ...(refl.extendedBy || []),
+            ];
+            for (const child of children) {
+                if (child.reflection) {
+                    jsonRecord.children ||= [];
+                    jsonRecord.children.push(child.reflection.id);
+                }
+            }
+            if (jsonRecord.children) {
+                queue.push(...jsonRecord.children);
+            }
+            hierarchy.reflections[id] = jsonRecord;
+        }
+        const hierarchyJs = Path.join(event.outputDirectory, "assets", "hierarchy.js");
+        await writeFile(hierarchyJs, `window.hierarchyData = "${await compressJson(hierarchy)}"`);
+    }
+}

package/dist/lib/output/plugins/IconsPlugin.d.ts

@@ -0,0 +1,12 @@
+import { RendererComponent } from "../components.js";
+import type { Renderer } from "../index.js";
+/**
+ * Plugin which is responsible for creating an icons.js file that embeds the icon SVGs
+ * within the page on page load to reduce page sizes.
+ */
+export declare class IconsPlugin extends RendererComponent {
+    iconHtml?: string;
+    constructor(owner: Renderer);
+    private onBeginRender;
+    private onRenderEnd;
+}

package/dist/lib/output/plugins/IconsPlugin.js

@@ -0,0 +1,54 @@
+import { RendererComponent } from "../components.js";
+import { RendererEvent } from "../events.js";
+import { writeFile } from "../../utils/fs.js";
+import { DefaultTheme } from "../themes/default/DefaultTheme.js";
+import { join } from "path";
+import { JSX } from "#utils";
+const ICONS_JS = `
+(function() {
+    addIcons();
+    function addIcons() {
+        if (document.readyState === "loading") return document.addEventListener("DOMContentLoaded", addIcons);
+        const svg = document.body.appendChild(document.createElementNS("http://www.w3.org/2000/svg", "svg"));
+        svg.innerHTML = \`SVG_HTML\`;
+        svg.style.display = "none";
+        if (location.protocol === "file:") updateUseElements();
+    }
+
+    function updateUseElements() {
+        document.querySelectorAll("use").forEach(el => {
+            if (el.getAttribute("href").includes("#icon-")) {
+                el.setAttribute("href", el.getAttribute("href").replace(/.*#/, "#"));
+            }
+        });
+    }
+})()
+`.trim();
+/**
+ * Plugin which is responsible for creating an icons.js file that embeds the icon SVGs
+ * within the page on page load to reduce page sizes.
+ */
+export class IconsPlugin extends RendererComponent {
+    iconHtml;
+    constructor(owner) {
+        super(owner);
+        this.owner.on(RendererEvent.BEGIN, this.onBeginRender.bind(this));
+    }
+    onBeginRender(_event) {
+        if (this.owner.theme instanceof DefaultTheme) {
+            this.owner.postRenderAsyncJobs.push((event) => this.onRenderEnd(event));
+        }
+    }
+    async onRenderEnd(event) {
+        const children = [];
+        const icons = this.owner.theme.icons;
+        for (const [name, icon] of Object.entries(icons)) {
+            children.push(JSX.createElement("g", { id: `icon-${name}`, class: "tsd-no-select" }, icon.call(icons).children));
+        }
+        const svg = JSX.renderElement(JSX.createElement("svg", { xmlns: "http://www.w3.org/2000/svg" }, children));
+        const js = ICONS_JS.replace("SVG_HTML", JSX.renderElement(JSX.createElement(JSX.Fragment, null, children)).replaceAll("`", "\\`"));
+        const svgPath = join(event.outputDirectory, "assets/icons.svg");
+        const jsPath = join(event.outputDirectory, "assets/icons.js");
+        await Promise.all([writeFile(svgPath, svg), writeFile(jsPath, js)]);
+    }
+}

package/dist/lib/output/plugins/JavascriptIndexPlugin.d.ts

@@ -0,0 +1,22 @@
+import { RendererComponent } from "../components.js";
+import type { Renderer } from "../index.js";
+/**
+ * A plugin that exports an index of the project to a javascript file.
+ *
+ * The resulting javascript file can be used to build a simple search function.
+ */
+export declare class JavascriptIndexPlugin extends RendererComponent {
+    private accessor searchComments;
+    private accessor searchDocuments;
+    private accessor searchGroupBoosts;
+    private accessor searchCategoryBoosts;
+    accessor groupReferencesByType: boolean;
+    private unusedGroupBoosts;
+    private unusedCatBoosts;
+    constructor(owner: Renderer);
+    private onRendererBegin;
+    private buildSearchIndex;
+    private getBoost;
+    private getCommentSearchText;
+    private getDocumentSearchText;
+}