@depup/typedoc 0.28.17-depup.0

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

@@ -0,0 +1 @@
+export declare function splitUnquotedString(input: string, delimiter: string): string[];

package/dist/lib/models/utils.js

@@ -0,0 +1,26 @@
+export function splitUnquotedString(input, delimiter) {
+    if (input.startsWith(delimiter)) {
+        return splitUnquotedString(input.substring(delimiter.length), delimiter);
+    }
+    if (input.startsWith('"')) {
+        // the part inside the quotes should not be split, the rest should
+        const closingQuoteIndex = input.indexOf('"', 1);
+        if (closingQuoteIndex === -1) {
+            // Unmatched quotes, just split it
+            return input.split(delimiter);
+        }
+        if (closingQuoteIndex === input.length - 1) {
+            return [input];
+        }
+        else {
+            const remainder = input.substring(closingQuoteIndex + 1);
+            return [
+                input.substring(0, closingQuoteIndex + 1),
+                ...splitUnquotedString(remainder, delimiter),
+            ];
+        }
+    }
+    else {
+        return input.split(delimiter);
+    }
+}

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

@@ -0,0 +1,21 @@
+import type { DeclarationReflection } from "./DeclarationReflection.js";
+import type { DocumentReflection } from "./DocumentReflection.js";
+import type { ParameterReflection } from "./ParameterReflection.js";
+import type { ProjectReflection } from "./ProjectReflection.js";
+import type { ReferenceReflection } from "./ReferenceReflection.js";
+import type { SignatureReflection } from "./SignatureReflection.js";
+import type { TypeParameterReflection } from "./TypeParameterReflection.js";
+/**
+ * A map of known {@link Reflection} concrete subclasses.
+ * This is used during deserialization to reconstruct serialized objects.
+ */
+export interface ReflectionVariant {
+    declaration: DeclarationReflection;
+    param: ParameterReflection;
+    project: ProjectReflection;
+    reference: ReferenceReflection;
+    signature: SignatureReflection;
+    typeParam: TypeParameterReflection;
+    document: DocumentReflection;
+}
+export type SomeReflection = ReflectionVariant[keyof ReflectionVariant];

package/dist/lib/models/variant.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,53 @@
+import { AbstractComponent } from "../utils/component.js";
+import type { ProjectReflection } from "../models/index.js";
+import type { Renderer } from "./renderer.js";
+import { PageEvent, RendererEvent } from "./events.js";
+export declare abstract class RendererComponent extends AbstractComponent<Renderer, {}> {
+}
+/**
+ * A plugin for the renderer that reads the current render context.
+ */
+export declare abstract class ContextAwareRendererComponent extends RendererComponent {
+    /**
+     * The project that is currently processed.
+     */
+    protected project?: ProjectReflection;
+    /**
+     * The reflection that is currently processed.
+     */
+    protected page?: PageEvent;
+    /**
+     * The url of the document that is being currently generated.
+     * Set when a page begins rendering.
+     *
+     * Defaulted to '.' so that tests don't have to set up events.
+     */
+    private location;
+    /**
+     * Regular expression to test if a string looks like an external url.
+     */
+    protected urlPrefix: RegExp;
+    protected get hostedBaseUrl(): string;
+    private accessor useHostedBaseUrlForAbsoluteLinks;
+    constructor(owner: Renderer);
+    private absoluteToRelativePathMap;
+    /**
+     * Transform the given absolute path into a relative path.
+     *
+     * @param absolute  The absolute path to transform.
+     * @returns A path relative to the document currently processed.
+     */
+    getRelativeUrl(absolute: string): string;
+    /**
+     * Triggered before the renderer starts rendering a project.
+     *
+     * @param event  An event object describing the current render operation.
+     */
+    protected onBeginRenderer(event: RendererEvent): void;
+    /**
+     * Triggered before a document will be rendered.
+     *
+     * @param page  An event object describing the current render operation.
+     */
+    protected onBeginPage(page: PageEvent): void;
+}

package/dist/lib/output/components.js

@@ -0,0 +1,133 @@
+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 * as Path from "path";
+import { AbstractComponent } from "../utils/component.js";
+import { PageEvent, RendererEvent } from "./events.js";
+import { Option } from "../utils/index.js";
+export class RendererComponent extends AbstractComponent {
+}
+/**
+ * A plugin for the renderer that reads the current render context.
+ */
+let ContextAwareRendererComponent = (() => {
+    let _classSuper = RendererComponent;
+    let _useHostedBaseUrlForAbsoluteLinks_decorators;
+    let _useHostedBaseUrlForAbsoluteLinks_initializers = [];
+    let _useHostedBaseUrlForAbsoluteLinks_extraInitializers = [];
+    return class ContextAwareRendererComponent extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _useHostedBaseUrlForAbsoluteLinks_decorators = [Option("useHostedBaseUrlForAbsoluteLinks")];
+            __esDecorate(this, null, _useHostedBaseUrlForAbsoluteLinks_decorators, { kind: "accessor", name: "useHostedBaseUrlForAbsoluteLinks", static: false, private: false, access: { has: obj => "useHostedBaseUrlForAbsoluteLinks" in obj, get: obj => obj.useHostedBaseUrlForAbsoluteLinks, set: (obj, value) => { obj.useHostedBaseUrlForAbsoluteLinks = value; } }, metadata: _metadata }, _useHostedBaseUrlForAbsoluteLinks_initializers, _useHostedBaseUrlForAbsoluteLinks_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        /**
+         * The project that is currently processed.
+         */
+        project;
+        /**
+         * The reflection that is currently processed.
+         */
+        page;
+        /**
+         * The url of the document that is being currently generated.
+         * Set when a page begins rendering.
+         *
+         * Defaulted to '.' so that tests don't have to set up events.
+         */
+        location = ".";
+        /**
+         * Regular expression to test if a string looks like an external url.
+         */
+        urlPrefix = /^(http|ftp)s?:\/\//;
+        get hostedBaseUrl() {
+            const url = this.application.options.getValue("hostedBaseUrl");
+            return !url || url.endsWith("/") ? url : url + "/";
+        }
+        #useHostedBaseUrlForAbsoluteLinks_accessor_storage = __runInitializers(this, _useHostedBaseUrlForAbsoluteLinks_initializers, void 0);
+        get useHostedBaseUrlForAbsoluteLinks() { return this.#useHostedBaseUrlForAbsoluteLinks_accessor_storage; }
+        set useHostedBaseUrlForAbsoluteLinks(value) { this.#useHostedBaseUrlForAbsoluteLinks_accessor_storage = value; }
+        constructor(owner) {
+            super(owner);
+            this.owner.on(RendererEvent.BEGIN, this.onBeginRenderer.bind(this));
+            this.owner.on(PageEvent.BEGIN, this.onBeginPage.bind(this));
+            this.owner.on(RendererEvent.END, () => this.absoluteToRelativePathMap.clear());
+        }
+        absoluteToRelativePathMap = (__runInitializers(this, _useHostedBaseUrlForAbsoluteLinks_extraInitializers), new Map());
+        /**
+         * Transform the given absolute path into a relative path.
+         *
+         * @param absolute  The absolute path to transform.
+         * @returns A path relative to the document currently processed.
+         */
+        getRelativeUrl(absolute) {
+            if (this.urlPrefix.test(absolute)) {
+                return absolute;
+            }
+            else {
+                const key = `${this.location}:${absolute}`;
+                let path = this.absoluteToRelativePathMap.get(key);
+                if (path)
+                    return path;
+                if (this.useHostedBaseUrlForAbsoluteLinks) {
+                    path = new URL(absolute, this.hostedBaseUrl).toString();
+                }
+                else {
+                    path = Path.posix.relative(this.location, absolute) || ".";
+                }
+                this.absoluteToRelativePathMap.set(key, path);
+                return path;
+            }
+        }
+        /**
+         * Triggered before the renderer starts rendering a project.
+         *
+         * @param event  An event object describing the current render operation.
+         */
+        onBeginRenderer(event) {
+            this.project = event.project;
+        }
+        /**
+         * Triggered before a document will be rendered.
+         *
+         * @param page  An event object describing the current render operation.
+         */
+        onBeginPage(page) {
+            this.location = Path.posix.dirname(page.url);
+            this.page = page;
+        }
+    };
+})();
+export { ContextAwareRendererComponent };

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

@@ -0,0 +1,175 @@
+import type { ProjectReflection } from "../models/ProjectReflection.js";
+import { type DeclarationReflection, type DocumentReflection, Reflection, type ReflectionKind } from "../models/index.js";
+import type { PageDefinition, PageKind, RouterTarget } from "./router.js";
+import { type Icons } from "./themes/default/partials/icon.js";
+/**
+ * An event emitted by the {@link Renderer} class at the very beginning and
+ * ending of the entire rendering process.
+ *
+ * @see {@link Renderer.EVENT_BEGIN}
+ * @see {@link Renderer.EVENT_END}
+ */
+export declare class RendererEvent {
+    /**
+     * The project the renderer is currently processing.
+     */
+    readonly project: ProjectReflection;
+    /**
+     * The path of the directory the documentation should be written to.
+     */
+    readonly outputDirectory: string;
+    /**
+     * A list of all pages that will be generated.
+     */
+    pages: PageDefinition[];
+    /**
+     * Triggered before the renderer starts rendering a project.
+     * @event
+     */
+    static readonly BEGIN = "beginRender";
+    /**
+     * Triggered after the renderer has written all documents.
+     * @event
+     */
+    static readonly END = "endRender";
+    constructor(outputDirectory: string, project: ProjectReflection, pages: PageDefinition[]);
+}
+export interface PageHeading {
+    link: string;
+    text: string;
+    level?: number;
+    kind?: ReflectionKind;
+    classes?: string;
+    icon?: keyof Icons & (string | number);
+}
+/**
+ * An event emitted by the {@link Renderer} class before and after the
+ * markup of a page is rendered.
+ *
+ * @see {@link Renderer.EVENT_BEGIN_PAGE}
+ * @see {@link Renderer.EVENT_END_PAGE}
+ */
+export declare class PageEvent<out Model extends RouterTarget = RouterTarget> {
+    /**
+     * The project the renderer is currently processing.
+     */
+    project: ProjectReflection;
+    /**
+     * The filename the page will be written to.
+     */
+    filename: string;
+    /**
+     * The url this page will be located at.
+     */
+    url: string;
+    /**
+     * The type of page this is.
+     */
+    pageKind: PageKind;
+    /**
+     * The model that should be rendered on this page.
+     */
+    readonly model: Model;
+    /**
+     * The final html content of this page.
+     *
+     * Should be rendered by layout templates and can be modified by plugins.
+     */
+    contents?: string;
+    /**
+     * Links to content within this page that should be rendered in the page navigation.
+     * This is built when rendering the document content.
+     */
+    pageHeadings: PageHeading[];
+    /**
+     * Sections of the page, generally set by `@group`s
+     */
+    pageSections: {
+        title: string;
+        headings: PageHeading[];
+    }[];
+    /**
+     * Start a new section of the page. Sections are collapsible within
+     * the "On This Page" sidebar.
+     */
+    startNewSection(title: string): void;
+    /**
+     * Triggered before a document will be rendered.
+     * @event
+     */
+    static readonly BEGIN = "beginPage";
+    /**
+     * Triggered after a document has been rendered, just before it is written to disc.
+     * @event
+     */
+    static readonly END = "endPage";
+    constructor(model: Model);
+    isReflectionEvent(): this is PageEvent<Reflection>;
+}
+/**
+ * An event emitted when markdown is being parsed. Allows other plugins to manipulate the result.
+ *
+ * @see {@link MarkdownEvent.PARSE}
+ */
+export declare class MarkdownEvent {
+    /**
+     * The unparsed original text.
+     */
+    readonly originalText: string;
+    /**
+     * The parsed output.
+     */
+    parsedText: string;
+    /**
+     * The page that this markdown is being parsed for.
+     */
+    readonly page: PageEvent;
+    /**
+     * Triggered on the renderer when this plugin parses a markdown string.
+     * @event
+     */
+    static readonly PARSE = "parseMarkdown";
+    constructor(page: PageEvent, originalText: string, parsedText: string);
+}
+/**
+ * An event emitted when the search index is being prepared.
+ */
+export declare class IndexEvent {
+    /**
+     * Triggered on the renderer when the search index is being prepared.
+     * @event
+     */
+    static readonly PREPARE_INDEX = "prepareIndex";
+    /**
+     * May be filtered by plugins to reduce the results available.
+     * Additional items *should not* be added to this array.
+     *
+     * If you remove an index from this array, you must also remove the
+     * same index from {@link searchFields}. The {@link removeResult} helper
+     * will do this for you.
+     */
+    searchResults: Array<DeclarationReflection | DocumentReflection>;
+    /**
+     * Additional search fields to be used when creating the search index.
+     * `name`, `comment` and `document` may be specified to overwrite TypeDoc's search fields.
+     *
+     * Do not use `id` as a custom search field.
+     */
+    searchFields: Record<string, string>[];
+    /**
+     * Weights for the fields defined in `searchFields`. The default will weight
+     * `name` as 10x more important than comment and document content.
+     *
+     * If a field added to {@link searchFields} is not added to this object, it
+     * will **not** be searchable.
+     *
+     * Do not replace this object, instead, set new properties on it for custom search
+     * fields added by your plugin.
+     */
+    readonly searchFieldWeights: Record<string, number>;
+    /**
+     * Remove a search result by index.
+     */
+    removeResult(index: number): void;
+    constructor(searchResults: Array<DeclarationReflection | DocumentReflection>);
+}

package/dist/lib/output/events.js

@@ -0,0 +1,195 @@
+import { Reflection, } from "../models/index.js";
+import {} from "./themes/default/partials/icon.js";
+/**
+ * An event emitted by the {@link Renderer} class at the very beginning and
+ * ending of the entire rendering process.
+ *
+ * @see {@link Renderer.EVENT_BEGIN}
+ * @see {@link Renderer.EVENT_END}
+ */
+export class RendererEvent {
+    /**
+     * The project the renderer is currently processing.
+     */
+    project;
+    /**
+     * The path of the directory the documentation should be written to.
+     */
+    outputDirectory;
+    /**
+     * A list of all pages that will be generated.
+     */
+    pages;
+    /**
+     * Triggered before the renderer starts rendering a project.
+     * @event
+     */
+    static BEGIN = "beginRender";
+    /**
+     * Triggered after the renderer has written all documents.
+     * @event
+     */
+    static END = "endRender";
+    constructor(outputDirectory, project, pages) {
+        this.outputDirectory = outputDirectory;
+        this.project = project;
+        this.pages = pages;
+    }
+}
+/**
+ * An event emitted by the {@link Renderer} class before and after the
+ * markup of a page is rendered.
+ *
+ * @see {@link Renderer.EVENT_BEGIN_PAGE}
+ * @see {@link Renderer.EVENT_END_PAGE}
+ */
+export class PageEvent {
+    /**
+     * The project the renderer is currently processing.
+     */
+    project;
+    /**
+     * The filename the page will be written to.
+     */
+    filename;
+    /**
+     * The url this page will be located at.
+     */
+    url;
+    /**
+     * The type of page this is.
+     */
+    pageKind;
+    /**
+     * The model that should be rendered on this page.
+     */
+    model;
+    /**
+     * The final html content of this page.
+     *
+     * Should be rendered by layout templates and can be modified by plugins.
+     */
+    contents;
+    /**
+     * Links to content within this page that should be rendered in the page navigation.
+     * This is built when rendering the document content.
+     */
+    pageHeadings = [];
+    /**
+     * Sections of the page, generally set by `@group`s
+     */
+    pageSections = [
+        {
+            title: "",
+            headings: this.pageHeadings,
+        },
+    ];
+    /**
+     * Start a new section of the page. Sections are collapsible within
+     * the "On This Page" sidebar.
+     */
+    startNewSection(title) {
+        this.pageHeadings = [];
+        this.pageSections.push({
+            title,
+            headings: this.pageHeadings,
+        });
+    }
+    /**
+     * Triggered before a document will be rendered.
+     * @event
+     */
+    static BEGIN = "beginPage";
+    /**
+     * Triggered after a document has been rendered, just before it is written to disc.
+     * @event
+     */
+    static END = "endPage";
+    constructor(model) {
+        this.model = model;
+    }
+    isReflectionEvent() {
+        return this.model instanceof Reflection;
+    }
+}
+/**
+ * An event emitted when markdown is being parsed. Allows other plugins to manipulate the result.
+ *
+ * @see {@link MarkdownEvent.PARSE}
+ */
+export class MarkdownEvent {
+    /**
+     * The unparsed original text.
+     */
+    originalText;
+    /**
+     * The parsed output.
+     */
+    parsedText;
+    /**
+     * The page that this markdown is being parsed for.
+     */
+    page;
+    /**
+     * Triggered on the renderer when this plugin parses a markdown string.
+     * @event
+     */
+    static PARSE = "parseMarkdown";
+    constructor(page, originalText, parsedText) {
+        this.page = page;
+        this.originalText = originalText;
+        this.parsedText = parsedText;
+    }
+}
+/**
+ * An event emitted when the search index is being prepared.
+ */
+export class IndexEvent {
+    /**
+     * Triggered on the renderer when the search index is being prepared.
+     * @event
+     */
+    static PREPARE_INDEX = "prepareIndex";
+    /**
+     * May be filtered by plugins to reduce the results available.
+     * Additional items *should not* be added to this array.
+     *
+     * If you remove an index from this array, you must also remove the
+     * same index from {@link searchFields}. The {@link removeResult} helper
+     * will do this for you.
+     */
+    searchResults;
+    /**
+     * Additional search fields to be used when creating the search index.
+     * `name`, `comment` and `document` may be specified to overwrite TypeDoc's search fields.
+     *
+     * Do not use `id` as a custom search field.
+     */
+    searchFields;
+    /**
+     * Weights for the fields defined in `searchFields`. The default will weight
+     * `name` as 10x more important than comment and document content.
+     *
+     * If a field added to {@link searchFields} is not added to this object, it
+     * will **not** be searchable.
+     *
+     * Do not replace this object, instead, set new properties on it for custom search
+     * fields added by your plugin.
+     */
+    searchFieldWeights = {
+        name: 10,
+        comment: 1,
+        document: 1,
+    };
+    /**
+     * Remove a search result by index.
+     */
+    removeResult(index) {
+        this.searchResults.splice(index, 1);
+        this.searchFields.splice(index, 1);
+    }
+    constructor(searchResults) {
+        this.searchResults = searchResults;
+        this.searchFields = Array.from({ length: this.searchResults.length }, () => ({}));
+    }
+}