typedoc 0.26.0-beta.5 → 0.26.1

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

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultThemeRenderContext = void 0;
 const default_1 = require("./layouts/default");
 const partials_1 = require("./partials");
-const analytics_1 = require("./partials/analytics");
 const breadcrumb_1 = require("./partials/breadcrumb");
 const comment_1 = require("./partials/comment");
 const footer_1 = require("./partials/footer");
@@ -71,7 +70,6 @@ class DefaultThemeRenderContext {
          * by their type declaration, which is already rendered by {@link DefaultThemeRenderContext.memberDeclaration}
          */
         this.reflectionPreview = bind(reflectionPreview_1.reflectionPreview, this);
-        this.analytics = bind(analytics_1.analytics, this);
         this.breadcrumb = bind(breadcrumb_1.breadcrumb, this);
         this.commentSummary = bind(comment_1.commentSummary, this);
         this.commentTags = bind(comment_1.commentTags, this);

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

@@ -45,6 +45,5 @@ const defaultLayout = (context, template, props) => (utils_1.JSX.createElement("
                     context.hook("sidebar.end", context)))),
         context.footer(),
         utils_1.JSX.createElement("div", { class: "overlay" }),
-        context.analytics(),
         context.hook("body.end", context))));
 exports.defaultLayout = defaultLayout;

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

@@ -6,6 +6,7 @@ exports.reflectionFlags = reflectionFlags;
 const utils_1 = require("../../../../utils");
 const models_1 = require("../../../../models");
 const anchor_icon_1 = require("./anchor-icon");
+const lib_1 = require("../../lib");
 // Note: Comment modifiers are handled in `renderFlags`
 function commentSummary({ markdown }, props) {
     if (!props.comment?.summary.some((part) => part.text))
@@ -47,7 +48,5 @@ function reflectionFlags(context, props) {
             }
         }
     }
-    return (utils_1.JSX.createElement(utils_1.JSX.Fragment, null, allFlags.map((item) => (utils_1.JSX.createElement(utils_1.JSX.Fragment, null,
-        utils_1.JSX.createElement("code", { class: "tsd-tag ts-flag" + item }, item),
-        " ")))));
+    return (0, lib_1.join)(" ", allFlags, (item) => utils_1.JSX.createElement("code", { class: "tsd-tag" }, item));
 }

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

@@ -78,7 +78,7 @@ const navigation = function navigation(context, props) {
             context.icons[models_1.ReflectionKind.Project](),
             utils_1.JSX.createElement("span", null, (0, lib_1.getDisplayName)(props.project))),
         utils_1.JSX.createElement("ul", { class: "tsd-small-nested-navigation", id: "tsd-nav-container", "data-base": context.relativeURL("./") },
-            utils_1.JSX.createElement("li", null, "Loading..."))));
+            utils_1.JSX.createElement("li", null, context.i18n.theme_loading()))));
 };
 exports.navigation = navigation;
 function pageSidebar(context, props) {

package/dist/lib/output/themes/default/templates/hierarchy.js

@@ -25,6 +25,6 @@ function fullHierarchy(context, root, seen = new Set()) {
 }
 function hierarchyTemplate(context, props) {
     return (utils_1.JSX.createElement(utils_1.JSX.Fragment, null,
-        utils_1.JSX.createElement("h2", null, "Class Hierarchy"),
+        utils_1.JSX.createElement("h2", null, context.i18n.theme_class_hierarchy_title()),
         (0, lib_1.getHierarchyRoots)(props.project).map((root) => (utils_1.JSX.createElement("ul", { class: "tsd-full-hierarchy" }, fullHierarchy(context, root))))));
 }

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

@@ -1,4 +1,3 @@
-import { Event } from "../utils/events";
 import type { ProjectReflection } from "../models";
 import type { ProjectReflection as JSONProjectReflection } from "./schema";
 /**
@@ -8,11 +7,11 @@ import type { ProjectReflection as JSONProjectReflection } from "./schema";
  * @see {@link Serializer.EVENT_BEGIN}
  * @see {@link Serializer.EVENT_END}
  */
-export declare class SerializeEvent extends Event {
+export declare class SerializeEvent {
     /**
      * The project the renderer is currently processing.
      */
     readonly project: ProjectReflection;
     output: JSONProjectReflection | undefined;
-    constructor(name: string, project: ProjectReflection, output?: JSONProjectReflection);
+    constructor(project: ProjectReflection, output?: JSONProjectReflection);
 }

package/dist/lib/serialization/events.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SerializeEvent = void 0;
-const events_1 = require("../utils/events");
 /**
  * An event emitted by the {@link Serializer} class at the very beginning and
  * ending of the a project serialization process.
@@ -9,9 +8,8 @@ const events_1 = require("../utils/events");
  * @see {@link Serializer.EVENT_BEGIN}
  * @see {@link Serializer.EVENT_END}
  */
-class SerializeEvent extends events_1.Event {
-    constructor(name, project, output) {
-        super(name);
+class SerializeEvent {
+    constructor(project, output) {
         this.project = project;
         this.output = output;
     }

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

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

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

@@ -1,18 +1,23 @@
 import { EventDispatcher } from "../utils";
 import type { ProjectReflection } from "../models";
+import { SerializeEvent } from "./events";
 import type { ModelToObject } from "./schema";
 import type { SerializerComponent } from "./components";
-export declare class Serializer extends EventDispatcher {
+export interface SerializerEvents {
+    begin: [SerializeEvent];
+    end: [SerializeEvent];
+}
+export declare class Serializer extends EventDispatcher<SerializerEvents> {
     /**
      * Triggered when the {@link Serializer} begins transforming a project.
-     * @event EVENT_BEGIN
+     * @event
      */
-    static EVENT_BEGIN: string;
+    static readonly EVENT_BEGIN = "begin";
     /**
      * Triggered when the {@link Serializer} has finished transforming a project.
-     * @event EVENT_END
+     * @event
      */
-    static EVENT_END: string;
+    static readonly EVENT_END = "end";
     private serializers;
     /**
      * Only set when serializing.

package/dist/lib/serialization/serializer.js

@@ -32,22 +32,22 @@ class Serializer extends utils_1.EventDispatcher {
      */
     projectToObject(value, projectRoot) {
         this.projectRoot = projectRoot;
-        const eventBegin = new events_1.SerializeEvent(Serializer.EVENT_BEGIN, value);
-        this.trigger(eventBegin);
+        const eventBegin = new events_1.SerializeEvent(value);
+        this.trigger(Serializer.EVENT_BEGIN, eventBegin);
         const project = this.toObject(value);
-        const eventEnd = new events_1.SerializeEvent(Serializer.EVENT_END, value, project);
-        this.trigger(eventEnd);
+        const eventEnd = new events_1.SerializeEvent(value, project);
+        this.trigger(Serializer.EVENT_END, eventEnd);
         return project;
     }
 }
 exports.Serializer = Serializer;
 /**
  * Triggered when the {@link Serializer} begins transforming a project.
- * @event EVENT_BEGIN
+ * @event
  */
 Serializer.EVENT_BEGIN = "begin";
 /**
  * Triggered when the {@link Serializer} has finished transforming a project.
- * @event EVENT_END
+ * @event
  */
 Serializer.EVENT_END = "end";

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

@@ -1,12 +1,12 @@
 import type { Application } from "../application";
-import { EventDispatcher, Event, type EventMap } from "./events";
+import { EventDispatcher } from "./events";
 /**
  * Exposes a reference to the root Application component.
  */
 export interface ComponentHost {
     readonly application: Application;
 }
-export interface Component extends AbstractComponent<ComponentHost> {
+export interface Component<E extends Record<keyof E, unknown[]> = {}> extends AbstractComponent<ComponentHost, E> {
 }
 export interface ComponentClass<T extends Component, O extends ComponentHost = ComponentHost> extends Function {
     new (owner: O): T;
@@ -24,20 +24,13 @@ export interface ComponentOptions {
  * Class decorator applied to Components
  */
 export declare function Component(options: ComponentOptions): (target: Function, _context: unknown) => void;
-export declare class ComponentEvent extends Event {
-    owner: ComponentHost;
-    component: AbstractComponent<ComponentHost>;
-    static ADDED: string;
-    static REMOVED: string;
-    constructor(name: string, owner: ComponentHost, component: AbstractComponent<ComponentHost>);
-}
 /**
  * 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.
  */
-export declare abstract class AbstractComponent<O extends ComponentHost> extends EventDispatcher implements ComponentHost {
+export declare abstract class AbstractComponent<O extends ComponentHost, E extends Record<keyof E, unknown[]>> extends EventDispatcher<E> implements ComponentHost {
     /**
      * The owner of this component instance.
      */
@@ -54,7 +47,6 @@ export declare abstract class AbstractComponent<O extends ComponentHost> extends
      * Initialize this component.
      */
     protected initialize(): void;
-    protected bubble(name: Event | EventMap | string, ...args: any[]): this;
     /**
      * Return the application / root component instance.
      */
@@ -70,10 +62,7 @@ export declare abstract class AbstractComponent<O extends ComponentHost> extends
  * @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> extends AbstractComponent<O> {
-    /**
-     *
-     */
+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?;
     /**
@@ -87,8 +76,5 @@ export declare abstract class ChildableComponent<O extends ComponentHost, C exte
      */
     getComponent(name: string): C | undefined;
     getComponents(): C[];
-    hasComponent(name: string): boolean;
     addComponent<T extends C>(name: string, componentClass: T | ComponentClass<T, O>): T;
-    removeComponent(name: string): C | undefined;
-    removeAllComponents(): void;
 }

package/dist/lib/utils/component.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChildableComponent = exports.AbstractComponent = exports.ComponentEvent = void 0;
+exports.ChildableComponent = exports.AbstractComponent = void 0;
 exports.Component = Component;
 const events_1 = require("./events");
 const childMappings = [];
@@ -44,16 +44,6 @@ function Component(options) {
         }
     };
 }
-class ComponentEvent extends events_1.Event {
-    constructor(name, owner, component) {
-        super(name);
-        this.owner = owner;
-        this.component = component;
-    }
-}
-exports.ComponentEvent = ComponentEvent;
-ComponentEvent.ADDED = "componentAdded";
-ComponentEvent.REMOVED = "componentRemoved";
 /**
  * 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.
@@ -75,14 +65,6 @@ class AbstractComponent extends events_1.EventDispatcher {
     initialize() {
         // empty default implementation
     }
-    bubble(name, ...args) {
-        super.trigger(name, ...args);
-        if (this.owner instanceof AbstractComponent &&
-            this._componentOwner !== null) {
-            this.owner.bubble(name, ...args);
-        }
-        return this;
-    }
     /**
      * Return the application / root component instance.
      */
@@ -129,9 +111,6 @@ class ChildableComponent extends AbstractComponent {
     getComponents() {
         return Object.values(this._componentChildren || {});
     }
-    hasComponent(name) {
-        return !!(this._componentChildren || {})[name];
-    }
     addComponent(name, componentClass) {
         if (!this._componentChildren) {
             this._componentChildren = {};
@@ -146,26 +125,9 @@ class ChildableComponent extends AbstractComponent {
             const component = typeof componentClass === "function"
                 ? new componentClass(this)
                 : componentClass;
-            const event = new ComponentEvent(ComponentEvent.ADDED, this, component);
-            this.bubble(event);
             this._componentChildren[name] = component;
             return component;
         }
     }
-    removeComponent(name) {
-        const component = (this._componentChildren || {})[name];
-        if (component) {
-            delete this._componentChildren[name];
-            component.stopListening();
-            this.bubble(new ComponentEvent(ComponentEvent.REMOVED, this, component));
-            return component;
-        }
-    }
-    removeAllComponents() {
-        for (const component of Object.values(this._componentChildren || {})) {
-            component.stopListening();
-        }
-        this._componentChildren = {};
-    }
 }
 exports.ChildableComponent = ChildableComponent;

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

@@ -1,123 +1,28 @@
-export interface EventCallback extends Function {
-    _callback?: Function;
-}
-export interface EventMap {
-    [name: string]: EventCallback;
-}
 /**
- * An event object.
- */
-export declare class Event {
-    /**
-     * The name of the event.
-     */
-    private _name;
-    /**
-     * Has {@link Event.stopPropagation} been called?
-     */
-    private _isPropagationStopped;
-    /**
-     * Has {@link Event.preventDefault} been called?
-     */
-    private _isDefaultPrevented;
-    /**
-     * Create a new Event instance.
-     */
-    constructor(name: string);
-    /**
-     * Stop the propagation of this event. Remaining event handlers will not be executed.
-     */
-    stopPropagation(): void;
-    /**
-     * Prevent the default action associated with this event from being executed.
-     */
-    preventDefault(): void;
-    /**
-     * Return the event name.
-     */
-    get name(): string;
-    /**
-     * Has {@link Event.stopPropagation} been called?
-     */
-    get isPropagationStopped(): boolean;
-    /**
-     * Has {@link Event.preventDefault} been called?
-     */
-    isDefaultPrevented(): boolean;
-}
-/**
- * A class that provides a custom event channel.
+ * Intentionally very simple event emitter.
  *
- * You may bind a callback to an event with `on` or remove with `off`;
- * `trigger`-ing an event fires all callbacks in succession.
+ * @privateRemarks
+ * This is essentially a stripped down copy of EventHooks in hooks.ts.
  */
-export declare class EventDispatcher {
-    /**
-     * Map of all handlers registered with the "on" function.
-     */
-    private _events?;
-    /**
-     * Map of all objects this instance is listening to.
-     */
-    private _listeningTo?;
-    /**
-     * Map of all objects that are listening to this instance.
-     */
-    private _listeners?;
-    /**
-     * A unique id that identifies this instance.
-     */
-    private get _listenId();
-    private _savedListenId?;
-    /**
-     * Bind an event to a `callback` function. Passing `"all"` will bind
-     * the callback to all events fired.
-     */
-    on(eventMap: EventMap, context?: any): this;
-    on(eventMap: EventMap, callback?: EventCallback, context?: any, priority?: number): this;
-    on(name: string, callback: EventCallback, context?: any, priority?: number): this;
-    /**
-     * Guard the `listening` argument from the public API.
-     */
-    private internalOn;
-    /**
-     * Bind an event to only be triggered a single time. After the first time
-     * the callback is invoked, its listener will be removed. If multiple events
-     * are passed in using the space-separated syntax, the handler will fire
-     * once for each event, not once for a combination of all events.
-     */
-    once(eventMap: EventMap, context?: any): this;
-    once(name: string, callback: EventCallback, context?: any, priority?: any): this;
-    /**
-     * Remove one or many callbacks. If `context` is null, removes all
-     * callbacks with that function. If `callback` is null, removes all
-     * callbacks for the event. If `name` is null, removes all bound
-     * callbacks for all events.
-     */
-    off(): this;
-    off(eventMap: EventMap | undefined, context?: any): this;
-    off(name: string | undefined, callback?: EventCallback, context?: any): this;
-    /**
-     * Inversion-of-control versions of `on`. Tell *this* object to listen to
-     * an event in another object... keeping track of what it's listening to
-     * for easier unbinding later.
-     */
-    listenTo(obj: EventDispatcher, name: EventMap | string, callback?: EventCallback, priority?: number): this;
+export declare class EventDispatcher<T extends Record<keyof T, unknown[]>> {
+    private _listeners;
     /**
-     * Inversion-of-control versions of `once`.
+     * Starts listening to an event.
+     * @param event the event to listen to.
+     * @param listener function to be called when an this event is emitted.
+     * @param priority optional priority to insert this hook with.
      */
-    listenToOnce(obj: EventDispatcher, eventMap: EventMap): this;
-    listenToOnce(obj: EventDispatcher, name: string, callback: EventCallback, priority?: number): this;
+    on<K extends keyof T>(event: K, listener: (this: undefined, ...args: T[K]) => void, priority?: number): void;
     /**
-     * Tell this object to stop listening to either specific events ... or
-     * to every object it's currently listening to.
+     * Stops listening to an event.
+     * @param event the event to stop listening to.
+     * @param listener the function to remove from the listener array.
      */
-    stopListening(obj?: EventDispatcher, name?: EventMap | string, callback?: EventCallback): this;
+    off<K extends keyof T>(event: K, listener: (this: undefined, ...args: T[K]) => void): void;
     /**
-     * Trigger one or many events, firing all bound callbacks. Callbacks are
-     * passed the same arguments as `trigger` is, apart from the event name
-     * (unless you're listening on `"all"`, which will cause your callback to
-     * receive the true name of the event as the first argument).
+     * Emits an event to all currently subscribed listeners.
+     * @param event the event to emit.
+     * @param args any arguments required for the event.
      */
-    trigger(name: Event | EventMap | string, ...args: any[]): this;
+    trigger<K extends keyof T>(event: K, ...args: T[K]): void;
 }