typedoc 0.28.0-beta.1 → 0.28.0-beta.2

package/dist/index.d.ts

@@ -41,7 +41,7 @@ export type { Icons, NavigationElement, PageDefinition, PageHeading, RendererEve
 export { Outputs } from "./lib/output/output.js";
 export { ArgumentsReader, CommentStyle, EntryPointStrategy, normalizePath, Option, OptionDefaults, Options, PackageJsonReader, ParameterHint, ParameterType, TSConfigReader, TypeDocReader, ValidatingFileRegistry, } from "./lib/utils/index.js";
 export type { ArrayDeclarationOption, BooleanDeclarationOption, DeclarationOption, DeclarationOptionBase, DeclarationOptionToOptionType, DocumentationEntryPoint, FancyConsoleLogger, FlagsDeclarationOption, JsDocCompatibility, KeyToDeclaration, ManuallyValidatedOption, MapDeclarationOption, MixedDeclarationOption, NumberDeclarationOption, ObjectDeclarationOption, OptionsReader, OutputSpecification, ParameterTypeToOptionTypeMap, SortStrategy, StringDeclarationOption, TypeDocOptionMap, TypeDocOptions, TypeDocOptionValues, ValidationOptions, } from "./lib/utils/index.js";
-export { type ComponentPath, ConsoleLogger, type DeclarationReference, type EnumKeys, EventDispatcher, EventHooks, type GlobString, i18n, JSX, Logger, LogLevel, type Meaning, type MeaningKeyword, type MinimalNode, MinimalSourceFile, type NormalizedPath, type NormalizedPathOrModule, type SymbolReference, 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/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/plugins/JavascriptIndexPlugin.js

@@ -139,6 +139,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

@@ -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.
      *

package/dist/lib/output/renderer.js

@@ -46,7 +46,6 @@ import { IndexEvent, PageEvent, RendererEvent } from "./events.js";
 import { writeFileSync } from "../utils/fs.js";
 import { DefaultTheme } from "./themes/default/DefaultTheme.js";
 import { AbstractComponent, Option } from "../utils/index.js";
-import { loadHighlighter } from "../utils/highlighter.js";
 import { EventHooks, i18n, JSX } from "#utils";
 import { AssetsPlugin, HierarchyPlugin, IconsPlugin, JavascriptIndexPlugin, MarkedPlugin, NavigationPlugin, SitemapPlugin, } from "./plugins/index.js";
 import { CategoryRouter, GroupRouter, KindDirRouter, KindRouter, StructureDirRouter, StructureRouter, } from "./router.js";
@@ -102,18 +101,6 @@ let Renderer = (() => {
     let _cacheBust_decorators;
     let _cacheBust_initializers = [];
     let _cacheBust_extraInitializers = [];
-    let _lightTheme_decorators;
-    let _lightTheme_initializers = [];
-    let _lightTheme_extraInitializers = [];
-    let _darkTheme_decorators;
-    let _darkTheme_initializers = [];
-    let _darkTheme_extraInitializers = [];
-    let _highlightLanguages_decorators;
-    let _highlightLanguages_initializers = [];
-    let _highlightLanguages_extraInitializers = [];
-    let _ignoredHighlightLanguages_decorators;
-    let _ignoredHighlightLanguages_initializers = [];
-    let _ignoredHighlightLanguages_extraInitializers = [];
     let _pretty_decorators;
     let _pretty_initializers = [];
     let _pretty_extraInitializers = [];
@@ -126,10 +113,6 @@ let Renderer = (() => {
             _cname_decorators = [Option("cname")];
             _githubPages_decorators = [Option("githubPages")];
             _cacheBust_decorators = [Option("cacheBust")];
-            _lightTheme_decorators = [Option("lightHighlightTheme")];
-            _darkTheme_decorators = [Option("darkHighlightTheme")];
-            _highlightLanguages_decorators = [Option("highlightLanguages")];
-            _ignoredHighlightLanguages_decorators = [Option("ignoredHighlightLanguages")];
             _pretty_decorators = [Option("pretty")];
             __esDecorate(this, null, _themeName_decorators, { kind: "accessor", name: "themeName", static: false, private: false, access: { has: obj => "themeName" in obj, get: obj => obj.themeName, set: (obj, value) => { obj.themeName = value; } }, metadata: _metadata }, _themeName_initializers, _themeName_extraInitializers);
             __esDecorate(this, null, _routerName_decorators, { kind: "accessor", name: "routerName", static: false, private: false, access: { has: obj => "routerName" in obj, get: obj => obj.routerName, set: (obj, value) => { obj.routerName = value; } }, metadata: _metadata }, _routerName_initializers, _routerName_extraInitializers);
@@ -137,10 +120,6 @@ let Renderer = (() => {
             __esDecorate(this, null, _cname_decorators, { kind: "accessor", name: "cname", static: false, private: false, access: { has: obj => "cname" in obj, get: obj => obj.cname, set: (obj, value) => { obj.cname = value; } }, metadata: _metadata }, _cname_initializers, _cname_extraInitializers);
             __esDecorate(this, null, _githubPages_decorators, { kind: "accessor", name: "githubPages", static: false, private: false, access: { has: obj => "githubPages" in obj, get: obj => obj.githubPages, set: (obj, value) => { obj.githubPages = value; } }, metadata: _metadata }, _githubPages_initializers, _githubPages_extraInitializers);
             __esDecorate(this, null, _cacheBust_decorators, { kind: "accessor", name: "cacheBust", static: false, private: false, access: { has: obj => "cacheBust" in obj, get: obj => obj.cacheBust, set: (obj, value) => { obj.cacheBust = value; } }, metadata: _metadata }, _cacheBust_initializers, _cacheBust_extraInitializers);
-            __esDecorate(this, null, _lightTheme_decorators, { kind: "accessor", name: "lightTheme", static: false, private: false, access: { has: obj => "lightTheme" in obj, get: obj => obj.lightTheme, set: (obj, value) => { obj.lightTheme = value; } }, metadata: _metadata }, _lightTheme_initializers, _lightTheme_extraInitializers);
-            __esDecorate(this, null, _darkTheme_decorators, { kind: "accessor", name: "darkTheme", static: false, private: false, access: { has: obj => "darkTheme" in obj, get: obj => obj.darkTheme, set: (obj, value) => { obj.darkTheme = value; } }, metadata: _metadata }, _darkTheme_initializers, _darkTheme_extraInitializers);
-            __esDecorate(this, null, _highlightLanguages_decorators, { kind: "accessor", name: "highlightLanguages", static: false, private: false, access: { has: obj => "highlightLanguages" in obj, get: obj => obj.highlightLanguages, set: (obj, value) => { obj.highlightLanguages = value; } }, metadata: _metadata }, _highlightLanguages_initializers, _highlightLanguages_extraInitializers);
-            __esDecorate(this, null, _ignoredHighlightLanguages_decorators, { kind: "accessor", name: "ignoredHighlightLanguages", static: false, private: false, access: { has: obj => "ignoredHighlightLanguages" in obj, get: obj => obj.ignoredHighlightLanguages, set: (obj, value) => { obj.ignoredHighlightLanguages = value; } }, metadata: _metadata }, _ignoredHighlightLanguages_initializers, _ignoredHighlightLanguages_extraInitializers);
             __esDecorate(this, null, _pretty_decorators, { kind: "accessor", name: "pretty", static: false, private: false, access: { has: obj => "pretty" in obj, get: obj => obj.pretty, set: (obj, value) => { obj.pretty = value; } }, metadata: _metadata }, _pretty_initializers, _pretty_extraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
@@ -224,19 +203,7 @@ let Renderer = (() => {
         /** @internal */
         get cacheBust() { return this.#cacheBust_accessor_storage; }
         set cacheBust(value) { this.#cacheBust_accessor_storage = value; }
-        #lightTheme_accessor_storage = (__runInitializers(this, _cacheBust_extraInitializers), __runInitializers(this, _lightTheme_initializers, void 0));
-        get lightTheme() { return this.#lightTheme_accessor_storage; }
-        set lightTheme(value) { this.#lightTheme_accessor_storage = value; }
-        #darkTheme_accessor_storage = (__runInitializers(this, _lightTheme_extraInitializers), __runInitializers(this, _darkTheme_initializers, void 0));
-        get darkTheme() { return this.#darkTheme_accessor_storage; }
-        set darkTheme(value) { this.#darkTheme_accessor_storage = value; }
-        #highlightLanguages_accessor_storage = (__runInitializers(this, _darkTheme_extraInitializers), __runInitializers(this, _highlightLanguages_initializers, void 0));
-        get highlightLanguages() { return this.#highlightLanguages_accessor_storage; }
-        set highlightLanguages(value) { this.#highlightLanguages_accessor_storage = value; }
-        #ignoredHighlightLanguages_accessor_storage = (__runInitializers(this, _highlightLanguages_extraInitializers), __runInitializers(this, _ignoredHighlightLanguages_initializers, void 0));
-        get ignoredHighlightLanguages() { return this.#ignoredHighlightLanguages_accessor_storage; }
-        set ignoredHighlightLanguages(value) { this.#ignoredHighlightLanguages_accessor_storage = value; }
-        #pretty_accessor_storage = (__runInitializers(this, _ignoredHighlightLanguages_extraInitializers), __runInitializers(this, _pretty_initializers, void 0));
+        #pretty_accessor_storage = (__runInitializers(this, _cacheBust_extraInitializers), __runInitializers(this, _pretty_initializers, void 0));
         get pretty() { return this.#pretty_accessor_storage; }
         set pretty(value) { this.#pretty_accessor_storage = value; }
         renderStartTime = (__runInitializers(this, _pretty_extraInitializers), -1);
@@ -298,6 +265,7 @@ let Renderer = (() => {
             for (const page of pages) {
                 this.renderDocument(outputDirectory, page);
             }
+            this.postRenderAsyncJobs.push(async (o) => await this.theme.postRender(o));
             await Promise.all(this.postRenderAsyncJobs.map((job) => job(output)));
             this.postRenderAsyncJobs = [];
             this.trigger(RendererEvent.END, output);
@@ -307,16 +275,11 @@ let Renderer = (() => {
         }
         async runPreRenderJobs(output) {
             const start = Date.now();
-            this.preRenderAsyncJobs.push(this.loadHighlighter.bind(this));
+            this.preRenderAsyncJobs.push(async (o) => await this.theme.preRender(o));
             await Promise.all(this.preRenderAsyncJobs.map((job) => job(output)));
             this.preRenderAsyncJobs = [];
             this.application.logger.verbose(`Pre render async jobs took ${Date.now() - start}ms`);
         }
-        async loadHighlighter() {
-            await loadHighlighter(this.lightTheme, this.darkTheme, 
-            // Checked in option validation
-            this.highlightLanguages, this.ignoredHighlightLanguages);
-        }
         /**
          * Render a single page.
          *

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

@@ -1,5 +1,5 @@
 import { RendererComponent } from "./components.js";
-import type { PageEvent } from "./events.js";
+import type { PageEvent, RendererEvent } from "./events.js";
 import type { Reflection } from "../models/index.js";
 /**
  * Base class of all themes.
@@ -12,4 +12,12 @@ 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;
+    /**
+     * Optional hook to call pre-render jobs
+     */
+    preRender(_event: RendererEvent): Promise<void>;
+    /**
+     * Optional hook to call post-render jobs
+     */
+    postRender(_event: RendererEvent): Promise<void>;
 }

package/dist/lib/output/theme.js

@@ -6,4 +6,12 @@ import { RendererComponent } from "./components.js";
  * class instance which is also created by the {@link Renderer} class.
  */
 export class Theme extends RendererComponent {
+    /**
+     * Optional hook to call pre-render jobs
+     */
+    async preRender(_event) { }
+    /**
+     * Optional hook to call post-render jobs
+     */
+    async postRender(_event) { }
 }