@depup/typedoc 0.28.17-depup.0

package/dist/lib/utils-common/jsx.elements.js

@@ -0,0 +1,3 @@
+export function JsxFragment() {
+    throw new Error("Should never be called");
+}

package/dist/lib/utils-common/jsx.js

@@ -0,0 +1,187 @@
+/**
+ * Custom JSX module designed specifically for TypeDoc's needs.
+ * When overriding a default TypeDoc theme output, your implementation must create valid {@link Element}
+ * instances, which can be most easily done by using TypeDoc's JSX implementation. To use it, set up
+ * your tsconfig with the following compiler options:
+ * ```json
+ * {
+ *     "jsx": "react",
+ *     "jsxFactory": "JSX.createElement",
+ *     "jsxFragmentFactory": "JSX.Fragment"
+ * }
+ * ```
+ * @summary Custom JSX module designed specifically for TypeDoc's needs.
+ * @module
+ */
+import { JsxFragment } from "./jsx.elements.js";
+import { escapeHtml } from "./string.js";
+export { JsxFragment as Fragment } from "./jsx.elements.js";
+/**
+ * Used to inject HTML directly into the document.
+ */
+export function Raw(_props) {
+    // This is handled specially by the renderElement function. Instead of being
+    // called, the tag is compared to this function and the `html` prop will be
+    // returned directly.
+    return null;
+}
+const voidElements = new Set([
+    "area",
+    "base",
+    "br",
+    "col",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "link",
+    "meta",
+    "param",
+    "source",
+    "track",
+    "wbr",
+]);
+const blockElements = new Set([
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "div",
+    "section",
+    "nav",
+    "details",
+    "p",
+    "ul",
+    "ol",
+    "li",
+]);
+/**
+ * JSX factory function to create an "element" that can later be rendered with {@link renderElement}
+ * @param tag
+ * @param props
+ * @param children
+ */
+export function createElement(tag, props, ...children) {
+    return { tag, props, children };
+}
+let renderPretty = true;
+export function setRenderSettings(options) {
+    renderPretty = options.pretty;
+}
+export function renderElement(element) {
+    if (!element) {
+        return "";
+    }
+    const { tag, props, children } = element;
+    let html = "";
+    if (typeof tag === "function") {
+        if (tag === Raw) {
+            return String(props.html);
+        }
+        if (tag === JsxFragment) {
+            renderChildren(children);
+            return html;
+        }
+        return renderElement(tag(Object.assign({ children }, props)));
+    }
+    if (blockElements.has(tag) && renderPretty && html) {
+        html += "\n";
+    }
+    html += "<";
+    html += tag;
+    for (const [key, val] of Object.entries(props ?? {})) {
+        if (val == null)
+            continue;
+        if (typeof val == "boolean") {
+            if (val) {
+                html += " ";
+                html += key;
+            }
+        }
+        else {
+            html += " ";
+            html += key;
+            html += '="';
+            html += (typeof val === "string" ? val : JSON.stringify(val)).replaceAll('"', "&quot;");
+            html += '"';
+        }
+    }
+    if (children.length) {
+        html += ">";
+        renderChildren(children);
+        html += "</";
+        html += tag;
+        html += ">";
+    }
+    else {
+        if (voidElements.has(tag)) {
+            html += "/>";
+        }
+        else {
+            html += "></";
+            html += tag;
+            html += ">";
+        }
+    }
+    return html;
+    function renderChildren(children) {
+        for (const child of children) {
+            if (typeof child === "boolean")
+                continue;
+            if (Array.isArray(child)) {
+                renderChildren(child);
+            }
+            else if (typeof child === "string" || typeof child === "number" || typeof child === "bigint") {
+                html += escapeHtml(child.toString());
+            }
+            else {
+                html += renderElement(child);
+            }
+        }
+    }
+}
+/**
+ * Render an element to text, stripping out any HTML tags.
+ * This is roughly equivalent to getting `innerText` on a rendered element.
+ * @internal
+ */
+export function renderElementToText(element) {
+    if (!element) {
+        return "";
+    }
+    const { tag, props, children } = element;
+    let html = "";
+    if (typeof tag === "function") {
+        if (tag === Raw) {
+            return String(props.html);
+        }
+        if (tag === JsxFragment) {
+            renderChildren(children);
+            return html;
+        }
+        return renderElementToText(tag(Object.assign({ children }, props)));
+    }
+    else if (tag === "br") {
+        return "\n";
+    }
+    renderChildren(children);
+    return html;
+    function renderChildren(children) {
+        for (const child of children) {
+            if (typeof child === "boolean")
+                continue;
+            if (Array.isArray(child)) {
+                renderChildren(child);
+            }
+            else if (typeof child === "string" || typeof child === "number" || typeof child === "bigint") {
+                // Turn non-breaking spaces into regular spaces
+                html += child.toString().replaceAll("\u00A0", " ");
+            }
+            else {
+                html += renderElementToText(child);
+            }
+        }
+    }
+}

package/dist/lib/utils-common/logger.d.ts

@@ -0,0 +1,97 @@
+import type { IfInternal } from "./general.js";
+import type { TranslatedString } from "./i18n.js";
+import type { MinimalNode, MinimalSourceFile } from "./minimalSourceFile.js";
+/**
+ * List of known log levels. Used to specify the urgency of a log message.
+ */
+export declare enum LogLevel {
+    Verbose = 0,
+    Info = 1,
+    Warn = 2,
+    Error = 3,
+    None = 4
+}
+/**
+ * A logger that will not produce any output.
+ *
+ * This logger also serves as the base class of other loggers as it implements
+ * all the required utility functions.
+ */
+export declare class Logger {
+    /**
+     * How many error messages have been logged?
+     */
+    errorCount: number;
+    /**
+     * How many warning messages have been logged?
+     */
+    warningCount: number;
+    /**
+     * How many validation warning messages have been logged?
+     */
+    validationWarningCount: number;
+    /**
+     * The minimum logging level to print.
+     */
+    level: LogLevel;
+    /**
+     * Has an error been raised through the log method?
+     */
+    hasErrors(): boolean;
+    /**
+     * Has a warning been raised through the log method?
+     */
+    hasWarnings(): boolean;
+    /**
+     * Reset the error counter.
+     */
+    resetErrors(): void;
+    /**
+     * Reset the warning counter.
+     */
+    resetWarnings(): void;
+    /**
+     * Log the given verbose message.
+     *
+     * @param text  The message that should be logged.
+     */
+    verbose(text: string): void;
+    /** Log the given info message. */
+    info(text: IfInternal<TranslatedString, string>): void;
+    /**
+     * Log the given warning.
+     *
+     * @param text The warning that should be logged.
+     */
+    warn(text: IfInternal<TranslatedString, string>, node?: MinimalNode): void;
+    warn(text: IfInternal<TranslatedString, string>, pos: number, file: MinimalSourceFile): void;
+    /**
+     * Log the given warning and records that a validation warning has occurred.
+     *
+     * @param text The warning that should be logged.
+     */
+    validationWarning(text: IfInternal<TranslatedString, string>, node?: MinimalNode): void;
+    validationWarning(text: IfInternal<TranslatedString, string>, pos: number, file: MinimalSourceFile): void;
+    /**
+     * Log the given error.
+     *
+     * @param text  The error that should be logged.
+     */
+    error(text: IfInternal<TranslatedString, string>, node?: MinimalNode): void;
+    error(text: IfInternal<TranslatedString, string>, pos: number, file: MinimalSourceFile): void;
+    /**
+     * Print a log message.
+     *
+     * @param _message The message itself.
+     * @param level The urgency of the log message.
+     */
+    log(_message: string, level: LogLevel): void;
+    protected addContext(message: string, _level: Exclude<LogLevel, LogLevel.None>, ..._args: [MinimalNode?] | [number, MinimalSourceFile]): string;
+}
+/**
+ * Logger implementation which logs to the console
+ */
+export declare class ConsoleLogger extends Logger {
+    log(message: string, level: Exclude<LogLevel, LogLevel.None>): void;
+    protected addContext(message: string, level: Exclude<LogLevel, LogLevel.None>, ..._args: [MinimalNode?] | [number, MinimalSourceFile]): string;
+}

package/dist/lib/utils-common/logger.js

@@ -0,0 +1,129 @@
+/**
+ * List of known log levels. Used to specify the urgency of a log message.
+ */
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["Verbose"] = 0] = "Verbose";
+    LogLevel[LogLevel["Info"] = 1] = "Info";
+    LogLevel[LogLevel["Warn"] = 2] = "Warn";
+    LogLevel[LogLevel["Error"] = 3] = "Error";
+    LogLevel[LogLevel["None"] = 4] = "None";
+})(LogLevel || (LogLevel = {}));
+const messagePrefixes = {
+    [LogLevel.Error]: "[error]",
+    [LogLevel.Warn]: "[warning]",
+    [LogLevel.Info]: "[info]",
+    [LogLevel.Verbose]: "[debug]",
+};
+/**
+ * A logger that will not produce any output.
+ *
+ * This logger also serves as the base class of other loggers as it implements
+ * all the required utility functions.
+ */
+export class Logger {
+    /**
+     * How many error messages have been logged?
+     */
+    errorCount = 0;
+    /**
+     * How many warning messages have been logged?
+     */
+    warningCount = 0;
+    /**
+     * How many validation warning messages have been logged?
+     */
+    validationWarningCount = 0;
+    /**
+     * The minimum logging level to print.
+     */
+    level = LogLevel.Info;
+    /**
+     * Has an error been raised through the log method?
+     */
+    hasErrors() {
+        return this.errorCount > 0;
+    }
+    /**
+     * Has a warning been raised through the log method?
+     */
+    hasWarnings() {
+        return this.warningCount > 0;
+    }
+    /**
+     * Reset the error counter.
+     */
+    resetErrors() {
+        this.errorCount = 0;
+    }
+    /**
+     * Reset the warning counter.
+     */
+    resetWarnings() {
+        this.warningCount = 0;
+        this.validationWarningCount = 0;
+    }
+    /**
+     * Log the given verbose message.
+     *
+     * @param text  The message that should be logged.
+     */
+    verbose(text) {
+        this.log(this.addContext(text, LogLevel.Verbose), LogLevel.Verbose);
+    }
+    /** Log the given info message. */
+    info(text) {
+        this.log(this.addContext(text, LogLevel.Info), LogLevel.Info);
+    }
+    warn(text, ...args) {
+        const text2 = this.addContext(text, LogLevel.Warn, ...args);
+        this.log(text2, LogLevel.Warn);
+    }
+    validationWarning(...args) {
+        this.validationWarningCount += 1;
+        this.warn(...args);
+    }
+    error(text, ...args) {
+        const text2 = this.addContext(text, LogLevel.Error, ...args);
+        this.log(text2, LogLevel.Error);
+    }
+    /**
+     * Print a log message.
+     *
+     * @param _message The message itself.
+     * @param level The urgency of the log message.
+     */
+    log(_message, level) {
+        if (level === LogLevel.Error) {
+            this.errorCount += 1;
+        }
+        if (level === LogLevel.Warn) {
+            this.warningCount += 1;
+        }
+    }
+    addContext(message, _level, ..._args) {
+        return message;
+    }
+}
+/**
+ * Logger implementation which logs to the console
+ */
+export class ConsoleLogger extends Logger {
+    log(message, level) {
+        super.log(message, level);
+        if (level < this.level) {
+            return;
+        }
+        const method = {
+            [LogLevel.Error]: "error",
+            [LogLevel.Warn]: "warn",
+            [LogLevel.Info]: "info",
+            [LogLevel.Verbose]: "log",
+        }[level];
+        // eslint-disable-next-line no-console
+        console[method](message);
+    }
+    addContext(message, level, ..._args) {
+        return `${messagePrefixes[level]} ${message}`;
+    }
+}

package/dist/lib/utils-common/map.d.ts

@@ -0,0 +1,23 @@
+export declare class DefaultMap<K, V> extends Map<K, V> {
+    private creator;
+    constructor(creator: (key: K) => V);
+    get(key: K): V;
+    getNoInsert(key: K): V | undefined;
+}
+export declare class StableKeyMap<K extends {
+    getStableKey(): string;
+}, V> {
+    [Symbol.toStringTag]: string;
+    private impl;
+    get size(): number;
+    set(key: K, value: V): this;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    clear(): void;
+    delete(key: K): boolean;
+    forEach(callbackfn: (value: V, key: K, map: StableKeyMap<K, V>) => void, thisArg?: any): void;
+    entries(): IterableIterator<[K, V]>;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+}

package/dist/lib/utils-common/map.js

@@ -0,0 +1,63 @@
+export class DefaultMap extends Map {
+    creator;
+    constructor(creator) {
+        super();
+        this.creator = creator;
+    }
+    get(key) {
+        const saved = super.get(key);
+        if (saved != null) {
+            return saved;
+        }
+        const created = this.creator(key);
+        this.set(key, created);
+        return created;
+    }
+    getNoInsert(key) {
+        return super.get(key);
+    }
+}
+export class StableKeyMap {
+    [Symbol.toStringTag] = "StableKeyMap";
+    impl = new Map();
+    get size() {
+        return this.impl.size;
+    }
+    set(key, value) {
+        this.impl.set(key.getStableKey(), [key, value]);
+        return this;
+    }
+    get(key) {
+        return this.impl.get(key.getStableKey())?.[1];
+    }
+    has(key) {
+        return this.get(key) != null;
+    }
+    clear() {
+        this.impl.clear();
+    }
+    delete(key) {
+        return this.impl.delete(key.getStableKey());
+    }
+    forEach(callbackfn, thisArg) {
+        for (const [k, v] of this.entries()) {
+            callbackfn.apply(thisArg, [v, k, this]);
+        }
+    }
+    entries() {
+        return this.impl.values();
+    }
+    *keys() {
+        for (const [k] of this.entries()) {
+            yield k;
+        }
+    }
+    *values() {
+        for (const [, v] of this.entries()) {
+            yield v;
+        }
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+}

package/dist/lib/utils-common/minimalSourceFile.d.ts

@@ -0,0 +1,12 @@
+import type { LineAndCharacter, SourceFileLike } from "typescript";
+import type { NormalizedPath } from "./path.js";
+export interface MinimalNode {
+    getStart(): number;
+    getSourceFile(): MinimalSourceFile;
+}
+export declare class MinimalSourceFile implements SourceFileLike {
+    readonly text: string;
+    readonly fileName: string;
+    constructor(text: string, fileName: NormalizedPath);
+    getLineAndCharacterOfPosition(pos: number): LineAndCharacter;
+}

package/dist/lib/utils-common/minimalSourceFile.js

@@ -0,0 +1,43 @@
+import { binaryFindPartition } from "./array.js";
+// I don't like this, but it's necessary so that the lineStarts property isn't
+// visible in the `MinimalSourceFile` type. Even when private it causes compilation
+// errors downstream.
+const lineStarts = new WeakMap();
+export class MinimalSourceFile {
+    text;
+    // This type is just string to ensure assignability from SourceFile
+    fileName;
+    constructor(text, fileName) {
+        // This is unfortunate, but the yaml library we use relies on the source
+        // text using LF line endings https://github.com/eemeli/yaml/issues/127.
+        // If we don't do this, in a simple document which includes a single key
+        // like:
+        // ---<CR><LF>
+        // title: Windows line endings<CR><LF>
+        // ---<CR><LF>
+        // we'll end up with a parsed title of "Windows line endings\r"
+        this.text = text.replaceAll("\r\n", "\n");
+        lineStarts.set(this, [0]);
+        this.fileName = fileName;
+    }
+    getLineAndCharacterOfPosition(pos) {
+        if (pos < 0 || pos >= this.text.length) {
+            throw new Error("pos must be within the range of the file.");
+        }
+        const starts = lineStarts.get(this);
+        while (pos >= starts[starts.length - 1]) {
+            const nextStart = this.text.indexOf("\n", starts[starts.length - 1]);
+            if (nextStart === -1) {
+                starts.push(Infinity);
+            }
+            else {
+                starts.push(nextStart + 1);
+            }
+        }
+        const line = binaryFindPartition(starts, (x) => x > pos) - 1;
+        return {
+            character: pos - starts[line],
+            line,
+        };
+    }
+}

package/dist/lib/utils-common/path.d.ts

@@ -0,0 +1,42 @@
+import type { Application } from "../application.js";
+/**
+ * Represents a normalized path with path separators being `/`
+ * On Windows, drives are represented like `C:/Users` for consistency
+ * with TypeScript.
+ *
+ * The empty string `""` is a valid normalized path.
+ */
+export type NormalizedPath = "" | "/" | string & {
+    readonly __normPath: unique symbol;
+};
+/**
+ * Represents either a {@link NormalizedPath} or a Node module name
+ * (e.g. `typedoc-plugin-mdn-links` or `@gerrit0/typedoc-plugin`)
+ */
+export type NormalizedPathOrModule = NormalizedPath | string & {
+    readonly __normPathOrModule: unique symbol;
+};
+/**
+ * Represents either a {@link NormalizedPath} or a Node module name
+ * (e.g. `typedoc-plugin-mdn-links` or `@gerrit0/typedoc-plugin`)
+ */
+export type NormalizedPathOrModuleOrFunction = NormalizedPathOrModule | ((app: Application) => Promise<void> | void);
+/**
+ * Represents a glob path configured by a user.
+ */
+export type GlobString = string & {
+    readonly __globString: unique symbol;
+};
+export declare namespace NormalizedPathUtils {
+    function dirname(path: NormalizedPath): NormalizedPath;
+    function basename(path: NormalizedPath): NormalizedPath;
+    function relative(from: NormalizedPath, to: NormalizedPath): NormalizedPath;
+    function normalize(path: NormalizedPath): NormalizedPath;
+    function resolve(from: NormalizedPath, to: NormalizedPath): NormalizedPath;
+    function isAbsolute(from: NormalizedPath): boolean;
+    function splitFilename(name: string): {
+        name: string;
+        ext: string;
+    };
+    function isDeclarationFilePath(path: NormalizedPath): boolean;
+}