typedoc 0.28.19 → 0.28.20

package/dist/lib/utils/tsconfig.js

@@ -1,60 +0,0 @@
-import ts from "typescript";
-import { isDir, isFile, readFile } from "./fs.js";
-import { createRequire } from "module";
-import { diagnostic, diagnostics } from "./loggers.js";
-export function findTsConfigFile(path, usedFile) {
-    let fileToRead = path;
-    if (isDir(fileToRead)) {
-        fileToRead = ts.findConfigFile(path, (file) => (usedFile?.(file), isFile(file)));
-    }
-    if (!fileToRead || !isFile(fileToRead)) {
-        return;
-    }
-    return fileToRead;
-}
-// We don't need recursive read checks because that would cause a diagnostic
-// when reading the tsconfig for compiler options, which happens first, and we bail before
-// doing this in that case.
-export function getTypeDocOptionsFromTsConfig(file) {
-    const readResult = ts.readConfigFile(file, readFile);
-    const result = {};
-    if (readResult.error) {
-        return result;
-    }
-    if ("extends" in readResult.config) {
-        const resolver = createRequire(file);
-        const extended = Array.isArray(readResult.config.extends)
-            ? readResult.config.extends.map(String)
-            : [String(readResult.config.extends)];
-        for (const extendedFile of extended) {
-            let resolvedParent;
-            try {
-                resolvedParent = resolver.resolve(extendedFile);
-            }
-            catch {
-                continue;
-            }
-            Object.assign(result, getTypeDocOptionsFromTsConfig(resolvedParent));
-        }
-    }
-    if ("typedocOptions" in readResult.config) {
-        Object.assign(result, readResult.config.typedocOptions);
-    }
-    return result;
-}
-const tsConfigCache = {};
-export function readTsConfig(path, logger) {
-    if (tsConfigCache[path]) {
-        return tsConfigCache[path];
-    }
-    const parsed = ts.getParsedCommandLineOfConfigFile(path, {}, {
-        ...ts.sys,
-        onUnRecoverableConfigFileDiagnostic: diagnostic.bind(null, logger),
-    });
-    if (!parsed) {
-        return;
-    }
-    diagnostics(logger, parsed.errors);
-    tsConfigCache[path] = parsed;
-    return parsed;
-}

package/dist/lib/utils/tsutils.js

@@ -1,23 +0,0 @@
-import ts from "typescript";
-export function getQualifiedName(symbol, defaultName) {
-    // Two implementation options for this one:
-    // 1. Use the internal symbol.parent, to walk up until we hit a source file symbol (if in a module)
-    //    or undefined (if in a global file)
-    // 2. Use checker.getFullyQualifiedName and parse out the name from the returned string.
-    // The symbol.parent method is easier to check for now.
-    let sym = symbol;
-    const parts = [];
-    while (sym && !sym.declarations?.some(ts.isSourceFile)) {
-        parts.unshift(getHumanName(sym.name));
-        sym = sym.parent;
-    }
-    return parts.join(".") || defaultName;
-}
-export function getHumanName(name) {
-    // Unique symbols get a name that will change between runs of the compiler.
-    const match = /^__@(.*)@\d+$/.exec(name);
-    if (match) {
-        return `[${match[1]}]`;
-    }
-    return name;
-}

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

@@ -1,152 +0,0 @@
-export const emptyArray = [];
-/**
- * Inserts an item into an array sorted by priority. If two items have the same priority,
- * the item will be inserted later will be placed later in the array.
- * Higher priority is placed earlier in the array.
- * @param arr modified by inserting item.
- * @param item
- */
-export function insertPrioritySorted(arr, item) {
-    const index = binaryFindPartition(arr, (v) => v.priority < item.priority);
-    arr.splice(index === -1 ? arr.length : index, 0, item);
-    return arr;
-}
-/**
- * Inserts an item into an array sorted by order. If two items have the same order,
- * the item inserted later will be placed later in the array.
- * The array will be sorted with lower order being placed sooner.
- * @param arr modified by inserting item.
- * @param item
- */
-export function insertOrderSorted(arr, item) {
-    const index = binaryFindPartition(arr, (v) => v.order > item.order);
-    arr.splice(index === -1 ? arr.length : index, 0, item);
-    return arr;
-}
-/**
- * Performs a binary search of a given array, returning the index of the first item
- * for which `partition` returns true. Returns the -1 if there are no items in `arr`
- * such that `partition(item)` is true.
- * @param arr
- * @param partition should return true while less than the partition point.
- */
-export function binaryFindPartition(arr, partition) {
-    if (arr.length === 0) {
-        return -1;
-    }
-    let low = 0, high = arr.length - 1;
-    while (high > low) {
-        const mid = low + Math.floor((high - low) / 2);
-        if (partition(arr[mid])) {
-            high = mid;
-        }
-        else {
-            low = mid + 1;
-        }
-    }
-    return partition(arr[low]) ? low : -1;
-}
-/**
- * Removes an item from the array if the array exists and the item is included
- * within it.
- * @param arr
- * @param item
- */
-export function removeIfPresent(arr, item) {
-    if (!arr) {
-        return;
-    }
-    const index = arr.indexOf(item);
-    if (index !== -1) {
-        arr.splice(index, 1);
-    }
-}
-/**
- * Remove items in an array which match a predicate.
- * @param arr
- * @param predicate
- */
-export function removeIf(arr, predicate) {
-    for (let i = 0; i < arr.length; i++) {
-        if (predicate(arr[i])) {
-            arr.splice(i, 1);
-            i--;
-        }
-    }
-}
-/**
- * Filters out duplicate values from the given iterable.
- * @param arr
- */
-export function unique(arr) {
-    return Array.from(new Set(arr));
-}
-export function partition(iter, predicate) {
-    const left = [];
-    const right = [];
-    for (const item of iter) {
-        if (predicate(item)) {
-            left.push(item);
-        }
-        else {
-            right.push(item);
-        }
-    }
-    return [left, right];
-}
-export function* zip(...args) {
-    const iterators = args.map((x) => x[Symbol.iterator]());
-    for (;;) {
-        const next = iterators.map((i) => i.next());
-        if (next.some((v) => v.done)) {
-            break;
-        }
-        yield next.map((v) => v.value);
-    }
-}
-export function filterMap(iter, fn) {
-    const result = [];
-    for (const item of iter || []) {
-        const newItem = fn(item);
-        if (newItem !== void 0) {
-            result.push(newItem);
-        }
-    }
-    return result;
-}
-export function firstDefined(array, callback) {
-    for (let i = 0; i < array.length; i++) {
-        const result = callback(array[i], i);
-        if (result !== undefined) {
-            return result;
-        }
-    }
-    return undefined;
-}
-export function filter(array, predicate) {
-    return array ? array.filter(predicate) : emptyArray;
-}
-export function aggregate(arr, fn) {
-    return arr.reduce((sum, it) => sum + fn(it), 0);
-}
-export function joinArray(arr, joiner, mapper) {
-    if (arr?.length) {
-        return arr.map(mapper).join(joiner);
-    }
-    return "";
-}
-export function maxElementByScore(arr, score) {
-    if (arr.length === 0) {
-        return undefined;
-    }
-    let largest = arr[0];
-    let largestScore = score(arr[0]);
-    for (let i = 1; i < arr.length; ++i) {
-        const itemScore = score(arr[i]);
-        if (itemScore > largestScore) {
-            largest = arr[i];
-            largestScore = itemScore;
-        }
-    }
-    return largest;
-}

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

@@ -1,341 +0,0 @@
-/**
- * Parser for declaration references, see the [TSDoc grammar](https://github.com/microsoft/tsdoc/blob/main/tsdoc/src/beta/DeclarationReference.grammarkdown)
- * for reference. TypeDoc **does not** support the full grammar today. This is intentional, since the TSDoc
- * specified grammar allows the user to construct nonsensical declaration references such as `abc![def!ghi]`
- *
- * @module
- */
-export const MeaningKeywords = [
-    "class", // SymbolFlags.Class
-    "interface", // SymbolFlags.Interface
-    "type", // SymbolFlags.TypeAlias
-    "enum", // SymbolFlags.Enum
-    "namespace", // SymbolFlags.Module
-    "function", // SymbolFlags.Function
-    "var", // SymbolFlags.Variable
-    "constructor", // SymbolFlags.Constructor
-    "member", // SymbolFlags.ClassMember | SymbolFlags.EnumMember
-    "event", //
-    "call", // SymbolFlags.Signature (for __call)
-    "new", // SymbolFlags.Signature (for __new)
-    "index", // SymbolFlags.Signature (for __index)
-    "complex", // Any complex type
-    // TypeDoc specific
-    "getter",
-    "setter",
-];
-export function meaningToString(meaning) {
-    let result = "";
-    if (meaning.keyword) {
-        result += meaning.keyword;
-    }
-    else if (meaning.label) {
-        result += meaning.label;
-    }
-    if (typeof meaning.index === "number") {
-        result += `(${meaning.index})`;
-    }
-    return result;
-}
-// <TAB> <VT> <FF> <SP> <NBSP> <ZWNBSP> <USP>
-const WhiteSpace = /[\t\u2B7F\u240C \u00A0\uFEFF\p{White_Space}]/u;
-const LineTerminator = "\r\n\u2028\u2029";
-const Punctuators = "{}()[]!.#~:,";
-const FutureReservedPunctuator = "{}@";
-const NavigationPunctuator = ".#~";
-const DecimalDigit = "0123456789";
-const HexDigit = DecimalDigit + "abcdefABCDEF";
-const SingleEscapeCharacter = `'"\\bfnrtv`;
-const EscapeCharacter = SingleEscapeCharacter + DecimalDigit + "xu";
-const UserLabelStart = "ABCDEFGHIJKLMNOPQRSTUVWXYZ_";
-const UserLabelCharacter = UserLabelStart + DecimalDigit;
-const SingleEscapeChars = {
-    "'": "'",
-    '"': '"',
-    "\\": "\\",
-    b: "\b",
-    f: "\f",
-    n: "\n",
-    r: "\r",
-    t: "\t",
-    v: "\v",
-};
-// EscapeSequence::
-//     SingleEscapeCharacter
-//     NonEscapeCharacter
-//     `0` [lookahead != DecimalDigit]
-//     HexEscapeSequence
-//     UnicodeEscapeSequence
-function parseEscapeSequence(source, pos, end) {
-    // SingleEscapeCharacter
-    if (SingleEscapeCharacter.includes(source[pos])) {
-        return [SingleEscapeChars[source[pos]], pos + 1];
-    }
-    // NonEscapeCharacter:: SourceCharacter but not one of EscapeCharacter or LineTerminator
-    if (!(EscapeCharacter + LineTerminator).includes(source[pos])) {
-        return [source[pos], pos + 1];
-    }
-    // `0` [lookahead != DecimalDigit]
-    if (source[pos] === "0" &&
-        pos + 1 < end &&
-        !DecimalDigit.includes(source[pos + 1])) {
-        return ["\x00", pos + 1];
-    }
-    // HexEscapeSequence:: x HexDigit HexDigit
-    if (source[pos] === "x" &&
-        pos + 2 < end &&
-        HexDigit.includes(source[pos + 1]) &&
-        HexDigit.includes(source[pos + 2])) {
-        return [
-            String.fromCharCode(parseInt(source.substring(pos + 1, pos + 3), 16)),
-            pos + 3,
-        ];
-    }
-    return parseUnicodeEscapeSequence(source, pos, end);
-}
-// UnicodeEscapeSequence::
-//     `u` HexDigit HexDigit HexDigit HexDigit
-//     `u` `{` CodePoint `}`
-// CodePoint:: > |HexDigits| but only if MV of |HexDigits| ≤ 0x10FFFF
-function parseUnicodeEscapeSequence(source, pos, end) {
-    if (source[pos] !== "u" || pos + 1 >= end) {
-        return;
-    }
-    if (HexDigit.includes(source[pos + 1])) {
-        if (pos + 4 >= end ||
-            !HexDigit.includes(source[pos + 2]) ||
-            !HexDigit.includes(source[pos + 3]) ||
-            !HexDigit.includes(source[pos + 4])) {
-            return;
-        }
-        return [
-            String.fromCharCode(parseInt(source.substring(pos + 1, pos + 5), 16)),
-            pos + 5,
-        ];
-    }
-    if (source[pos + 1] === "{" &&
-        pos + 2 < end &&
-        HexDigit.includes(source[pos + 2])) {
-        let lookahead = pos + 3;
-        while (lookahead < end && HexDigit.includes(source[lookahead])) {
-            lookahead++;
-        }
-        if (lookahead >= end || source[lookahead] !== "}")
-            return;
-        const codePoint = parseInt(source.substring(pos + 2, lookahead), 16);
-        if (codePoint <= 0x10ffff) {
-            return [String.fromCodePoint(codePoint), lookahead + 1];
-        }
-    }
-}
-// String:: `"` StringCharacters? `"`
-// StringCharacters:: StringCharacter StringCharacters?
-// StringCharacter::
-//   SourceCharacter but not one of `"` or `\` or LineTerminator
-//   `\` EscapeSequence
-export function parseString(source, pos, end) {
-    let result = "";
-    if (source[pos++] !== '"')
-        return;
-    while (pos < end) {
-        if (source[pos] === '"') {
-            return [result, pos + 1];
-        }
-        if (LineTerminator.includes(source[pos]))
-            return;
-        if (source[pos] === "\\") {
-            const esc = parseEscapeSequence(source, pos + 1, end);
-            if (!esc)
-                return;
-            result += esc[0];
-            pos = esc[1];
-            continue;
-        }
-        result += source[pos++];
-    }
-}
-// ModuleSource:: String | ModuleSourceCharacters
-export function parseModuleSource(source, pos, end) {
-    if (pos >= end)
-        return;
-    if (source[pos] === '"') {
-        return parseString(source, pos, end);
-    }
-    let lookahead = pos;
-    while (lookahead < end &&
-        !('"!' + LineTerminator).includes(source[lookahead])) {
-        lookahead++;
-    }
-    if (lookahead === pos)
-        return;
-    return [source.substring(pos, lookahead), lookahead];
-}
-// SymbolReference:
-//     ComponentPath Meaning?
-//     Meaning
-export function parseSymbolReference(source, pos, end) {
-    const path = parseComponentPath(source, pos, end);
-    pos = path?.[1] ?? pos;
-    const meaning = parseMeaning(source, pos, end);
-    pos = meaning?.[1] ?? pos;
-    if (path || meaning) {
-        return [{ path: path?.[0], meaning: meaning?.[0] }, pos];
-    }
-}
-// Component::
-//     String
-//     ComponentCharacters
-//     `[` DeclarationReference `]` <--- THIS ONE IS NOT IMPLEMENTED.
-export function parseComponent(source, pos, end) {
-    if (pos < end && source[pos] === '"') {
-        return parseString(source, pos, end);
-    }
-    let lookahead = pos;
-    while (lookahead < end &&
-        !('"' +
-            Punctuators +
-            FutureReservedPunctuator +
-            LineTerminator).includes(source[lookahead]) &&
-        !WhiteSpace.test(source[lookahead])) {
-        lookahead++;
-    }
-    if (lookahead === pos)
-        return;
-    return [source.substring(pos, lookahead), lookahead];
-}
-// ComponentPath:
-//     Component
-//     ComponentPath `.` Component                      // Navigate via 'exports' of |ComponentPath|
-//     ComponentPath `#` Component                      // Navigate via 'members' of |ComponentPath|
-//     ComponentPath `~` Component                      // Navigate via 'locals' of |ComponentPath|
-export function parseComponentPath(source, pos, end) {
-    const components = [];
-    let component = parseComponent(source, pos, end);
-    if (!component)
-        return;
-    pos = component[1];
-    components.push({ navigation: ".", path: component[0] });
-    while (pos < end && NavigationPunctuator.includes(source[pos])) {
-        const navigation = source[pos];
-        pos++;
-        component = parseComponent(source, pos, end);
-        if (!component) {
-            return;
-        }
-        pos = component[1];
-        components.push({ navigation, path: component[0] });
-    }
-    return [components, pos];
-}
-// The TSDoc specification permits the first four branches of Meaning. TypeDoc adds the UserLabel
-// branch so that the @label tag can be used with this form of declaration references.
-// Meaning:
-//     `:` MeaningKeyword                            // Indicates the meaning of a symbol (i.e. ':class')
-//     `:` MeaningKeyword `(` DecimalDigits `)`      // Indicates an overloaded meaning (i.e. ':function(1)')
-//     `:` `(` DecimalDigits `)`                     // Shorthand for an overloaded meaning (i.e. `:(1)`)
-//     `:` DecimalDigits                             // Shorthand for an overloaded meaning (i.e. ':1')
-//     `:` UserLabel                                 // Indicates a user defined label via {@label CUSTOM_LABEL}
-//
-// UserLabel:
-//     UserLabelStart UserLabelCharacter*
-export function parseMeaning(source, pos, end) {
-    if (source[pos++] !== ":")
-        return;
-    const keyword = MeaningKeywords.find((kw) => pos + kw.length <= end && source.startsWith(kw, pos));
-    if (keyword) {
-        pos += keyword.length;
-    }
-    if (!keyword && UserLabelStart.includes(source[pos])) {
-        let lookahead = pos + 1;
-        while (lookahead < end &&
-            UserLabelCharacter.includes(source[lookahead])) {
-            lookahead++;
-        }
-        return [{ label: source.substring(pos, lookahead) }, lookahead];
-    }
-    if (pos + 1 < end &&
-        source[pos] === "(" &&
-        DecimalDigit.includes(source[pos + 1])) {
-        let lookahead = pos + 1;
-        while (lookahead < end && DecimalDigit.includes(source[lookahead])) {
-            lookahead++;
-        }
-        if (lookahead < end && source[lookahead] === ")") {
-            return [
-                {
-                    keyword,
-                    index: parseInt(source.substring(pos + 1, lookahead)),
-                },
-                lookahead + 1,
-            ];
-        }
-    }
-    if (!keyword && pos < end && DecimalDigit.includes(source[pos])) {
-        let lookahead = pos;
-        while (lookahead < end && DecimalDigit.includes(source[lookahead])) {
-            lookahead++;
-        }
-        return [
-            {
-                index: parseInt(source.substring(pos, lookahead)),
-            },
-            lookahead,
-        ];
-    }
-    if (keyword) {
-        return [{ keyword }, pos];
-    }
-}
-// // NOTE: The following grammar is incorrect as |SymbolReference| and |ModuleSource| have an
-// //       ambiguous parse. The correct solution is to use a cover grammar to parse
-// //       |SymbolReference| until we hit a `!` and then reinterpret the grammar.
-// DeclarationReference:
-//   [empty]
-//   SymbolReference                               // Shorthand reference to symbol
-//   ModuleSource `!`                              // Reference to a module
-//   ModuleSource `!` SymbolReference              // Reference to an export of a module
-//   ModuleSource `!` `~` SymbolReference          // Reference to a local of a module
-//   `!` SymbolReference                           // Reference to global symbol
-export function parseDeclarationReference(source, pos, end) {
-    let moduleSource;
-    let symbolReference;
-    let resolutionStart = "local";
-    let topLevelLocalReference = false;
-    const moduleSourceOrSymbolRef = parseModuleSource(source, pos, end);
-    if (moduleSourceOrSymbolRef) {
-        if (moduleSourceOrSymbolRef[1] < end &&
-            source[moduleSourceOrSymbolRef[1]] === "!") {
-            // We had a module source!
-            pos = moduleSourceOrSymbolRef[1] + 1;
-            resolutionStart = "global";
-            moduleSource = moduleSourceOrSymbolRef[0];
-            // We might be referencing a local of a module
-            if (source[pos] === "~") {
-                topLevelLocalReference = true;
-                pos++;
-            }
-        }
-    }
-    else if (source[pos] === "!") {
-        pos++;
-        resolutionStart = "global";
-    }
-    const ref = parseSymbolReference(source, pos, end);
-    if (ref) {
-        symbolReference = ref[0];
-        if (topLevelLocalReference && symbolReference.path?.length) {
-            symbolReference.path[0].navigation = "~";
-        }
-        pos = ref[1];
-    }
-    if (!moduleSource && !symbolReference)
-        return;
-    return [
-        {
-            moduleSource,
-            resolutionStart,
-            symbolReference,
-        },
-        pos,
-    ];
-}

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

@@ -1,27 +0,0 @@
-export function getEnumFlags(flags) {
-    const result = [];
-    for (let i = 1; i <= flags; i <<= 1) {
-        if (flags & i) {
-            result.push(i);
-        }
-    }
-    return result;
-}
-// T & {} reduces inference priority
-export function removeFlag(flag, remove) {
-    return (flag & ~remove);
-}
-export function hasAllFlags(flags, check) {
-    return (flags & check) === check;
-}
-export function hasAnyFlag(flags, check) {
-    return (flags & check) !== 0;
-}
-export function debugFlags(Enum, flags) {
-    return getEnumKeys(Enum).filter((key) => (Enum[key] & flags) === Enum[key]);
-}
-// Note: String enums are not handled.
-export function getEnumKeys(Enum) {
-    const E = Enum;
-    return Object.keys(E).filter((k) => E[E[k]] === k);
-}

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

@@ -1,49 +0,0 @@
-import { insertPrioritySorted } from "./array.js";
-/**
- * Intentionally very simple event emitter.
- *
- * @privateRemarks
- * This is essentially a stripped down copy of EventHooks in hooks.ts.
- */
-export class EventDispatcher {
-    // 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.
-     * @param listener function to be called when an this event is emitted.
-     * @param priority optional priority to insert this hook with.
-     *  Higher priority is placed earlier in the listener array.
-     */
-    on(event, listener, priority = 0) {
-        const list = (this._listeners.get(event) || []).slice();
-        insertPrioritySorted(list, { listener, priority });
-        this._listeners.set(event, list);
-    }
-    /**
-     * Stops listening to an event.
-     * @param event the event to stop listening to.
-     * @param listener the function to remove from the listener array.
-     */
-    off(event, listener) {
-        const listeners = this._listeners.get(event);
-        if (listeners) {
-            const index = listeners.findIndex((lo) => lo.listener === listener);
-            if (index > -1) {
-                listeners.splice(index, 1);
-            }
-        }
-    }
-    /**
-     * Emits an event to all currently subscribed listeners.
-     * @param event the event to emit.
-     * @param args any arguments required for the event.
-     */
-    trigger(event, ...args) {
-        const listeners = this._listeners.get(event)?.slice() || [];
-        for (const { listener } of listeners) {
-            listener(...args);
-        }
-    }
-}

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

@@ -1,22 +0,0 @@
-/**
- * Utility to help type checking ensure that there is no uncovered case.
- */
-export function assertNever(x) {
-    throw new Error(`Expected handling to cover all possible cases, but it didn't cover: ${JSON.stringify(x)}`);
-}
-export function assert(x, message = "Assertion failed") {
-    if (!x) {
-        // eslint-disable-next-line no-debugger
-        debugger;
-        throw new Error(message);
-    }
-}
-export function NonEnumerable(_cls, context) {
-    context.addInitializer(function () {
-        Object.defineProperty(this, context.name, {
-            enumerable: false,
-            configurable: true,
-            writable: true,
-        });
-    });
-}