typedoc 0.26.11 → 0.27.0-beta.1

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

@@ -1,5 +1,5 @@
-export type { SerializerComponent } from "./components";
-export { Deserializer, type Deserializable, type DeserializerComponent, } from "./deserializer";
-export { SerializeEvent } from "./events";
-export * as JSONOutput from "./schema";
-export { Serializer, type SerializerEvents } from "./serializer";
+export type { SerializerComponent } from "./components.js";
+export { Deserializer, type Deserializable, type DeserializerComponent, } from "./deserializer.js";
+export { SerializeEvent } from "./events.js";
+export * as JSONOutput from "./schema.js";
+export { Serializer, type SerializerEvents } from "./serializer.js";

package/dist/lib/serialization/index.js

@@ -1,33 +1,4 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Serializer = exports.JSONOutput = exports.SerializeEvent = exports.Deserializer = void 0;
-var deserializer_1 = require("./deserializer");
-Object.defineProperty(exports, "Deserializer", { enumerable: true, get: function () { return deserializer_1.Deserializer; } });
-var events_1 = require("./events");
-Object.defineProperty(exports, "SerializeEvent", { enumerable: true, get: function () { return events_1.SerializeEvent; } });
-exports.JSONOutput = __importStar(require("./schema"));
-var serializer_1 = require("./serializer");
-Object.defineProperty(exports, "Serializer", { enumerable: true, get: function () { return serializer_1.Serializer; } });
+export { Deserializer, } from "./deserializer.js";
+export { SerializeEvent } from "./events.js";
+export * as JSONOutput from "./schema.js";
+export { Serializer } from "./serializer.js";

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

@@ -25,10 +25,11 @@
  * ```
  *
  * For documentation on the JSON output properties, view the corresponding model.
+ * @summary Contains interfaces which describe the JSON output.
  * @module
  */
-import type * as M from "../models";
-import type { IfInternal } from "../utils";
+import type * as M from "../models/index.js";
+import type { IfInternal } from "../utils/index.js";
 /**
  * Describes the mapping from Model types to the corresponding JSON output type.
  */
@@ -170,6 +171,7 @@ export interface ReferenceType extends Type, S<M.ReferenceType, "type" | "name"
     qualifiedName?: string;
     refersToTypeParameter?: boolean;
     preferValues?: boolean;
+    highlightedProperties?: Record<string, CommentDisplayPart[]>;
 }
 /** @category Types */
 export interface ReflectionType extends Type, S<M.ReflectionType, "type" | "declaration"> {
@@ -258,6 +260,10 @@ export interface RelativeLinkDisplayPart {
      * File ID, if present
      */
     target?: number;
+    /**
+     * Anchor within the target file, if present
+     */
+    targetAnchor?: string;
 }
 export interface SourceReference extends S<M.SourceReference, "fileName" | "line" | "character" | "url"> {
 }

package/dist/lib/serialization/schema.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Contains interfaces which describe the JSON output. Each interface is related to a specific type of serializer.
  *
@@ -26,6 +25,7 @@
  * ```
  *
  * For documentation on the JSON output properties, view the corresponding model.
+ * @summary Contains interfaces which describe the JSON output.
  * @module
  */
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

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

@@ -1,12 +1,18 @@
-import { EventDispatcher } from "../utils";
-import type { ProjectReflection } from "../models";
-import { SerializeEvent } from "./events";
-import type { ModelToObject } from "./schema";
-import type { SerializerComponent } from "./components";
+import { EventDispatcher } from "../utils/index.js";
+import type { ProjectReflection } from "../models/index.js";
+import { SerializeEvent } from "./events.js";
+import type { ModelToObject } from "./schema.js";
+import type { SerializerComponent } from "./components.js";
 export interface SerializerEvents {
     begin: [SerializeEvent];
     end: [SerializeEvent];
 }
+/**
+ * Serializes TypeDoc's models to JSON
+ *
+ * @group Common
+ * @summary Serializes TypeDoc's models to JSON
+ */
 export declare class Serializer extends EventDispatcher<SerializerEvents> {
     /**
      * Triggered when the {@link Serializer} begins transforming a project.

package/dist/lib/serialization/serializer.js

@@ -1,16 +1,34 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Serializer = void 0;
-const utils_1 = require("../utils");
-const events_1 = require("./events");
-const array_1 = require("../utils/array");
-class Serializer extends utils_1.EventDispatcher {
-    constructor() {
-        super(...arguments);
-        this.serializers = [];
-    }
+import { EventDispatcher } from "../utils/index.js";
+import { SerializeEvent } from "./events.js";
+import { insertPrioritySorted } from "../utils/array.js";
+/**
+ * Serializes TypeDoc's models to JSON
+ *
+ * @group Common
+ * @summary Serializes TypeDoc's models to JSON
+ */
+export class Serializer extends EventDispatcher {
+    /**
+     * Triggered when the {@link Serializer} begins transforming a project.
+     * @event
+     */
+    static EVENT_BEGIN = "begin";
+    /**
+     * Triggered when the {@link Serializer} has finished transforming a project.
+     * @event
+     */
+    static EVENT_END = "end";
+    serializers = [];
+    /**
+     * Only set when serializing.
+     */
+    projectRoot;
+    /**
+     * Only set when serializing
+     */
+    project;
     addSerializer(serializer) {
-        (0, array_1.insertPrioritySorted)(this.serializers, serializer);
+        insertPrioritySorted(this.serializers, serializer);
     }
     toObject(value) {
         if (value === undefined) {
@@ -33,24 +51,13 @@ class Serializer extends utils_1.EventDispatcher {
     projectToObject(value, projectRoot) {
         this.projectRoot = projectRoot;
         this.project = value;
-        const eventBegin = new events_1.SerializeEvent(value);
+        const eventBegin = new SerializeEvent(value);
         this.trigger(Serializer.EVENT_BEGIN, eventBegin);
         const project = this.toObject(value);
-        const eventEnd = new events_1.SerializeEvent(value, project);
+        const eventEnd = new SerializeEvent(value, project);
         this.trigger(Serializer.EVENT_END, eventEnd);
         this.project = undefined;
         this.projectRoot = undefined;
         return project;
     }
 }
-exports.Serializer = Serializer;
-/**
- * Triggered when the {@link Serializer} begins transforming a project.
- * @event
- */
-Serializer.EVENT_BEGIN = "begin";
-/**
- * Triggered when the {@link Serializer} has finished transforming a project.
- * @event
- */
-Serializer.EVENT_END = "end";

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

@@ -51,3 +51,6 @@ export declare function zip<T extends Iterable<any>[]>(...args: T): Iterable<{
 export declare function filterMap<T, U>(iter: Iterable<T> | undefined, fn: (item: T) => U | undefined): U[];
 export declare function firstDefined<T, U>(array: readonly T[] | undefined, callback: (element: T, index: number) => U | undefined): U | undefined;
 export declare function filter<T>(array: readonly T[] | undefined, predicate: (value: T, index: number, array: readonly T[]) => boolean): readonly T[];
+export declare function aggregate<T>(arr: T[], fn: (item: T) => number): number;
+export declare function aggregateWithJoiner<T>(arr: T[], fn: (item: T) => number, joiner: string): number;
+export declare function joinArray<T>(arr: readonly T[] | undefined, joiner: string, mapper: (item: T) => string): string;

package/dist/lib/utils/array.js

@@ -1,25 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.emptyArray = void 0;
-exports.insertPrioritySorted = insertPrioritySorted;
-exports.insertOrderSorted = insertOrderSorted;
-exports.binaryFindPartition = binaryFindPartition;
-exports.removeIfPresent = removeIfPresent;
-exports.removeIf = removeIf;
-exports.unique = unique;
-exports.partition = partition;
-exports.zip = zip;
-exports.filterMap = filterMap;
-exports.firstDefined = firstDefined;
-exports.filter = filter;
-exports.emptyArray = [];
+export const emptyArray = [];
 /**
  * Inserts an item into an array sorted by priority. If two items have the same priority,
  * the item will be inserted later will be placed later in the array.
  * @param arr modified by inserting item.
  * @param item
  */
-function insertPrioritySorted(arr, item) {
+export function insertPrioritySorted(arr, item) {
     const index = binaryFindPartition(arr, (v) => v.priority < item.priority);
     arr.splice(index === -1 ? arr.length : index, 0, item);
     return arr;
@@ -31,7 +17,7 @@ function insertPrioritySorted(arr, item) {
  * @param arr modified by inserting item.
  * @param item
  */
-function insertOrderSorted(arr, item) {
+export function insertOrderSorted(arr, item) {
     const index = binaryFindPartition(arr, (v) => v.order > item.order);
     arr.splice(index === -1 ? arr.length : index, 0, item);
     return arr;
@@ -43,7 +29,7 @@ function insertOrderSorted(arr, item) {
  * @param arr
  * @param partition should return true while less than the partition point.
  */
-function binaryFindPartition(arr, partition) {
+export function binaryFindPartition(arr, partition) {
     if (arr.length === 0) {
         return -1;
     }
@@ -65,7 +51,7 @@ function binaryFindPartition(arr, partition) {
  * @param arr
  * @param item
  */
-function removeIfPresent(arr, item) {
+export function removeIfPresent(arr, item) {
     if (!arr) {
         return;
     }
@@ -79,7 +65,7 @@ function removeIfPresent(arr, item) {
  * @param arr
  * @param predicate
  */
-function removeIf(arr, predicate) {
+export function removeIf(arr, predicate) {
     for (let i = 0; i < arr.length; i++) {
         if (predicate(arr[i])) {
             arr.splice(i, 1);
@@ -91,10 +77,10 @@ function removeIf(arr, predicate) {
  * Filters out duplicate values from the given iterable.
  * @param arr
  */
-function unique(arr) {
+export function unique(arr) {
     return Array.from(new Set(arr));
 }
-function partition(iter, predicate) {
+export function partition(iter, predicate) {
     const left = [];
     const right = [];
     for (const item of iter) {
@@ -107,7 +93,7 @@ function partition(iter, predicate) {
     }
     return [left, right];
 }
-function* zip(...args) {
+export function* zip(...args) {
     const iterators = args.map((x) => x[Symbol.iterator]());
     for (;;) {
         const next = iterators.map((i) => i.next());
@@ -117,7 +103,7 @@ function* zip(...args) {
         yield next.map((v) => v.value);
     }
 }
-function filterMap(iter, fn) {
+export function filterMap(iter, fn) {
     const result = [];
     for (const item of iter || []) {
         const newItem = fn(item);
@@ -127,7 +113,7 @@ function filterMap(iter, fn) {
     }
     return result;
 }
-function firstDefined(array, callback) {
+export function firstDefined(array, callback) {
     if (array === undefined) {
         return undefined;
     }
@@ -139,6 +125,19 @@ function firstDefined(array, callback) {
     }
     return undefined;
 }
-function filter(array, predicate) {
-    return array ? array.filter(predicate) : exports.emptyArray;
+export function filter(array, predicate) {
+    return array ? array.filter(predicate) : emptyArray;
+}
+export function aggregate(arr, fn) {
+    return arr.reduce((sum, it) => sum + fn(it), 0);
+}
+export function aggregateWithJoiner(arr, fn, joiner) {
+    return (arr.reduce((sum, it) => sum + fn(it), 0) +
+        (arr.length - 1) * joiner.length);
+}
+export function joinArray(arr, joiner, mapper) {
+    if (arr?.length) {
+        return arr.map(mapper).join(joiner);
+    }
+    return "";
 }

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

@@ -1,5 +1,5 @@
-import type { Application } from "../application";
-import { EventDispatcher } from "./events";
+import type { Application } from "../application.js";
+import { EventDispatcher } from "./events.js";
 /**
  * Exposes a reference to the root Application component.
  */
@@ -8,22 +8,6 @@ export interface ComponentHost {
 }
 export interface Component<E extends Record<keyof E, unknown[]> = {}> extends AbstractComponent<ComponentHost, E> {
 }
-export interface ComponentClass<T extends Component, O extends ComponentHost = ComponentHost> {
-    new (owner: O): T;
-}
-/**
- * Option-bag passed to Component decorator.
- */
-export interface ComponentOptions {
-    name?: string;
-    /** Specify valid child component class.  Used to prove that children are valid via `instanceof` checks */
-    childClass?: Function;
-    internal?: boolean;
-}
-/**
- * Class decorator applied to Components
- */
-export declare function Component(options: ComponentOptions): (target: Function, _context: unknown) => void;
 /**
  * Component base class.  Has an owner (unless it's the application root component),
  * can dispatch events to its children, and has access to the root Application component.
@@ -43,10 +27,6 @@ export declare abstract class AbstractComponent<O extends ComponentHost, E exten
      * Create new Component instance.
      */
     constructor(owner: O);
-    /**
-     * Initialize this component.
-     */
-    protected initialize(): void;
     /**
      * Return the application / root component instance.
      */
@@ -56,25 +36,3 @@ export declare abstract class AbstractComponent<O extends ComponentHost, E exten
      */
     get owner(): O;
 }
-/**
- * Component that can have child components.
- *
- * @template O type of Component's owner
- * @template C type of Component's children
- */
-export declare abstract class ChildableComponent<O extends ComponentHost, C extends Component, E extends Record<keyof E, unknown[]>> extends AbstractComponent<O, E> {
-    private _componentChildren?;
-    private _defaultComponents?;
-    /**
-     * Create new Component instance.
-     */
-    constructor(owner: O);
-    /**
-     * Retrieve a plugin instance.
-     *
-     * @returns  The instance of the plugin or undefined if no plugin with the given class is attached.
-     */
-    getComponent(name: string): C | undefined;
-    getComponents(): C[];
-    addComponent<T extends C>(name: string, componentClass: T | ComponentClass<T, O>): T;
-}

package/dist/lib/utils/component.js

@@ -1,69 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChildableComponent = exports.AbstractComponent = void 0;
-exports.Component = Component;
-const events_1 = require("./events");
-const childMappings = [];
-/**
- * Class decorator applied to Components
- */
-function Component(options) {
-    // _context is ClassDecoratorContext, but that then requires a public constructor
-    // which Application does not have.
-    return (target, _context) => {
-        const proto = target.prototype;
-        if (!(proto instanceof AbstractComponent)) {
-            throw new Error("The `Component` decorator can only be used with a subclass of `AbstractComponent`.");
-        }
-        if (options.childClass) {
-            if (!(proto instanceof ChildableComponent)) {
-                throw new Error("The `Component` decorator accepts the parameter `childClass` only when used with a subclass of `ChildableComponent`.");
-            }
-            childMappings.push({
-                host: proto,
-                child: options.childClass,
-            });
-        }
-        const name = options.name;
-        if (name) {
-            proto.componentName = name;
-        }
-        // If not marked internal, and if we are a subclass of another component T's declared
-        // childClass, then register ourselves as a _defaultComponents of T.
-        const internal = !!options.internal;
-        if (name && !internal) {
-            for (const childMapping of childMappings) {
-                if (!(proto instanceof childMapping.child)) {
-                    continue;
-                }
-                const host = childMapping.host;
-                host["_defaultComponents"] = host["_defaultComponents"] || {};
-                host["_defaultComponents"][name] = target;
-                break;
-            }
-        }
-    };
-}
+import { EventDispatcher } from "./events.js";
 /**
  * Component base class.  Has an owner (unless it's the application root component),
  * can dispatch events to its children, and has access to the root Application component.
  *
  * @template O type of component's owner.
  */
-class AbstractComponent extends events_1.EventDispatcher {
+export class AbstractComponent extends EventDispatcher {
+    /**
+     * The owner of this component instance.
+     */
+    _componentOwner;
+    /**
+     * The name of this component as set by the `@Component` decorator.
+     */
+    componentName;
     /**
      * Create new Component instance.
      */
     constructor(owner) {
         super();
         this._componentOwner = owner;
-        this.initialize();
-    }
-    /**
-     * Initialize this component.
-     */
-    initialize() {
-        // empty default implementation
     }
     /**
      * Return the application / root component instance.
@@ -83,51 +39,3 @@ class AbstractComponent extends events_1.EventDispatcher {
             : this._componentOwner;
     }
 }
-exports.AbstractComponent = AbstractComponent;
-/**
- * Component that can have child components.
- *
- * @template O type of Component's owner
- * @template C type of Component's children
- */
-class ChildableComponent extends AbstractComponent {
-    /**
-     * Create new Component instance.
-     */
-    constructor(owner) {
-        super(owner);
-        Object.entries(this._defaultComponents || {}).forEach(([name, component]) => {
-            this.addComponent(name, component);
-        });
-    }
-    /**
-     * Retrieve a plugin instance.
-     *
-     * @returns  The instance of the plugin or undefined if no plugin with the given class is attached.
-     */
-    getComponent(name) {
-        return (this._componentChildren || {})[name];
-    }
-    getComponents() {
-        return Object.values(this._componentChildren || {});
-    }
-    addComponent(name, componentClass) {
-        if (!this._componentChildren) {
-            this._componentChildren = {};
-        }
-        if (this._componentChildren[name]) {
-            // Component already added so we will return the existing component
-            // TODO: add better logging around this because it could be unexpected but shouldn't be fatal
-            // See https://github.com/TypeStrong/typedoc/issues/846
-            return this._componentChildren[name];
-        }
-        else {
-            const component = typeof componentClass === "function"
-                ? new componentClass(this)
-                : componentClass;
-            this._componentChildren[name] = component;
-            return component;
-        }
-    }
-}
-exports.ChildableComponent = ChildableComponent;

package/dist/lib/utils/entry-point.d.ts

@@ -1,6 +1,6 @@
 import ts from "typescript";
-import type { Logger } from "./loggers";
-import type { Options } from "./options";
+import type { Logger } from "./loggers.js";
+import type { Options } from "./options/index.js";
 /**
  * Defines how entry points are interpreted.
  * @enum
@@ -29,15 +29,14 @@ export declare const EntryPointStrategy: {
 export type EntryPointStrategy = (typeof EntryPointStrategy)[keyof typeof EntryPointStrategy];
 export interface DocumentationEntryPoint {
     displayName: string;
-    readmeFile?: string;
     program: ts.Program;
     sourceFile: ts.SourceFile;
-    version?: string;
 }
 export interface DocumentEntryPoint {
     displayName: string;
     path: string;
 }
+export declare function inferEntryPoints(logger: Logger, options: Options): Promise<DocumentationEntryPoint[]>;
 export declare function getEntryPoints(logger: Logger, options: Options): DocumentationEntryPoint[] | undefined;
 /**
  * Document entry points are markdown documents that the user has requested we include in the project with