typedoc 0.28.0-beta.1 → 0.28.0

package/dist/index.d.ts

@@ -37,11 +37,11 @@ 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";
-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, 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 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/converter/context.d.ts

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { DeclarationReflection, type DocumentReflection, type ProjectReflection, type Reflection, ReflectionKind } from "../models/index.js";
+import { Comment, DeclarationReflection, type DocumentReflection, type ProjectReflection, ReferenceType, type Reflection, ReflectionKind } from "../models/index.js";
 import type { Converter } from "./converter.js";
 import { type NormalizedPath } from "#utils";
 /**
@@ -35,6 +35,8 @@ export declare class Context {
     convertingTypeNode: boolean;
     convertingClassOrInterface: boolean;
     shouldBeStatic: boolean;
+    inlineType: Set<string>;
+    preventInline: Set<string>;
     private reflectionIdToSymbolMap;
     /**
      * Create a new Context instance.
@@ -58,6 +60,13 @@ export declare class Context {
     createDeclarationReflection(kind: ReflectionKind, symbol: ts.Symbol | undefined, exportSymbol: ts.Symbol | undefined, nameOverride?: string): DeclarationReflection;
     postReflectionCreation(reflection: Reflection, symbol: ts.Symbol | undefined, exportSymbol: ts.Symbol | undefined): void;
     finalizeDeclarationReflection(reflection: DeclarationReflection): void;
+    /**
+     * Create a {@link ReferenceType} which points to the provided symbol.
+     *
+     * @privateRemarks
+     * 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;
     addChild(reflection: DeclarationReflection | DocumentReflection): void;
     shouldIgnore(symbol: ts.Symbol): boolean;
     /**
@@ -72,10 +81,11 @@ export declare class Context {
     getSymbolFromReflection(reflection: Reflection): ts.Symbol | undefined;
     /** @internal */
     setActiveProgram(program: ts.Program | undefined): void;
-    getComment(symbol: ts.Symbol, kind: ReflectionKind): import("../models/Comment.js").Comment | undefined;
-    getNodeComment(node: ts.Node, moduleComment: boolean): import("../models/Comment.js").Comment | undefined;
-    getFileComment(node: ts.SourceFile): import("../models/Comment.js").Comment | undefined;
-    getJsDocComment(declaration: ts.JSDocPropertyLikeTag | ts.JSDocCallbackTag | ts.JSDocTypedefTag | ts.JSDocTemplateTag | ts.JSDocEnumTag): import("../models/Comment.js").Comment | undefined;
-    getSignatureComment(declaration: ts.SignatureDeclaration | ts.JSDocSignature): import("../models/Comment.js").Comment | undefined;
+    getComment(symbol: ts.Symbol, kind: ReflectionKind): Comment | undefined;
+    getNodeComment(node: ts.Node, moduleComment: boolean): Comment | undefined;
+    getFileComment(node: ts.SourceFile): Comment | undefined;
+    getJsDocComment(declaration: ts.JSDocPropertyLikeTag | ts.JSDocCallbackTag | ts.JSDocTypedefTag | ts.JSDocTemplateTag | ts.JSDocEnumTag): Comment | undefined;
+    getSignatureComment(declaration: ts.SignatureDeclaration | ts.JSDocSignature): Comment | undefined;
+    shouldInline(symbol: ts.Symbol, name: string): boolean;
     withScope(scope: Reflection): Context;
 }

package/dist/lib/converter/context.js

@@ -1,12 +1,12 @@
 import { ok as assert } from "assert";
 import ts from "typescript";
-import { ContainerReflection, DeclarationReflection, ReflectionFlag, ReflectionKind, } from "../models/index.js";
+import { Comment, ContainerReflection, DeclarationReflection, ReferenceType, ReflectionFlag, ReflectionKind, } from "../models/index.js";
 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 { getHumanName } from "../utils/tsutils.js";
-import { normalizePath } from "#node-utils";
+import { getHumanName, getQualifiedName } from "../utils/tsutils.js";
+import { findPackageForPath, normalizePath } from "#node-utils";
 import { createSymbolId } from "./factories/symbol-id.js";
 import { removeIf } from "#utils";
 /**
@@ -47,6 +47,8 @@ export class Context {
     convertingTypeNode = false; // Inherited by withScope
     convertingClassOrInterface = false; // Not inherited
     shouldBeStatic = false; // Not inherited
+    inlineType = new Set(); // Inherited by withScope
+    preventInline = new Set(); // Inherited by withScope
     reflectionIdToSymbolMap = new Map();
     /**
      * Create a new Context instance.
@@ -165,6 +167,21 @@ export class Context {
             this.converter.processDocumentTags(reflection, reflection);
         }
     }
+    /**
+     * Create a {@link ReferenceType} which points to the provided symbol.
+     *
+     * @privateRemarks
+     * 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));
+        ref.refersToTypeParameter = !!(symbol.flags & ts.SymbolFlags.TypeParameter);
+        const symbolPath = symbol.declarations?.[0]?.getSourceFile().fileName;
+        if (!symbolPath)
+            return ref;
+        ref.package = findPackageForPath(symbolPath)?.[0];
+        return ref;
+    }
     addChild(reflection) {
         if (this.scope instanceof ContainerReflection) {
             this.scope.addChild(reflection);
@@ -233,12 +250,31 @@ export class Context {
     getSignatureComment(declaration) {
         return getSignatureComment(declaration, this.converter.config, this.logger, this.checker, this.project.files);
     }
+    shouldInline(symbol, name) {
+        if (this.preventInline.has(name))
+            return false;
+        if (this.inlineType.has(name))
+            return true;
+        return this
+            .getComment(symbol, ReflectionKind.Interface)
+            ?.hasModifier("@inline") ?? false;
+    }
     withScope(scope) {
         assert(scope.parent === this.scope || scope === this.scope, "Incorrect context used for withScope");
         const context = new Context(this.converter, this.programs, this.project, scope);
         context.convertingTypeNode = this.convertingTypeNode;
         context.setActiveProgram(this._program);
         context.reflectionIdToSymbolMap = this.reflectionIdToSymbolMap;
+        context.preventInline = new Set(this.preventInline);
+        context.inlineType = new Set(this.inlineType);
+        for (const tag of scope.comment?.blockTags || []) {
+            if (tag.tag === "@preventInline") {
+                context.preventInline.add(Comment.combineDisplayParts(tag.content));
+            }
+            else if (tag.tag === "@inlineType") {
+                context.inlineType.add(Comment.combineDisplayParts(tag.content));
+            }
+        }
         return context;
     }
 }

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

@@ -16,7 +16,6 @@ export function createSignature(context, kind, signature, symbol, declaration) {
     if (context.shouldBeStatic) {
         sigRef.setFlag(ReflectionFlag.Static);
     }
-    const sigRefCtx = context.withScope(sigRef);
     if (symbol && declaration) {
         context.project.registerSymbolId(sigRef, createSymbolId(symbol, declaration));
     }
@@ -34,6 +33,7 @@ export function createSignature(context, kind, signature, symbol, declaration) {
             }
         }
     }
+    const sigRefCtx = context.withScope(sigRef);
     sigRef.typeParameters = convertTypeParameters(sigRefCtx, sigRef, signature.typeParameters);
     const parameterSymbols = signature.thisParameter
         ? [signature.thisParameter, ...signature.parameters]

package/dist/lib/converter/factories/symbol-id.js

@@ -43,6 +43,7 @@ export function createSymbolId(symbol, declaration) {
     });
     id.pos = pos;
     id.transientId = transientId;
+    id.fileName = normalizePath(sourceFileName);
     return id;
 }
 function resolveDeclarationMaps(file) {

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

@@ -45,6 +45,6 @@ export class MergeModuleWithPlugin extends ConverterComponent {
             tempRefl = tempRefl.parent;
         }
         this.application.logger.verbose(`Merging ${refl.getFullName()} into ${target.getFullName()}`);
-        project.mergeModules(refl, target);
+        project.mergeReflections(refl, target);
     }
 }

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

@@ -113,8 +113,8 @@ let SourcePlugin = (() => {
             this.owner.on(ConverterEvents.RESOLVE_BEGIN, this.onBeginResolve.bind(this));
         }
         onEnd() {
-            // Should probably clear repositories/ignoredPaths here, but these aren't likely to change between runs...
             this.fileNames.clear();
+            delete this.repositories;
         }
         /**
          * Triggered when the converter has created a declaration reflection.

package/dist/lib/converter/symbols.js

@@ -116,7 +116,8 @@ function _convertSymbolNow(context, symbol, exportSymbol) {
 export function convertSymbol(context, symbol, exportSymbol) {
     // #1795, defer conversion of symbols named `default` so that if a function
     // is default exported and also exported with a name, the name takes precedence
-    if ((exportSymbol?.name ?? symbol.name) === "default") {
+    if ((exportSymbol?.name ?? symbol.name) === "default" &&
+        context.scope.kindOf(ReflectionKind.ExportContainer)) {
         context.converter.deferConversion(() => {
             _convertSymbolNow(context, symbol, exportSymbol);
         });
@@ -204,6 +205,7 @@ function convertTypeAlias(context, symbol, exportSymbol) {
             return convertTypeAliasAsInterface(context, symbol, exportSymbol, declaration);
         }
         const reflection = context.createDeclarationReflection(ReflectionKind.TypeAlias, symbol, exportSymbol);
+        context.finalizeDeclarationReflection(reflection);
         if (reflection.comment?.hasModifier("@useDeclaredType")) {
             reflection.comment.removeModifier("@useDeclaredType");
             reflection.type = context.converter.convertType(context.withScope(reflection), context.checker.getDeclaredTypeOfSymbol(symbol));
@@ -214,9 +216,17 @@ function convertTypeAlias(context, symbol, exportSymbol) {
         if (reflection.type.type === "union") {
             attachUnionComments(context, declaration, reflection.type);
         }
-        context.finalizeDeclarationReflection(reflection);
-        // Do this after finalization so that the CommentPlugin can get @typeParam tags
-        // from the parent comment. Ugly, but works for now. Should be cleaned up eventually.
+        else if (reflection.type.type === "reflection" && reflection.type.declaration.children) {
+            // #2817 lift properties of object literal types up to the reflection level.
+            const typeDecl = reflection.type.declaration;
+            reflection.project.mergeReflections(typeDecl, reflection);
+            delete reflection.type;
+            // When created any signatures will be created with __type as their
+            // name, rename them so that they have the alias's name as their name
+            for (const sig of reflection.signatures || []) {
+                sig.name = reflection.name;
+            }
+        }
         reflection.typeParameters = declaration.typeParameters?.map((param) => createTypeParamReflection(param, context.withScope(reflection)));
     }
     else if (ts.isJSDocTypedefTag(declaration) ||

package/dist/lib/converter/types.js

@@ -8,7 +8,6 @@ import { convertParameterNodes, convertTypeParameterNodes, createSignature } fro
 import { convertSymbol } from "./symbols.js";
 import { isObjectType, isTypeReference } from "./utils/nodes.js";
 import { removeUndefined } from "./utils/reflections.js";
-import { createSymbolReference } from "./factories/types.js";
 import { createSymbolId } from "./factories/symbol-id.js";
 const converters = new Map();
 export function loadConverters() {
@@ -189,7 +188,7 @@ const exprWithTypeArgsConverter = {
             return convertType(context, context.checker.getTypeAtLocation(node));
         }
         const parameters = node.typeArguments?.map((type) => convertType(context, type)) ?? [];
-        const ref = createSymbolReference(context.resolveAliasedSymbol(targetSymbol), context);
+        const ref = context.createSymbolReference(context.resolveAliasedSymbol(targetSymbol), context);
         ref.typeArguments = parameters;
         return ref;
     },
@@ -239,12 +238,12 @@ const importType = {
         if (!symbol) {
             return new IntrinsicType("any");
         }
-        return createSymbolReference(context.resolveAliasedSymbol(symbol), context, name);
+        return context.createSymbolReference(context.resolveAliasedSymbol(symbol), context, name);
     },
     convertType(context, type) {
         const symbol = type.getSymbol();
         assert(symbol, "Missing symbol when converting import type"); // Should be a compiler error
-        return createSymbolReference(context.resolveAliasedSymbol(symbol), context, "__module");
+        return context.createSymbolReference(context.resolveAliasedSymbol(symbol), context, "__module");
     },
 };
 const indexedAccessConverter = {
@@ -413,7 +412,7 @@ const queryConverter = {
             // on a variable typed as `any` with a name that doesn't exist.
             return new QueryType(ReferenceType.createBrokenReference(node.exprName.getText(), context.project));
         }
-        const ref = createSymbolReference(context.resolveAliasedSymbol(querySymbol), context, node.exprName.getText());
+        const ref = context.createSymbolReference(context.resolveAliasedSymbol(querySymbol), context, node.exprName.getText());
         ref.preferValues = true;
         return new QueryType(ref);
     },
@@ -422,7 +421,7 @@ const queryConverter = {
         // an instantiation expression we get the user's exprName.
         const symbol = context.getSymbolAtLocation(node.exprName) || type.getSymbol();
         assert(symbol, `Query type failed to get a symbol for: ${context.checker.typeToString(type)}. This is a bug.`);
-        const ref = createSymbolReference(context.resolveAliasedSymbol(symbol), context);
+        const ref = context.createSymbolReference(context.resolveAliasedSymbol(symbol), context);
         ref.preferValues = true;
         return new QueryType(ref);
     },
@@ -436,20 +435,18 @@ const referenceConverter = {
             return new ArrayType(convertType(context, node.typeArguments?.[0]));
         }
         const symbol = context.expectSymbolAtLocation(node.typeName);
+        const name = node.typeName.getText();
         // Ignore @inline if there are type arguments, as they won't be resolved
         // in the type we just retrieved from node.typeName.
         if (!node.typeArguments &&
-            context
-                .getComment(symbol, ReflectionKind.Interface)
-                ?.hasModifier("@inline")) {
+            context.shouldInline(symbol, name)) {
             // typeLiteralConverter doesn't use the node, so we can get away with lying here.
             // This might not actually be safe, it appears that it is in the relatively small
             // amount of testing I've done with it, but I wouldn't be surprised if someone manages
             // to find a crash.
             return typeLiteralConverter.convertType(context, type, null, undefined);
         }
-        const name = node.typeName.getText();
-        const ref = createSymbolReference(context.resolveAliasedSymbol(symbol), context, name);
+        const ref = context.createSymbolReference(context.resolveAliasedSymbol(symbol), context, name);
         ref.typeArguments = node.typeArguments?.map((type) => convertType(context, type));
         return ref;
     },
@@ -465,15 +462,6 @@ const referenceConverter = {
             ref.refersToTypeParameter = true;
             return ref;
         }
-        if (context
-            .getComment(symbol, ReflectionKind.Interface)
-            ?.hasModifier("@inline")) {
-            // typeLiteralConverter doesn't use the node, so we can get away with lying here.
-            // This might not actually be safe, it appears that it is in the relatively small
-            // amount of testing I've done with it, but I wouldn't be surprised if someone manages
-            // to find a crash.
-            return typeLiteralConverter.convertType(context, type, null, undefined);
-        }
         let name;
         if (ts.isIdentifier(node.typeName)) {
             name = node.typeName.text;
@@ -481,7 +469,14 @@ const referenceConverter = {
         else {
             name = node.typeName.right.text;
         }
-        const ref = createSymbolReference(context.resolveAliasedSymbol(symbol), context, name);
+        if (context.shouldInline(symbol, name)) {
+            // typeLiteralConverter doesn't use the node, so we can get away with lying here.
+            // This might not actually be safe, it appears that it is in the relatively small
+            // amount of testing I've done with it, but I wouldn't be surprised if someone manages
+            // to find a crash.
+            return typeLiteralConverter.convertType(context, type, null, undefined);
+        }
+        const ref = context.createSymbolReference(context.resolveAliasedSymbol(symbol), context, name);
         if (type.flags & ts.TypeFlags.Substitution) {
             // NoInfer<T>
             ref.typeArguments = [

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

@@ -1,7 +1,7 @@
 import { Reflection, type TraverseCallback } from "./Reflection.js";
 import { ReflectionCategory } from "./ReflectionCategory.js";
 import { ReflectionGroup } from "./ReflectionGroup.js";
-import type { ReflectionKind } from "./kind.js";
+import { ReflectionKind } from "./kind.js";
 import type { Deserializer, JSONOutput, Serializer } from "#serialization";
 import type { DocumentReflection } from "./DocumentReflection.js";
 import type { DeclarationReflection } from "./DeclarationReflection.js";
@@ -47,7 +47,7 @@ export declare abstract class ContainerReflection extends Reflection {
      * @returns     An array containing all children with the desired kind.
      */
     getChildrenByKind(kind: ReflectionKind): DeclarationReflection[];
-    addChild(child: DeclarationReflection | DocumentReflection): void;
+    addChild(child: Reflection): void;
     removeChild(child: DeclarationReflection | DocumentReflection): void;
     traverse(callback: TraverseCallback): void;
     toObject(serializer: Serializer): JSONOutput.ContainerReflection;

package/dist/lib/models/ContainerReflection.js

@@ -1,7 +1,8 @@
 import { Reflection, TraverseProperty } from "./Reflection.js";
 import { ReflectionCategory } from "./ReflectionCategory.js";
 import { ReflectionGroup } from "./ReflectionGroup.js";
-import { removeIfPresent } from "#utils";
+import { ReflectionKind } from "./kind.js";
+import { assertNever, removeIfPresent } from "#utils";
 /**
  * @category Reflections
  */
@@ -50,13 +51,36 @@ export class ContainerReflection extends Reflection {
         if (child.isDeclaration()) {
             this.children ||= [];
             this.children.push(child);
+            this.childrenIncludingDocuments ||= [];
+            this.childrenIncludingDocuments.push(child);
         }
-        else {
+        else if (child.isDocument()) {
             this.documents ||= [];
             this.documents.push(child);
+            this.childrenIncludingDocuments ||= [];
+            this.childrenIncludingDocuments.push(child);
+        }
+        else if (this.isDeclaration() && child.isSignature()) {
+            switch (child.kind) {
+                case ReflectionKind.CallSignature:
+                case ReflectionKind.ConstructorSignature:
+                    this.signatures ||= [];
+                    this.signatures.push(child);
+                    break;
+                case ReflectionKind.IndexSignature:
+                    this.indexSignatures ||= [];
+                    this.indexSignatures.push(child);
+                    break;
+                case ReflectionKind.GetSignature:
+                case ReflectionKind.SetSignature:
+                    throw new Error("Unsupported child type: " + ReflectionKind[child.kind]);
+                default:
+                    assertNever(child.kind);
+            }
+        }
+        else {
+            throw new Error("Unsupported child type: " + ReflectionKind[child.kind]);
         }
-        this.childrenIncludingDocuments ||= [];
-        this.childrenIncludingDocuments.push(child);
     }
     removeChild(child) {
         if (child.isDeclaration()) {

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

@@ -82,7 +82,7 @@ export declare class ProjectReflection extends ContainerReflection {
      */
     removeReflection(reflection: Reflection): void;
     /** @internal */
-    mergeModules(source: DeclarationReflection, target: DeclarationReflection | ProjectReflection): void;
+    mergeReflections(source: DeclarationReflection, target: DeclarationReflection | ProjectReflection): void;
     /**
      * Remove a reflection without updating the parent reflection to remove references to the removed reflection.
      */

package/dist/lib/models/ProjectReflection.js

@@ -168,7 +168,7 @@ export class ProjectReflection extends ContainerReflection {
         });
     }
     /** @internal */
-    mergeModules(source, target) {
+    mergeReflections(source, target) {
         // First, tell the children about their new parent
         delete this.referenceGraph;
         const oldChildrenIds = this.reflectionChildren.getNoInsert(source.id) || [];

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

@@ -46,6 +46,16 @@ export declare class ReflectionSymbolId {
      * Note: This can only be non-NaN if {@link pos} is finite.
      */
     transientId: number;
+    /**
+     * Note: This is **not** serialized, only {@link packageName} and {@link packagePath} path
+     * information is preserved when serializing. This is set so that it is available to plugins
+     * when initially converting a project.
+     *
+     * @privateRemarks
+     * This is used by typedoc-plugin-dt-links to determine the path to read to get the source
+     * code of a definitely typed package.
+     */
+    fileName?: NormalizedPath;
     constructor(json: JSONOutput.ReflectionSymbolId);
     getStableKey(): ReflectionSymbolIdString;
     toDeclarationReference(): DeclarationReference;

package/dist/lib/models/ReflectionSymbolId.js

@@ -40,6 +40,16 @@ export class ReflectionSymbolId {
      * Note: This can only be non-NaN if {@link pos} is finite.
      */
     transientId = NaN;
+    /**
+     * Note: This is **not** serialized, only {@link packageName} and {@link packagePath} path
+     * information is preserved when serializing. This is set so that it is available to plugins
+     * when initially converting a project.
+     *
+     * @privateRemarks
+     * This is used by typedoc-plugin-dt-links to determine the path to read to get the source
+     * code of a definitely typed package.
+     */
+    fileName;
     constructor(json) {
         this.packageName = json.packageName;
         this.packagePath = json.packagePath;

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/formatter.d.ts

@@ -70,6 +70,7 @@ export declare class FormattedCodeBuilder {
     reflection(reflection: DeclarationReflection, options: {
         topLevelLinks: boolean;
     }): FormatterNode;
+    typeAlias(item: DeclarationReflection): FormatterNode;
     interface(item: DeclarationReflection): FormatterNode;
     member(members: FormatterNode[], item: DeclarationReflection, options: {
         topLevelLinks: boolean;

package/dist/lib/output/formatter.js

@@ -515,6 +515,9 @@ export class FormattedCodeBuilder {
         }
         return simpleElement(JSX.createElement("span", { class: "tsd-signature-symbol" }, "{}"));
     }
+    typeAlias(item) {
+        return nodes(simpleElement(JSX.createElement("span", { class: "tsd-signature-keyword" }, "type")), space(), simpleElement(JSX.createElement("span", { class: getKindClass(item) }, item.name)), this.typeParameters(item), space(), simpleElement(JSX.createElement("span", { class: "tsd-signature-symbol" }, "=")), space(), this.reflection(item, { topLevelLinks: true }));
+    }
     interface(item) {
         return nodes(simpleElement(JSX.createElement("span", { class: "tsd-signature-keyword" }, "interface")), space(), simpleElement(JSX.createElement("span", { class: getKindClass(item) }, item.name)), this.typeParameters(item), space(), this.reflection(item, { topLevelLinks: true }));
     }

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);
@@ -139,6 +141,10 @@ let JavascriptIndexPlugin = (() => {
                     url: theme.router.getFullUrl(reflection),
                     classes: theme.getReflectionClasses(reflection),
                 };
+                const icon = theme.getReflectionIcon(reflection);
+                if (icon !== reflection.kind) {
+                    row.icon = icon;
+                }
                 if (parent) {
                     row.parent = parent.getFullName();
                 }

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];
@@ -177,10 +177,6 @@ export declare class Renderer extends AbstractComponent<Application, RendererEve
     private accessor githubPages;
     /** @internal */
     accessor cacheBust: boolean;
-    private accessor lightTheme;
-    private accessor darkTheme;
-    private accessor highlightLanguages;
-    private accessor ignoredHighlightLanguages;
     private accessor pretty;
     renderStartTime: number;
     markedPlugin: MarkedPlugin;
@@ -207,7 +203,6 @@ export declare class Renderer extends AbstractComponent<Application, RendererEve
      */
     render(project: ProjectReflection, outputDirectory: string): Promise<void>;
     private runPreRenderJobs;
-    private loadHighlighter;
     /**
      * Render a single page.
      *