typedoc 0.28.7 → 0.28.9

package/dist/index.d.ts

@@ -41,7 +41,7 @@ export type { Icons, NavigationElement, PageDefinition, PageHeading, RendererEve
 export { Outputs } from "./lib/output/output.js";
 export { ArgumentsReader, CommentStyle, EntryPointStrategy, normalizePath, Option, OptionDefaults, Options, PackageJsonReader, ParameterHint, ParameterType, TSConfigReader, TypeDocReader, ValidatingFileRegistry, } from "./lib/utils/index.js";
 export type { ArrayDeclarationOption, BooleanDeclarationOption, DeclarationOption, DeclarationOptionBase, DeclarationOptionToOptionType, DocumentationEntryPoint, FancyConsoleLogger, FlagsDeclarationOption, JsDocCompatibility, KeyToDeclaration, ManuallyValidatedOption, MapDeclarationOption, MixedDeclarationOption, NumberDeclarationOption, ObjectDeclarationOption, OptionsReader, OutputSpecification, ParameterTypeToOptionTypeMap, SortStrategy, StringDeclarationOption, TypeDocOptionMap, TypeDocOptions, TypeDocOptionValues, ValidationOptions, } from "./lib/utils/index.js";
-export { type ComponentPath, ConsoleLogger, type DeclarationReference, type EnumKeys, EventDispatcher, EventHooks, type GlobString, i18n, JSX, Logger, LogLevel, type Meaning, type MeaningKeyword, type MinimalNode, MinimalSourceFile, type NormalizedPath, type NormalizedPathOrModule, type SymbolReference, type TranslatedString, translateTagName, } from "#utils";
+export { type ComponentPath, ConsoleLogger, type DeclarationReference, type EnumKeys, EventDispatcher, EventHooks, type GlobString, i18n, JSX, Logger, LogLevel, type Meaning, type MeaningKeyword, type MinimalNode, MinimalSourceFile, type NormalizedPath, type NormalizedPathOrModule, type NormalizedPathOrModuleOrFunction, type SymbolReference, type TranslatedString, translateTagName, } from "#utils";
 export { type Deserializable, Deserializer, type DeserializerComponent, JSONOutput, SerializeEvent, Serializer, type SerializerComponent, type SerializerEvents, } from "./lib/serialization/index.js";
 export * as Internationalization from "./lib/internationalization/index.js";
 export type { TranslatableStrings } from "./lib/internationalization/internationalization.js";

package/dist/lib/application.js

@@ -59,7 +59,6 @@ import { Outputs } from "./output/output.js";
 import { validateMergeModuleWith } from "./validation/unusedMergeModuleWith.js";
 import { diagnostic, diagnostics } from "./utils/loggers.js";
 import { ValidatingFileRegistry } from "./utils/ValidatingFileRegistry.js";
-import { addInferredDeclarationMapPaths } from "./converter/factories/symbol-id.js";
 import { Internationalization } from "./internationalization/internationalization.js";
 const packageInfo = JSON.parse(readFileSync(Path.join(fileURLToPath(import.meta.url), "../../../package.json"), "utf8"));
 const supportedVersionMajorMinor = packageInfo.peerDependencies.typescript
@@ -626,7 +625,6 @@ let Application = (() => {
                     this.logger.error(i18n.nested_packages_unsupported_0(nicePath(dir)));
                     continue;
                 }
-                addInferredDeclarationMapPaths(opts.getCompilerOptions(), opts.getFileNames());
                 projectsToConvert.push({ dir, options: opts });
             }
             for (const { dir, options } of projectsToConvert) {

package/dist/lib/converter/comments/blockLexer.d.ts

@@ -1,3 +1,4 @@
 import ts from "typescript";
 import { type Token } from "./lexer.js";
-export declare function lexBlockComment(file: string, pos?: number, end?: number, jsDoc?: ts.JSDoc | undefined, checker?: ts.TypeChecker | undefined): Generator<Token, undefined, undefined>;
+import type { Context } from "../context.js";
+export declare function lexBlockComment(file: string, pos?: number, end?: number, createSymbolId?: Context["createSymbolId"], jsDoc?: ts.JSDoc | undefined, checker?: ts.TypeChecker | undefined): Generator<Token, undefined, undefined>;

package/dist/lib/converter/comments/blockLexer.js

@@ -1,11 +1,12 @@
 import ts from "typescript";
 import { TokenSyntaxKind } from "./lexer.js";
 import { resolveAliasedSymbol } from "../utils/symbols.js";
-import { createSymbolId } from "../factories/symbol-id.js";
-export function* lexBlockComment(file, pos = 0, end = file.length, jsDoc = undefined, checker = undefined) {
+export function* lexBlockComment(file, pos = 0, end = file.length, createSymbolId = () => {
+    throw new Error("unreachable");
+}, jsDoc = undefined, checker = undefined) {
     // Wrapper around our real lex function to collapse adjacent text tokens.
     let textToken;
-    for (const token of lexBlockComment2(file, pos, end, getLinkTags(jsDoc), checker)) {
+    for (const token of lexBlockComment2(file, pos, end, getLinkTags(jsDoc), checker, createSymbolId)) {
         if (token.kind === TokenSyntaxKind.Text) {
             if (textToken) {
                 textToken.text += token.text;
@@ -53,7 +54,7 @@ function getLinkTags(jsDoc) {
     }
     return result;
 }
-function* lexBlockComment2(file, pos, end, linkTags, checker) {
+function* lexBlockComment2(file, pos, end, linkTags, checker, createSymbolId) {
     pos += 2; // Leading '/*'
     end -= 2; // Trailing '*/'
     if (pos < end && file[pos] === "*") {
@@ -208,7 +209,7 @@ function* lexBlockComment2(file, pos, end, linkTags, checker) {
                 }
                 if (lookahead !== pos + 1) {
                     while (lookahead < end &&
-                        /[a-z0-9]/i.test(file[lookahead])) {
+                        /[a-z0-9-]/i.test(file[lookahead])) {
                         lookahead++;
                     }
                 }

package/dist/lib/converter/comments/index.d.ts

@@ -3,6 +3,7 @@ import { Comment, ReflectionKind } from "../../models/index.js";
 import type { CommentStyle, JsDocCompatibility } from "../../utils/options/declaration.js";
 import type { FileRegistry } from "../../models/FileRegistry.js";
 import { type Logger } from "#utils";
+import type { Context } from "../context.js";
 export interface CommentParserConfig {
     blockTags: Set<string>;
     inlineTags: Set<string>;
@@ -12,9 +13,23 @@ export interface CommentParserConfig {
     useTsLinkResolution: boolean;
     commentStyle: CommentStyle;
 }
+export interface CommentContext {
+    config: CommentParserConfig;
+    logger: Logger;
+    checker: ts.TypeChecker;
+    files: FileRegistry;
+    createSymbolId: Context["createSymbolId"];
+}
+export interface CommentContextOptionalChecker {
+    config: CommentParserConfig;
+    logger: Logger;
+    checker?: ts.TypeChecker | undefined;
+    files: FileRegistry;
+    createSymbolId: Context["createSymbolId"];
+}
 export declare function clearCommentCache(): void;
-export declare function getComment(symbol: ts.Symbol, kind: ReflectionKind, config: CommentParserConfig, logger: Logger, checker: ts.TypeChecker, files: FileRegistry): Comment | undefined;
-export declare function getNodeComment(node: ts.Node, moduleComment: boolean, config: CommentParserConfig, logger: Logger, checker: ts.TypeChecker | undefined, files: FileRegistry): Comment | undefined;
-export declare function getFileComment(file: ts.SourceFile, config: CommentParserConfig, logger: Logger, checker: ts.TypeChecker | undefined, files: FileRegistry): Comment | undefined;
-export declare function getSignatureComment(declaration: ts.SignatureDeclaration | ts.JSDocSignature, config: CommentParserConfig, logger: Logger, checker: ts.TypeChecker, files: FileRegistry): Comment | undefined;
-export declare function getJsDocComment(declaration: ts.JSDocPropertyLikeTag | ts.JSDocCallbackTag | ts.JSDocTypedefTag | ts.JSDocTemplateTag | ts.JSDocEnumTag, config: CommentParserConfig, logger: Logger, checker: ts.TypeChecker | undefined, files: FileRegistry): Comment | undefined;
+export declare function getComment(symbol: ts.Symbol, kind: ReflectionKind, context: CommentContext): Comment | undefined;
+export declare function getNodeComment(node: ts.Node, moduleComment: boolean, context: CommentContext): Comment | undefined;
+export declare function getFileComment(file: ts.SourceFile, context: CommentContext): Comment | undefined;
+export declare function getSignatureComment(declaration: ts.SignatureDeclaration | ts.JSDocSignature, context: CommentContext): Comment | undefined;
+export declare function getJsDocComment(declaration: ts.JSDocPropertyLikeTag | ts.JSDocCallbackTag | ts.JSDocTypedefTag | ts.JSDocTemplateTag | ts.JSDocEnumTag, context: CommentContext): Comment | undefined;

package/dist/lib/converter/comments/index.js

@@ -21,7 +21,7 @@ export function clearCommentCache() {
     commentCache = new WeakMap();
     commentDiscoveryId = 0;
 }
-function getCommentWithCache(discovered, config, logger, checker, files) {
+function getCommentWithCache(discovered, context) {
     if (!discovered)
         return;
     const { file, ranges, jsDoc } = discovered;
@@ -34,10 +34,10 @@ function getCommentWithCache(discovered, config, logger, checker, files) {
     let comment;
     switch (ranges[0].kind) {
         case ts.SyntaxKind.MultiLineCommentTrivia:
-            comment = parseComment(lexBlockComment(file.text, ranges[0].pos, ranges[0].end, jsDoc, checker), config, file, logger, files);
+            comment = parseComment(lexBlockComment(file.text, ranges[0].pos, ranges[0].end, context.createSymbolId, jsDoc, context.checker), file, context);
             break;
         case ts.SyntaxKind.SingleLineCommentTrivia:
-            comment = parseComment(lexLineComments(file.text, ranges), config, file, logger, files);
+            comment = parseComment(lexLineComments(file.text, ranges), file, context);
             break;
         default:
             assertNever(ranges[0].kind);
@@ -48,8 +48,11 @@ function getCommentWithCache(discovered, config, logger, checker, files) {
     commentCache.set(file, cache);
     return comment.clone();
 }
-function getCommentImpl(commentSource, config, logger, moduleComment, checker, files) {
-    const comment = getCommentWithCache(commentSource, config, logger, config.useTsLinkResolution ? checker : undefined, files);
+function getCommentImpl(commentSource, moduleComment, context) {
+    const comment = getCommentWithCache(commentSource, {
+        ...context,
+        checker: context.config.useTsLinkResolution ? context.checker : undefined,
+    });
     if (comment?.getTag("@import") || comment?.getTag("@license")) {
         return;
     }
@@ -70,15 +73,15 @@ function getCommentImpl(commentSource, config, logger, moduleComment, checker, f
     }
     return comment;
 }
-export function getComment(symbol, kind, config, logger, checker, files) {
+export function getComment(symbol, kind, context) {
     const declarations = symbol.declarations || [];
     if (declarations.length &&
         declarations.every((d) => jsDocCommentKinds.includes(d.kind))) {
-        return getJsDocComment(declarations[0], config, logger, checker, files);
+        return getJsDocComment(declarations[0], context);
     }
     const sf = declarations.find(ts.isSourceFile);
     if (sf) {
-        return getFileComment(sf, config, logger, checker, files);
+        return getFileComment(sf, context);
     }
     const isModule = declarations.some((decl) => {
         if (ts.isModuleDeclaration(decl) && ts.isStringLiteral(decl.name)) {
@@ -86,18 +89,18 @@ export function getComment(symbol, kind, config, logger, checker, files) {
         }
         return false;
     });
-    const comment = getCommentImpl(discoverComment(symbol, kind, logger, config.commentStyle, checker, !config.suppressCommentWarningsInDeclarationFiles), config, logger, isModule, checker, files);
+    const comment = getCommentImpl(discoverComment(symbol, kind, context.logger, context.config.commentStyle, context.checker, !context.config.suppressCommentWarningsInDeclarationFiles), isModule, context);
     if (!comment && kind === ReflectionKind.Property) {
-        return getConstructorParamPropertyComment(symbol, config, logger, checker, files);
+        return getConstructorParamPropertyComment(symbol, context);
     }
     return comment;
 }
-export function getNodeComment(node, moduleComment, config, logger, checker, files) {
-    return getCommentImpl(discoverNodeComment(node, config.commentStyle), config, logger, moduleComment, checker, files);
+export function getNodeComment(node, moduleComment, context) {
+    return getCommentImpl(discoverNodeComment(node, context.config.commentStyle), moduleComment, context);
 }
-export function getFileComment(file, config, logger, checker, files) {
-    for (const commentSource of discoverFileComments(file, config.commentStyle)) {
-        const comment = getCommentWithCache(commentSource, config, logger, config.useTsLinkResolution ? checker : undefined, files);
+export function getFileComment(file, context) {
+    for (const commentSource of discoverFileComments(file, context.config.commentStyle)) {
+        const comment = getCommentWithCache(commentSource, context);
         if (comment?.getTag("@license") || comment?.getTag("@import")) {
             continue;
         }
@@ -108,12 +111,12 @@ export function getFileComment(file, config, logger, checker, files) {
         return;
     }
 }
-function getConstructorParamPropertyComment(symbol, config, logger, checker, files) {
+function getConstructorParamPropertyComment(symbol, context) {
     const decl = symbol.declarations?.find(ts.isParameter);
     if (!decl)
         return;
     const ctor = decl.parent;
-    const comment = getSignatureComment(ctor, config, logger, checker, files);
+    const comment = getSignatureComment(ctor, context);
     const paramTag = comment?.getIdentifiedTag(symbol.name, "@param");
     if (paramTag) {
         const result = new Comment(paramTag.content);
@@ -121,10 +124,10 @@ function getConstructorParamPropertyComment(symbol, config, logger, checker, fil
         return result;
     }
 }
-export function getSignatureComment(declaration, config, logger, checker, files) {
-    return getCommentImpl(discoverSignatureComment(declaration, checker, config.commentStyle), config, logger, false, checker, files);
+export function getSignatureComment(declaration, context) {
+    return getCommentImpl(discoverSignatureComment(declaration, context.checker, context.config.commentStyle), false, context);
 }
-export function getJsDocComment(declaration, config, logger, checker, files) {
+export function getJsDocComment(declaration, context) {
     const file = declaration.getSourceFile();
     // First, get the whole comment. We know we'll need all of it.
     let parent = declaration.parent;
@@ -143,7 +146,7 @@ export function getJsDocComment(declaration, config, logger, checker, files) {
         ],
         jsDoc: parent,
         inheritedFromParentDeclaration: false,
-    }, config, logger, config.useTsLinkResolution ? checker : undefined, files);
+    }, context);
     // And pull out the tag we actually care about.
     if (ts.isJSDocEnumTag(declaration)) {
         const result = new Comment(comment.getTag("@enum")?.content);
@@ -156,7 +159,7 @@ export function getJsDocComment(declaration, config, logger, checker, files) {
         // We could just put the same comment on everything, but due to how comment parsing works,
         // we'd have to search for any @template with a name starting with the first type parameter's name
         // which feels horribly hacky.
-        logger.warn(i18n.multiple_type_parameters_on_template_tag_unsupported(), declaration);
+        context.logger.warn(i18n.multiple_type_parameters_on_template_tag_unsupported(), declaration);
         return;
     }
     let name;
@@ -176,7 +179,7 @@ export function getJsDocComment(declaration, config, logger, checker, files) {
         // was a comment attached. If there wasn't, then don't error about failing to find
         // a tag because this is unsupported.
         if (!ts.isJSDocTemplateTag(declaration)) {
-            logger.error(i18n.failed_to_find_jsdoc_tag_for_name_0(name), declaration);
+            context.logger.error(i18n.failed_to_find_jsdoc_tag_for_name_0(name), declaration);
         }
     }
     else {

package/dist/lib/converter/comments/lineLexer.js

@@ -145,7 +145,7 @@ function* lexLineComments2(file, pos, end) {
                 }
                 if (lookahead !== pos + 1) {
                     while (lookahead < end &&
-                        /[a-z0-9]/i.test(file[lookahead])) {
+                        /[a-z0-9-]/i.test(file[lookahead])) {
                         lookahead++;
                     }
                 }

package/dist/lib/converter/comments/parser.d.ts

@@ -1,10 +1,10 @@
-import type { CommentParserConfig } from "./index.js";
+import type { CommentContextOptionalChecker, CommentParserConfig } from "./index.js";
 import { Comment, type CommentDisplayPart } from "../../models/index.js";
 import type { MinimalSourceFile } from "#utils";
 import { type Token } from "./lexer.js";
 import { FileRegistry } from "../../models/FileRegistry.js";
 import { type Logger } from "#utils";
-export declare function parseComment(tokens: Generator<Token, undefined, undefined>, config: CommentParserConfig, file: MinimalSourceFile, logger: Logger, files: FileRegistry): Comment;
+export declare function parseComment(tokens: Generator<Token, undefined, undefined>, file: MinimalSourceFile, context: CommentContextOptionalChecker): Comment;
 /**
  * Intended for parsing markdown documents. This only parses code blocks and
  * inline tags outside of code blocks, everything else is text.

package/dist/lib/converter/comments/parser.js

@@ -40,24 +40,24 @@ function makeLookaheadGenerator(gen) {
         },
     };
 }
-export function parseComment(tokens, config, file, logger, files) {
+export function parseComment(tokens, file, context) {
     const lexer = makeLookaheadGenerator(tokens);
     const tok = lexer.done() || lexer.peek();
     const comment = new Comment();
     comment.sourcePath = file.fileName;
-    comment.summary = blockContent(comment, lexer, config, i18n, warningImpl, files);
+    comment.summary = blockContent(comment, lexer, context.config, i18n, warningImpl, context.files);
     while (!lexer.done()) {
-        comment.blockTags.push(blockTag(comment, lexer, config, i18n, warningImpl, files));
+        comment.blockTags.push(blockTag(comment, lexer, context.config, i18n, warningImpl, context.files));
     }
     const tok2 = tok;
-    postProcessComment(comment, i18n, () => `${nicePath(file.fileName)}:${file.getLineAndCharacterOfPosition(tok2.pos).line + 1}`, (message) => logger.warn(message));
+    postProcessComment(comment, i18n, () => `${nicePath(file.fileName)}:${file.getLineAndCharacterOfPosition(tok2.pos).line + 1}`, (message) => context.logger.warn(message));
     return comment;
     function warningImpl(message, token) {
-        if (config.suppressCommentWarningsInDeclarationFiles &&
+        if (context.config.suppressCommentWarningsInDeclarationFiles &&
             hasDeclarationFileExtension(file.fileName)) {
             return;
         }
-        logger.warn(message, token.pos, file);
+        context.logger.warn(message, token.pos, file);
     }
 }
 /**

package/dist/lib/converter/comments/rawLexer.js

@@ -151,7 +151,7 @@ function* lexCommentString2(file) {
                 }
                 if (lookahead !== pos + 1) {
                     while (lookahead < end &&
-                        /[a-z0-9]/i.test(file[lookahead])) {
+                        /[a-z0-9-]/i.test(file[lookahead])) {
                         lookahead++;
                     }
                 }

package/dist/lib/converter/comments/textParser.js

@@ -85,9 +85,11 @@ export function textContent(sourcePath, token, i18n, warning, outContent, files,
             addRef(reference);
             continue;
         }
-        const tagLink = checkTagLink(data);
-        if (tagLink) {
-            addRef(tagLink);
+        const tagLinks = checkTagLink(data);
+        if (tagLinks.length) {
+            for (const tagLink of tagLinks) {
+                addRef(tagLink);
+            }
             continue;
         }
         const atNewLine = token.text[data.pos] === "\n";
@@ -221,39 +223,111 @@ function checkReference(data) {
     }
 }
 /**
- * Looks for `<a href="./relative">` and `<img src="./relative">`
+ * Looks for `<a href="./relative">`, `<img src="./relative">`, and `<source srcset="./relative">`
  */
 function checkTagLink(data) {
     const { pos, token } = data;
     if (token.text.startsWith("<img ", pos)) {
         data.pos += 4;
-        return checkAttribute(data, "src");
+        return checkAttributes(data, {
+            src: checkAttributeDirectPath,
+            srcset: checkAttributeSrcSet,
+        });
+    }
+    if (token.text.startsWith("<link ", pos)) {
+        data.pos += 4;
+        return checkAttributes(data, {
+            imagesrcset: checkAttributeSrcSet,
+        });
     }
     if (token.text.startsWith("<a ", pos)) {
         data.pos += 3;
-        return checkAttribute(data, "href");
+        return checkAttributes(data, { href: checkAttributeDirectPath });
     }
+    if (token.text.startsWith("<source ", pos)) {
+        data.pos += 8;
+        return checkAttributes(data, {
+            src: checkAttributeDirectPath,
+            srcset: checkAttributeSrcSet,
+        });
+    }
+    return [];
 }
-function checkAttribute(data, attr) {
+function checkAttributes(data, attributes) {
+    const links = [];
     const parser = new HtmlAttributeParser(data.token.text, data.pos);
     while (parser.state !== ParserState.END) {
         if (parser.state === ParserState.BeforeAttributeValue &&
-            parser.currentAttributeName === attr) {
+            Object.prototype.hasOwnProperty.call(attributes, parser.currentAttributeName)) {
             parser.step();
-            if (isRelativePath(parser.currentAttributeValue)) {
-                data.pos = parser.pos;
-                const { target, anchor } = data.files.register(data.sourcePath, parser.currentAttributeValue) || { target: undefined, anchor: undefined };
-                return {
-                    pos: parser.currentAttributeValueStart,
-                    end: parser.currentAttributeValueEnd,
-                    target,
-                    targetAnchor: anchor,
-                };
-            }
-            return;
+            links.push(...attributes[parser.currentAttributeName](data, parser.currentAttributeValue, parser.currentAttributeValueStart, parser.currentAttributeValueEnd));
         }
         parser.step();
     }
+    return links;
+}
+function checkAttributeDirectPath(data, text, pos, end) {
+    if (isRelativePath(text.trim())) {
+        const { target, anchor } = data.files.register(data.sourcePath, text.trim()) || { target: undefined, anchor: undefined };
+        return [{
+                pos,
+                end,
+                target,
+                targetAnchor: anchor,
+            }];
+    }
+    return [];
+}
+// See https://html.spec.whatwg.org/multipage/images.html#srcset-attribute
+function checkAttributeSrcSet(data, text, pos, _end) {
+    const result = [];
+    let textPos = 0;
+    parseImageCandidate();
+    while (textPos < text.length && text[textPos] == ",") {
+        ++textPos;
+        parseImageCandidate();
+    }
+    return result;
+    function parseImageCandidate() {
+        // 1. Zero or more ASCII whitespace
+        while (textPos < text.length && /[\t\r\f\n ]/.test(text[textPos]))
+            ++textPos;
+        // 2. A valid non-empty URL that does not start or end with a comma
+        // TypeDoc: We don't exactly match this, PR welcome! For now, just permit anything
+        // that's not whitespace or a comma
+        const url = text.slice(textPos).match(/^[^\t\r\f\n ,]+/);
+        if (url && isRelativePath(url[0])) {
+            const { target, anchor } = data.files.register(data.sourcePath, url[0]) || { target: undefined, anchor: undefined };
+            result.push({
+                pos: pos + textPos,
+                end: pos + textPos + url[0].length,
+                target,
+                targetAnchor: anchor,
+            });
+        }
+        textPos += url ? url[0].length : 0;
+        // 3. Zero or more ASCII whitespace
+        while (textPos < text.length && /[\t\r\f\n ]/.test(text[textPos]))
+            ++textPos;
+        // 4. Zero or one of the following:
+        {
+            // A width descriptor, consisting of: ASCII whitespace, a valid non-negative integer giving
+            // a number greater than zero representing the width descriptor value, and a U+0077 LATIN
+            // SMALL LETTER W character.
+            const w = text.slice(textPos).match(/^\+?\d+\s*w/);
+            textPos += w ? w[0].length : 0;
+            // A pixel density descriptor, consisting of: ASCII whitespace, a valid floating-point number
+            // giving a number greater than zero representing the pixel density descriptor value, and a
+            // U+0078 LATIN SMALL LETTER X character.
+            if (!w) {
+                const x = text.slice(textPos).match(/^\+?\d+(\.\d+)?([eE][+-]\d+)?\s*x/);
+                textPos += x ? x[0].length : 0;
+            }
+        }
+        // 5. Zero or more ASCII whitespace
+        while (textPos < text.length && /[\t\r\f\n ]/.test(text[textPos]))
+            ++textPos;
+    }
 }
 function isRelativePath(link) {
     // Lots of edge cases encoded right here!

package/dist/lib/converter/context.d.ts

@@ -67,6 +67,15 @@ export declare class Context {
      * This is available on Context so that it can be monkey-patched by typedoc-plugin-missing-exports
      */
     createSymbolReference(symbol: ts.Symbol, context: Context, name?: string): ReferenceType;
+    /**
+     * Create a stable {@link ReflectionSymbolId} for the provided symbol,
+     * optionally targeting a specific declaration.
+     *
+     * @privateRemarks
+     * This is available on Context so that it can be monkey-patched by typedoc-plugin-missing-exports
+     * It might also turn out to be generally useful for other plugin users.
+     */
+    createSymbolId(symbol: ts.Symbol, declaration?: ts.Declaration): import("../models/ReflectionSymbolId.js").ReflectionSymbolId;
     addChild(reflection: DeclarationReflection | DocumentReflection): void;
     shouldIgnore(symbol: ts.Symbol): boolean;
     /**
@@ -81,6 +90,7 @@ export declare class Context {
     getSymbolFromReflection(reflection: Reflection): ts.Symbol | undefined;
     /** @internal */
     setActiveProgram(program: ts.Program | undefined): void;
+    private createCommentContext;
     getComment(symbol: ts.Symbol, kind: ReflectionKind): Comment | undefined;
     getNodeComment(node: ts.Node, moduleComment: boolean): Comment | undefined;
     getFileComment(node: ts.SourceFile): Comment | undefined;

package/dist/lib/converter/context.js

@@ -4,10 +4,10 @@ import { Comment, ContainerReflection, DeclarationReflection, ReferenceType, Ref
 import { isNamedNode } from "./utils/nodes.js";
 import { ConverterEvents } from "./converter-events.js";
 import { resolveAliasedSymbol } from "./utils/symbols.js";
-import { getComment, getFileComment, getJsDocComment, getNodeComment, getSignatureComment } from "./comments/index.js";
+import { getComment, getFileComment, getJsDocComment, getNodeComment, getSignatureComment, } from "./comments/index.js";
 import { getHumanName, getQualifiedName } from "../utils/tsutils.js";
 import { findPackageForPath, normalizePath } from "#node-utils";
-import { createSymbolId } from "./factories/symbol-id.js";
+import { createSymbolIdImpl } from "./factories/symbol-id.js";
 import { removeIf } from "#utils";
 /**
  * The context describes the current state the converter is in.
@@ -185,7 +185,7 @@ export class Context {
      * This is available on Context so that it can be monkey-patched by typedoc-plugin-missing-exports
      */
     createSymbolReference(symbol, context, name) {
-        const ref = ReferenceType.createUnresolvedReference(name ?? symbol.name, createSymbolId(symbol), context.project, getQualifiedName(symbol, name ?? symbol.name));
+        const ref = ReferenceType.createUnresolvedReference(name ?? symbol.name, this.createSymbolId(symbol), context.project, getQualifiedName(symbol, name ?? symbol.name));
         ref.refersToTypeParameter = !!(symbol.flags & ts.SymbolFlags.TypeParameter);
         const symbolPath = symbol.declarations?.[0]?.getSourceFile().fileName;
         if (!symbolPath)
@@ -193,6 +193,17 @@ export class Context {
         ref.package = findPackageForPath(symbolPath)?.[0];
         return ref;
     }
+    /**
+     * Create a stable {@link ReflectionSymbolId} for the provided symbol,
+     * optionally targeting a specific declaration.
+     *
+     * @privateRemarks
+     * This is available on Context so that it can be monkey-patched by typedoc-plugin-missing-exports
+     * It might also turn out to be generally useful for other plugin users.
+     */
+    createSymbolId(symbol, declaration) {
+        return createSymbolIdImpl(symbol, declaration);
+    }
     addChild(reflection) {
         if (this.scope instanceof ContainerReflection) {
             this.scope.addChild(reflection);
@@ -211,7 +222,7 @@ export class Context {
     registerReflection(reflection, symbol, filePath) {
         if (symbol) {
             this.reflectionIdToSymbolMap.set(reflection.id, symbol);
-            const id = createSymbolId(symbol);
+            const id = this.createSymbolId(symbol);
             // #2466
             // If we just registered a member of a class or interface, then we need to check if
             // we've registered this symbol before under the wrong parent reflection.
@@ -237,7 +248,7 @@ export class Context {
         }
     }
     getReflectionFromSymbol(symbol) {
-        return this.project.getReflectionFromSymbolId(createSymbolId(symbol));
+        return this.project.getReflectionFromSymbolId(this.createSymbolId(symbol));
     }
     getSymbolFromReflection(reflection) {
         return this.reflectionIdToSymbolMap.get(reflection.id);
@@ -246,20 +257,29 @@ export class Context {
     setActiveProgram(program) {
         this._program = program;
     }
+    createCommentContext() {
+        return {
+            config: this.converter.config,
+            logger: this.logger,
+            checker: this.checker,
+            files: this.project.files,
+            createSymbolId: (s, d) => this.createSymbolId(s, d),
+        };
+    }
     getComment(symbol, kind) {
-        return getComment(symbol, kind, this.converter.config, this.logger, this.checker, this.project.files);
+        return getComment(symbol, kind, this.createCommentContext());
     }
     getNodeComment(node, moduleComment) {
-        return getNodeComment(node, moduleComment, this.converter.config, this.logger, this.checker, this.project.files);
+        return getNodeComment(node, moduleComment, this.createCommentContext());
     }
     getFileComment(node) {
-        return getFileComment(node, this.converter.config, this.logger, this.checker, this.project.files);
+        return getFileComment(node, this.createCommentContext());
     }
     getJsDocComment(declaration) {
-        return getJsDocComment(declaration, this.converter.config, this.logger, this.checker, this.project.files);
+        return getJsDocComment(declaration, this.createCommentContext());
     }
     getSignatureComment(declaration) {
-        return getSignatureComment(declaration, this.converter.config, this.logger, this.checker, this.project.files);
+        return getSignatureComment(declaration, this.createCommentContext());
     }
     shouldInline(symbol, name) {
         if (this.preventInline.has(name))

package/dist/lib/converter/factories/signature.js

@@ -4,7 +4,6 @@ import { DeclarationReflection, IntrinsicType, ParameterReflection, PredicateTyp
 import { ConverterEvents } from "../converter-events.js";
 import { convertDefaultValue } from "../convert-expression.js";
 import { removeUndefined } from "../utils/reflections.js";
-import { createSymbolId } from "./symbol-id.js";
 export function createSignature(context, kind, signature, symbol, declaration) {
     assert(context.scope instanceof DeclarationReflection);
     declaration ||= signature.getDeclaration();
@@ -17,7 +16,7 @@ export function createSignature(context, kind, signature, symbol, declaration) {
         sigRef.setFlag(ReflectionFlag.Static);
     }
     if (symbol && declaration) {
-        context.project.registerSymbolId(sigRef, createSymbolId(symbol, declaration));
+        context.project.registerSymbolId(sigRef, context.createSymbolId(symbol, declaration));
     }
     let parentReflection = context.scope;
     if (parentReflection.kindOf(ReflectionKind.TypeLiteral) &&

package/dist/lib/converter/factories/symbol-id.d.ts

@@ -1,4 +1,3 @@
 import { ReflectionSymbolId } from "#models";
 import ts from "typescript";
-export declare function createSymbolId(symbol: ts.Symbol, declaration?: ts.Declaration): ReflectionSymbolId;
-export declare function addInferredDeclarationMapPaths(opts: ts.CompilerOptions, files: readonly string[]): void;
+export declare function createSymbolIdImpl(symbol: ts.Symbol, declaration?: ts.Declaration): ReflectionSymbolId;