typedoc 0.28.19 → 0.28.20

package/dist/lib/utils/options/tsdoc-defaults.js

@@ -1,94 +0,0 @@
-// If updating these lists, also update tsdoc.json
-export const tsdocBlockTags = [
-    "@defaultValue",
-    "@deprecated",
-    "@example",
-    "@jsx",
-    "@param",
-    "@privateRemarks",
-    "@remarks",
-    "@returns",
-    "@see",
-    "@throws",
-    "@typeParam",
-];
-export const blockTags = [
-    ...tsdocBlockTags,
-    "@author",
-    "@callback",
-    "@category",
-    "@categoryDescription",
-    "@default",
-    "@document",
-    "@extends",
-    "@augments", // Alias for @extends
-    "@yields",
-    "@group",
-    "@groupDescription",
-    "@import",
-    "@inheritDoc",
-    "@license",
-    "@module",
-    "@mergeModuleWith",
-    "@prop",
-    "@property",
-    "@return",
-    "@satisfies",
-    "@since",
-    "@sortStrategy",
-    "@template", // Alias for @typeParam
-    "@this",
-    "@type",
-    "@typedef",
-    "@summary",
-    "@preventInline",
-    "@inlineType",
-    "@preventExpand",
-    "@expandType",
-];
-export const tsdocInlineTags = ["@link", "@inheritDoc", "@label"];
-export const inlineTags = [
-    ...tsdocInlineTags,
-    "@linkcode",
-    "@linkplain",
-    "@include",
-    "@includeCode",
-];
-export const tsdocModifierTags = [
-    "@alpha",
-    "@beta",
-    "@eventProperty",
-    "@experimental",
-    "@internal",
-    "@override",
-    "@packageDocumentation",
-    "@public",
-    "@readonly",
-    "@sealed",
-    "@virtual",
-];
-export const modifierTags = [
-    ...tsdocModifierTags,
-    "@abstract",
-    "@class",
-    "@disableGroups",
-    "@enum",
-    "@event",
-    "@expand",
-    "@hidden",
-    "@hideCategories",
-    "@hideconstructor",
-    "@hideGroups",
-    "@ignore",
-    "@inline",
-    "@interface",
-    "@namespace",
-    "@function",
-    "@overload",
-    "@private",
-    "@protected",
-    "@showCategories",
-    "@showGroups",
-    "@useDeclaredType",
-    "@primaryExport",
-];

package/dist/lib/utils/package-manifest.js

@@ -1,84 +0,0 @@
-// Utilities to support the inspection of node package "manifests"
-import { dirname } from "path";
-import { glob, readFile } from "./fs.js";
-import { createGlobString, nicePath, normalizePath } from "./paths.js";
-import { i18n } from "#utils";
-/**
- * Helper for the TS type system to understand hasOwnProperty
- * and narrow a type appropriately.
- * @param obj the receiver of the hasOwnProperty method call
- * @param prop the property to test for
- */
-function hasOwnProperty(obj, prop) {
-    return Object.prototype.hasOwnProperty.call(obj, prop);
-}
-/**
- * Loads a package.json and validates that it is a JSON Object
- */
-export function loadPackageManifest(logger, packageJsonPath) {
-    const packageJson = JSON.parse(readFile(packageJsonPath));
-    if (typeof packageJson !== "object" || !packageJson) {
-        logger.error(i18n.file_0_not_an_object(nicePath(packageJsonPath)));
-        return undefined;
-    }
-    return packageJson;
-}
-/**
- * Load the paths to packages specified in a Yarn workspace package JSON
- * Returns undefined if packageJSON does not define a Yarn workspace
- * @param packageJSON the package json object
- */
-function getPackagePaths(packageJSON) {
-    if (Array.isArray(packageJSON["workspaces"]) &&
-        packageJSON["workspaces"].every((i) => typeof i === "string")) {
-        return packageJSON["workspaces"];
-    }
-    if (typeof packageJSON["workspaces"] === "object" &&
-        packageJSON["workspaces"] != null) {
-        const workspaces = packageJSON["workspaces"];
-        if (hasOwnProperty(workspaces, "packages") &&
-            Array.isArray(workspaces["packages"]) &&
-            workspaces["packages"].every((i) => typeof i === "string")) {
-            return workspaces["packages"];
-        }
-    }
-    return undefined;
-}
-/**
- * Given a list of (potentially wildcard containing) package paths,
- * return all the actual package folders found.
- */
-export function expandPackages(logger, packageJsonDir, workspaces, exclude) {
-    // Technically npm and Yarn workspaces don't support recursive nesting,
-    // however we support the passing of paths to either packages or
-    // to the root of a workspace tree in our params and so we could here
-    // be dealing with either a root or a leaf. So let's do this recursively,
-    // as it actually is simpler from an implementation perspective anyway.
-    return workspaces.flatMap((workspace) => {
-        const expandedPackageJsonPaths = glob(createGlobString(packageJsonDir, `${workspace}/package.json`), packageJsonDir);
-        if (expandedPackageJsonPaths.length === 0) {
-            logger.warn(i18n.entry_point_0_did_not_match_any_packages(nicePath(workspace)));
-        }
-        else if (expandedPackageJsonPaths.length !== 1) {
-            logger.verbose(`Expanded ${nicePath(workspace)} to:\n\t${expandedPackageJsonPaths
-                .map(nicePath)
-                .join("\n\t")}`);
-        }
-        return expandedPackageJsonPaths.flatMap((packageJsonPath) => {
-            if (exclude.matchesAny(dirname(packageJsonPath))) {
-                return [];
-            }
-            const packageJson = loadPackageManifest(logger, packageJsonPath);
-            if (packageJson === undefined) {
-                return [];
-            }
-            const packagePaths = getPackagePaths(packageJson);
-            if (packagePaths === undefined) {
-                // Assume this is a single package repo
-                return [dirname(packageJsonPath)];
-            }
-            // This is a workspace root package, recurse
-            return expandPackages(logger, normalizePath(dirname(packageJsonPath)), packagePaths.map(p => createGlobString(normalizePath(dirname(packageJsonPath)), p)), exclude);
-        });
-    });
-}

package/dist/lib/utils/paths.js

@@ -1,127 +0,0 @@
-import { countMatches, filterMap } from "#utils";
-import { Minimatch } from "minimatch";
-import { dirname, isAbsolute, relative, resolve } from "path";
-export class MinimatchSet {
-    patterns;
-    constructor(patterns) {
-        this.patterns = patterns.map(p => new Minimatch(p, { dot: true }));
-    }
-    matchesAny(path) {
-        return this.patterns.some(p => {
-            return p.match(path);
-        });
-    }
-}
-function escapeGlob(glob) {
-    return glob.replace(/[?*()[\]\\{}]/g, "\\$&");
-}
-function isGlobalGlob(glob) {
-    const start = glob.match(/^[!#]+/)?.[0].length ?? 0;
-    return glob.startsWith("**", start);
-}
-export function splitGlobToPathAndSpecial(glob) {
-    const modifiers = glob.match(/^[!#]+/)?.[0] ?? "";
-    const noModifierGlob = glob.substring(modifiers.length);
-    if (isGlobalGlob(glob)) {
-        return { modifiers, path: "", glob: noModifierGlob };
-    }
-    const mini = new Minimatch(noModifierGlob, { dot: true });
-    const basePaths = mini.set.map(set => {
-        const stop = set.findIndex((part) => typeof part !== "string");
-        if (stop === -1) {
-            return set.join("/");
-        }
-        else {
-            return set.slice(0, stop).join("/");
-        }
-    });
-    const base = getCommonPath(basePaths);
-    if (base) {
-        const skipIndex = countMatches(base, "/") + 1;
-        const globPart = mini.globParts.map(s => s.slice(skipIndex));
-        // This isn't ideal, it will end up re-writing the glob if braces are used,
-        // but I don't want to write a glob minimizer at this point, and this should
-        // handle all the edge cases as we're just using Minimatch's glob parsing
-        const resultingGlob = globPart.length === 1
-            ? globPart[0].join("/")
-            : `{${globPart.map(s => s.join("/")).join(",")}}`;
-        return { modifiers, path: base, glob: resultingGlob };
-    }
-    return { modifiers, path: "", glob: noModifierGlob };
-}
-export function createGlobString(relativeTo, glob) {
-    if (isAbsolute(glob) || isGlobalGlob(glob))
-        return glob;
-    const split = splitGlobToPathAndSpecial(glob);
-    const leadingPath = normalizePath(resolve(relativeTo, split.path));
-    if (!split.glob) {
-        return split.modifiers + escapeGlob(leadingPath);
-    }
-    return `${split.modifiers}${escapeGlob(leadingPath)}/${split.glob}`;
-}
-/**
- * Get the longest directory path common to all files.
- */
-export function getCommonPath(files) {
-    if (!files.length) {
-        return "";
-    }
-    const roots = files.map((f) => f.split("/"));
-    if (roots.length === 1) {
-        return roots[0].join("/");
-    }
-    let i = 0;
-    while (i < roots[0].length &&
-        new Set(roots.map((part) => part[i])).size === 1) {
-        i++;
-    }
-    return roots[0].slice(0, i).join("/");
-}
-export function getCommonDirectory(files) {
-    if (files.length === 1) {
-        return normalizePath(dirname(files[0]));
-    }
-    return getCommonPath(files);
-}
-export function deriveRootDir(globPaths) {
-    const globs = new MinimatchSet(globPaths).patterns;
-    const rootPaths = globs.flatMap((glob, i) => filterMap(glob.set, (set) => {
-        const stop = set.findIndex((part) => typeof part !== "string");
-        if (stop === -1) {
-            return globPaths[i];
-        }
-        else {
-            const kept = set.slice(0, stop).join("/");
-            return globPaths[i].substring(0, globPaths[i].indexOf(kept) + kept.length);
-        }
-    }));
-    return getCommonDirectory(rootPaths);
-}
-export function nicePath(absPath) {
-    if (!isAbsolute(absPath))
-        return absPath;
-    const relativePath = relative(process.cwd(), absPath);
-    if (relativePath.startsWith("..")) {
-        return normalizePath(absPath);
-    }
-    return `./${normalizePath(relativePath)}`;
-}
-/**
- * Normalize the given path.
- *
- * @param path  The path that should be normalized.
- * @returns The normalized path.
- */
-export function normalizePath(path) {
-    if (process.platform === "win32") {
-        // Ensure forward slashes
-        path = path.replace(/\\/g, "/");
-        // Msys2 git on windows will give paths which use unix-style
-        // absolute paths, like /c/users/you. Since the rest of TypeDoc
-        // expects drive letters, convert it to that here.
-        path = path.replace(/^\/([a-zA-Z])\//, (_m, m1) => `${m1}:/`);
-        // Make Windows drive letters upper case
-        path = path.replace(/^([^:]+):\//, (_m, m1) => m1.toUpperCase() + ":/");
-    }
-    return path;
-}

package/dist/lib/utils/perf.js

@@ -1,86 +0,0 @@
-/* eslint-disable no-console */
-const benchmarks = [];
-export function bench(fn, name = fn.name) {
-    const matching = benchmarks.find((b) => b.name === name);
-    const timer = matching || {
-        name,
-        calls: 0,
-        time: 0,
-    };
-    if (!matching)
-        benchmarks.push(timer);
-    return function bench(...args) {
-        timer.calls++;
-        const start = performance.now();
-        const end = () => (timer.time += performance.now() - start);
-        let result;
-        try {
-            result = fn.apply(this, args);
-        }
-        catch (error) {
-            end();
-            throw error;
-        }
-        if (result instanceof Promise) {
-            result.then((res) => {
-                end();
-                return res;
-            }, (reason) => {
-                end();
-                throw reason;
-            });
-        }
-        else {
-            end();
-        }
-        return result;
-    };
-}
-function BenchField(_value, context) {
-    let runner;
-    return function (value) {
-        if (!runner) {
-            const className = context.static
-                ? this.name
-                : Object.getPrototypeOf(this).constructor.name;
-            runner = bench(value, `${className}.${String(context.name)}`);
-        }
-        return function (...args) {
-            return runner.apply(this, args);
-        };
-    };
-}
-function BenchMethod(value, context) {
-    let runner;
-    return function (...args) {
-        if (!runner) {
-            const className = context.static
-                ? this.name
-                : Object.getPrototypeOf(this).constructor.name;
-            runner = bench(value, `${className}.${String(context.name)}`);
-        }
-        return runner.apply(this, args);
-    };
-}
-export const Bench = (value, context) => {
-    if (context.kind === "field") {
-        return BenchField(value, context);
-    }
-    return BenchMethod(value, context);
-};
-export function measure(cb) {
-    return bench(cb, "measure()")();
-}
-process.on("exit", () => {
-    if (!benchmarks.length)
-        return;
-    const table = benchmarks.map((b) => {
-        return {
-            Benchmarked: b.name,
-            Calls: b.calls,
-            "Time (ms)": Math.round(b.time * 100) / 100,
-            "Average (ms)": Math.round((b.time / b.calls) * 100) / 100,
-        };
-    });
-    console.table(table);
-});

package/dist/lib/utils/plugins.js

@@ -1,61 +0,0 @@
-import { isAbsolute } from "path";
-import { pathToFileURL } from "url";
-import { nicePath } from "./paths.js";
-import { i18n } from "#utils";
-export async function loadPlugins(app, plugins) {
-    for (const plugin of plugins) {
-        const pluginDisplay = getPluginDisplayName(plugin);
-        try {
-            let initFunction;
-            if (typeof plugin === "function") {
-                initFunction = plugin;
-            }
-            else {
-                let instance;
-                // Try importing first to avoid warnings about requiring ESM being experimental.
-                // If that fails due to importing a directory, fall back to require.
-                try {
-                    // On Windows, we need to ensure this path is a file path.
-                    // Or we'll get ERR_UNSUPPORTED_ESM_URL_SCHEME
-                    const esmPath = isAbsolute(plugin)
-                        ? pathToFileURL(plugin).toString()
-                        : plugin;
-                    instance = await import(esmPath);
-                }
-                catch (error) {
-                    if (error.code === "ERR_UNSUPPORTED_DIR_IMPORT") {
-                        // eslint-disable-next-line @typescript-eslint/no-require-imports
-                        instance = require(plugin);
-                    }
-                    else {
-                        throw error;
-                    }
-                }
-                initFunction = instance.load;
-            }
-            if (typeof initFunction === "function") {
-                await initFunction(app);
-                app.logger.info(i18n.loaded_plugin_0(pluginDisplay));
-            }
-            else {
-                app.logger.error(i18n.invalid_plugin_0_missing_load_function(pluginDisplay));
-            }
-        }
-        catch (error) {
-            app.logger.error(i18n.plugin_0_could_not_be_loaded(pluginDisplay));
-            if (error instanceof Error && error.stack) {
-                app.logger.error(error.stack);
-            }
-        }
-    }
-}
-function getPluginDisplayName(plugin) {
-    if (typeof plugin === "function") {
-        return plugin.name || "function";
-    }
-    const path = nicePath(plugin);
-    if (path.startsWith("./node_modules/")) {
-        return path.substring("./node_modules/".length);
-    }
-    return plugin;
-}

package/dist/lib/utils/reflections.js

@@ -1,64 +0,0 @@
-import { ContainerReflection, DeclarationReflection, makeRecursiveVisitor, ParameterReflection, Reflection, SignatureReflection, TypeParameterReflection, } from "../models/index.js";
-export function discoverAllReferenceTypes(project, forExportValidation) {
-    let current = project;
-    const queue = [];
-    const result = [];
-    const visitor = makeRecursiveVisitor({
-        reference(type) {
-            result.push({ type, owner: current });
-        },
-        reflection(type) {
-            queue.push(type.declaration);
-        },
-    });
-    const add = (item) => {
-        if (!item)
-            return;
-        if (item instanceof Reflection) {
-            queue.push(item);
-        }
-        else {
-            queue.push(...item);
-        }
-    };
-    do {
-        if (current instanceof ContainerReflection) {
-            add(current.children);
-        }
-        if (current instanceof DeclarationReflection) {
-            current.type?.visit(visitor);
-            add(current.typeParameters);
-            add(current.signatures);
-            add(current.indexSignatures);
-            add(current.getSignature);
-            add(current.setSignature);
-            current.overwrites?.visit(visitor);
-            current.implementedTypes?.forEach((type) => type.visit(visitor));
-            if (!forExportValidation) {
-                current.inheritedFrom?.visit(visitor);
-                current.implementationOf?.visit(visitor);
-                current.extendedTypes?.forEach((t) => t.visit(visitor));
-                current.extendedBy?.forEach((t) => t.visit(visitor));
-                current.implementedBy?.forEach((t) => t.visit(visitor));
-            }
-        }
-        if (current instanceof SignatureReflection) {
-            add(current.parameters);
-            add(current.typeParameters);
-            current.type?.visit(visitor);
-            current.overwrites?.visit(visitor);
-            if (!forExportValidation) {
-                current.inheritedFrom?.visit(visitor);
-                current.implementationOf?.visit(visitor);
-            }
-        }
-        if (current instanceof ParameterReflection) {
-            current.type?.visit(visitor);
-        }
-        if (current instanceof TypeParameterReflection) {
-            current.type?.visit(visitor);
-            current.default?.visit(visitor);
-        }
-    } while ((current = queue.shift()));
-    return result;
-}

package/dist/lib/utils/sort.js

@@ -1,153 +0,0 @@
-/**
- * Module which handles sorting reflections according to a user specified strategy.
- * @module
- */
-import { ReflectionKind } from "../models/kind.js";
-import * as OptionDefaults from "./options/defaults.js";
-export const SORT_STRATEGIES = [
-    "source-order",
-    "alphabetical",
-    "alphabetical-ignoring-documents",
-    "enum-value-ascending",
-    "enum-value-descending",
-    "enum-member-source-order",
-    "static-first",
-    "instance-first",
-    "visibility",
-    "required-first",
-    "kind",
-    "external-last",
-    "documents-first",
-    "documents-last",
-];
-// Return true if a < b
-const sorts = {
-    "source-order"(a, b) {
-        // This is going to be somewhat ambiguous. No way around that. Treat the first
-        // declaration of a symbol as its ordering declaration.
-        const aSymbol = a.project.getSymbolIdFromReflection(a);
-        const bSymbol = b.project.getSymbolIdFromReflection(b);
-        if (aSymbol && bSymbol) {
-            if (aSymbol.packageName < bSymbol.packageName) {
-                return true;
-            }
-            if (aSymbol.packageName === bSymbol.packageName &&
-                aSymbol.packagePath < bSymbol.packagePath) {
-                return true;
-            }
-            if (aSymbol.packageName === bSymbol.packageName &&
-                aSymbol.packagePath === bSymbol.packagePath &&
-                aSymbol.pos < bSymbol.pos) {
-                return true;
-            }
-            return false;
-        }
-        // Someone is doing something weird. Fail to re-order. This could happen if someone
-        // tries to sort with a reflection that has been removed from the project.
-        return false;
-    },
-    alphabetical(a, b) {
-        return a.name.localeCompare(b.name) < 0;
-    },
-    "alphabetical-ignoring-documents"(a, b) {
-        if (a.kindOf(ReflectionKind.Document) ||
-            b.kindOf(ReflectionKind.Document)) {
-            return false;
-        }
-        return a.name.localeCompare(b.name) < 0;
-    },
-    "enum-value-ascending"(a, b) {
-        if (a.kind == ReflectionKind.EnumMember &&
-            b.kind == ReflectionKind.EnumMember) {
-            const aRefl = a;
-            const bRefl = b;
-            const aValue = aRefl.type?.type === "literal" ? aRefl.type.value : -Infinity;
-            const bValue = bRefl.type?.type === "literal" ? bRefl.type.value : -Infinity;
-            return aValue < bValue;
-        }
-        return false;
-    },
-    "enum-value-descending"(a, b) {
-        if (a.kind == ReflectionKind.EnumMember &&
-            b.kind == ReflectionKind.EnumMember) {
-            const aRefl = a;
-            const bRefl = b;
-            const aValue = aRefl.type?.type === "literal" ? aRefl.type.value : -Infinity;
-            const bValue = bRefl.type?.type === "literal" ? bRefl.type.value : -Infinity;
-            return bValue < aValue;
-        }
-        return false;
-    },
-    "enum-member-source-order"(a, b, data) {
-        if (a.kind === ReflectionKind.EnumMember &&
-            b.kind === ReflectionKind.EnumMember) {
-            return sorts["source-order"](a, b, data);
-        }
-        return false;
-    },
-    "static-first"(a, b) {
-        return a.flags.isStatic && !b.flags.isStatic;
-    },
-    "instance-first"(a, b) {
-        return !a.flags.isStatic && b.flags.isStatic;
-    },
-    visibility(a, b) {
-        // Note: flags.isPublic may not be set on public members. It will only be set
-        // if the user explicitly marks members as public. Therefore, we can't use it
-        // here to get a reliable sort order.
-        if (a.flags.isPrivate) {
-            return false; // Not sorted before anything
-        }
-        if (a.flags.isProtected) {
-            return b.flags.isPrivate; // Sorted before privates
-        }
-        if (b.flags.isPrivate || b.flags.isProtected) {
-            return true; // We are public, sort before b if b is less visible
-        }
-        return false;
-    },
-    "required-first"(a, b) {
-        return !a.flags.isOptional && b.flags.isOptional;
-    },
-    kind(a, b, { kindSortOrder }) {
-        return kindSortOrder.indexOf(a.kind) < kindSortOrder.indexOf(b.kind);
-    },
-    "external-last"(a, b) {
-        return !a.flags.isExternal && b.flags.isExternal;
-    },
-    "documents-first"(a, b) {
-        return (a.kindOf(ReflectionKind.Document) &&
-            !b.kindOf(ReflectionKind.Document));
-    },
-    "documents-last"(a, b) {
-        return (!a.kindOf(ReflectionKind.Document) &&
-            b.kindOf(ReflectionKind.Document));
-    },
-};
-export function isValidSortStrategy(strategy) {
-    return SORT_STRATEGIES.includes(strategy);
-}
-export function getSortFunction(opts, strategies = opts.getValue("sort")) {
-    const kindSortOrder = opts
-        .getValue("kindSortOrder")
-        .map((k) => ReflectionKind[k]);
-    for (const kind of OptionDefaults.kindSortOrder) {
-        if (!kindSortOrder.includes(ReflectionKind[kind])) {
-            kindSortOrder.push(ReflectionKind[kind]);
-        }
-    }
-    const data = { kindSortOrder };
-    return function sortReflections(reflections) {
-        reflections.sort((a, b) => {
-            for (const s of strategies) {
-                if (sorts[s](a, b, data)) {
-                    return -1;
-                }
-                if (sorts[s](b, a, data)) {
-                    return 1;
-                }
-            }
-            return 0;
-        });
-    };
-}