typedoc 0.23.13 → 0.23.14

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export { EventDispatcher, Event } from "./lib/utils/events";
 export { resetReflectionID } from "./lib/models/reflections/abstract";
 export { normalizePath } from "./lib/utils/fs";
 export * from "./lib/models";
-export { Converter, Context, type CommentParserConfig } from "./lib/converter";
+export { Converter, Context, type CommentParserConfig, type DeclarationReference, type SymbolReference, type ComponentPath, type Meaning, type MeaningKeyword, } from "./lib/converter";
 export { Renderer, DefaultTheme, DefaultThemeRenderContext, UrlMapping, Theme, PageEvent, RendererEvent, MarkdownEvent, IndexEvent, } from "./lib/output";
 export type { RenderTemplate, RendererHooks } from "./lib/output";
 export { ArgumentsReader, BindOption, CommentStyle, JSX, LogLevel, Logger, Options, ParameterHint, ParameterType, TSConfigReader, TypeDocReader, EntryPointStrategy, EventHooks, MinimalSourceFile, } from "./lib/utils";

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

@@ -1,4 +1,5 @@
 import { Comment, CommentDisplayPart, Reflection } from "../../models";
 import type { Logger, ValidationOptions } from "../../utils";
-export declare function resolveLinks(comment: Comment, reflection: Reflection, validation: ValidationOptions, logger: Logger): void;
-export declare function resolvePartLinks(reflection: Reflection, parts: readonly CommentDisplayPart[], warn: () => void, validation: ValidationOptions, logger: Logger): CommentDisplayPart[];
+import { DeclarationReference } from "./declarationReference";
+export declare function resolveLinks(comment: Comment, reflection: Reflection, validation: ValidationOptions, logger: Logger, attemptExternalResolve: (ref: DeclarationReference) => string | undefined): void;
+export declare function resolvePartLinks(reflection: Reflection, parts: readonly CommentDisplayPart[], warn: () => void, validation: ValidationOptions, logger: Logger, attemptExternalResolve: (ref: DeclarationReference) => string | undefined): CommentDisplayPart[];

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

@@ -7,7 +7,7 @@ const declarationReference_1 = require("./declarationReference");
 const declarationReferenceResolver_1 = require("./declarationReferenceResolver");
 const urlPrefix = /^(http|ftp)s?:\/\//;
 const brackets = /\[\[(?!include:)([^\]]+)\]\]/g;
-function resolveLinks(comment, reflection, validation, logger) {
+function resolveLinks(comment, reflection, validation, logger, attemptExternalResolve) {
     let warned = false;
     const warn = () => {
         if (!warned) {
@@ -15,20 +15,20 @@ function resolveLinks(comment, reflection, validation, logger) {
             logger.warn(`${reflection.getFriendlyFullName()}: Comment [[target]] style links are deprecated and will be removed in 0.24`);
         }
     };
-    comment.summary = resolvePartLinks(reflection, comment.summary, warn, validation, logger);
+    comment.summary = resolvePartLinks(reflection, comment.summary, warn, validation, logger, attemptExternalResolve);
     for (const tag of comment.blockTags) {
-        tag.content = resolvePartLinks(reflection, tag.content, warn, validation, logger);
+        tag.content = resolvePartLinks(reflection, tag.content, warn, validation, logger, attemptExternalResolve);
     }
     if (reflection instanceof models_1.DeclarationReflection && reflection.readme) {
-        reflection.readme = resolvePartLinks(reflection, reflection.readme, warn, validation, logger);
+        reflection.readme = resolvePartLinks(reflection, reflection.readme, warn, validation, logger, attemptExternalResolve);
     }
 }
 exports.resolveLinks = resolveLinks;
-function resolvePartLinks(reflection, parts, warn, validation, logger) {
-    return parts.flatMap((part) => processPart(reflection, part, warn, validation, logger));
+function resolvePartLinks(reflection, parts, warn, validation, logger, attemptExternalResolve) {
+    return parts.flatMap((part) => processPart(reflection, part, warn, validation, logger, attemptExternalResolve));
 }
 exports.resolvePartLinks = resolvePartLinks;
-function processPart(reflection, part, warn, validation, logger) {
+function processPart(reflection, part, warn, validation, logger, attemptExternalResolve) {
     if (part.kind === "text" && brackets.test(part.text)) {
         warn();
         return replaceBrackets(reflection, part.text, validation, logger);
@@ -37,7 +37,7 @@ function processPart(reflection, part, warn, validation, logger) {
         if (part.tag === "@link" ||
             part.tag === "@linkcode" ||
             part.tag === "@linkplain") {
-            return resolveLinkTag(reflection, part, (msg) => {
+            return resolveLinkTag(reflection, part, attemptExternalResolve, (msg) => {
                 if (validation.invalidLink) {
                     logger.warn(msg);
                 }
@@ -46,7 +46,7 @@ function processPart(reflection, part, warn, validation, logger) {
     }
     return part;
 }
-function resolveLinkTag(reflection, part, warn) {
+function resolveLinkTag(reflection, part, attemptExternalResolve, warn) {
     let pos = 0;
     const end = part.text.length;
     while (pos < end && ts.isWhiteSpaceLike(part.text.charCodeAt(pos))) {
@@ -56,10 +56,21 @@ function resolveLinkTag(reflection, part, warn) {
     // Try to parse one
     const declRef = (0, declarationReference_1.parseDeclarationReference)(part.text, pos, end);
     let target;
+    let defaultDisplayText;
     if (declRef) {
         // Got one, great! Try to resolve the link
         target = (0, declarationReferenceResolver_1.resolveDeclarationReference)(reflection, declRef[0]);
         pos = declRef[1];
+        if (target) {
+            defaultDisplayText = target.name;
+        }
+        else {
+            // If we didn't find a link, it might be a @link tag to an external symbol, check that next.
+            target = attemptExternalResolve(declRef[0]);
+            if (target) {
+                defaultDisplayText = part.text.substring(0, pos);
+            }
+        }
     }
     if (!target) {
         if (urlPrefix.test(part.text)) {
@@ -67,13 +78,14 @@ function resolveLinkTag(reflection, part, warn) {
             target =
                 wsIndex === -1 ? part.text : part.text.substring(0, wsIndex);
             pos = target.length;
+            defaultDisplayText = target;
         }
     }
     // If resolution via a declaration reference failed, revert to the legacy "split and check"
     // method... this should go away in 0.24, once people have had a chance to migrate any failing links.
     if (!target) {
         const resolved = legacyResolveLinkTag(reflection, part);
-        if (resolved) {
+        if (resolved.target) {
             warn(`Failed to resolve {@link ${origText}} in ${reflection.getFriendlyFullName()} with declaration references. This link will break in v0.24.`);
         }
         return resolved;
@@ -87,9 +99,7 @@ function resolveLinkTag(reflection, part, warn) {
         pos++;
     }
     part.target = target;
-    part.text =
-        part.text.substring(pos).trim() ||
-            (typeof target === "string" ? target : target.name);
+    part.text = part.text.substring(pos).trim() || defaultDisplayText;
     return part;
 }
 function legacyResolveLinkTag(reflection, part) {

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

@@ -8,25 +8,31 @@ import { MinimalSourceFile } from "../utils";
 import type { DocumentationEntryPoint } from "../utils/entry-point";
 import { CommentParserConfig } from "./comments";
 import type { CommentStyle, ValidationOptions } from "../utils/options/declaration";
+import type { DeclarationReference } from "./comments/declarationReference";
 /**
  * Compiles source files using TypeScript and converts compiler symbols to reflections.
  */
 export declare class Converter extends ChildableComponent<Application, ConverterComponent> {
-    /**
-     * The human readable name of the project. Used within the templates to set the title of the document.
-     */
-    name: string;
+    /** @internal */
     externalPattern: string[];
     private externalPatternCache?;
     private excludeCache?;
+    /** @internal */
     excludeExternals: boolean;
+    /** @internal */
     excludeNotDocumented: boolean;
+    /** @internal */
     excludePrivate: boolean;
+    /** @internal */
     excludeProtected: boolean;
+    /** @internal */
     commentStyle: CommentStyle;
     /** @internal */
     validation: ValidationOptions;
+    /** @internal */
+    externalSymbolLinkMappings: Record<string, Record<string, string>>;
     private _config?;
+    private _externalSymbolResolvers;
     get config(): CommentParserConfig;
     /**
      * General events
@@ -92,6 +98,7 @@ export declare class Converter extends ChildableComponent<Application, Converter
      * @event
      */
     static readonly EVENT_RESOLVE_END: "resolveEnd";
+    constructor(owner: Application);
     /**
      * Compile the given source files and create a project reflection for them.
      */
@@ -111,6 +118,21 @@ export declare class Converter extends ChildableComponent<Application, Converter
      * Parse the given file into a comment. Intended to be used with markdown files.
      */
     parseRawComment(file: MinimalSourceFile): Comment;
+    /**
+     * Adds a new resolver that the theme can use to try to figure out how to link to a symbol declared
+     * by a third-party library which is not included in the documentation.
+     *
+     * The resolver function will be passed a declaration reference which it can attempt to resolve. If
+     * resolution fails, the function should return undefined.
+     *
+     * Note: This will be used for both references to types declared in node_modules (in which case the
+     * reference passed will have the `moduleSource` set and the `symbolReference` will navigate via `.`)
+     * and user defined \{\@link\} tags which cannot be resolved.
+     * @since 0.22.14
+     */
+    addUnknownSymbolResolver(resolver: (ref: DeclarationReference) => string | undefined): void;
+    /** @internal */
+    resolveExternalLink(ref: DeclarationReference): string | undefined;
     resolveLinks(comment: Comment, owner: Reflection): void;
     resolveLinks(parts: readonly CommentDisplayPart[], owner: Reflection): CommentDisplayPart[];
     /**

package/dist/lib/converter/converter.js

@@ -27,6 +27,31 @@ const linkResolver_1 = require("./comments/linkResolver");
  * Compiles source files using TypeScript and converts compiler symbols to reflections.
  */
 let Converter = Converter_1 = class Converter extends component_1.ChildableComponent {
+    constructor(owner) {
+        super(owner);
+        this._externalSymbolResolvers = [];
+        this.addUnknownSymbolResolver((ref) => {
+            // Require global links, matching local ones will likely hide mistakes where the
+            // user meant to link to a local type.
+            if (ref.resolutionStart !== "global" || !ref.symbolReference) {
+                return;
+            }
+            const modLinks = this.externalSymbolLinkMappings[ref.moduleSource ?? "global"];
+            if (typeof modLinks !== "object") {
+                return;
+            }
+            let name = "";
+            if (ref.symbolReference.path) {
+                name += ref.symbolReference.path.map((p) => p.path).join(".");
+            }
+            if (ref.symbolReference.meaning) {
+                name += ":" + ref.symbolReference.meaning;
+            }
+            if (typeof modLinks[name] === "string") {
+                return modLinks[name];
+            }
+        });
+    }
     get config() {
         return this._config || this._buildCommentParserConfig();
     }
@@ -36,7 +61,7 @@ let Converter = Converter_1 = class Converter extends component_1.ChildableCompo
     convert(entryPoints) {
         const programs = entryPoints.map((e) => e.program);
         this.externalPatternCache = void 0;
-        const project = new index_1.ProjectReflection(this.name);
+        const project = new index_1.ProjectReflection(this.application.options.getValue("name"));
         const context = new context_1.Context(this, programs, project);
         this.trigger(Converter_1.EVENT_BEGIN, context);
         this.compile(entryPoints, context);
@@ -67,9 +92,32 @@ let Converter = Converter_1 = class Converter extends component_1.ChildableCompo
     parseRawComment(file) {
         return (0, parser_1.parseComment)((0, rawLexer_1.lexCommentString)(file.text), this.config, file, this.application.logger);
     }
+    /**
+     * Adds a new resolver that the theme can use to try to figure out how to link to a symbol declared
+     * by a third-party library which is not included in the documentation.
+     *
+     * The resolver function will be passed a declaration reference which it can attempt to resolve. If
+     * resolution fails, the function should return undefined.
+     *
+     * Note: This will be used for both references to types declared in node_modules (in which case the
+     * reference passed will have the `moduleSource` set and the `symbolReference` will navigate via `.`)
+     * and user defined \{\@link\} tags which cannot be resolved.
+     * @since 0.22.14
+     */
+    addUnknownSymbolResolver(resolver) {
+        this._externalSymbolResolvers.push(resolver);
+    }
+    /** @internal */
+    resolveExternalLink(ref) {
+        for (const resolver of this._externalSymbolResolvers) {
+            const resolved = resolver(ref);
+            if (resolved)
+                return resolved;
+        }
+    }
     resolveLinks(comment, owner) {
         if (comment instanceof index_1.Comment) {
-            (0, linkResolver_1.resolveLinks)(comment, owner, this.validation, this.owner.logger);
+            (0, linkResolver_1.resolveLinks)(comment, owner, this.validation, this.owner.logger, (ref) => this.resolveExternalLink(ref));
         }
         else {
             let warned = false;
@@ -79,7 +127,7 @@ let Converter = Converter_1 = class Converter extends component_1.ChildableCompo
                     this.application.logger.warn(`${owner.name}: Comment [[target]] style links are deprecated and will be removed in 0.24`);
                 }
             };
-            return (0, linkResolver_1.resolvePartLinks)(owner, comment, warn, this.validation, this.owner.logger);
+            return (0, linkResolver_1.resolvePartLinks)(owner, comment, warn, this.validation, this.owner.logger, (ref) => this.resolveExternalLink(ref));
         }
     }
     /**
@@ -262,9 +310,6 @@ Converter.EVENT_RESOLVE = converter_events_1.ConverterEvents.RESOLVE;
  * @event
  */
 Converter.EVENT_RESOLVE_END = converter_events_1.ConverterEvents.RESOLVE_END;
-__decorate([
-    (0, utils_1.BindOption)("name")
-], Converter.prototype, "name", void 0);
 __decorate([
     (0, utils_1.BindOption)("externalPattern")
 ], Converter.prototype, "externalPattern", void 0);
@@ -286,6 +331,9 @@ __decorate([
 __decorate([
     (0, utils_1.BindOption)("validation")
 ], Converter.prototype, "validation", void 0);
+__decorate([
+    (0, utils_1.BindOption)("externalSymbolLinkMappings")
+], Converter.prototype, "externalSymbolLinkMappings", void 0);
 Converter = Converter_1 = __decorate([
     (0, component_1.Component)({
         name: "converter",

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

@@ -2,4 +2,5 @@ export { Context } from "./context";
 export { Converter } from "./converter";
 export type { CommentParserConfig } from "./comments/index";
 export { convertDefaultValue, convertExpression } from "./convert-expression";
+export type { DeclarationReference, SymbolReference, ComponentPath, Meaning, MeaningKeyword, } from "./comments/declarationReference";
 import "./plugins/index";

package/dist/lib/converter/plugins/LinkResolverPlugin.js

@@ -11,6 +11,7 @@ const components_1 = require("../components");
 const converter_events_1 = require("../converter-events");
 const utils_1 = require("../../utils");
 const models_1 = require("../../models");
+const reflections_1 = require("../../utils/reflections");
 /**
  * A plugin that resolves `{@link Foo}` tags.
  */
@@ -35,6 +36,11 @@ let LinkResolverPlugin = class LinkResolverPlugin extends components_1.Converter
         if (context.project.readme) {
             context.project.readme = context.converter.resolveLinks(context.project.readme, context.project);
         }
+        for (const { type } of (0, reflections_1.discoverAllReferenceTypes)(context.project, false)) {
+            if (!type.reflection) {
+                type.externalUrl = context.converter.resolveExternalLink(type.toDeclarationReference());
+            }
+        }
     }
 };
 __decorate([

package/dist/lib/converter/types.js

@@ -348,6 +348,9 @@ const typeLiteralConverter = {
         for (const signature of type.getCallSignatures()) {
             (0, signature_1.createSignature)(rc, models_1.ReflectionKind.CallSignature, signature);
         }
+        for (const signature of type.getConstructSignatures()) {
+            (0, signature_1.createSignature)(rc, models_1.ReflectionKind.ConstructorSignature, signature);
+        }
         (0, index_signature_1.convertIndexSignature)(rc, symbol);
         return new models_1.ReflectionType(reflection);
     },
@@ -364,6 +367,9 @@ const typeLiteralConverter = {
         for (const signature of type.getCallSignatures()) {
             (0, signature_1.createSignature)(context.withScope(reflection), models_1.ReflectionKind.CallSignature, signature);
         }
+        for (const signature of type.getConstructSignatures()) {
+            (0, signature_1.createSignature)(context.withScope(reflection), models_1.ReflectionKind.ConstructorSignature, signature);
+        }
         (0, index_signature_1.convertIndexSignature)(context.withScope(reflection), type.symbol);
         return new models_1.ReflectionType(reflection);
     },

package/dist/lib/models/types.d.ts

@@ -4,6 +4,7 @@ import { Reflection } from "./reflections/abstract";
 import type { DeclarationReflection } from "./reflections/declaration";
 import type { ProjectReflection } from "./reflections/project";
 import type { Serializer, JSONOutput } from "../serialization";
+import type { DeclarationReference } from "../converter/comments/declarationReference";
 /**
  * Base class of all type definitions.
  */
@@ -320,6 +321,10 @@ export declare class ReferenceType extends Type {
      * @internal
      */
     getSymbol(): ts.Symbol | undefined;
+    /**
+     * Convert this reference type to a declaration reference used for resolution of external types.
+     */
+    toDeclarationReference(): DeclarationReference;
     /**
      * The fully qualified name of the referenced type, relative to the file it is defined in.
      * This will usually be the same as `name`, unless namespaces are used.
@@ -330,10 +335,15 @@ export declare class ReferenceType extends Type {
      * Will only be set for `ReferenceType`s pointing to a symbol within `node_modules`.
      */
     package?: string;
+    /**
+     * If this reference type refers to a reflection defined by a project not being rendered,
+     * points to the url that this type should be linked to.
+     */
+    externalUrl?: string;
     private _target;
     private _project;
     private constructor();
-    static createResolvedReference(name: string, target: Reflection | number, project: ProjectReflection | null): ReferenceType;
+    static createResolvedReference(name: string, target: Reflection | number, project: ProjectReflection): ReferenceType;
     static createSymbolReference(symbol: ts.Symbol, context: Context, name?: string): ReferenceType;
     /** @internal this is used for type parameters, which don't actually point to something */
     static createBrokenReference(name: string, project: ProjectReflection): ReferenceType;

package/dist/lib/models/types.js

@@ -661,6 +661,20 @@ class ReferenceType extends Type {
         }
         return this._target;
     }
+    /**
+     * Convert this reference type to a declaration reference used for resolution of external types.
+     */
+    toDeclarationReference() {
+        return {
+            resolutionStart: "global",
+            moduleSource: this.package,
+            symbolReference: {
+                path: this.qualifiedName
+                    .split(".")
+                    .map((p) => ({ path: p, navigation: "." })),
+            },
+        };
+    }
     static createResolvedReference(name, target, project) {
         return new ReferenceType(name, target, project, name);
     }
@@ -709,6 +723,7 @@ class ReferenceType extends Type {
             id: this.reflection?.id,
             typeArguments: serializer.toObjectsOptional(this.typeArguments),
             name: this.name,
+            externalUrl: this.externalUrl,
         };
         if (this.package) {
             result.qualifiedName = this.qualifiedName;

package/dist/lib/output/renderer.d.ts

@@ -5,7 +5,6 @@ import { RendererComponent } from "./components";
 import { ChildableComponent } from "../utils/component";
 import { EventHooks } from "../utils";
 import type { Theme as ShikiTheme } from "shiki";
-import { ReferenceType } from "../models";
 import type { JsxElement } from "../utils/jsx.elements";
 import type { DefaultThemeRenderContext } from "./themes/default/DefaultThemeRenderContext";
 /**
@@ -80,7 +79,6 @@ export interface RendererHooks {
  */
 export declare class Renderer extends ChildableComponent<Application, RendererComponent> {
     private themes;
-    private unknownSymbolResolvers;
     /** @event */
     static readonly EVENT_BEGIN_PAGE = "beginPage";
     /** @event */
@@ -125,7 +123,7 @@ export declare class Renderer extends ChildableComponent<Application, RendererCo
      */
     defineTheme(name: string, theme: new (renderer: Renderer) => Theme): void;
     /**
-     * Adds a new resolver that the theme can used to try to figure out how to link to a symbol
+     * Adds a new resolver that the theme can use to try to figure out how to link to a symbol
      * declared by a third-party library which is not included in the documentation.
      * @param packageName the npm package name that this resolver can handle to limit which files it will be tried on.
      *   If the resolver will create links for Node builtin types, it should be set to `@types/node`.
@@ -133,15 +131,11 @@ export declare class Renderer extends ChildableComponent<Application, RendererCo
      * @param resolver a function that will be called to create links for a given symbol name in the registered path.
      *  If the provided name is not contained within the docs, should return `undefined`.
      * @since 0.22.0
+     * @deprecated
+     * Deprecated since v0.23.14, use {@link Converter.addUnknownSymbolResolver | Converter.addUnknownSymbolResolver} instead.
+     * This signature will be removed in 0.24 or possibly 0.25.
      */
     addUnknownSymbolResolver(packageName: string, resolver: (name: string) => string | undefined): void;
-    /**
-     * Marked as internal for now. Using this requires the internal `getSymbol()` method on ReferenceType.
-     * Someday that needs to be fixed so that this can be made public. ReferenceTypes really shouldn't store
-     * symbols so that we don't need to keep the program around forever.
-     * @internal
-     */
-    attemptExternalResolution(type: ReferenceType): string | undefined;
     /**
      * Render the given project reflection to the specified output directory.
      *

package/dist/lib/output/renderer.js

@@ -64,7 +64,6 @@ let Renderer = class Renderer extends component_1.ChildableComponent {
         this.themes = new Map([
             ["default", DefaultTheme_1.DefaultTheme],
         ]);
-        this.unknownSymbolResolvers = new Map();
         /**
          * Hooks which will be called when rendering pages.
          * Note:
@@ -89,7 +88,7 @@ let Renderer = class Renderer extends component_1.ChildableComponent {
         this.themes.set(name, theme);
     }
     /**
-     * Adds a new resolver that the theme can used to try to figure out how to link to a symbol
+     * Adds a new resolver that the theme can use to try to figure out how to link to a symbol
      * declared by a third-party library which is not included in the documentation.
      * @param packageName the npm package name that this resolver can handle to limit which files it will be tried on.
      *   If the resolver will create links for Node builtin types, it should be set to `@types/node`.
@@ -97,32 +96,19 @@ let Renderer = class Renderer extends component_1.ChildableComponent {
      * @param resolver a function that will be called to create links for a given symbol name in the registered path.
      *  If the provided name is not contained within the docs, should return `undefined`.
      * @since 0.22.0
+     * @deprecated
+     * Deprecated since v0.23.14, use {@link Converter.addUnknownSymbolResolver | Converter.addUnknownSymbolResolver} instead.
+     * This signature will be removed in 0.24 or possibly 0.25.
      */
     addUnknownSymbolResolver(packageName, resolver) {
-        const existing = this.unknownSymbolResolvers.get(packageName);
-        if (existing) {
-            existing.push(resolver);
-        }
-        else {
-            this.unknownSymbolResolvers.set(packageName, [resolver]);
-        }
-    }
-    /**
-     * Marked as internal for now. Using this requires the internal `getSymbol()` method on ReferenceType.
-     * Someday that needs to be fixed so that this can be made public. ReferenceTypes really shouldn't store
-     * symbols so that we don't need to keep the program around forever.
-     * @internal
-     */
-    attemptExternalResolution(type) {
-        if (!type.qualifiedName || !type.package) {
-            return;
-        }
-        const resolvers = this.unknownSymbolResolvers.get(type.package);
-        for (const resolver of resolvers || []) {
-            const resolved = resolver(type.qualifiedName);
-            if (resolved)
-                return resolved;
-        }
+        this.owner.converter.addUnknownSymbolResolver((ref) => {
+            const path = ref.symbolReference?.path
+                ?.map((path) => path.path)
+                .join(".");
+            if (ref.moduleSource === packageName && path) {
+                return resolver(path);
+            }
+        });
     }
     /**
      * Render the given project reflection to the specified output directory.

package/dist/lib/output/themes/default/DefaultThemeRenderContext.d.ts

@@ -12,7 +12,12 @@ export declare class DefaultThemeRenderContext {
     relativeURL: (url: string | undefined) => string | undefined;
     urlTo: (reflection: Reflection) => string | undefined;
     markdown: (md: readonly CommentDisplayPart[] | NeverIfInternal<string | undefined>) => string;
-    attemptExternalResolution: (type: ReferenceType) => string | undefined;
+    /**
+     * Using this method will repeat work already done, instead of calling it, use `type.externalUrl`.
+     * @deprecated
+     * Will be removed in 0.24.
+     */
+    attemptExternalResolution: (type: NeverIfInternal<ReferenceType>) => string | undefined;
     reflectionTemplate: (props: import("../..").PageEvent<import("../../../models").ContainerReflection>) => import("../../../utils/jsx.elements").JsxElement;
     indexTemplate: (props: import("../..").PageEvent<import("../../../models").ProjectReflection>) => import("../../../utils/jsx.elements").JsxElement;
     defaultLayout: (props: import("../..").PageEvent<Reflection>) => import("../../../utils/jsx.elements").JsxElement;

package/dist/lib/output/themes/default/DefaultThemeRenderContext.js

@@ -48,8 +48,13 @@ class DefaultThemeRenderContext {
             }
             return md ? this.theme.markedPlugin.parseMarkdown(md) : "";
         };
+        /**
+         * Using this method will repeat work already done, instead of calling it, use `type.externalUrl`.
+         * @deprecated
+         * Will be removed in 0.24.
+         */
         this.attemptExternalResolution = (type) => {
-            return this.theme.owner.attemptExternalResolution(type);
+            return type.externalUrl;
         };
         this.reflectionTemplate = bind(reflection_1.reflectionTemplate, this);
         this.indexTemplate = bind(templates_1.indexTemplate, this);

package/dist/lib/output/themes/default/partials/type.js

@@ -175,14 +175,11 @@ const typeRenderers = {
                 name = renderUniquePath(context, reflection);
             }
         }
+        else if (type.externalUrl) {
+            name = (utils_1.JSX.createElement("a", { href: type.externalUrl, class: "tsd-signature-type external", target: "_blank" }, type.name));
+        }
         else {
-            const externalUrl = context.attemptExternalResolution(type);
-            if (externalUrl) {
-                name = (utils_1.JSX.createElement("a", { href: externalUrl, class: "tsd-signature-type external", target: "_blank" }, type.name));
-            }
-            else {
-                name = utils_1.JSX.createElement("span", { class: "tsd-signature-type" }, type.name);
-            }
+            name = utils_1.JSX.createElement("span", { class: "tsd-signature-type" }, type.name);
         }
         if (type.typeArguments?.length) {
             return (utils_1.JSX.createElement(utils_1.JSX.Fragment, null,

package/dist/lib/serialization/schema.d.ts

@@ -119,7 +119,7 @@ export interface PredicateType extends Type, S<M.PredicateType, "type" | "name"
 }
 export interface QueryType extends Type, S<M.QueryType, "type" | "queryType"> {
 }
-export interface ReferenceType extends Type, S<M.ReferenceType, "type" | "name" | "typeArguments" | "package"> {
+export interface ReferenceType extends Type, S<M.ReferenceType, "type" | "name" | "typeArguments" | "package" | "externalUrl"> {
     id?: number;
     qualifiedName?: string;
 }

package/dist/lib/utils/fs.js

@@ -149,10 +149,7 @@ function glob(pattern, root, options) {
             }
             if (child.isDirectory() && child.name !== "node_modules") {
                 const childPath = dir.concat(child.name);
-                if (mini.set.some((row) => mini.matchOne(childPath, 
-                // @ts-expect-error https://github.com/DefinitelyTyped/DefinitelyTyped/pull/62049
-                row, 
-                /* partial */ true))) {
+                if (mini.set.some((row) => mini.matchOne(childPath, row, /* partial */ true))) {
                     dirs.push(childPath);
                 }
             }

package/dist/lib/utils/options/declaration.d.ts

@@ -55,6 +55,7 @@ export interface TypeDocOptionMap {
     excludeInternal: boolean;
     excludePrivate: boolean;
     excludeProtected: boolean;
+    externalSymbolLinkMappings: ManuallyValidatedOption<Record<string, Record<string, string>>>;
     media: string;
     includes: string;
     out: string;
@@ -126,7 +127,7 @@ export declare type ValidationOptions = {
      */
     notExported: boolean;
     /**
-     * If set, TypeDoc will produce warnings about \{&amp;link\} tags which will produce broken links.
+     * If set, TypeDoc will produce warnings about \{\@link\} tags which will produce broken links.
      */
     invalidLink: boolean;
     /**

package/dist/lib/utils/options/sources/typedoc.js

@@ -89,6 +89,28 @@ function addTypeDocOptions(options) {
         help: "Ignore protected variables and methods.",
         type: declaration_1.ParameterType.Boolean,
     });
+    options.addDeclaration({
+        name: "externalSymbolLinkMappings",
+        help: "Define custom links for symbols not included in the documentation.",
+        type: declaration_1.ParameterType.Mixed,
+        defaultValue: {},
+        validate(value) {
+            const error = "externalSymbolLinkMappings must be a Record<package name, Record<symbol name, link>>";
+            if (!Validation.validate({}, value)) {
+                throw new Error(error);
+            }
+            for (const mappings of Object.values(value)) {
+                if (!Validation.validate({}, mappings)) {
+                    throw new Error(error);
+                }
+                for (const link of Object.values(mappings)) {
+                    if (typeof link !== "string") {
+                        throw new Error(error);
+                    }
+                }
+            }
+        },
+    });
     options.addDeclaration({
         name: "media",
         help: "Specify the location with media files that should be copied to the output directory.",

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

@@ -0,0 +1,5 @@
+import { ProjectReflection, ReferenceType, Reflection } from "../models";
+export declare function discoverAllReferenceTypes(project: ProjectReflection, forExportValidation: boolean): {
+    type: ReferenceType;
+    owner: Reflection;
+}[];

package/dist/lib/utils/reflections.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverAllReferenceTypes = void 0;
+const models_1 = require("../models");
+function discoverAllReferenceTypes(project, forExportValidation) {
+    let current = project;
+    const queue = [];
+    const result = [];
+    const visitor = (0, models_1.makeRecursiveVisitor)({
+        reference(type) {
+            result.push({ type, owner: current });
+        },
+        reflection(type) {
+            queue.push(type.declaration);
+        },
+    });
+    const add = (item) => {
+        if (!item)
+            return;
+        if (item instanceof models_1.Reflection) {
+            queue.push(item);
+        }
+        else {
+            queue.push(...item);
+        }
+    };
+    do {
+        if (current instanceof models_1.ContainerReflection) {
+            add(current.children);
+        }
+        if (current instanceof models_1.DeclarationReflection) {
+            current.type?.visit(visitor);
+            add(current.typeParameters);
+            add(current.signatures);
+            add(current.indexSignature);
+            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 models_1.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 models_1.ParameterReflection) {
+            current.type?.visit(visitor);
+        }
+        if (current instanceof models_1.TypeParameterReflection) {
+            current.type?.visit(visitor);
+            current.default?.visit(visitor);
+        }
+    } while ((current = queue.shift()));
+    return result;
+}
+exports.discoverAllReferenceTypes = discoverAllReferenceTypes;

package/dist/lib/validation/exports.d.ts

@@ -1,3 +1,3 @@
-import { ProjectReflection } from "../models";
+import type { ProjectReflection } from "../models";
 import type { Logger } from "../utils";
 export declare function validateExports(project: ProjectReflection, logger: Logger, intentionallyNotExported: readonly string[]): void;

package/dist/lib/validation/exports.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateExports = void 0;
 const ts = require("typescript");
-const models_1 = require("../models");
+const reflections_1 = require("../utils/reflections");
 function makeIntentionallyExportedHelper(intentional, logger) {
     const used = new Set();
     const processed = intentional.map((v) => {
@@ -45,73 +45,21 @@ function makeIntentionallyExportedHelper(intentional, logger) {
     };
 }
 function validateExports(project, logger, intentionallyNotExported) {
-    let current = project;
-    const queue = [];
     const intentional = makeIntentionallyExportedHelper(intentionallyNotExported, logger);
     const warned = new Set();
-    const visitor = (0, models_1.makeRecursiveVisitor)({
-        reference(type) {
-            // If we don't have a symbol, then this was an intentionally broken reference.
-            const symbol = type.getSymbol();
-            if (!type.reflection && symbol) {
-                if ((symbol.flags & ts.SymbolFlags.TypeParameter) === 0 &&
-                    !intentional.has(symbol, type.qualifiedName) &&
-                    !warned.has(symbol)) {
-                    warned.add(symbol);
-                    const decl = symbol.declarations[0];
-                    logger.warn(`${type.qualifiedName} is referenced by ${current.getFullName()} but not included in the documentation.`, decl);
-                }
+    for (const { type, owner } of (0, reflections_1.discoverAllReferenceTypes)(project, true)) {
+        // If we don't have a symbol, then this was an intentionally broken reference.
+        const symbol = type.getSymbol();
+        if (!type.reflection && !type.externalUrl && symbol) {
+            if ((symbol.flags & ts.SymbolFlags.TypeParameter) === 0 &&
+                !intentional.has(symbol, type.qualifiedName) &&
+                !warned.has(symbol)) {
+                warned.add(symbol);
+                const decl = symbol.declarations[0];
+                logger.warn(`${type.qualifiedName} is referenced by ${owner.getFullName()} but not included in the documentation.`, decl);
             }
-        },
-        reflection(type) {
-            queue.push(type.declaration);
-        },
-    });
-    const add = (item) => {
-        if (!item)
-            return;
-        if (item instanceof models_1.Reflection) {
-            queue.push(item);
-        }
-        else {
-            queue.push(...item);
-        }
-    };
-    do {
-        if (current instanceof models_1.ContainerReflection) {
-            add(current.children);
-        }
-        if (current instanceof models_1.DeclarationReflection) {
-            current.type?.visit(visitor);
-            add(current.typeParameters);
-            add(current.signatures);
-            add(current.indexSignature);
-            add(current.getSignature);
-            add(current.setSignature);
-            current.overwrites?.visit(visitor);
-            // Do not check inheritedFrom, it doesn't always make sense to export a base type.
-            // Do not validate implementationOf will always be defined or intentionally broken.
-            // Do not check extendedTypes, it doesn't always make sense to export a base type.
-            // Do not validate extendedBy, guaranteed to all be in the documentation.
-            current.implementedTypes?.forEach((type) => type.visit(visitor));
-            // Do not validate implementedBy, guaranteed to all be in the documentation.
-        }
-        if (current instanceof models_1.SignatureReflection) {
-            add(current.parameters);
-            add(current.typeParameters);
-            current.type?.visit(visitor);
-            current.overwrites?.visit(visitor);
-            // Do not check inheritedFrom, it doesn't always make sense to export a base type.
-            // Do not validate implementationOf will always be defined or intentionally broken.
         }
-        if (current instanceof models_1.ParameterReflection) {
-            current.type?.visit(visitor);
-        }
-        if (current instanceof models_1.TypeParameterReflection) {
-            current.type?.visit(visitor);
-            current.default?.visit(visitor);
-        }
-    } while ((current = queue.shift()));
+    }
     const unusedIntentional = intentional.getUnused();
     if (unusedIntentional.length) {
         logger.warn("The following symbols were marked as intentionally not exported, but were either not referenced in the documentation, or were exported:\n\t" +

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typedoc",
   "description": "Create api documentation for TypeScript projects.",
-  "version": "0.23.13",
+  "version": "0.23.14",
   "homepage": "https://typedoc.org",
   "main": "./dist/index.js",
   "exports": {
@@ -35,7 +35,7 @@
   "devDependencies": {
     "@types/lunr": "^2.3.4",
     "@types/marked": "^4.0.6",
-    "@types/minimatch": "5.1.1",
+    "@types/minimatch": "5.1.2",
     "@types/mocha": "^9.1.1",
     "@types/node": "14",
     "@typescript-eslint/eslint-plugin": "^5.36.1",

package/static/style.css

@@ -1109,7 +1109,6 @@ ul.tsd-type-parameter-list h5 {
     background: var(--color-background-secondary);
     border-bottom: 1px var(--color-accent) solid;
     transition: transform 0.3s ease-in-out;
-    margin: 0 auto;
 }
 .tsd-page-toolbar a {
     color: var(--color-text);
@@ -1125,6 +1124,7 @@ ul.tsd-type-parameter-list h5 {
     display: flex;
     justify-content: space-between;
     height: 2.5rem;
+    margin: 0 auto;
 }
 .tsd-page-toolbar .table-cell {
     position: relative;