@limble/limble-tree 1.0.0-alpha.2 → 1.0.0-beta.2

package/lib/core/configuration/configuration.d.ts

@@ -1,5 +1,5 @@
-import { TreeRoot } from "../tree-root/tree-root";
-import { TreeOptions } from "./tree-options.interface";
+import type { TreeRoot } from "../tree-root/tree-root";
+import type { TreeOptions } from "./tree-options.interface";
 declare class Configuration {
     private readonly configStorage;
     constructor();

package/lib/core/configuration/tree-options.interface.d.ts

@@ -1,32 +1,54 @@
-import { TreeBranch } from "../tree-branch/tree-branch";
-import { TreeRoot } from "../tree-root/tree-root";
+import type { TreeBranch } from "../tree-branch/tree-branch";
+import type { TreeRoot } from "../tree-root/tree-root";
+/** The configuration options for a tree, as identified by a TreeRoot */
 export interface TreeOptions {
     dragAndDrop?: {
         /**
-         * A function to indicate whether to allow a node to be dragged. The node in
-         * question is passed in. Defaults to a function that always returns true. This
-         * function runs when DragAndDropService.dragStart runs, and before the branch
-         * is pruned from the tree.
+         * A function that determines whether to allow a node to be dragged.
+         *
+         * @remarks
+         * Runs when a drag begins, but before the branch is pruned from the tree.
+         *
+         * @param treeBranch - The node of the tree that is about to be dragged.
+         *
+         * @defaultValue A function that always returns true.
+         *
+         * @returns `true` if the node can be dragged; `false` if it cannot.
          */
         allowDragging?: <T>(treeBranch: TreeBranch<T>) => boolean;
         /**
-         * A function to determine whether a sourceNode can be dropped at a particular location.
-         * The sourceNode, the new proposedParent for the sourceNode, and the new proposedIndex
-         * for the source node are passed in. This function runs just before displaying a
-         * family of dropzones.
+         * A function to determine whether a sourceNode can be dropped at a
+         * particular location.
+         *
+         * @remarks
+         * This function runs just before displaying a family of dropzones.
+         *
+         * @param sourceBranch - The branch that is being dragged.
+         * @param proposedParent - The proposed new parent of the sourceBranch.
+         * @param proposedIndex - The proposed new index of the sourceBranch.
+         *
+         * @defaultValue A function that always returns true.
          */
-        allowDrop?: <T>(sourceNode: TreeBranch<T>, proposedParent: TreeBranch<T> | TreeRoot<T>, proposedIndex: number) => boolean;
+        allowDrop?: <T>(sourceBranch: TreeBranch<T>, proposedParent: TreeBranch<T> | TreeRoot<T>, proposedIndex: number) => boolean;
         /**
-         * A function to indicate whether to allow "nesting" (placing a branch one level
-         * deeper than its parent). The node in question is passed in. Defaults to a function
-         * that always returns true. This function runs just before displaying a family of
-         * dropzones.
+         * A function to indicate whether to allow "nesting" (placing a branch as
+         * a child) of a particular branch.
+         *
+         * @remarks
+         * This function runs just before displaying a family of dropzones.
+         *
+         * @param treeBranch - The node of the tree whose nesting capability is being
+         * checked.
+         *
+         * @defaultValue A function that always returns true.
          */
         allowNesting?: <T>(treeBranch: TreeBranch<T>) => boolean;
     };
     /**
      * The number of pixels each level of the tree will be indented relative to
-     * its parent. Defaults to 16.
+     * its parent.
+     *
+     * @defaultValue 16
      */
     indentation?: number;
 }

package/lib/core/index.d.ts

@@ -2,4 +2,3 @@ export * from "./tree-service/tree.service";
 export * from "./tree-root/tree-root";
 export * from "./tree-branch/tree-branch";
 export * from "./configuration/tree-options.interface";
-export * from "./configuration/configuration";

package/lib/core/tree-branch/tree-branch.d.ts

@@ -1,13 +1,19 @@
-import { TreePlot } from "../../structure/tree-plot";
-import { Observable } from "rxjs";
-import { TreeEvent } from "../../structure/tree-event.interface";
-import { TreeBranchNode } from "../../structure/tree-branch-node.interface";
-import { ComponentRef, Type, ViewContainerRef, ViewRef } from "@angular/core";
+import type { Observable } from "rxjs";
+import type { ComponentRef, Type, ViewContainerRef, ViewRef } from "@angular/core";
 import { BranchComponent } from "../../components/branch/branch.component";
-import { NodeComponent } from "../../components/node-component.interface";
-import { BranchOptions, FullBranchOptions } from "../branch-options.interface";
+import type { NodeComponent } from "../../components/node-component.interface";
+import type { BranchOptions, FullBranchOptions } from "../branch-options.interface";
 import { TreeRoot } from "..";
-import { TreeNode } from "../../structure";
+import type { TreeNode, TreePlot, TreeEvent, TreeBranchNode } from "../../structure";
+/** Represents a standard node in a tree. Renders a BranchComponent.
+ *
+ * @remarks
+ * This class renders a branch component, which does the following:
+ * 1. Renders a component provided by the user
+ * 2. Provides a container in which child branches may be rendered
+ * 3. Contains two Dropzones: one for dropping branches below this branch (as a
+ * sibling), and one for dropping branches as a first child of this branch.
+ */
 export declare class TreeBranch<UserlandComponent> implements TreeBranchNode<BranchComponent<UserlandComponent>, TreeBranch<UserlandComponent>, NodeComponent> {
     readonly branchOptions: FullBranchOptions<UserlandComponent>;
     private readonly branchController;
@@ -15,30 +21,201 @@ export declare class TreeBranch<UserlandComponent> implements TreeBranchNode<Bra
     private _parent;
     private readonly treeNodeBase;
     constructor(parent: TreeNode<TreeBranch<UserlandComponent>, NodeComponent>, branchOptions: FullBranchOptions<UserlandComponent>);
+    /** @returns All child branches as an array of TreeBranch instances, in order. */
     branches(): Array<TreeBranch<UserlandComponent>>;
+    /**
+     * Recursively destroys all descendant branches, as well as itself. This
+     * releases all resources held or consumed by this branch and its descendants.
+     *
+     * @remarks
+     * It is important to call this method when a branch is discarded, otherwise
+     * the branch will remain in memory and continue to consume resources.
+     */
     destroy(): void;
+    /** Run Angular change detection on this branch */
     detectChanges(): void;
+    /**
+     * Emits the specified TreeEvent.
+     *
+     * @remarks
+     * Caution: It is not recommended to manually emit TreeEvents that are already
+     * provided by the library. For example, it is not recommended to emit a
+     * `GraftEvent`, `DestructionEvent`, etc. These events may be used by the tree,
+     * and emitting them manually may cause unexpected behavior. Instead, we
+     * recommend implementing the TreeEvent interface with your own custom events
+     * and dispatching those.
+     *
+     * @param event - The TreeEvent that will be emitted.
+     */
     dispatch(event: TreeEvent): void;
+    /**
+     * @returns
+     * An observable that emits TreeEvents whenever an event is dispatched
+     * in this branch or any of its descendant branches.
+     */
     events(): Observable<TreeEvent>;
+    /**
+     * @param index - The index of the child branch to retrieve.
+     *
+     * @returns
+     * The child branch at the specified index, or undefined if there is
+     * no child branch at the specified index.
+     */
     getBranch(index: number): TreeBranch<UserlandComponent> | undefined;
+    /** @returns The ViewContainerRef in which child branches are rendered */
     getBranchesContainer(): ViewContainerRef | undefined;
+    /** @returns The instance of BranchComponent that is rendered by this class. */
     getComponentInstance(): BranchComponent<UserlandComponent>;
+    /** @returns The Host View in which the BranchComponent is rendered */
     getHostView(): ViewRef;
+    /** @returns The BranchComponent as a native HTML Element */
     getNativeElement(): HTMLElement;
+    /**
+     * @returns
+     * A ComponentRef containing the instance of the user-provided
+     * component which is rendered by this branch.
+     */
     getUserlandComponentRef(): ComponentRef<UserlandComponent> | undefined;
+    /**
+     * Attaches a branch to a new parent node.
+     *
+     * @remarks
+     * If not already pruned, this method prunes (removes) this branch from its
+     * current position in the tree; then grafts (reattaches) it as a child of the
+     * specified parent branch at the specified index. If no index is specified,
+     * the branch is appended as the last child of the parent. This causes this
+     * branch's associated BranchComponent to be re-rendered in the DOM at the
+     * new location.
+     *
+     * @param newParent - The new parent branch unto which this branch will be grafted.
+     * @param index - The index at which this branch will be grafted. If not specified,
+     * this branch will be appended as the last child of the new parent.
+     *
+     * @returns The index at which this branch was grafted.
+     */
     graftTo(newParent: TreeNode<TreeBranch<UserlandComponent>, NodeComponent>, index?: number): number;
+    /**
+     * Appends a new child branch to this branch. The child branch will render
+     * the specified component according to the (optional) configuration parameter.
+     *
+     * @param component - The component to render in the new child branch.
+     * @param options - Configuration options for the new child branch.
+     *
+     * @returns
+     * The newly-created child branch.
+     */
     grow(component: Type<UserlandComponent>, options?: BranchOptions<UserlandComponent>): TreeBranch<UserlandComponent>;
+    /**
+     * Determines this branch's index in relation to its sibling branches.
+     *
+     * @remarks
+     * For example, if it is the first child of its parent, this method will return
+     * 0. If it is the second child of its parent, this method will return 1.
+     *
+     * If this branch has no parent, (eg, if this branch has been pruned) this
+     * method will return undefined.
+     *
+     * @returns
+     * The index of this branch in relation to its sibling branches, or undefined.
+     */
     index(): number | undefined;
+    /** @returns `true` if the branch is destroyed, `false` otherwise */
     isDestroyed(): boolean;
+    /**
+     * @returns
+     * The data that was passed into the `branchOptions`' `meta` property
+     * at construction.
+     */
     meta(): Record<string, any>;
+    /**
+     * @returns
+     * This branch's parent node (which may be a TreeBranch or TreeRoot).
+     * If this branch has no parent, (eg, if this branch has been pruned) this
+     * method will return undefined.
+     */
     parent(): TreeNode<TreeBranch<UserlandComponent>, NodeComponent> | undefined;
+    /**
+     * Provides a model describing this branch's descendants.
+     *
+     * @returns
+     * A multi-dimensional Map which describes the shape of this branch's
+     * descendants.
+     *
+     * @example
+     * A branch with no children will return an empty Map. A branch with
+     * a single child will return a Map with a single entry, where the key is the index
+     * of the branch (zero) and the value is an empty Map. A Tree like this:
+     *
+     * ```
+     *         ---Branch-------Branch
+     *        /
+     * Branch-------Branch
+     *        \
+     *         ---Branch
+     * ```
+     * Will return a Map of matching shape:
+     * ```
+     * Map {
+     *    0: Map { 0: Map {}},
+     *    1: Map {},
+     *    2: Map {}
+     * }
+     * ```
+     */
     plot(): TreePlot;
+    /**
+     * Calculates the branch's position in the tree relative to the Root.
+     *
+     * @remarks
+     * The position is described as an array of numbers, where each number
+     * represents the index of the branch at that level of the tree.
+     *
+     * For example, if this branch is the first child of the Root, this method
+     * will return [0]. If this branch is the second child of the first child
+     * of the Root, this method will return [0, 1].
+     *
+     * If the branch is not related to a TreeRoot, (such as when it has been
+     * pruned,) this method will throw an error.
+     *
+     * @returns
+     * An array of numbers which describe the branch's position in the tree
+     * relative to the Root.
+     */
     position(): Array<number>;
+    /**
+     * Removes a branch from its tree without destroying it.
+     *
+     * @remarks
+     * Removes this branch from its parent and detaches its associated
+     * BranchComponent from the DOM. This puts the branch in a "pruned" state,
+     * which may affect the behavior of other methods.
+     *
+     * A pruned branch can be reattached to any other node using the `graftTo` method.
+     *
+     * @returns
+     * Itself, or undefined if it is already in a pruned state.
+     */
     prune(): this | undefined;
+    /**
+     * Get the root of the tree to which this Branch is attached.
+     *
+     * @returns
+     * The TreeRoot of the tree this branch is in. If this branch is
+     * does not have a root (such as when it has been pruned) this method will
+     * return undefined.
+     */
     root(): TreeRoot<UserlandComponent> | undefined;
+    /**
+     * Traverses this branch's descendants in depth-first pre-order, executing
+     * the provided callback function on each node. Traversal includes this branch.
+     *
+     * @param callback - A function to execute on each node.
+     */
     traverse(callback: (node: TreeNode<TreeBranch<UserlandComponent>, NodeComponent>) => void): void;
     private checkGraftLocationValidity;
+    private handleUserlandError;
     private indexIsOutOfRange;
+    private furthestAncestor;
     private reattachView;
     private setIndentation;
 }

package/lib/core/tree-node-base.d.ts

@@ -15,6 +15,7 @@ export declare class TreeNodeBase<UserlandComponent> implements Partial<TreeNode
     dispatch(event: TreeEvent): void;
     events(): Observable<TreeEvent>;
     getBranch(index: number): TreeBranch<UserlandComponent> | undefined;
+    handleUserlandError(error: unknown): never;
     isDestroyed(): boolean;
     plot(): TreePlot;
     traverse(callback: (node: TreeNode<TreeBranch<UserlandComponent>, NodeComponent>) => void): void;

package/lib/core/tree-root/tree-root.d.ts

@@ -1,30 +1,124 @@
-import { TreePlot } from "../../structure/tree-plot";
-import { Observable } from "rxjs";
-import { TreeEvent } from "../../structure/tree-event.interface";
+import type { Observable } from "rxjs";
 import { TreeBranch } from "../tree-branch/tree-branch";
-import { Type, ViewContainerRef, ViewRef } from "@angular/core";
+import type { Type, ViewContainerRef, ViewRef } from "@angular/core";
 import { RootComponent } from "../../components/root/root.component";
-import { NodeComponent } from "../../components/node-component.interface";
-import { BranchOptions } from "../branch-options.interface";
-import { TreeNode } from "../../structure";
+import type { NodeComponent } from "../../components/node-component.interface";
+import type { BranchOptions } from "../branch-options.interface";
+import type { TreeNode, TreePlot, TreeEvent } from "../../structure";
+/**
+ * Represents the base of the tree. It renders a very simple container for child
+ * branches. It has methods for creating and accessing those branches. It emits
+ * events when things happen in the tree.
+ */
 export declare class TreeRoot<UserlandComponent> implements TreeNode<TreeBranch<UserlandComponent>, RootComponent> {
     private readonly viewContainerRef;
     private readonly rootController;
     private readonly treeNodeBase;
     constructor(viewContainerRef: ViewContainerRef);
+    /** @returns All child branches as an array of TreeBranch instances */
     branches(): Array<TreeBranch<UserlandComponent>>;
+    /**
+     * Recursively destroys all branches of the tree, as well as itself.
+     *
+     * @remarks
+     * This releases all resources held or consumed by the tree.
+     *
+     * It is important to call this method when a tree is discarded, otherwise
+     * the tree will remain in memory and continue to consume resources.
+     */
     destroy(): void;
+    /** Run Angular change detection on the root of the tree */
     detectChanges(): void;
+    /**
+     * Emits the specified TreeEvent.
+     *
+     * @remarks
+     * Caution: It is not recommended to manually emit TreeEvents that are already
+     * provided by the library. For example, it is not recommended to emit a
+     * `GraftEvent`, `DestructionEvent`, etc. These events may be used by the tree,
+     * and emitting them manually may cause unexpected behavior. Instead, we
+     * recommend implementing the TreeEvent interface with your own custom events
+     * and dispatching those.
+     *
+     * @param event - The TreeEvent that will be emitted.
+     */
     dispatch(event: TreeEvent): void;
+    /**
+     * @returns
+     * An observable that emits TreeEvents whenever an event is dispatched
+     * in the root or any of its descendant branches.
+     */
     events(): Observable<TreeEvent>;
+    /**
+     * @returns
+     * The child branch at the specified index, or undefined if there is
+     * no child branch at the specified index.
+     */
     getBranch(index: number): TreeBranch<UserlandComponent> | undefined;
+    /** @returns The ViewContainerRef in which child branches are rendered */
     getBranchesContainer(): ViewContainerRef | undefined;
+    /**
+     * Retrieves the RootComponent.
+     *
+     * @remarks
+     * The RootComponent holds the BranchesContainer, as well as a single Dropzone
+     * for drag-and-drop operations.
+     *
+     * @returns The instance of RootComponent that is rendered by this class.
+     */
     getComponentInstance(): RootComponent;
+    /** @returns The Host View in which the RootComponent is rendered */
     getHostView(): ViewRef;
+    /** @returns The RootComponent as a native HTML Element */
     getNativeElement(): HTMLElement;
+    /**
+     * Appends a new child branch to this branch. The child branch will render
+     * the specified component according to the (optional) configuration parameter.
+     *
+     * @param component - The component to render in the new child branch.
+     * @param options - Configuration options for the new child branch.
+     *
+     * @returns
+     * The newly-created child branch.
+     */
     grow(component: Type<UserlandComponent>, options?: BranchOptions<UserlandComponent>): TreeBranch<UserlandComponent>;
+    /** @returns `true` if the tree is destroyed, `false` otherwise */
     isDestroyed(): boolean;
+    /**
+     * Provides a model describing the shape of the tree.
+     *
+     * @returns A multi-dimensional Map which describes the shape of the tree.
+     *
+     * @example
+     * For example, an empty tree will return an empty Map. A tree with a single
+     * branch will return a Map with a single entry, where the key is the index
+     * of the branch (zero) and the value is an empty Map. A Tree like this:
+     *
+     * ```
+     *         ---Branch-------Branch
+     *        /
+     * Root-------Branch
+     *        \
+     *         ---Branch
+     * ```
+     * Will return a Map of matching shape:
+     * ```
+     * Map {
+     *    0: Map { 0: Map {}},
+     *    1: Map {},
+     *    2: Map {}
+     * }
+     * ```
+     */
     plot(): TreePlot;
+    /** @returns Itself */
     root(): this;
+    /**
+     * Traverses the tree in depth-first pre-order, executing the provided
+     * callback function on each node. Traversal includes the Root.
+     *
+     * @param callback - A function to execute on each node.
+     */
     traverse(callback: (node: TreeNode<TreeBranch<UserlandComponent>, NodeComponent>) => void): void;
+    private handleUserlandError;
 }

package/lib/core/tree-service/tree.service.d.ts

@@ -1,8 +1,14 @@
-import { ViewContainerRef } from "@angular/core";
-import { TreeOptions } from "../configuration/tree-options.interface";
+import { type ViewContainerRef } from "@angular/core";
+import type { TreeOptions } from "../configuration/tree-options.interface";
 import { TreeRoot } from "../tree-root/tree-root";
 import * as i0 from "@angular/core";
+/** Responsible for the creation of new trees. */
 export declare class TreeService {
+    /**
+     * Creates a new, empty tree structure inside the provided container.
+     *
+     * @returns A `TreeRoot` representing the base of the new tree.
+     */
     createEmptyTree<Component>(container: ViewContainerRef, options?: TreeOptions): TreeRoot<Component>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TreeService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<TreeService>;

package/lib/events/drag/drag-end-event.d.ts

@@ -1,24 +1,27 @@
-import { NodeComponent } from "../../components/node-component.interface";
-import { TreeBranch } from "../../core";
-import { TreeNode } from "../../structure";
-import { EventConduit } from "../../structure/event-conduit.interface";
-import { TreeEvent } from "../../structure/tree-event.interface";
+import type { NodeComponent } from "../../components/node-component.interface";
+import type { TreeBranch } from "../../core";
+import type { TreeNode } from "../../structure";
+import type { TreeEvent } from "../../structure/tree-event.interface";
+/** Emitted when a drag-and-drop operation has completed */
 export declare class DragEndEvent<T> implements TreeEvent {
     private readonly _source;
     private readonly _newParent;
     private readonly _newIndex;
     private readonly _oldParent;
     private readonly _oldIndex;
-    constructor(source: EventConduit, endpoints: {
+    constructor(source: TreeNode<TreeBranch<T>, NodeComponent>, endpoints: {
         oldParent: TreeNode<TreeBranch<T>, NodeComponent>;
         oldIndex: number;
         newParent: TreeNode<TreeBranch<T>, NodeComponent>;
         newIndex: number;
     });
-    type(): "drag end";
-    source(): EventConduit;
+    /** @returns The new index of the dropped branch */
     newIndex(): number;
+    /** @returns The new parent of the dropped branch */
     newParent(): TreeNode<TreeBranch<T>, NodeComponent>;
+    /** @returns The index of the dropped branch before it was dragged */
     oldIndex(): number;
+    /** @returns The parent of the dropped branch before it was dragged */
     oldParent(): TreeNode<TreeBranch<T>, NodeComponent>;
+    source(): TreeNode<TreeBranch<T>, NodeComponent>;
 }

package/lib/events/drag/drag-start-event.d.ts

@@ -1,8 +1,9 @@
-import { EventConduit } from "../../structure/event-conduit.interface";
-import { TreeEvent } from "../../structure/tree-event.interface";
+import type { NodeComponent } from "../../components/node-component.interface";
+import type { TreeNode } from "../../structure";
+import type { TreeEvent } from "../../structure/tree-event.interface";
+/** Emitted when a TreeBranch begins being dragged */
 export declare class DragStartEvent implements TreeEvent {
     private readonly _source;
-    constructor(source: EventConduit);
-    type(): "drag start";
-    source(): EventConduit;
+    constructor(source: TreeNode<unknown, NodeComponent>);
+    source(): TreeNode<unknown, NodeComponent>;
 }

package/lib/events/drag/drop-event.d.ts

@@ -1,13 +1,13 @@
-import { NodeComponent } from "../../components/node-component.interface";
-import { TreeBranch } from "../../core";
-import { TreeNode, EventConduit, TreeEvent } from "../../structure";
+import type { NodeComponent } from "../../components/node-component.interface";
+import type { TreeBranch } from "../../core";
+import type { TreeNode, TreeEvent } from "../../structure";
+/** Emitted when a TreeBranch is dropped into a valid Dropzone */
 export declare class DropEvent<T> implements TreeEvent {
     private readonly _source;
     private readonly _parent;
     private readonly _index;
-    constructor(source: EventConduit, parent: TreeNode<TreeBranch<T>, NodeComponent>, index: number);
-    type(): "drag end";
-    source(): EventConduit;
+    constructor(source: TreeNode<TreeBranch<T>, NodeComponent>, parent: TreeNode<TreeBranch<T>, NodeComponent>, index: number);
+    source(): TreeNode<TreeBranch<T>, NodeComponent>;
     index(): number;
     parent(): TreeNode<TreeBranch<T>, NodeComponent>;
 }

package/lib/events/general/destruction-event.d.ts

@@ -1,8 +1,8 @@
-import { EventConduit } from "../../structure/event-conduit.interface";
-import { TreeEvent } from "../../structure/tree-event.interface";
+import type { NodeComponent } from "../../components/node-component.interface";
+import type { TreeNode, TreeEvent } from "../../structure";
+/** Emitted when a node is destroyed */
 export declare class DestructionEvent implements TreeEvent {
     private readonly _source;
-    constructor(source: EventConduit);
-    type(): "destruction";
-    source(): EventConduit;
+    constructor(source: TreeNode<unknown, NodeComponent>);
+    source(): TreeNode<unknown, NodeComponent>;
 }

package/lib/events/relational/graft-event.d.ts

@@ -1,15 +1,14 @@
-import { EventConduit } from "../../structure/event-conduit.interface";
-import { RelationalTreeEvent } from "./relational-tree-event.interface";
-import { TreeRelationship } from "../../structure/tree-relationship.interface";
+import type { RelationalTreeEvent } from "./relational-tree-event.interface";
+import type { TreeRelationship } from "../../structure/tree-relationship.interface";
+/** Emits when a branch is grafted to another tree node */
 export declare class GraftEvent<T extends TreeRelationship<any, any>> implements RelationalTreeEvent<T["parent"], T["child"]> {
     private readonly _source;
     private readonly _parent;
     private readonly _child;
     private readonly _index;
-    constructor(source: EventConduit, relationship: T);
+    constructor(source: T["child"], relationship: T);
     child(): T["child"];
-    type(): "graft";
     index(): number;
     parent(): T["parent"];
-    source(): EventConduit;
+    source(): T["child"];
 }

package/lib/events/relational/prune-event.d.ts

@@ -1,15 +1,14 @@
-import { EventConduit } from "../../structure/event-conduit.interface";
-import { RelationalTreeEvent } from "./relational-tree-event.interface";
-import { TreeRelationship } from "../../structure/tree-relationship.interface";
+import type { RelationalTreeEvent } from "./relational-tree-event.interface";
+import type { TreeRelationship } from "../../structure/tree-relationship.interface";
+/** Emitted when a branch is pruned from its parent branch */
 export declare class PruneEvent<T extends TreeRelationship<any, any>> implements RelationalTreeEvent<T["parent"], T["child"]> {
     private readonly _source;
     private readonly _parent;
     private readonly _child;
     private readonly _index;
-    constructor(source: EventConduit, relationship: T);
+    constructor(source: T["child"], relationship: T);
     child(): T["child"];
-    type(): "prune";
     index(): number;
     parent(): T["parent"];
-    source(): EventConduit;
+    source(): T["child"];
 }

package/lib/events/relational/relational-tree-event.interface.d.ts

@@ -1,6 +1,10 @@
-import { TreeEvent } from "../../structure/tree-event.interface";
+import type { TreeEvent } from "../../structure/tree-event.interface";
+/** A TreeEvent which involves a parent/child relationship */
 export interface RelationalTreeEvent<Parent, Child> extends TreeEvent {
+    /** @returns The parent branch of the relationship */
     parent: () => Parent;
+    /** @returns The child branch of the relationship */
     child: () => Child;
+    /** @returns The index location of the child */
     index: () => number;
 }

package/lib/extras/collapse/collapse.module.d.ts

@@ -1,4 +1,5 @@
 import * as i0 from "@angular/core";
+/** A module containing the entities which provide collapse functionality */
 export declare class TreeCollapseModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<TreeCollapseModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<TreeCollapseModule, never, never, never>;