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

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,16 +1,13 @@
-import { ComponentRef } from "@angular/core";
-import { NodeComponent } from "../../components/node-component.interface";
-import { TreeBranch } from "../../core";
-import { ContainerTreeNode } from "../../structure/container-tree-node.interface";
-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, 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: ContainerTreeNode<ComponentRef<NodeComponent>, TreeBranch<T>>, 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(): ContainerTreeNode<ComponentRef<NodeComponent>, TreeBranch<T>>;
+    parent(): TreeNode<TreeBranch<T>, NodeComponent>;
 }

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

@@ -0,0 +1,8 @@
+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: TreeNode<unknown, NodeComponent>);
+    source(): TreeNode<unknown, NodeComponent>;
+}

package/lib/events/general/index.d.ts

@@ -0,0 +1 @@
+export * from "./destruction-event";

package/lib/events/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./relational";
 export * from "./drag";
+export * from "./general";

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>;

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

@@ -1,8 +1,33 @@
 import { TreeBranch } from "../../core";
 import * as i0 from "@angular/core";
+/** A service that collapses and expands tree branches */
 export declare class TreeCollapseService {
+    /**
+     * Causes a TreeBranch to collapse, temporarily pruning all of its children
+     * from the tree.
+     *
+     * @param treeBranch - The branch to collapse.
+     */
     collapse<T>(treeBranch: TreeBranch<T>): void;
+    /**
+     * Causes a TreeBranch to expand, restoring all of its children which were
+     * previously pruned by a call to `collapse()`.
+     *
+     * @param treeBranch - The branch to expand.
+     */
     expand<T>(treeBranch: TreeBranch<T>): void;
+    /**
+     * Determines whether a TreeBranch currently has any children which are
+     * pruned from the tree due to a call to  the `collapse()` method.
+     *
+     * @remarks
+     * Child branches which are pruned manually from the tree, rather than
+     * through the `collapse()` method, will not be considered.
+     *
+     * @param treeBranch - The branch to check.
+     *
+     * @returns `true` if the branch is currently collapsed; `false` if it is not.
+     */
     isCollapsed<T>(treeBranch: TreeBranch<T>): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<TreeCollapseService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<TreeCollapseService>;

package/lib/extras/drag-and-drop/drag-and-drop.d.ts

@@ -1,12 +1,11 @@
-import { ComponentRef } from "@angular/core";
 import { Subject } from "rxjs";
 import { NodeComponent } from "../../components/node-component.interface";
 import { TreeBranch } from "../../core";
-import { ContainerTreeNode } from "../../structure/container-tree-node.interface";
+import { TreeNode } from "../../structure";
 declare class DragAndDrop {
     readonly dragAborted$: Subject<DragEvent>;
     dragStart<T>(treeBranch: TreeBranch<T>, event: DragEvent): void;
-    drop<T>(parent: ContainerTreeNode<ComponentRef<NodeComponent>, TreeBranch<T>>, index: number): void;
+    drop<T>(parent: TreeNode<TreeBranch<T>, NodeComponent>, index: number): void;
     private getDragImageOffsets;
     private setDragEffects;
     private watchForDragend;

package/lib/extras/drag-and-drop/drag-and-drop.module.d.ts

@@ -1,6 +1,10 @@
 import * as i0 from "@angular/core";
 import * as i1 from "./draggable.directive";
 import * as i2 from "./dragover-no-change-detect";
+/**
+ * An Angular module containing all of the entities which provide Drag-And-Drop
+ * functionality.
+ */
 export declare class TreeDragAndDropModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<TreeDragAndDropModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<TreeDragAndDropModule, never, [typeof i1.DraggableDirective, typeof i2.DragoverNoChangeDetectDirective], [typeof i1.DraggableDirective, typeof i2.DragoverNoChangeDetectDirective]>;

package/lib/extras/drag-and-drop/drag-and-drop.service.d.ts

@@ -1,15 +1,34 @@
-import { Observable } from "rxjs";
-import { TreeBranch, TreeRoot } from "../../core";
+import type { Observable } from "rxjs";
+import type { TreeBranch, TreeRoot } from "../../core";
 import { DragStates } from "./drag-state";
 import * as i0 from "@angular/core";
 export declare class TreeDragAndDropService {
+    /** Hides all Dropzones */
     clearDropzones(): void;
-    dragStart<T>(treeBranch: TreeBranch<T>, event: DragEvent): void;
+    /**
+     * @returns An object that indicates which dropzones are currently being displayed.
+     * If no dropzones are being displayed, then null is returned.
+     */
     getCurrentlyDisplayedDropzoneFamily(): {
         treeBranch: TreeRoot<any> | TreeBranch<any>;
         direction: "upper" | "lower";
     } | null;
+    /**
+     * Causes the dropzone of the TreeRoot to be displayed.
+     *
+     * @remarks
+     * This is a useful function when you want to show the dropzone of a TreeRoot
+     * that has no child branches.
+     *
+     * @param root - The TreeRoot whose dropzone you want to show.
+     */
     showRootDropzone<T>(root: TreeRoot<T>): void;
+    /**
+     * @returns An observable that emits a number whenever the drag state changes.
+     *
+     * @remarks
+     * See the `DragStates` enum for a list of possible states.
+     */
     state(): Observable<DragStates>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TreeDragAndDropService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<TreeDragAndDropService>;

package/lib/extras/drag-and-drop/draggable.directive.d.ts

@@ -1,11 +1,10 @@
 import { ElementRef, Renderer2 } from "@angular/core";
-import { TreeBranch } from "../../core";
-import { TreeDragAndDropService } from "./drag-and-drop.service";
+import type { TreeBranch } from "../../core";
 import * as i0 from "@angular/core";
+/** Makes an TreeBranch draggable when the host element is dragged */
 export declare class DraggableDirective {
-    private readonly dragAndDropService;
-    limbleTreeDraggable?: TreeBranch<any>;
-    constructor(dragAndDropService: TreeDragAndDropService, renderer: Renderer2, hostElement: ElementRef<HTMLElement>);
+    limbleTreeDraggable?: TreeBranch<any> | undefined;
+    constructor(renderer: Renderer2, hostElement: ElementRef<HTMLElement>);
     onDragstart(event: DragEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DraggableDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DraggableDirective, "[limbleTreeDraggable]", never, { "limbleTreeDraggable": "limbleTreeDraggable"; }, {}, never, never, true>;

package/lib/extras/drag-and-drop/dragover-no-change-detect.d.ts

@@ -1,14 +1,18 @@
-import { ElementRef, EventEmitter, NgZone, OnDestroy, OnInit } from "@angular/core";
+import { ElementRef, EventEmitter, NgZone, type OnDestroy, type OnInit } from "@angular/core";
 import * as i0 from "@angular/core";
+/**
+ * Works just like Angular's built-in `(dragover)` event binding, but is much
+ * more performant. It throttles the event to a configurable rate (default once
+ * every 25ms) and runs outside of Angular's change detection.
+ */
 export declare class DragoverNoChangeDetectDirective implements OnInit, OnDestroy {
     private readonly ngZone;
     private readonly el;
-    dragoverEventThrottle: number;
     readonly dragoverNoChangeDetect: EventEmitter<DragEvent>;
     private eventSubscription;
     constructor(ngZone: NgZone, el: ElementRef<Element>);
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DragoverNoChangeDetectDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DragoverNoChangeDetectDirective, "[dragoverNoChangeDetect]", never, { "dragoverEventThrottle": "dragoverEventThrottle"; }, { "dragoverNoChangeDetect": "dragoverNoChangeDetect"; }, never, never, true>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragoverNoChangeDetectDirective, "[dragoverNoChangeDetect]", never, {}, { "dragoverNoChangeDetect": "dragoverNoChangeDetect"; }, never, never, true>;
 }

package/lib/legacy/legacy-component-obj.interface.d.ts

@@ -1,4 +1,4 @@
-import { Type } from "@angular/core";
+import type { Type } from "@angular/core";
 /**
  * An object that references the component to be rendered and its bindings
  * @deprecated

package/lib/legacy/legacy-tree-data.interface.d.ts

@@ -1,4 +1,4 @@
-import { ComponentObj } from "./legacy-component-obj.interface";
+import type { ComponentObj } from "./legacy-component-obj.interface";
 /**
  * An object describing a node of the tree
  * @deprecated

package/lib/legacy/legacy-tree-options.interface.d.ts

@@ -1,5 +1,5 @@
-import { TreeBranch, TreeRoot } from "../core";
-import { ComponentObj } from "./legacy-component-obj.interface";
+import type { TreeBranch, TreeRoot } from "../core";
+import type { ComponentObj } from "./legacy-component-obj.interface";
 /**
  * A group of settings for changing the functionality of the tree
  * @deprecated

package/lib/legacy/legacy-tree.d.ts

@@ -1,7 +1,7 @@
-import { ViewContainerRef } from "@angular/core";
-import { TreeRoot, TreeOptions } from "../core";
-import { LimbleTreeOptions as LegacyLimbleTreeOptions } from "./legacy-tree-options.interface";
-import { LimbleTreeData } from "./legacy-tree-data.interface";
+import type { ViewContainerRef } from "@angular/core";
+import { TreeRoot, type TreeOptions } from "../core";
+import type { LimbleTreeOptions as LegacyLimbleTreeOptions } from "./legacy-tree-options.interface";
+import type { LimbleTreeData } from "./legacy-tree-data.interface";
 /**
  * A shim to help with the transition from v0 to v1.
  * @deprecated

package/lib/legacy/limble-tree-root/limble-tree-root.component.d.ts

@@ -1,7 +1,7 @@
-import { AfterViewInit, EventEmitter, OnChanges, OnDestroy, ViewContainerRef } from "@angular/core";
-import { LimbleTreeData } from "../legacy-tree-data.interface";
-import { LimbleTreeOptions } from "../legacy-tree-options.interface";
-import { TreeRoot } from "../../core";
+import { type AfterViewInit, EventEmitter, type OnChanges, type OnDestroy, ViewContainerRef } from "@angular/core";
+import type { LimbleTreeData } from "../legacy-tree-data.interface";
+import type { LimbleTreeOptions } from "../legacy-tree-options.interface";
+import type { TreeRoot } from "../../core";
 import { DragEndEvent } from "../../events";
 import * as i0 from "@angular/core";
 /** @deprecated */

package/lib/limble-tree.module.d.ts

@@ -2,6 +2,10 @@ import * as i0 from "@angular/core";
 import * as i1 from "./legacy/limble-tree-legacy.module";
 import * as i2 from "./extras/collapse/collapse.module";
 import * as i3 from "./extras/drag-and-drop/drag-and-drop.module";
+/**
+ * Import this Angular module into your application to gain access to the
+ * components, directives, and services provided by Limble Tree.
+ */
 export declare class LimbleTreeModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LimbleTreeModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LimbleTreeModule, never, [typeof i1.LimbleTreeLegacyModule, typeof i2.TreeCollapseModule, typeof i3.TreeDragAndDropModule], [typeof i1.LimbleTreeLegacyModule, typeof i2.TreeCollapseModule, typeof i3.TreeDragAndDropModule]>;

package/lib/structure/branchable.interface.d.ts

@@ -1,5 +1,4 @@
 export interface Branchable<Child> {
     branches: () => Array<Child>;
-    deleteBranch: (index?: number) => void;
     getBranch: (index: number) => Child | undefined;
 }

package/lib/structure/component-container.interface.d.ts

@@ -0,0 +1,8 @@
+import type { ViewContainerRef, ViewRef } from "@angular/core";
+export interface ComponentContainer<Component> {
+    detectChanges: () => void;
+    getBranchesContainer: () => ViewContainerRef | undefined;
+    getComponentInstance: () => Component;
+    getHostView: () => ViewRef;
+    getNativeElement: () => HTMLElement;
+}

package/lib/structure/index.d.ts

@@ -1,11 +1,8 @@
 export * from "./branchable.interface";
-export * from "./container-tree-node.interface";
-export * from "./content-container.interface";
-export * from "./event-conduit.interface";
+export * from "./component-container.interface";
 export * from "./graftable.interface";
 export * from "./tree-branch-node.interface";
 export * from "./tree-event.interface";
 export * from "./tree-node.interface";
 export * from "./tree-plot";
 export * from "./tree-relationship.interface";
-export * from "./tree-root.node.interface";

package/lib/structure/tree-branch-node.interface.d.ts

@@ -1,5 +1,5 @@
-import { Graftable } from "./graftable.interface";
-import { ContainerTreeNode } from "./container-tree-node.interface";
-export declare type TreeBranchNode<Contents, Children, ParentContents> = ContainerTreeNode<Contents, Children> & Graftable<ContainerTreeNode<ParentContents, Children>> & {
+import type { Graftable } from "./graftable.interface";
+import type { TreeNode } from "./tree-node.interface";
+export declare type TreeBranchNode<Contents, Children, ParentContents> = TreeNode<Children, Contents> & Graftable<TreeNode<Children, ParentContents>> & {
     position: () => Array<number>;
 };

package/lib/structure/tree-event.interface.d.ts

@@ -1,5 +1,5 @@
-import { EventConduit } from "./event-conduit.interface";
+import type { TreeNode } from "./tree-node.interface";
+/** An event emitted by a node in the tree */
 export interface TreeEvent {
-    type: () => string;
-    source: () => EventConduit;
+    source: () => TreeNode<unknown, unknown>;
 }

package/lib/structure/tree-node.interface.d.ts

@@ -1,9 +1,14 @@
-import { Branchable } from "./branchable.interface";
-import { EventConduit } from "./event-conduit.interface";
-import { TreePlot } from "./tree-plot";
-import { TreeRoot } from "../core";
-export interface TreeNode<Children> extends EventConduit, Branchable<Children> {
+import type { Branchable } from "./branchable.interface";
+import type { TreePlot } from "./tree-plot";
+import type { TreeRoot } from "../core";
+import type { ComponentContainer } from "./component-container.interface";
+import type { Observable } from "rxjs";
+import type { TreeEvent } from "./tree-event.interface";
+export interface TreeNode<Children, Component> extends Branchable<Children>, ComponentContainer<Component> {
+    dispatch: (event: TreeEvent) => void;
+    events: () => Observable<TreeEvent>;
+    isDestroyed: () => boolean;
     plot: () => TreePlot;
-    traverse: (callback: (node: Branchable<Children>) => void) => void;
     root: () => TreeRoot<any> | undefined;
+    traverse: (callback: (node: Branchable<Children>) => void) => void;
 }

package/lib/structure/tree-relationship.interface.d.ts

@@ -1,5 +1,5 @@
-import { Branchable } from "./branchable.interface";
-import { Graftable } from "./graftable.interface";
+import type { Branchable } from "./branchable.interface";
+import type { Graftable } from "./graftable.interface";
 export interface TreeRelationship<Parent extends Branchable<Child>, Child extends Graftable<Parent>> {
     parent: Parent;
     child: Child;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@limble/limble-tree",
-  "version": "1.0.0-alpha.1",
+  "version": "1.0.0-beta.1",
   "peerDependencies": {
     "@angular/common": "^14.2.0",
     "@angular/core": "^14.2.0",

package/esm2020/lib/structure/container-tree-node.interface.mjs

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGFpbmVyLXRyZWUtbm9kZS5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saW1ibGUtdHJlZS9zcmMvbGliL3N0cnVjdHVyZS9jb250YWluZXItdHJlZS1ub2RlLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29udGVudENvbnRhaW5lciB9IGZyb20gXCIuL2NvbnRlbnQtY29udGFpbmVyLmludGVyZmFjZVwiO1xuaW1wb3J0IHsgVHJlZU5vZGUgfSBmcm9tIFwiLi90cmVlLW5vZGUuaW50ZXJmYWNlXCI7XG5cbmV4cG9ydCB0eXBlIENvbnRhaW5lclRyZWVOb2RlPENvbnRlbnRzLCBDaGlsZHJlbj4gPSBUcmVlTm9kZTxDaGlsZHJlbj4gJlxuICAgQ29udGVudENvbnRhaW5lcjxDb250ZW50cz47XG4iXX0=

package/esm2020/lib/structure/content-container.interface.mjs

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGVudC1jb250YWluZXIuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbGltYmxlLXRyZWUvc3JjL2xpYi9zdHJ1Y3R1cmUvY29udGVudC1jb250YWluZXIuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIENvbnRlbnRDb250YWluZXI8Q29udGVudHM+IHtcbiAgIGdldENvbnRlbnRzOiAoKSA9PiBDb250ZW50cztcbn1cbiJdfQ==

package/esm2020/lib/structure/event-conduit.interface.mjs

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnQtY29uZHVpdC5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saW1ibGUtdHJlZS9zcmMvbGliL3N0cnVjdHVyZS9ldmVudC1jb25kdWl0LmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gXCJyeGpzXCI7XG5pbXBvcnQgeyBUcmVlRXZlbnQgfSBmcm9tIFwiLi90cmVlLWV2ZW50LmludGVyZmFjZVwiO1xuXG5leHBvcnQgaW50ZXJmYWNlIEV2ZW50Q29uZHVpdCB7XG4gICBkaXNwYXRjaDogKGV2ZW50OiBUcmVlRXZlbnQpID0+IHZvaWQ7XG4gICBldmVudHM6ICgpID0+IE9ic2VydmFibGU8VHJlZUV2ZW50Pjtcbn1cbiJdfQ==

package/esm2020/lib/structure/tree-root.node.interface.mjs

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZS1yb290Lm5vZGUuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbGltYmxlLXRyZWUvc3JjL2xpYi9zdHJ1Y3R1cmUvdHJlZS1yb290Lm5vZGUuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb250YWluZXJUcmVlTm9kZSB9IGZyb20gXCIuL2NvbnRhaW5lci10cmVlLW5vZGUuaW50ZXJmYWNlXCI7XG5cbmV4cG9ydCB0eXBlIFRyZWVSb290Tm9kZTxDb250ZW50cywgQ2hpbGRyZW4+ID0gQ29udGFpbmVyVHJlZU5vZGU8XG4gICBDb250ZW50cyxcbiAgIENoaWxkcmVuXG4+O1xuIl19

package/lib/structure/container-tree-node.interface.d.ts

@@ -1,3 +0,0 @@
-import { ContentContainer } from "./content-container.interface";
-import { TreeNode } from "./tree-node.interface";
-export declare type ContainerTreeNode<Contents, Children> = TreeNode<Children> & ContentContainer<Contents>;

package/lib/structure/content-container.interface.d.ts

@@ -1,3 +0,0 @@
-export interface ContentContainer<Contents> {
-    getContents: () => Contents;
-}

package/lib/structure/event-conduit.interface.d.ts

@@ -1,6 +0,0 @@
-import { Observable } from "rxjs";
-import { TreeEvent } from "./tree-event.interface";
-export interface EventConduit {
-    dispatch: (event: TreeEvent) => void;
-    events: () => Observable<TreeEvent>;
-}

package/lib/structure/tree-root.node.interface.d.ts

@@ -1,2 +0,0 @@
-import { ContainerTreeNode } from "./container-tree-node.interface";
-export declare type TreeRootNode<Contents, Children> = ContainerTreeNode<Contents, Children>;