typedoc 0.26.10 → 0.27.0-beta.0

package/dist/lib/utils/fs.js

@@ -1,52 +1,11 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFile = isFile;
-exports.isDir = isDir;
-exports.deriveRootDir = deriveRootDir;
-exports.getCommonDirectory = getCommonDirectory;
-exports.readFile = readFile;
-exports.writeFileSync = writeFileSync;
-exports.writeFile = writeFile;
-exports.copy = copy;
-exports.copySync = copySync;
-exports.glob = glob;
-exports.hasTsExtension = hasTsExtension;
-exports.hasDeclarationFileExtension = hasDeclarationFileExtension;
-exports.discoverInParentDir = discoverInParentDir;
-exports.discoverInParentDirExactMatch = discoverInParentDirExactMatch;
-exports.discoverPackageJson = discoverPackageJson;
-exports.findPackageForPath = findPackageForPath;
-const fs = __importStar(require("fs"));
-const fs_1 = require("fs");
-const minimatch_1 = require("minimatch");
-const path_1 = require("path");
-const validation_1 = require("./validation");
-const paths_1 = require("./paths");
-const array_1 = require("./array");
-function isFile(file) {
+import * as fs from "fs";
+import { promises as fsp } from "fs";
+import { Minimatch } from "minimatch";
+import { dirname, join, relative, resolve } from "path";
+import { optional, validate } from "./validation.js";
+import { createMinimatch, normalizePath } from "./paths.js";
+import { filterMap } from "./array.js";
+export function isFile(file) {
     try {
         return fs.statSync(file).isFile();
     }
@@ -54,7 +13,7 @@ function isFile(file) {
         return false;
     }
 }
-function isDir(path) {
+export function isDir(path) {
     try {
         return fs.statSync(path).isDirectory();
     }
@@ -62,10 +21,10 @@ function isDir(path) {
         return false;
     }
 }
-function deriveRootDir(globPaths) {
-    const normalized = globPaths.map(paths_1.normalizePath);
-    const globs = (0, paths_1.createMinimatch)(normalized);
-    const rootPaths = globs.flatMap((glob, i) => (0, array_1.filterMap)(glob.set, (set) => {
+export function deriveRootDir(globPaths) {
+    const normalized = globPaths.map(normalizePath);
+    const globs = createMinimatch(normalized);
+    const rootPaths = globs.flatMap((glob, i) => filterMap(glob.set, (set) => {
         const stop = set.findIndex((part) => typeof part !== "string");
         if (stop === -1) {
             return normalized[i];
@@ -80,7 +39,7 @@ function deriveRootDir(globPaths) {
 /**
  * Get the longest directory path common to all files.
  */
-function getCommonDirectory(files) {
+export function getCommonDirectory(files) {
     if (!files.length) {
         return "";
     }
@@ -101,7 +60,7 @@ function getCommonDirectory(files) {
  * @param file  The path of the file to read.
  * @returns The files contents.
  */
-function readFile(file) {
+export function readFile(file) {
     const buffer = fs.readFileSync(file);
     switch (buffer[0]) {
         case 0xfe:
@@ -136,9 +95,9 @@ function readFile(file) {
  * @param fileName  The name of the file that should be written.
  * @param data  The contents of the file.
  */
-function writeFileSync(fileName, data) {
-    fs.mkdirSync((0, path_1.dirname)((0, paths_1.normalizePath)(fileName)), { recursive: true });
-    fs.writeFileSync((0, paths_1.normalizePath)(fileName), data);
+export function writeFileSync(fileName, data) {
+    fs.mkdirSync(dirname(normalizePath(fileName)), { recursive: true });
+    fs.writeFileSync(normalizePath(fileName), data);
 }
 /**
  * Write a file to disc.
@@ -148,37 +107,37 @@ function writeFileSync(fileName, data) {
  * @param fileName  The name of the file that should be written.
  * @param data  The contents of the file.
  */
-async function writeFile(fileName, data) {
-    await fs_1.promises.mkdir((0, path_1.dirname)((0, paths_1.normalizePath)(fileName)), {
+export async function writeFile(fileName, data) {
+    await fsp.mkdir(dirname(normalizePath(fileName)), {
         recursive: true,
     });
-    await fs_1.promises.writeFile((0, paths_1.normalizePath)(fileName), data);
+    await fsp.writeFile(normalizePath(fileName), data);
 }
 /**
  * Copy a file or directory recursively.
  */
-async function copy(src, dest) {
-    const stat = await fs_1.promises.stat(src);
+export async function copy(src, dest) {
+    const stat = await fsp.stat(src);
     if (stat.isDirectory()) {
-        const contained = await fs_1.promises.readdir(src);
-        await Promise.all(contained.map((file) => copy((0, path_1.join)(src, file), (0, path_1.join)(dest, file))));
+        const contained = await fsp.readdir(src);
+        await Promise.all(contained.map((file) => copy(join(src, file), join(dest, file))));
     }
     else if (stat.isFile()) {
-        await fs_1.promises.mkdir((0, path_1.dirname)(dest), { recursive: true });
-        await fs_1.promises.copyFile(src, dest);
+        await fsp.mkdir(dirname(dest), { recursive: true });
+        await fsp.copyFile(src, dest);
     }
     else {
         // Do nothing for FIFO, special devices.
     }
 }
-function copySync(src, dest) {
+export function copySync(src, dest) {
     const stat = fs.statSync(src);
     if (stat.isDirectory()) {
         const contained = fs.readdirSync(src);
-        contained.forEach((file) => copySync((0, path_1.join)(src, file), (0, path_1.join)(dest, file)));
+        contained.forEach((file) => copySync(join(src, file), join(dest, file)));
     }
     else if (stat.isFile()) {
-        fs.mkdirSync((0, path_1.dirname)(dest), { recursive: true });
+        fs.mkdirSync(dirname(dest), { recursive: true });
         fs.copyFileSync(src, dest);
     }
     else {
@@ -188,10 +147,10 @@ function copySync(src, dest) {
 /**
  * Simpler version of `glob.sync` that only covers our use cases, always ignoring node_modules.
  */
-function glob(pattern, root, options = {}) {
+export function glob(pattern, root, options = {}) {
     const result = [];
-    const mini = new minimatch_1.Minimatch((0, paths_1.normalizePath)(pattern));
-    const dirs = [(0, paths_1.normalizePath)(root).split("/")];
+    const mini = new Minimatch(normalizePath(pattern));
+    const dirs = [normalizePath(root).split("/")];
     // cache of real paths to avoid infinite recursion
     const symlinkTargetsSeen = new Set();
     // cache of fs.realpathSync results to avoid extra I/O
@@ -244,7 +203,7 @@ function glob(pattern, root, options = {}) {
                     // special case: real path of symlink is the directory we're currently traversing
                     return;
                 }
-                const targetPath = (0, path_1.relative)(dirpath, realpath);
+                const targetPath = relative(dirpath, realpath);
                 handleSymlink(targetPath);
             } // everything else should be ignored
         }
@@ -275,61 +234,61 @@ function glob(pattern, root, options = {}) {
     }
     return result;
 }
-function hasTsExtension(path) {
+export function hasTsExtension(path) {
     return /\.[cm]?ts$|\.tsx$/.test(path);
 }
-function hasDeclarationFileExtension(path) {
+export function hasDeclarationFileExtension(path) {
     return /\.d\.[cm]?ts$/.test(path);
 }
-function discoverInParentDir(name, dir, read) {
+export function discoverInParentDir(name, dir, read) {
     if (!isDir(dir))
         return;
-    const reachedTopDirectory = (dirName) => dirName === (0, path_1.resolve)((0, path_1.join)(dirName, ".."));
+    const reachedTopDirectory = (dirName) => dirName === resolve(join(dirName, ".."));
     while (!reachedTopDirectory(dir)) {
         for (const file of fs.readdirSync(dir)) {
             if (file.toLowerCase() !== name.toLowerCase())
                 continue;
             try {
-                const content = read(readFile((0, path_1.join)(dir, file)));
+                const content = read(readFile(join(dir, file)));
                 if (content != null) {
-                    return { file: (0, path_1.join)(dir, file), content };
+                    return { file: join(dir, file), content };
                 }
             }
             catch {
                 // Ignore, file didn't pass validation
             }
         }
-        dir = (0, path_1.resolve)((0, path_1.join)(dir, ".."));
+        dir = resolve(join(dir, ".."));
     }
 }
-function discoverInParentDirExactMatch(name, dir, read) {
+export function discoverInParentDirExactMatch(name, dir, read) {
     if (!isDir(dir))
         return;
-    const reachedTopDirectory = (dirName) => dirName === (0, path_1.resolve)((0, path_1.join)(dirName, ".."));
+    const reachedTopDirectory = (dirName) => dirName === resolve(join(dirName, ".."));
     while (!reachedTopDirectory(dir)) {
         try {
-            const content = read(readFile((0, path_1.join)(dir, name)));
+            const content = read(readFile(join(dir, name)));
             if (content != null) {
-                return { file: (0, path_1.join)(dir, name), content };
+                return { file: join(dir, name), content };
             }
         }
         catch {
             // Ignore, file didn't pass validation
         }
-        dir = (0, path_1.resolve)((0, path_1.join)(dir, ".."));
+        dir = resolve(join(dir, ".."));
     }
 }
-function discoverPackageJson(dir) {
+export function discoverPackageJson(dir) {
     return discoverInParentDirExactMatch("package.json", dir, (content) => {
         const pkg = JSON.parse(content);
-        if ((0, validation_1.validate)({ name: String, version: (0, validation_1.optional)(String) }, pkg)) {
+        if (validate({ name: String, version: optional(String) }, pkg)) {
             return pkg;
         }
     });
 }
 // dir -> package name according to package.json in this or some parent dir
 const packageCache = new Map();
-function findPackageForPath(sourcePath) {
+export function findPackageForPath(sourcePath) {
     // Attempt to decide package name from path if it contains "node_modules"
     let startIndex = sourcePath.lastIndexOf("node_modules/");
     if (startIndex !== -1) {
@@ -341,7 +300,7 @@ function findPackageForPath(sourcePath) {
         }
         return sourcePath.substring(startIndex, stopIndex);
     }
-    const dir = (0, path_1.dirname)(sourcePath);
+    const dir = dirname(sourcePath);
     const cache = packageCache.get(dir);
     if (cache) {
         return cache;

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

@@ -39,7 +39,8 @@ export type Chars<T extends string> = T extends `${infer C}${infer R}` ? C | Cha
  * Utility to help type checking ensure that there is no uncovered case.
  */
 export declare function assertNever(x: never): never;
-export declare function camelToTitleCase(text: string): string;
+export declare function editDistance(s: string, t: string): number;
+export declare function getSimilarValues(values: Iterable<string>, compareTo: string): string[];
 export declare function NonEnumerable(_cls: unknown, context: ClassFieldDecoratorContext): void;
 export declare function hasBeenLoadedMultipleTimes(): boolean;
 export declare function getLoadedPaths(): string[];

package/dist/lib/utils/general.js

@@ -1,46 +1,56 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertNever = assertNever;
-exports.camelToTitleCase = camelToTitleCase;
-exports.NonEnumerable = NonEnumerable;
-exports.hasBeenLoadedMultipleTimes = hasBeenLoadedMultipleTimes;
-exports.getLoadedPaths = getLoadedPaths;
-const path_1 = require("path");
-const Util = __importStar(require("util"));
+import { dirname } from "path";
+import * as Util from "util";
+import url from "url";
+import { DefaultMap } from "./map.js";
 /**
  * Utility to help type checking ensure that there is no uncovered case.
  */
-function assertNever(x) {
+export function assertNever(x) {
     throw new Error(`Expected handling to cover all possible cases, but it didn't cover: ${Util.inspect(x)}`);
 }
-function camelToTitleCase(text) {
-    return (text.substring(0, 1).toUpperCase() +
-        text.substring(1).replace(/[a-z][A-Z]/g, (x) => `${x[0]} ${x[1]}`));
+// Based on https://en.wikipedia.org/wiki/Levenshtein_distance#Iterative_with_two_matrix_rows
+// Slightly modified for improved match results for options
+export function editDistance(s, t) {
+    if (s.length < t.length)
+        return editDistance(t, s);
+    let v0 = Array.from({ length: t.length + 1 }, (_, i) => i);
+    let v1 = Array.from({ length: t.length + 1 }, () => 0);
+    for (let i = 0; i < s.length; i++) {
+        v1[0] = i + 1;
+        for (let j = 0; j < s.length; j++) {
+            const deletionCost = v0[j + 1] + 1;
+            const insertionCost = v1[j] + 1;
+            let substitutionCost;
+            if (s[i] === t[j]) {
+                substitutionCost = v0[j];
+            }
+            else if (s[i]?.toUpperCase() === t[j]?.toUpperCase()) {
+                substitutionCost = v0[j] + 1;
+            }
+            else {
+                substitutionCost = v0[j] + 3;
+            }
+            v1[j + 1] = Math.min(deletionCost, insertionCost, substitutionCost);
+        }
+        [v0, v1] = [v1, v0];
+    }
+    return v0[t.length];
+}
+export function getSimilarValues(values, compareTo) {
+    const results = new DefaultMap(() => []);
+    let lowest = Infinity;
+    for (const name of values) {
+        const distance = editDistance(compareTo, name);
+        lowest = Math.min(lowest, distance);
+        results.get(distance).push(name);
+    }
+    // Experimenting a bit, it seems an edit distance of 3 is roughly the
+    // right metric for relevant "similar" results without showing obviously wrong suggestions
+    return results
+        .get(lowest)
+        .concat(results.get(lowest + 1), results.get(lowest + 2));
 }
-function NonEnumerable(_cls, context) {
+export function NonEnumerable(_cls, context) {
     context.addInitializer(function () {
         Object.defineProperty(this, context.name, {
             enumerable: false,
@@ -60,10 +70,10 @@ const g = globalThis;
 g[loadSymbol] = (g[loadSymbol] || 0) + 1;
 g[pathSymbol] ||= [];
 // transform /abs/path/to/typedoc/dist/lib/utils/general -> /abs/path/to/typedoc
-g[pathSymbol].push((0, path_1.dirname)((0, path_1.dirname)((0, path_1.dirname)(__dirname))));
-function hasBeenLoadedMultipleTimes() {
+g[pathSymbol].push(dirname(dirname(dirname(dirname(url.fileURLToPath(import.meta.url))))));
+export function hasBeenLoadedMultipleTimes() {
     return g[loadSymbol] !== 1;
 }
-function getLoadedPaths() {
+export function getLoadedPaths() {
     return g[pathSymbol] || [];
 }

package/dist/lib/utils/highlighter.js

@@ -1,45 +1,12 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadShikiMetadata = loadShikiMetadata;
-exports.loadHighlighter = loadHighlighter;
-exports.isSupportedLanguage = isSupportedLanguage;
-exports.getSupportedLanguages = getSupportedLanguages;
-exports.getSupportedLanguagesWithoutAliases = getSupportedLanguagesWithoutAliases;
-exports.getSupportedThemes = getSupportedThemes;
-exports.isLoadedLanguage = isLoadedLanguage;
-exports.highlight = highlight;
-exports.getStyles = getStyles;
-const assert_1 = require("assert");
-const JSX = __importStar(require("./jsx"));
-const array_1 = require("./array");
+import { ok as assert, ok } from "assert";
+import * as JSX from "./jsx.js";
+import { unique } from "./array.js";
 const aliases = new Map();
 let supportedLanguagesWithoutAliases = [];
 let supportedLanguages = [];
 let supportedThemes = [];
-async function loadShikiMetadata() {
+const plaintextLanguages = ["txt", "text"];
+export async function loadShikiMetadata() {
     if (aliases.size)
         return;
     const shiki = await import("shiki");
@@ -48,20 +15,26 @@ async function loadShikiMetadata() {
             aliases.set(alias, lang.id);
         }
     }
-    supportedLanguages = (0, array_1.unique)([
-        "text",
+    supportedLanguages = unique([
+        ...plaintextLanguages,
         ...aliases.keys(),
         ...shiki.bundledLanguagesInfo.map((lang) => lang.id),
     ]).sort();
-    supportedLanguagesWithoutAliases = (0, array_1.unique)(["text", ...shiki.bundledLanguagesInfo.map((lang) => lang.id)]);
+    supportedLanguagesWithoutAliases = unique([
+        ...plaintextLanguages,
+        ...shiki.bundledLanguagesInfo.map((lang) => lang.id),
+    ]);
     supportedThemes = Object.keys(shiki.bundledThemes);
 }
 class DoubleHighlighter {
+    highlighter;
+    light;
+    dark;
+    schemes = new Map();
     constructor(highlighter, light, dark) {
         this.highlighter = highlighter;
         this.light = light;
         this.dark = dark;
-        this.schemes = new Map();
     }
     supports(lang) {
         return this.highlighter.getLoadedLanguages().includes(lang);
@@ -129,39 +102,39 @@ class DoubleHighlighter {
     }
 }
 let highlighter;
-async function loadHighlighter(lightTheme, darkTheme, langs) {
+export async function loadHighlighter(lightTheme, darkTheme, langs) {
     if (highlighter)
         return;
     const shiki = await import("shiki");
     const hl = await shiki.createHighlighter({ themes: [lightTheme, darkTheme], langs });
     highlighter = new DoubleHighlighter(hl, lightTheme, darkTheme);
 }
-function isSupportedLanguage(lang) {
+export function isSupportedLanguage(lang) {
     return getSupportedLanguages().includes(lang);
 }
-function getSupportedLanguages() {
-    (0, assert_1.ok)(supportedLanguages.length > 0, "loadShikiMetadata has not been called");
+export function getSupportedLanguages() {
+    ok(supportedLanguages.length > 0, "loadShikiMetadata has not been called");
     return supportedLanguages;
 }
-function getSupportedLanguagesWithoutAliases() {
-    (0, assert_1.ok)(supportedLanguagesWithoutAliases.length > 0, "loadShikiMetadata has not been called");
+export function getSupportedLanguagesWithoutAliases() {
+    ok(supportedLanguagesWithoutAliases.length > 0, "loadShikiMetadata has not been called");
     return supportedLanguages;
 }
-function getSupportedThemes() {
-    (0, assert_1.ok)(supportedThemes.length > 0, "loadShikiMetadata has not been called");
+export function getSupportedThemes() {
+    ok(supportedThemes.length > 0, "loadShikiMetadata has not been called");
     return supportedThemes;
 }
-function isLoadedLanguage(lang) {
-    return lang === "text" || (highlighter?.supports(lang) ?? false);
+export function isLoadedLanguage(lang) {
+    return plaintextLanguages.includes(lang) || (highlighter?.supports(lang) ?? false);
 }
-function highlight(code, lang) {
-    (0, assert_1.ok)(highlighter, "Tried to highlight with an uninitialized highlighter");
-    if (lang === "text") {
+export function highlight(code, lang) {
+    assert(highlighter, "Tried to highlight with an uninitialized highlighter");
+    if (plaintextLanguages.includes(lang)) {
         return JSX.renderElement(JSX.createElement(JSX.Fragment, null, code));
     }
     return highlighter.highlight(code, aliases.get(lang) ?? lang);
 }
-function getStyles() {
-    (0, assert_1.ok)(highlighter, "Tried to highlight with an uninitialized highlighter");
+export function getStyles() {
+    assert(highlighter, "Tried to highlight with an uninitialized highlighter");
     return highlighter.getStyles();
 }

package/dist/lib/utils/hooks.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventHooks = void 0;
-const array_1 = require("./array");
+import { insertOrderSorted } from "./array.js";
 const momentos = new WeakMap();
 /**
  * Event emitter which allows listeners to return a value.
@@ -19,12 +16,10 @@ const momentos = new WeakMap();
  * x.on('a' a => 1) // error, returns a number but expected a string
  * ```
  */
-class EventHooks {
-    constructor() {
-        // Function is *usually* not a good type to use, but here it lets us specify stricter
-        // contracts in the methods while not casting everywhere this is used.
-        this._listeners = new Map();
-    }
+export class EventHooks {
+    // Function is *usually* not a good type to use, but here it lets us specify stricter
+    // contracts in the methods while not casting everywhere this is used.
+    _listeners = new Map();
     /**
      * Starts listening to an event.
      * @param event the event to listen to.
@@ -33,7 +28,7 @@ class EventHooks {
      */
     on(event, listener, order = 0) {
         const list = (this._listeners.get(event) || []).slice();
-        (0, array_1.insertOrderSorted)(list, { listener, order });
+        insertOrderSorted(list, { listener, order });
         this._listeners.set(event, list);
     }
     /**
@@ -44,7 +39,7 @@ class EventHooks {
      */
     once(event, listener, order = 0) {
         const list = (this._listeners.get(event) || []).slice();
-        (0, array_1.insertOrderSorted)(list, { listener, once: true, order });
+        insertOrderSorted(list, { listener, once: true, order });
         this._listeners.set(event, list);
     }
     /**
@@ -93,4 +88,3 @@ class EventHooks {
         }
     }
 }
-exports.EventHooks = EventHooks;