typedoc 0.28.0-beta.2 → 0.28.0

package/dist/index.d.ts

@@ -37,7 +37,7 @@ export * from "./lib/models/index.js";
 /** @primaryExport */
 export * as Configuration from "./lib/utils/options/index.js";
 export { BaseRouter, CategoryRouter, DefaultTheme, DefaultThemeRenderContext, GroupRouter, IndexEvent, KindDirRouter, KindRouter, MarkdownEvent, PageEvent, PageKind, Renderer, RendererEvent, Slugger, StructureDirRouter, StructureRouter, Theme, } from "./lib/output/index.js";
-export type { Icons, NavigationElement, PageDefinition, PageHeading, RendererEvents, RendererHooks, RenderTemplate, Router, } from "./lib/output/index.js";
+export type { Icons, NavigationElement, PageDefinition, PageHeading, RendererEvents, RendererHooks, RenderTemplate, Router, RouterTarget, } from "./lib/output/index.js";
 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";

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

@@ -415,7 +415,7 @@ export declare class ReflectionType extends Type {
     readonly type = "reflection";
     constructor(declaration: DeclarationReflection);
     protected getTypeString(): string;
-    needsParenthesis(): boolean;
+    needsParenthesis(where: TypeContext): boolean;
     toObject(serializer: Serializer): JSONOutput.ReflectionType;
 }
 /**

package/dist/lib/models/types.js

@@ -917,7 +917,13 @@ export class ReflectionType extends Type {
         }
         return `{ ${parts.join("; ")} }`;
     }
-    needsParenthesis() {
+    needsParenthesis(where) {
+        if (this.declaration.children || this.declaration.indexSignatures) {
+            return false;
+        }
+        if (this.declaration.signatures?.length === 1) {
+            return where === TypeContext.arrayElement || where === TypeContext.unionElement;
+        }
         return false;
     }
     toObject(serializer) {

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

@@ -1,5 +1,5 @@
 import { AbstractComponent } from "../utils/component.js";
-import type { ProjectReflection, Reflection } from "../models/index.js";
+import type { ProjectReflection } from "../models/index.js";
 import type { Renderer } from "./renderer.js";
 import { PageEvent, RendererEvent } from "./events.js";
 export declare abstract class RendererComponent extends AbstractComponent<Renderer, {}> {
@@ -15,7 +15,7 @@ export declare abstract class ContextAwareRendererComponent extends RendererComp
     /**
      * The reflection that is currently processed.
      */
-    protected page?: PageEvent<Reflection>;
+    protected page?: PageEvent;
     /**
      * The url of the document that is being currently generated.
      * Set when a page begins rendering.
@@ -49,5 +49,5 @@ export declare abstract class ContextAwareRendererComponent extends RendererComp
      *
      * @param page  An event object describing the current render operation.
      */
-    protected onBeginPage(page: PageEvent<Reflection>): void;
+    protected onBeginPage(page: PageEvent): void;
 }

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

@@ -1,6 +1,6 @@
 import type { ProjectReflection } from "../models/ProjectReflection.js";
-import type { DeclarationReflection, DocumentReflection, ReflectionKind } from "../models/index.js";
-import type { PageDefinition, PageKind } from "./router.js";
+import { type DeclarationReflection, type DocumentReflection, Reflection, type ReflectionKind } from "../models/index.js";
+import type { PageDefinition, PageKind, RouterTarget } from "./router.js";
 /**
  * An event emitted by the {@link Renderer} class at the very beginning and
  * ending of the entire rendering process.
@@ -47,7 +47,7 @@ export interface PageHeading {
  * @see {@link Renderer.EVENT_BEGIN_PAGE}
  * @see {@link Renderer.EVENT_END_PAGE}
  */
-export declare class PageEvent<out Model = unknown> {
+export declare class PageEvent<out Model extends RouterTarget = RouterTarget> {
     /**
      * The project the renderer is currently processing.
      */
@@ -102,6 +102,7 @@ export declare class PageEvent<out Model = unknown> {
      */
     static readonly END = "endPage";
     constructor(model: Model);
+    isReflectionEvent(): this is PageEvent<Reflection>;
 }
 /**
  * An event emitted when markdown is being parsed. Allows other plugins to manipulate the result.

package/dist/lib/output/events.js

@@ -1,3 +1,4 @@
+import { Reflection, } from "../models/index.js";
 /**
  * An event emitted by the {@link Renderer} class at the very beginning and
  * ending of the entire rendering process.
@@ -106,6 +107,9 @@ export class PageEvent {
     constructor(model) {
         this.model = model;
     }
+    isReflectionEvent() {
+        return this.model instanceof Reflection;
+    }
 }
 /**
  * An event emitted when markdown is being parsed. Allows other plugins to manipulate the result.

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

@@ -6,4 +6,4 @@ export { DefaultTheme, type NavigationElement, type RenderTemplate } from "./the
 export { DefaultThemeRenderContext } from "./themes/default/DefaultThemeRenderContext.js";
 export type { Icons } from "./themes/default/partials/icon.js";
 export { Slugger } from "./themes/default/Slugger.js";
-export { BaseRouter, CategoryRouter, GroupRouter, KindDirRouter, KindRouter, type PageDefinition, PageKind, type Router, StructureDirRouter, StructureRouter, } from "./router.js";
+export { BaseRouter, CategoryRouter, GroupRouter, KindDirRouter, KindRouter, type PageDefinition, PageKind, type Router, type RouterTarget, StructureDirRouter, StructureRouter, } from "./router.js";

package/dist/lib/output/plugins/JavascriptIndexPlugin.js

@@ -34,6 +34,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 };
 import * as Path from "path";
 import lunr from "lunr";
+import { Reflection } from "../../models/index.js";
 import { RendererComponent } from "../components.js";
 import { IndexEvent, RendererEvent } from "../events.js";
 import { Option, writeFile } from "../../utils/index.js";
@@ -112,8 +113,9 @@ let JavascriptIndexPlugin = (() => {
             const theme = this.owner.theme;
             const rows = [];
             const initialSearchResults = this.owner
-                .router.getLinkableReflections()
-                .filter((refl) => (refl.isDeclaration() || refl.isDocument()) &&
+                .router.getLinkTargets()
+                .filter((refl) => refl instanceof Reflection &&
+                (refl.isDeclaration() || refl.isDocument()) &&
                 refl.name &&
                 !refl.flags.isExternal);
             const indexEvent = new IndexEvent(initialSearchResults);

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

@@ -79,8 +79,8 @@ export interface RendererHooks {
 }
 export interface RendererEvents {
     beginRender: [RendererEvent];
-    beginPage: [PageEvent<Reflection>];
-    endPage: [PageEvent<Reflection>];
+    beginPage: [PageEvent];
+    endPage: [PageEvent];
     endRender: [RendererEvent];
     parseMarkdown: [MarkdownEvent];
     prepareIndex: [IndexEvent];

package/dist/lib/output/renderer.js

@@ -263,7 +263,7 @@ let Renderer = (() => {
             await this.runPreRenderJobs(output);
             this.application.logger.verbose(`There are ${pages.length} pages to write.`);
             for (const page of pages) {
-                this.renderDocument(outputDirectory, page);
+                this.renderDocument(outputDirectory, page, project);
             }
             this.postRenderAsyncJobs.push(async (o) => await this.theme.postRender(o));
             await Promise.all(this.postRenderAsyncJobs.map((job) => job(output)));
@@ -286,13 +286,13 @@ let Renderer = (() => {
          * @param page An event describing the current page.
          * @return TRUE if the page has been saved to disc, otherwise FALSE.
          */
-        renderDocument(outputDirectory, page) {
+        renderDocument(outputDirectory, page, project) {
             const momento = this.hooks.saveMomento();
             const event = new PageEvent(page.model);
             event.url = page.url;
             event.filename = path.join(outputDirectory, page.url);
             event.pageKind = page.kind;
-            event.project = page.model.project;
+            event.project = project;
             this.trigger(PageEvent.BEGIN, event);
             event.contents = this.theme.render(event);
             this.trigger(PageEvent.END, event);

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

@@ -1,9 +1,12 @@
 import type { Application } from "../application.js";
-import { type ProjectReflection, type Reflection, ReflectionKind } from "../models/index.js";
+import { ProjectReflection, Reflection, ReflectionKind } from "../models/index.js";
 import { type TypeDocOptionMap } from "../utils/index.js";
 import { Slugger } from "./themes/default/Slugger.js";
 /**
  * The type of page which should be rendered. This may be extended in the future.
+ *
+ * Note: TypeDoc any string may be used as the page kind. TypeDoc defines a few
+ * described by this object.
  * @enum
  */
 export declare const PageKind: {
@@ -12,11 +15,20 @@ export declare const PageKind: {
     readonly Document: "document";
     readonly Hierarchy: "hierarchy";
 };
-export type PageKind = (typeof PageKind)[keyof typeof PageKind];
-export interface PageDefinition {
+export type PageKind = (typeof PageKind)[keyof typeof PageKind] | string & {};
+/**
+ * A router target is something that may be linked to within a page. Notably,
+ * {@link Reflection} is compatible with this interface. TypeDoc supports non-reflection
+ * router targets, but does not currently create any.
+ */
+export type RouterTarget = {
+    name: string;
+    parent: RouterTarget;
+} | Reflection;
+export interface PageDefinition<out Model extends RouterTarget = RouterTarget> {
     readonly url: string;
     readonly kind: PageKind;
-    readonly model: Reflection;
+    readonly model: Model;
 }
 /**
  * Interface which routers must conform to.
@@ -28,36 +40,36 @@ export interface Router {
      */
     buildPages(project: ProjectReflection): PageDefinition[];
     /**
-     * Can be used to check if the reflection can be linked to.
+     * Can be used to check if the target can be linked to.
      */
-    hasUrl(reflection: Reflection): boolean;
+    hasUrl(target: RouterTarget): boolean;
     /**
-     * Get a list of all reflections which can be linked to.
+     * Get a list of all targets which can be linked to.
      * This is used for creating the search index.
      */
-    getLinkableReflections(): Reflection[];
+    getLinkTargets(): RouterTarget[];
     /**
-     * Gets an anchor for this reflection within its containing page.
-     * May be undefined if this reflection owns its own page.
+     * Gets an anchor for this target within its containing page.
+     * May be undefined if this target owns its own page.
      */
-    getAnchor(refl: Reflection): string | undefined;
+    getAnchor(refl: RouterTarget): string | undefined;
     /**
-     * Returns true if the reflection has its own page, false if embedded within
+     * Returns true if the target has its own page, false if embedded within
      * another page.
      */
-    hasOwnDocument(refl: Reflection): boolean;
+    hasOwnDocument(refl: RouterTarget): boolean;
     /**
      * Should return a URL which when clicked on the page containing `from`
      * takes the user to the page/anchor containing `to`.
      */
-    relativeUrl(from: Reflection, to: Reflection): string;
+    relativeUrl(from: RouterTarget, to: RouterTarget): string;
     /**
      * Should return a URL relative to the project base. This is used for
      * determining links to items in the assets folder.
      */
-    baseRelativeUrl(from: Reflection, target: string): string;
+    baseRelativeUrl(from: RouterTarget, target: string): string;
     /**
-     * Get the full URL to the reflection. In TypeDoc's default router this
+     * Get the full URL to the target. In TypeDoc's default router this
      * is equivalent to `relativeUrl(project, refl)`, but this might not be
      * the case for custom routers which place the project somewhere else
      * besides `index.html`.
@@ -65,13 +77,13 @@ export interface Router {
      * The URL returned by this by the frontend JS when building dynamic URLs
      * for the search, full hierarchy, and navigation components.
      */
-    getFullUrl(refl: Reflection): string;
+    getFullUrl(refl: RouterTarget): string;
     /**
-     * Responsible for getting a slugger for the given reflection. If a
-     * reflection is not associated with a page, the slugger for the parent
-     * reflection should be returned instead.
+     * Responsible for getting a slugger for the given target. If a
+     * target is not associated with a page, the slugger for the parent
+     * target should be returned instead.
      */
-    getSlugger(reflection: Reflection): Slugger;
+    getSlugger(reflection: RouterTarget): Slugger;
 }
 /**
  * Base router class intended to make it easier to implement a router.
@@ -84,36 +96,36 @@ export declare abstract class BaseRouter implements Router {
     readonly application: Application;
     extension: string;
     protected usedFileNames: Set<string>;
-    protected sluggers: Map<Reflection, Slugger>;
-    protected fullUrls: Map<Reflection, string>;
-    protected anchors: Map<Reflection, string>;
+    protected sluggers: Map<RouterTarget, Slugger>;
+    protected fullUrls: Map<RouterTarget, string>;
+    protected anchors: Map<RouterTarget, string>;
     protected accessor sluggerConfiguration: TypeDocOptionMap["sluggerConfiguration"];
     protected accessor includeHierarchySummary: boolean;
     constructor(application: Application);
     /**
-     * Should return the base-relative desired file name for a reflection.
+     * Should return the base-relative desired file name for a router target.
      * This name may not be used exactly as TypeDoc will detect conflicts
      * and automatically introduce a unique identifier to the URL to resolve
      * them.
      */
-    protected abstract getIdealBaseName(reflection: Reflection): string;
+    protected abstract getIdealBaseName(reflection: RouterTarget): string;
     buildPages(project: ProjectReflection): PageDefinition[];
-    hasUrl(reflection: Reflection): boolean;
-    getLinkableReflections(): Reflection[];
-    getAnchor(refl: Reflection): string | undefined;
-    hasOwnDocument(refl: Reflection): boolean;
-    relativeUrl(from: Reflection, to: Reflection): string;
-    baseRelativeUrl(from: Reflection, target: string): string;
-    getFullUrl(refl: Reflection): string;
-    getSlugger(reflection: Reflection): Slugger;
+    hasUrl(target: RouterTarget): boolean;
+    getLinkTargets(): RouterTarget[];
+    getAnchor(target: RouterTarget): string | undefined;
+    hasOwnDocument(target: RouterTarget): boolean;
+    relativeUrl(from: RouterTarget, to: RouterTarget): string;
+    baseRelativeUrl(from: RouterTarget, target: string): string;
+    getFullUrl(target: RouterTarget): string;
+    getSlugger(target: RouterTarget): Slugger;
     /**
      * Should the page kind to use if a reflection should have its own rendered
      * page in the output. Note that once `undefined` is returned, children of
      * that reflection will not have their own document.
      */
-    protected getPageKind(reflection: Reflection): PageKind | undefined;
-    protected buildChildPages(reflection: Reflection, outPages: PageDefinition[]): void;
-    protected buildAnchors(reflection: Reflection, pageReflection: Reflection): void;
+    protected getPageKind(target: RouterTarget): PageKind | undefined;
+    protected buildChildPages(target: RouterTarget, outPages: PageDefinition[]): void;
+    protected buildAnchors(target: RouterTarget, pageTarget: RouterTarget): void;
     /** Strip non-url safe characters from the specified string. */
     protected getUrlSafeName(name: string): string;
     protected getFileName(baseName: string): string;

package/dist/lib/output/router.js

@@ -34,13 +34,16 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 };
 import { CategoryPlugin } from "../converter/plugins/CategoryPlugin.js";
 import { GroupPlugin } from "../converter/plugins/GroupPlugin.js";
-import { ReflectionKind, } from "../models/index.js";
+import { ProjectReflection, Reflection, ReflectionKind } from "../models/index.js";
 import { createNormalizedUrl } from "#node-utils";
 import { Option } from "../utils/index.js";
 import { Slugger } from "./themes/default/Slugger.js";
 import { getHierarchyRoots } from "./themes/lib.js";
 /**
  * The type of page which should be rendered. This may be extended in the future.
+ *
+ * Note: TypeDoc any string may be used as the page kind. TypeDoc defines a few
+ * described by this object.
  * @enum
  */
 export const PageKind = {
@@ -49,6 +52,18 @@ export const PageKind = {
     Document: "document",
     Hierarchy: "hierarchy",
 };
+function getFullName(target) {
+    if (target instanceof ProjectReflection) {
+        return target.name;
+    }
+    const parts = [target.name];
+    let current = target;
+    while (!(current instanceof ProjectReflection)) {
+        parts.unshift(current.name);
+        current = current.parent;
+    }
+    return parts.join(".");
+}
 /**
  * Base router class intended to make it easier to implement a router.
  *
@@ -128,24 +143,27 @@ let BaseRouter = (() => {
             }
             return pages;
         }
-        hasUrl(reflection) {
-            return this.fullUrls.has(reflection);
+        hasUrl(target) {
+            return this.fullUrls.has(target);
         }
-        getLinkableReflections() {
+        getLinkTargets() {
             return Array.from(this.fullUrls.keys());
         }
-        getAnchor(refl) {
-            if (!this.anchors.has(refl)) {
-                this.application.logger.verbose(`${refl.getFullName()} does not have an anchor but one was requested, this is a bug in the theme`);
+        getAnchor(target) {
+            if (!this.anchors.has(target)) {
+                this.application.logger.verbose(`${getFullName(target)} does not have an anchor but one was requested, this is a bug in the theme`);
             }
-            return this.anchors.get(refl);
+            return this.anchors.get(target);
         }
-        hasOwnDocument(refl) {
-            return this.anchors.get(refl) === undefined && this.hasUrl(refl);
+        hasOwnDocument(target) {
+            return this.anchors.get(target) === undefined && this.hasUrl(target);
         }
         relativeUrl(from, to) {
             let slashes = 0;
             while (!this.hasOwnDocument(from)) {
+                // We know we must have a parent here as the Project is the only
+                // root level element without a parent, and the project always has
+                // an own document.
                 from = from.parent;
             }
             const fromUrl = this.getFullUrl(from);
@@ -163,7 +181,7 @@ let BaseRouter = (() => {
                     }
                 }
             }
-            if (equal && !to.isProject()) {
+            if (equal && !(to instanceof ProjectReflection)) {
                 if (fromUrl === toUrl) {
                     return "";
                 }
@@ -180,26 +198,29 @@ let BaseRouter = (() => {
             }
             return "../".repeat(slashes) + target;
         }
-        getFullUrl(refl) {
-            const url = this.fullUrls.get(refl);
+        getFullUrl(target) {
+            const url = this.fullUrls.get(target);
             if (!url) {
-                throw new Error(`Tried to get a URL of a reflection ${refl.getFullName()} which did not receive a URL`);
+                throw new Error(`Tried to get a URL of a router target ${getFullName(target)} which did not receive a URL`);
             }
             return url;
         }
-        getSlugger(reflection) {
-            if (this.sluggers.has(reflection)) {
-                return this.sluggers.get(reflection);
+        getSlugger(target) {
+            if (this.sluggers.has(target)) {
+                return this.sluggers.get(target);
             }
             // A slugger should always be defined at least for the project
-            return this.getSlugger(reflection.parent);
+            return this.getSlugger(target.parent);
         }
         /**
          * Should the page kind to use if a reflection should have its own rendered
          * page in the output. Note that once `undefined` is returned, children of
          * that reflection will not have their own document.
          */
-        getPageKind(reflection) {
+        getPageKind(target) {
+            if (!(target instanceof Reflection)) {
+                return undefined;
+            }
             const pageReflectionKinds = ReflectionKind.Class |
                 ReflectionKind.Interface |
                 ReflectionKind.Enum |
@@ -209,38 +230,43 @@ let BaseRouter = (() => {
                 ReflectionKind.Function |
                 ReflectionKind.Variable;
             const documentReflectionKinds = ReflectionKind.Document;
-            if (reflection.kindOf(pageReflectionKinds)) {
+            if (target.kindOf(pageReflectionKinds)) {
                 return PageKind.Reflection;
             }
-            if (reflection.kindOf(documentReflectionKinds)) {
+            if (target.kindOf(documentReflectionKinds)) {
                 return PageKind.Document;
             }
         }
-        buildChildPages(reflection, outPages) {
-            const kind = this.getPageKind(reflection);
+        buildChildPages(target, outPages) {
+            const kind = this.getPageKind(target);
             if (kind) {
-                const idealName = this.getIdealBaseName(reflection);
+                const idealName = this.getIdealBaseName(target);
                 const actualName = this.getFileName(idealName);
-                this.fullUrls.set(reflection, actualName);
-                this.sluggers.set(reflection, new Slugger(this.sluggerConfiguration));
+                this.fullUrls.set(target, actualName);
+                this.sluggers.set(target, new Slugger(this.sluggerConfiguration));
                 outPages.push({
                     kind,
-                    model: reflection,
+                    model: target,
                     url: actualName,
                 });
-                reflection.traverse((child) => {
-                    this.buildChildPages(child, outPages);
-                    return true;
-                });
+                if (target instanceof Reflection) {
+                    target.traverse((child) => {
+                        this.buildChildPages(child, outPages);
+                        return true;
+                    });
+                }
             }
             else {
-                this.buildAnchors(reflection, reflection.parent);
+                this.buildAnchors(target, target.parent);
             }
         }
-        buildAnchors(reflection, pageReflection) {
-            if (!reflection.isDeclaration() &&
-                !reflection.isSignature() &&
-                !reflection.isTypeParameter()) {
+        buildAnchors(target, pageTarget) {
+            if (!(target instanceof Reflection) || !(pageTarget instanceof Reflection)) {
+                return;
+            }
+            if (!target.isDeclaration() &&
+                !target.isSignature() &&
+                !target.isTypeParameter()) {
                 return;
             }
             // We support linking to reflections for types directly contained within an export
@@ -248,16 +274,16 @@ let BaseRouter = (() => {
             // for a property depending on whether or not it is deemed useful, and defining a link
             // which might not be used may result in a link being generated which isn't valid. #2808.
             // This should be kept in sync with the renderingChildIsUseful function.
-            if (reflection.kindOf(ReflectionKind.TypeLiteral) &&
-                (!reflection.parent?.kindOf(ReflectionKind.SomeExport) ||
-                    reflection.parent.type?.type !==
+            if (target.kindOf(ReflectionKind.TypeLiteral) &&
+                (!target.parent?.kindOf(ReflectionKind.SomeExport) ||
+                    target.parent.type?.type !==
                         "reflection")) {
                 return;
             }
-            if (!reflection.kindOf(ReflectionKind.TypeLiteral)) {
-                let refl = reflection;
+            if (!target.kindOf(ReflectionKind.TypeLiteral)) {
+                let refl = target;
                 const parts = [refl.name];
-                while (refl.parent && refl.parent !== pageReflection) {
+                while (refl.parent && refl.parent !== pageTarget) {
                     refl = refl.parent;
                     // Avoid duplicate names for signatures and useless __type in anchors
                     if (!refl.kindOf(ReflectionKind.TypeLiteral |
@@ -265,12 +291,12 @@ let BaseRouter = (() => {
                         parts.unshift(refl.name);
                     }
                 }
-                const anchor = this.getSlugger(pageReflection).slug(parts.join("."));
-                this.fullUrls.set(reflection, this.fullUrls.get(pageReflection) + "#" + anchor);
-                this.anchors.set(reflection, anchor);
+                const anchor = this.getSlugger(pageTarget).slug(parts.join("."));
+                this.fullUrls.set(target, this.fullUrls.get(pageTarget) + "#" + anchor);
+                this.anchors.set(target, anchor);
             }
-            reflection.traverse((child) => {
-                this.buildAnchors(child, pageReflection);
+            target.traverse((child) => {
+                this.buildAnchors(child, pageTarget);
                 return true;
             });
         }

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

@@ -1,6 +1,5 @@
 import { RendererComponent } from "./components.js";
 import type { PageEvent, RendererEvent } from "./events.js";
-import type { Reflection } from "../models/index.js";
 /**
  * Base class of all themes.
  *
@@ -11,7 +10,7 @@ export declare abstract class Theme extends RendererComponent {
     /**
      * Renders the provided page to a string, which will be written to disk by the {@link Renderer}
      */
-    abstract render(event: PageEvent<Reflection>): string;
+    abstract render(event: PageEvent): string;
     /**
      * Optional hook to call pre-render jobs
      */

package/dist/lib/output/themes/MarkedPlugin.js

@@ -39,7 +39,22 @@ import { Option } from "../../utils/index.js";
 import { highlight, isLoadedLanguage, isSupportedLanguage } from "../../utils/highlighter.js";
 import { assertNever, escapeHtml, i18n, JSX } from "#utils";
 import { anchorIcon } from "./default/partials/anchor-icon.js";
-import { ReflectionKind, } from "../../models/index.js";
+import { Reflection, ReflectionKind, } from "../../models/index.js";
+function getFriendlyFullName(target) {
+    if (target instanceof Reflection) {
+        return target.getFriendlyFullName();
+    }
+    if (target.parent) {
+        return target.name;
+    }
+    const parts = [target.name];
+    let current = target;
+    while (current.parent) {
+        parts.unshift(current.name);
+        current = current.parent;
+    }
+    return parts.join(".");
+}
 /**
  * Implements markdown and relativeURL helpers for templates.
  * @internal
@@ -115,11 +130,11 @@ let MarkedPlugin = (() => {
             lang = lang || "typescript";
             lang = lang.toLowerCase();
             if (!isSupportedLanguage(lang)) {
-                this.application.logger.warn(i18n.unsupported_highlight_language_0_not_highlighted_in_comment_for_1(lang, this.page?.model.getFriendlyFullName() ?? "(unknown)"));
+                this.application.logger.warn(i18n.unsupported_highlight_language_0_not_highlighted_in_comment_for_1(lang, getFriendlyFullName(this.page?.model || { name: "(unknown)" })));
                 return text;
             }
             if (!isLoadedLanguage(lang)) {
-                this.application.logger.warn(i18n.unloaded_language_0_not_highlighted_in_comment_for_1(lang, this.page?.model.getFriendlyFullName() ?? "(unknown)"));
+                this.application.logger.warn(i18n.unloaded_language_0_not_highlighted_in_comment_for_1(lang, getFriendlyFullName(this.page?.model || { name: "(unknown)" })));
                 return text;
             }
             return highlight(text, lang);
@@ -258,7 +273,7 @@ let MarkedPlugin = (() => {
             for (const { source, target, link } of this.renderedRelativeLinks) {
                 const slugger = this.owner.router.getSlugger(target);
                 if (!slugger.hasAnchor(link.targetAnchor)) {
-                    this.application.logger.warn(i18n.reflection_0_links_to_1_but_anchor_does_not_exist_try_2(source.getFriendlyFullName(), link.text, slugger
+                    this.application.logger.warn(i18n.reflection_0_links_to_1_but_anchor_does_not_exist_try_2(getFriendlyFullName(source), link.text, slugger
                         .getSimilarAnchors(link.targetAnchor)
                         .map((a) => link.text.replace(/#.*/, "#" + a))
                         .join("\n\t")));

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

@@ -61,7 +61,7 @@ export declare class DefaultTheme extends Theme {
      * @param renderer  The renderer this theme is attached to.
      */
     constructor(renderer: Renderer);
-    render(page: PageEvent<Reflection>): string;
+    render(page: PageEvent): string;
     preRender(_event: RendererEvent): Promise<void>;
     private _navigationCache;
     /**

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

@@ -140,12 +140,19 @@ let DefaultTheme = (() => {
             this.router = renderer.router;
         }
         render(page) {
-            const template = {
+            const templateMapping = {
                 [PageKind.Index]: this.indexTemplate,
                 [PageKind.Document]: this.documentTemplate,
                 [PageKind.Hierarchy]: this.hierarchyTemplate,
                 [PageKind.Reflection]: this.reflectionTemplate,
-            }[page.pageKind];
+            };
+            const template = templateMapping[page.pageKind];
+            if (!template) {
+                throw new Error(`TypeDoc's DefaultTheme does not support the page kind ${page.pageKind}`);
+            }
+            if (!page.isReflectionEvent()) {
+                throw new Error(`TypeDoc's DefaultTheme requires that a page model be a reflection when rendering ${page.pageKind}`);
+            }
             const templateOutput = this.defaultLayoutTemplate(page, template);
             return "<!DOCTYPE html>" + JSX.renderElement(templateOutput) + "\n";
         }

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

@@ -67,7 +67,7 @@ export const defaultLayout = (context, template, props) => (JSX.createElement("h
         JSX.createElement("script", null,
             JSX.createElement(JSX.Raw, { html: 'document.documentElement.dataset.theme = localStorage.getItem("tsd-theme") || "os";' }),
             JSX.createElement(JSX.Raw, { html: 'document.body.style.display="none";' }),
-            JSX.createElement(JSX.Raw, { html: 'setTimeout(() => app?app.showPage():document.body.style.removeProperty("display"),500)' })),
+            JSX.createElement(JSX.Raw, { html: 'setTimeout(() => window.app?app.showPage():document.body.style.removeProperty("display"),500)' })),
         context.toolbar(props),
         JSX.createElement("div", { class: "container container-main" },
             JSX.createElement("div", { class: "col-content" },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typedoc",
   "description": "Create api documentation for TypeScript projects.",
-  "version": "0.28.0-beta.2",
+  "version": "0.28.0",
   "homepage": "https://typedoc.org",
   "type": "module",
   "exports": {
@@ -31,7 +31,7 @@
     "pnpm": ">= 10"
   },
   "dependencies": {
-    "@gerrit0/mini-shiki": "^3.0.0",
+    "@gerrit0/mini-shiki": "^3.2.1",
     "lunr": "^2.3.9",
     "markdown-it": "^14.1.0",
     "minimatch": "^9.0.5",
@@ -41,7 +41,7 @@
     "typescript": "5.0.x || 5.1.x || 5.2.x || 5.3.x || 5.4.x || 5.5.x || 5.6.x || 5.7.x || 5.8.x"
   },
   "devDependencies": {
-    "@eslint/js": "^9.21.0",
+    "@eslint/js": "^9.22.0",
     "@types/lunr": "^2.3.7",
     "@types/markdown-it": "^14.1.2",
     "@types/mocha": "^10.0.10",
@@ -49,14 +49,14 @@
     "@typestrong/fs-fixture-builder": "github:TypeStrong/fs-fixture-builder#34113409e3a171e68ce5e2b55461ef5c35591cfe",
     "c8": "^10.1.3",
     "dprint": "^0.49.0",
-    "esbuild": "^0.24.2",
-    "eslint": "^9.21.0",
+    "esbuild": "^0.25.1",
+    "eslint": "^9.22.0",
     "mocha": "^11.1.0",
-    "puppeteer": "^24.2.1",
+    "puppeteer": "^24.4.0",
     "semver": "^7.7.1",
     "tsx": "^4.19.3",
-    "typescript": "5.8.1-rc",
-    "typescript-eslint": "^8.24.1"
+    "typescript": "5.8.2",
+    "typescript-eslint": "^8.26.1"
   },
   "files": [
     "/bin",

package/static/style.css

@@ -1076,9 +1076,8 @@
     .tsd-index-summary {
         margin-top: 1.5rem;
         margin-bottom: 0.75rem;
-    }
-    .tsd-index-heading {
-        margin: 0;
+        display: flex;
+        align-content: center;
     }
 
     .tsd-no-select {
@@ -1475,7 +1474,7 @@
     @media (max-width: 769px) {
         #tsd-toolbar-menu-trigger {
             display: inline-block;
-            /* temporary fix to vertically align, for compatibilty */
+            /* temporary fix to vertically align, for compatibility */
             line-height: 2.5;
         }
         #tsd-toolbar-links {