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

package/esm2020/lib/core/tree-branch/tree-branch.mjs

@@ -0,0 +1,224 @@
+import { assert } from "../../../shared/assert";
+import { GraftEvent } from "../../events/relational/graft-event";
+import { PruneEvent } from "../../events/relational/prune-event";
+import { TreeNodeBase } from "../tree-node-base";
+import { TreeError } from "../../errors/tree-error";
+import { dropzoneRenderer } from "../../extras/drag-and-drop/dropzone-renderer";
+import { config } from "../configuration/configuration";
+import { TreeRoot } from "..";
+import { treeCollapser } from "../../extras/collapse/collapse";
+import { DestructionEvent } from "../../events/general";
+import { BranchController } from "./branch-controller";
+export class TreeBranch {
+    constructor(parent, branchOptions) {
+        this.branchOptions = branchOptions;
+        this.detachedView = null;
+        this.treeNodeBase = new TreeNodeBase();
+        const parentBranchesContainer = parent.getBranchesContainer();
+        assert(parentBranchesContainer !== undefined);
+        this.branchController = new BranchController(this, parentBranchesContainer);
+        this.setIndentation(parent);
+        if (parent instanceof TreeBranch &&
+            parent.branchOptions.defaultCollapsed === true) {
+            treeCollapser.storePrecollapsedNode(parent, this);
+            this.detachedView = this.branchController.getHostView();
+        }
+        else {
+            parentBranchesContainer.insert(this.branchController.getHostView());
+            this.detectChanges();
+            this._parent = parent;
+            this.dispatch(new GraftEvent(this, {
+                parent: this._parent,
+                child: this,
+                index: this._parent.branches().length
+            }));
+        }
+    }
+    branches() {
+        return this.treeNodeBase.branches();
+    }
+    destroy() {
+        if (this.isDestroyed()) {
+            throw new TreeError("Cannot destroy a destroyed tree branch");
+        }
+        this.prune();
+        treeCollapser.expand(this);
+        dropzoneRenderer.clearTreeFromRegistry(this);
+        this.branchController.getHostView().destroy();
+        this.treeNodeBase.destroy();
+        this.branchController.destroy();
+        this.dispatch(new DestructionEvent(this));
+    }
+    detectChanges() {
+        this.branchController.detectChanges();
+    }
+    dispatch(event) {
+        this.treeNodeBase.dispatch(event);
+        this._parent?.dispatch(event);
+    }
+    events() {
+        return this.treeNodeBase.events();
+    }
+    getBranch(index) {
+        return this.treeNodeBase.getBranch(index);
+    }
+    getBranchesContainer() {
+        if (this.isDestroyed()) {
+            throw new TreeError("Cannot get branches container from a destroyed tree branch");
+        }
+        return this.branchController.getBranchesContainer();
+    }
+    getComponentInstance() {
+        if (this.isDestroyed()) {
+            throw new TreeError("Cannot get component instance from a destroyed tree branch");
+        }
+        return this.branchController.getComponentInstance();
+    }
+    getHostView() {
+        if (this.isDestroyed()) {
+            throw new TreeError("Cannot get component host view from a destroyed tree branch");
+        }
+        return this.branchController.getHostView();
+    }
+    getNativeElement() {
+        if (this.isDestroyed()) {
+            throw new TreeError("Cannot get native element from a destroyed tree branch");
+        }
+        return this.branchController.getNativeElement();
+    }
+    getUserlandComponentRef() {
+        if (this.isDestroyed()) {
+            throw new TreeError("Cannot get userland component from a destroyed tree branch");
+        }
+        return this.branchController.getUserlandComponentRef();
+    }
+    graftTo(newParent, index) {
+        this.checkGraftLocationValidity(newParent, index);
+        const ownIndex = this.index();
+        if (ownIndex !== undefined) {
+            this.prune();
+        }
+        this._parent = newParent;
+        const newIndex = index ?? newParent.branches().length;
+        this.reattachView(newIndex);
+        this.dispatch(new GraftEvent(this, {
+            parent: newParent,
+            child: this,
+            index: newIndex
+        }));
+        return newIndex;
+    }
+    grow(component, options) {
+        if (this.isDestroyed()) {
+            throw new TreeError("Cannot grow a branch on a destroyed tree branch");
+        }
+        return new TreeBranch(this, { component, ...options });
+    }
+    index() {
+        if (!this._parent) {
+            return undefined;
+        }
+        const index = this._parent
+            .branches()
+            .findIndex((branch) => branch === this);
+        assert(index >= 0);
+        return index;
+    }
+    isDestroyed() {
+        return this.treeNodeBase.isDestroyed();
+    }
+    meta() {
+        return this.branchOptions.meta ?? {};
+    }
+    parent() {
+        return this._parent;
+    }
+    plot() {
+        return this.treeNodeBase.plot();
+    }
+    position() {
+        const index = this.index();
+        if (index === undefined) {
+            throw new TreeError("branch has no parent. Position cannot be determined.");
+        }
+        if (this._parent instanceof TreeBranch) {
+            const parentPosition = this._parent.position();
+            return [...parentPosition, index];
+        }
+        return [index];
+    }
+    prune() {
+        if (this.isDestroyed()) {
+            throw new TreeError("Cannot prune a destroyed tree branch");
+        }
+        const parent = this._parent;
+        const index = this.index();
+        if (index === undefined || parent === undefined)
+            return;
+        const container = parent.getBranchesContainer();
+        assert(container !== undefined);
+        this.detachedView = container.detach(index);
+        assert(this.detachedView !== null);
+        this.detachedView.detach();
+        this.dispatch(new PruneEvent(this, {
+            parent: parent,
+            child: this,
+            index: index
+        }));
+        this._parent = undefined;
+        return this;
+    }
+    root() {
+        const parent = this.parent();
+        if (parent instanceof TreeBranch) {
+            return parent.root();
+        }
+        assert(parent instanceof TreeRoot || parent === undefined);
+        return parent;
+    }
+    traverse(callback) {
+        callback(this);
+        this.treeNodeBase.traverse(callback);
+    }
+    checkGraftLocationValidity(newParent, index) {
+        if (this.isDestroyed()) {
+            throw new TreeError("Cannot graft a destroyed tree branch");
+        }
+        if (newParent.isDestroyed()) {
+            throw new TreeError("Cannot graft to a destroyed tree branch");
+        }
+        if (typeof index === "number" &&
+            this.indexIsOutOfRange(newParent, index)) {
+            throw new TreeError(`Cannot graft branch at index ${index} of the parent. Out of range.`);
+        }
+        this.traverse((node) => {
+            if (node === newParent) {
+                throw new TreeError("Cannot graft a branch to itself or any of its own descendants");
+            }
+        });
+    }
+    indexIsOutOfRange(parent, index) {
+        return index < 0 || index > parent.branches().length;
+    }
+    reattachView(index) {
+        assert(this._parent !== undefined);
+        assert(this.detachedView !== null);
+        const container = this._parent.getBranchesContainer();
+        assert(container !== undefined);
+        this.detachedView.reattach();
+        container.insert(this.detachedView, index);
+        this.detachedView = null;
+    }
+    setIndentation(parent) {
+        const root = parent.root();
+        assert(root !== undefined);
+        const options = config.getConfig(root);
+        const branchesContainerEl = this.branchController
+            .getNativeElement()
+            .getElementsByClassName("branches-container")
+            .item(0);
+        assert(branchesContainerEl instanceof HTMLElement);
+        branchesContainerEl.style.marginLeft = `${options?.indentation ?? 16}px`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-branch.js","sourceRoot":"","sources":["../../../../../../projects/limble-tree/src/lib/core/tree-branch/tree-branch.ts"],"names":[],"mappings":"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","sourcesContent":["import { assert } from \"../../../shared/assert\";\nimport { TreePlot } from \"../../structure/tree-plot\";\nimport { Observable } from \"rxjs\";\nimport { GraftEvent } from \"../../events/relational/graft-event\";\nimport { PruneEvent } from \"../../events/relational/prune-event\";\nimport { TreeEvent } from \"../../structure/tree-event.interface\";\nimport { TreeBranchNode } from \"../../structure/tree-branch-node.interface\";\nimport { ComponentRef, Type, ViewContainerRef, ViewRef } from \"@angular/core\";\nimport { BranchComponent } from \"../../components/branch/branch.component\";\nimport { NodeComponent } from \"../../components/node-component.interface\";\nimport { TreeNodeBase } from \"../tree-node-base\";\nimport { TreeError } from \"../../errors/tree-error\";\nimport { BranchOptions, FullBranchOptions } from \"../branch-options.interface\";\nimport { dropzoneRenderer } from \"../../extras/drag-and-drop/dropzone-renderer\";\nimport { config } from \"../configuration/configuration\";\nimport { TreeRoot } from \"..\";\nimport { treeCollapser } from \"../../extras/collapse/collapse\";\nimport { DestructionEvent } from \"../../events/general\";\nimport { TreeNode } from \"../../structure\";\nimport { BranchController } from \"./branch-controller\";\n\nexport class TreeBranch<UserlandComponent>\n   implements\n      TreeBranchNode<\n         BranchComponent<UserlandComponent>,\n         TreeBranch<UserlandComponent>,\n         NodeComponent\n      >\n{\n   private readonly branchController: BranchController<UserlandComponent>;\n   private detachedView: ViewRef | null = null;\n   private _parent:\n      | TreeNode<TreeBranch<UserlandComponent>, NodeComponent>\n      | undefined;\n   private readonly treeNodeBase: TreeNodeBase<UserlandComponent>;\n\n   public constructor(\n      parent: TreeNode<TreeBranch<UserlandComponent>, NodeComponent>,\n      public readonly branchOptions: FullBranchOptions<UserlandComponent>\n   ) {\n      this.treeNodeBase = new TreeNodeBase();\n      const parentBranchesContainer = parent.getBranchesContainer();\n      assert(parentBranchesContainer !== undefined);\n      this.branchController = new BranchController(\n         this,\n         parentBranchesContainer\n      );\n      this.setIndentation(parent);\n      if (\n         parent instanceof TreeBranch &&\n         parent.branchOptions.defaultCollapsed === true\n      ) {\n         treeCollapser.storePrecollapsedNode(parent, this);\n         this.detachedView = this.branchController.getHostView();\n      } else {\n         parentBranchesContainer.insert(this.branchController.getHostView());\n         this.detectChanges();\n         this._parent = parent;\n         this.dispatch(\n            new GraftEvent(this, {\n               parent: this._parent,\n               child: this,\n               index: this._parent.branches().length\n            })\n         );\n      }\n   }\n\n   public branches(): Array<TreeBranch<UserlandComponent>> {\n      return this.treeNodeBase.branches();\n   }\n\n   public destroy(): void {\n      if (this.isDestroyed()) {\n         throw new TreeError(\"Cannot destroy a destroyed tree branch\");\n      }\n      this.prune();\n      treeCollapser.expand(this);\n      dropzoneRenderer.clearTreeFromRegistry(this);\n      this.branchController.getHostView().destroy();\n      this.treeNodeBase.destroy();\n      this.branchController.destroy();\n      this.dispatch(new DestructionEvent(this));\n   }\n\n   public detectChanges(): void {\n      this.branchController.detectChanges();\n   }\n\n   public dispatch(event: TreeEvent): void {\n      this.treeNodeBase.dispatch(event);\n      this._parent?.dispatch(event);\n   }\n\n   public events(): Observable<TreeEvent> {\n      return this.treeNodeBase.events();\n   }\n\n   public getBranch(index: number): TreeBranch<UserlandComponent> | undefined {\n      return this.treeNodeBase.getBranch(index);\n   }\n\n   public getBranchesContainer(): ViewContainerRef | undefined {\n      if (this.isDestroyed()) {\n         throw new TreeError(\n            \"Cannot get branches container from a destroyed tree branch\"\n         );\n      }\n      return this.branchController.getBranchesContainer();\n   }\n\n   public getComponentInstance(): BranchComponent<UserlandComponent> {\n      if (this.isDestroyed()) {\n         throw new TreeError(\n            \"Cannot get component instance from a destroyed tree branch\"\n         );\n      }\n      return this.branchController.getComponentInstance();\n   }\n\n   public getHostView(): ViewRef {\n      if (this.isDestroyed()) {\n         throw new TreeError(\n            \"Cannot get component host view from a destroyed tree branch\"\n         );\n      }\n      return this.branchController.getHostView();\n   }\n\n   public getNativeElement(): HTMLElement {\n      if (this.isDestroyed()) {\n         throw new TreeError(\n            \"Cannot get native element from a destroyed tree branch\"\n         );\n      }\n      return this.branchController.getNativeElement();\n   }\n\n   public getUserlandComponentRef():\n      | ComponentRef<UserlandComponent>\n      | undefined {\n      if (this.isDestroyed()) {\n         throw new TreeError(\n            \"Cannot get userland component from a destroyed tree branch\"\n         );\n      }\n      return this.branchController.getUserlandComponentRef();\n   }\n\n   public graftTo(\n      newParent: TreeNode<TreeBranch<UserlandComponent>, NodeComponent>,\n      index?: number\n   ): number {\n      this.checkGraftLocationValidity(newParent, index);\n      const ownIndex = this.index();\n      if (ownIndex !== undefined) {\n         this.prune();\n      }\n      this._parent = newParent;\n      const newIndex = index ?? newParent.branches().length;\n      this.reattachView(newIndex);\n      this.dispatch(\n         new GraftEvent(this, {\n            parent: newParent,\n            child: this,\n            index: newIndex\n         })\n      );\n      return newIndex;\n   }\n\n   public grow(\n      component: Type<UserlandComponent>,\n      options?: BranchOptions<UserlandComponent>\n   ): TreeBranch<UserlandComponent> {\n      if (this.isDestroyed()) {\n         throw new TreeError(\"Cannot grow a branch on a destroyed tree branch\");\n      }\n      return new TreeBranch(this, { component, ...options });\n   }\n\n   public index(): number | undefined {\n      if (!this._parent) {\n         return undefined;\n      }\n      const index = this._parent\n         .branches()\n         .findIndex((branch) => branch === this);\n      assert(index >= 0);\n      return index;\n   }\n\n   public isDestroyed(): boolean {\n      return this.treeNodeBase.isDestroyed();\n   }\n\n   public meta(): Record<string, any> {\n      return this.branchOptions.meta ?? {};\n   }\n\n   public parent():\n      | TreeNode<TreeBranch<UserlandComponent>, NodeComponent>\n      | undefined {\n      return this._parent;\n   }\n\n   public plot(): TreePlot {\n      return this.treeNodeBase.plot();\n   }\n\n   public position(): Array<number> {\n      const index = this.index();\n      if (index === undefined) {\n         throw new TreeError(\n            \"branch has no parent. Position cannot be determined.\"\n         );\n      }\n      if (this._parent instanceof TreeBranch) {\n         const parentPosition = this._parent.position();\n         return [...parentPosition, index];\n      }\n      return [index];\n   }\n\n   public prune(): this | undefined {\n      if (this.isDestroyed()) {\n         throw new TreeError(\"Cannot prune a destroyed tree branch\");\n      }\n      const parent = this._parent;\n      const index = this.index();\n      if (index === undefined || parent === undefined) return;\n      const container = parent.getBranchesContainer();\n      assert(container !== undefined);\n      this.detachedView = container.detach(index);\n      assert(this.detachedView !== null);\n      this.detachedView.detach();\n      this.dispatch(\n         new PruneEvent(this, {\n            parent: parent,\n            child: this,\n            index: index\n         })\n      );\n      this._parent = undefined;\n      return this;\n   }\n\n   public root(): TreeRoot<UserlandComponent> | undefined {\n      const parent = this.parent();\n      if (parent instanceof TreeBranch) {\n         return parent.root();\n      }\n      assert(parent instanceof TreeRoot || parent === undefined);\n      return parent;\n   }\n\n   public traverse(\n      callback: (\n         node: TreeNode<TreeBranch<UserlandComponent>, NodeComponent>\n      ) => void\n   ): void {\n      callback(this);\n      this.treeNodeBase.traverse(callback);\n   }\n\n   private checkGraftLocationValidity(\n      newParent: TreeNode<TreeBranch<UserlandComponent>, NodeComponent>,\n      index?: number\n   ): void {\n      if (this.isDestroyed()) {\n         throw new TreeError(\"Cannot graft a destroyed tree branch\");\n      }\n      if (newParent.isDestroyed()) {\n         throw new TreeError(\"Cannot graft to a destroyed tree branch\");\n      }\n      if (\n         typeof index === \"number\" &&\n         this.indexIsOutOfRange(newParent, index)\n      ) {\n         throw new TreeError(\n            `Cannot graft branch at index ${index} of the parent. Out of range.`\n         );\n      }\n      this.traverse((node) => {\n         if (node === newParent) {\n            throw new TreeError(\n               \"Cannot graft a branch to itself or any of its own descendants\"\n            );\n         }\n      });\n   }\n\n   private indexIsOutOfRange(\n      parent: TreeNode<TreeBranch<UserlandComponent>, NodeComponent>,\n      index: number\n   ): boolean {\n      return index < 0 || index > parent.branches().length;\n   }\n\n   private reattachView(index?: number): void {\n      assert(this._parent !== undefined);\n      assert(this.detachedView !== null);\n      const container = this._parent.getBranchesContainer();\n      assert(container !== undefined);\n      this.detachedView.reattach();\n      container.insert(this.detachedView, index);\n      this.detachedView = null;\n   }\n\n   private setIndentation(\n      parent: TreeNode<TreeBranch<UserlandComponent>, NodeComponent>\n   ): void {\n      const root = parent.root();\n      assert(root !== undefined);\n      const options = config.getConfig(root);\n      const branchesContainerEl = this.branchController\n         .getNativeElement()\n         .getElementsByClassName(\"branches-container\")\n         .item(0);\n      assert(branchesContainerEl instanceof HTMLElement);\n      branchesContainerEl.style.marginLeft = `${options?.indentation ?? 16}px`;\n   }\n}\n"]}

package/esm2020/lib/core/tree-node-base.mjs

@@ -0,0 +1,69 @@
+import { filter, Subject } from "rxjs";
+import { TreeError } from "../errors";
+import { GraftEvent } from "../events/relational/graft-event";
+import { PruneEvent } from "../events/relational/prune-event";
+export class TreeNodeBase {
+    constructor() {
+        this.destroyed = false;
+        this._branches = [];
+        this.events$ = new Subject();
+        this.subscriptions = [
+            this.graftsToSelf().subscribe((event) => {
+                this.registerChildRelationship(event.child(), event.index());
+            }),
+            this.prunesToSelf().subscribe((event) => {
+                this.deregisterChildRelationship(event.child());
+            })
+        ];
+    }
+    branches() {
+        return [...this._branches];
+    }
+    destroy() {
+        this.branches().forEach((branch) => {
+            branch.destroy();
+        });
+        this.subscriptions.forEach((sub) => {
+            sub.unsubscribe();
+        });
+        this.destroyed = true;
+    }
+    dispatch(event) {
+        this.events$.next(event);
+    }
+    events() {
+        return this.events$;
+    }
+    getBranch(index) {
+        return this._branches[index];
+    }
+    isDestroyed() {
+        return this.destroyed;
+    }
+    plot() {
+        return new Map(this.branches().map((branch, index) => [index, branch.plot()]));
+    }
+    traverse(callback) {
+        this.branches().forEach((branch) => {
+            branch.traverse(callback);
+        });
+    }
+    deregisterChildRelationship(child) {
+        const index = this.branches().findIndex((branch) => branch === child);
+        this._branches.splice(index, 1);
+    }
+    graftsToSelf() {
+        return this.events().pipe(filter((event) => event instanceof GraftEvent), filter((event) => event.parent().events() === this.events$));
+    }
+    prunesToSelf() {
+        return this.events().pipe(filter((event) => event instanceof PruneEvent), filter((event) => event.parent().events() === this.events$));
+    }
+    registerChildRelationship(child, index) {
+        const branches = this.branches();
+        if (index < 0 || index > branches.length) {
+            throw new TreeError(`Can't register child at index ${index}. Out of range.`);
+        }
+        this._branches.splice(index, 0, child);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-node-base.js","sourceRoot":"","sources":["../../../../../projects/limble-tree/src/lib/core/tree-node-base.ts"],"names":[],"mappings":"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","sourcesContent":["import { filter, Observable, Subject, Subscription } from \"rxjs\";\nimport { NodeComponent } from \"../components/node-component.interface\";\nimport { TreeError } from \"../errors\";\nimport { GraftEvent } from \"../events/relational/graft-event\";\nimport { PruneEvent } from \"../events/relational/prune-event\";\nimport { TreeEvent } from \"../structure/tree-event.interface\";\nimport { TreeNode } from \"../structure/tree-node.interface\";\nimport { TreePlot } from \"../structure/tree-plot\";\nimport { Relationship } from \"./relationship.interface\";\nimport { TreeBranch } from \"./tree-branch/tree-branch\";\n\nexport class TreeNodeBase<UserlandComponent>\n   implements Partial<TreeNode<TreeBranch<UserlandComponent>, NodeComponent>>\n{\n   private readonly _branches: Array<TreeBranch<UserlandComponent>>;\n   private readonly events$: Subject<TreeEvent>;\n   private destroyed: boolean = false;\n   private readonly subscriptions: Array<Subscription>;\n\n   public constructor() {\n      this._branches = [];\n      this.events$ = new Subject();\n      this.subscriptions = [\n         this.graftsToSelf().subscribe((event) => {\n            this.registerChildRelationship(event.child(), event.index());\n         }),\n         this.prunesToSelf().subscribe((event) => {\n            this.deregisterChildRelationship(event.child());\n         })\n      ];\n   }\n\n   public branches(): Array<TreeBranch<UserlandComponent>> {\n      return [...this._branches];\n   }\n\n   public destroy(): void {\n      this.branches().forEach((branch) => {\n         branch.destroy();\n      });\n      this.subscriptions.forEach((sub) => {\n         sub.unsubscribe();\n      });\n      this.destroyed = true;\n   }\n\n   public dispatch(event: TreeEvent): void {\n      this.events$.next(event);\n   }\n\n   public events(): Observable<TreeEvent> {\n      return this.events$;\n   }\n\n   public getBranch(index: number): TreeBranch<UserlandComponent> | undefined {\n      return this._branches[index];\n   }\n\n   public isDestroyed(): boolean {\n      return this.destroyed;\n   }\n\n   public plot(): TreePlot {\n      return new Map(\n         this.branches().map((branch, index) => [index, branch.plot()])\n      );\n   }\n\n   public traverse(\n      callback: (\n         node: TreeNode<TreeBranch<UserlandComponent>, NodeComponent>\n      ) => void\n   ): void {\n      this.branches().forEach((branch) => {\n         branch.traverse(callback);\n      });\n   }\n\n   private deregisterChildRelationship(\n      child: TreeBranch<UserlandComponent>\n   ): void {\n      const index = this.branches().findIndex((branch) => branch === child);\n      this._branches.splice(index, 1);\n   }\n\n   private graftsToSelf(): Observable<\n      GraftEvent<Relationship<UserlandComponent>>\n   > {\n      return this.events().pipe(\n         filter(\n            (event): event is GraftEvent<Relationship<UserlandComponent>> =>\n               event instanceof GraftEvent\n         ),\n         filter((event) => event.parent().events() === this.events$)\n      );\n   }\n\n   private prunesToSelf(): Observable<\n      PruneEvent<Relationship<UserlandComponent>>\n   > {\n      return this.events().pipe(\n         filter(\n            (event): event is PruneEvent<Relationship<UserlandComponent>> =>\n               event instanceof PruneEvent\n         ),\n         filter((event) => event.parent().events() === this.events$)\n      );\n   }\n\n   private registerChildRelationship(\n      child: TreeBranch<UserlandComponent>,\n      index: number\n   ): void {\n      const branches = this.branches();\n      if (index < 0 || index > branches.length) {\n         throw new TreeError(\n            `Can't register child at index ${index}. Out of range.`\n         );\n      }\n      this._branches.splice(index, 0, child);\n   }\n}\n"]}

package/esm2020/lib/core/tree-root/root-controller.mjs

@@ -0,0 +1,42 @@
+import { assert } from "../../../shared/assert";
+import { RootComponent } from "../../components/root/root.component";
+import { dropzoneRenderer } from "../../extras/drag-and-drop/dropzone-renderer";
+/**
+ * A wrapper around the BranchComponent that helps instantiate it and handles its events.
+ */
+export class RootController {
+    constructor(treeRoot, viewContainerRef) {
+        this.treeRoot = treeRoot;
+        this.rootComponentRef = viewContainerRef.createComponent(RootComponent);
+        const viewInitSub = this.rootComponentRef.instance.afterViewInit.subscribe(() => {
+            const dropzone = this.rootComponentRef.instance.dropzone;
+            assert(dropzone !== undefined);
+            dropzoneRenderer.registerDropzone(dropzone, this.treeRoot);
+        });
+        const droppedSub = this.rootComponentRef.instance.dropped.subscribe(() => {
+            dropzoneRenderer.handleDrop(this.treeRoot, "inner");
+        });
+        this.instanceSubscriptions = [viewInitSub, droppedSub];
+    }
+    destroy() {
+        this.instanceSubscriptions.forEach((sub) => {
+            sub.unsubscribe();
+        });
+    }
+    detectChanges() {
+        this.rootComponentRef.changeDetectorRef.detectChanges();
+    }
+    getBranchesContainer() {
+        return this.rootComponentRef.instance.branchesContainer;
+    }
+    getComponentInstance() {
+        return this.rootComponentRef.instance;
+    }
+    getHostView() {
+        return this.rootComponentRef.hostView;
+    }
+    getNativeElement() {
+        return this.rootComponentRef.location.nativeElement;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/tree-root/tree-root.mjs

@@ -0,0 +1,85 @@
+import { TreeBranch } from "../tree-branch/tree-branch";
+import { TreeNodeBase } from "../tree-node-base";
+import { dropzoneRenderer } from "../../extras/drag-and-drop/dropzone-renderer";
+import { config } from "../configuration/configuration";
+import { TreeError } from "../../errors";
+import { DestructionEvent } from "../../events/general";
+import { RootController } from "./root-controller";
+export class TreeRoot {
+    constructor(viewContainerRef) {
+        this.viewContainerRef = viewContainerRef;
+        this.treeNodeBase = new TreeNodeBase();
+        this.rootController = new RootController(this, viewContainerRef);
+        this.detectChanges();
+    }
+    branches() {
+        return this.treeNodeBase.branches();
+    }
+    destroy() {
+        if (this.isDestroyed()) {
+            throw new TreeError("Cannot destroy a destroyed tree root");
+        }
+        dropzoneRenderer.clearTreeFromRegistry(this);
+        this.treeNodeBase.destroy();
+        this.rootController.destroy();
+        this.viewContainerRef.clear();
+        config.delete(this);
+        this.dispatch(new DestructionEvent(this));
+    }
+    detectChanges() {
+        this.rootController.detectChanges();
+    }
+    dispatch(event) {
+        this.treeNodeBase.dispatch(event);
+    }
+    events() {
+        return this.treeNodeBase.events();
+    }
+    getBranch(index) {
+        return this.treeNodeBase.getBranch(index);
+    }
+    getBranchesContainer() {
+        if (this.isDestroyed()) {
+            throw new TreeError("Cannot get branches container from a destroyed tree root");
+        }
+        return this.rootController.getBranchesContainer();
+    }
+    getComponentInstance() {
+        if (this.isDestroyed()) {
+            throw new TreeError("Cannot get component instance from a destroyed tree root");
+        }
+        return this.rootController.getComponentInstance();
+    }
+    getHostView() {
+        if (this.isDestroyed()) {
+            throw new TreeError("Cannot get component host view from a destroyed tree root");
+        }
+        return this.rootController.getHostView();
+    }
+    getNativeElement() {
+        if (this.isDestroyed()) {
+            throw new TreeError("Cannot get native element from a destroyed tree root");
+        }
+        return this.rootController.getNativeElement();
+    }
+    grow(component, options) {
+        if (this.isDestroyed()) {
+            throw new TreeError("Cannot grow a branch on a destroyed tree root");
+        }
+        return new TreeBranch(this, { component, ...options });
+    }
+    isDestroyed() {
+        return this.treeNodeBase.isDestroyed();
+    }
+    plot() {
+        return this.treeNodeBase.plot();
+    }
+    root() {
+        return this;
+    }
+    traverse(callback) {
+        callback(this);
+        this.treeNodeBase.traverse(callback);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-root.js","sourceRoot":"","sources":["../../../../../../projects/limble-tree/src/lib/core/tree-root/tree-root.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAGxD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AAChF,OAAO,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,MAAM,OAAO,QAAQ;IAMlB,YAAoC,gBAAkC;QAAlC,qBAAgB,GAAhB,gBAAgB,CAAkB;QACnE,IAAI,CAAC,YAAY,GAAG,IAAI,YAAY,EAAE,CAAC;QACvC,IAAI,CAAC,cAAc,GAAG,IAAI,cAAc,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAC;QACjE,IAAI,CAAC,aAAa,EAAE,CAAC;IACxB,CAAC;IAEM,QAAQ;QACZ,OAAO,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;IACvC,CAAC;IAEM,OAAO;QACX,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE;YACrB,MAAM,IAAI,SAAS,CAAC,sCAAsC,CAAC,CAAC;SAC9D;QACD,gBAAgB,CAAC,qBAAqB,CAAC,IAAI,CAAC,CAAC;QAC7C,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC;QAC5B,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC;QAC9B,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC;QAC9B,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACpB,IAAI,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC;IAC7C,CAAC;IAEM,aAAa;QACjB,IAAI,CAAC,cAAc,CAAC,aAAa,EAAE,CAAC;IACvC,CAAC;IAEM,QAAQ,CAAC,KAAgB;QAC7B,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACrC,CAAC;IAEM,MAAM;QACV,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC;IACrC,CAAC;IAEM,SAAS,CAAC,KAAa;QAC3B,OAAO,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IAC7C,CAAC;IAEM,oBAAoB;QACxB,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE;YACrB,MAAM,IAAI,SAAS,CAChB,0DAA0D,CAC5D,CAAC;SACJ;QACD,OAAO,IAAI,CAAC,cAAc,CAAC,oBAAoB,EAAE,CAAC;IACrD,CAAC;IAEM,oBAAoB;QACxB,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE;YACrB,MAAM,IAAI,SAAS,CAChB,0DAA0D,CAC5D,CAAC;SACJ;QACD,OAAO,IAAI,CAAC,cAAc,CAAC,oBAAoB,EAAE,CAAC;IACrD,CAAC;IAEM,WAAW;QACf,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE;YACrB,MAAM,IAAI,SAAS,CAChB,2DAA2D,CAC7D,CAAC;SACJ;QACD,OAAO,IAAI,CAAC,cAAc,CAAC,WAAW,EAAE,CAAC;IAC5C,CAAC;IAEM,gBAAgB;QACpB,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE;YACrB,MAAM,IAAI,SAAS,CAChB,sDAAsD,CACxD,CAAC;SACJ;QACD,OAAO,IAAI,CAAC,cAAc,CAAC,gBAAgB,EAAE,CAAC;IACjD,CAAC;IAEM,IAAI,CACR,SAAkC,EAClC,OAA0C;QAE1C,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE;YACrB,MAAM,IAAI,SAAS,CAAC,+CAA+C,CAAC,CAAC;SACvE;QACD,OAAO,IAAI,UAAU,CAAC,IAAI,EAAE,EAAE,SAAS,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IAC1D,CAAC;IAEM,WAAW;QACf,OAAO,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC;IAC1C,CAAC;IAEM,IAAI;QACR,OAAO,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;IACnC,CAAC;IAEM,IAAI;QACR,OAAO,IAAI,CAAC;IACf,CAAC;IAEM,QAAQ,CACZ,QAES;QAET,QAAQ,CAAC,IAAI,CAAC,CAAC;QACf,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACxC,CAAC;CACH","sourcesContent":["import { TreePlot } from \"../../structure/tree-plot\";\nimport { Observable } from \"rxjs\";\nimport { TreeEvent } from \"../../structure/tree-event.interface\";\nimport { TreeBranch } from \"../tree-branch/tree-branch\";\nimport { Type, ViewContainerRef, ViewRef } from \"@angular/core\";\nimport { RootComponent } from \"../../components/root/root.component\";\nimport { TreeNodeBase } from \"../tree-node-base\";\nimport { NodeComponent } from \"../../components/node-component.interface\";\nimport { BranchOptions } from \"../branch-options.interface\";\nimport { dropzoneRenderer } from \"../../extras/drag-and-drop/dropzone-renderer\";\nimport { config } from \"../configuration/configuration\";\nimport { TreeError } from \"../../errors\";\nimport { DestructionEvent } from \"../../events/general\";\nimport { TreeNode } from \"../../structure\";\nimport { RootController } from \"./root-controller\";\n\nexport class TreeRoot<UserlandComponent>\n   implements TreeNode<TreeBranch<UserlandComponent>, RootComponent>\n{\n   private readonly rootController: RootController<UserlandComponent>;\n   private readonly treeNodeBase: TreeNodeBase<UserlandComponent>;\n\n   public constructor(private readonly viewContainerRef: ViewContainerRef) {\n      this.treeNodeBase = new TreeNodeBase();\n      this.rootController = new RootController(this, viewContainerRef);\n      this.detectChanges();\n   }\n\n   public branches(): Array<TreeBranch<UserlandComponent>> {\n      return this.treeNodeBase.branches();\n   }\n\n   public destroy(): void {\n      if (this.isDestroyed()) {\n         throw new TreeError(\"Cannot destroy a destroyed tree root\");\n      }\n      dropzoneRenderer.clearTreeFromRegistry(this);\n      this.treeNodeBase.destroy();\n      this.rootController.destroy();\n      this.viewContainerRef.clear();\n      config.delete(this);\n      this.dispatch(new DestructionEvent(this));\n   }\n\n   public detectChanges(): void {\n      this.rootController.detectChanges();\n   }\n\n   public dispatch(event: TreeEvent): void {\n      this.treeNodeBase.dispatch(event);\n   }\n\n   public events(): Observable<TreeEvent> {\n      return this.treeNodeBase.events();\n   }\n\n   public getBranch(index: number): TreeBranch<UserlandComponent> | undefined {\n      return this.treeNodeBase.getBranch(index);\n   }\n\n   public getBranchesContainer(): ViewContainerRef | undefined {\n      if (this.isDestroyed()) {\n         throw new TreeError(\n            \"Cannot get branches container from a destroyed tree root\"\n         );\n      }\n      return this.rootController.getBranchesContainer();\n   }\n\n   public getComponentInstance(): RootComponent {\n      if (this.isDestroyed()) {\n         throw new TreeError(\n            \"Cannot get component instance from a destroyed tree root\"\n         );\n      }\n      return this.rootController.getComponentInstance();\n   }\n\n   public getHostView(): ViewRef {\n      if (this.isDestroyed()) {\n         throw new TreeError(\n            \"Cannot get component host view from a destroyed tree root\"\n         );\n      }\n      return this.rootController.getHostView();\n   }\n\n   public getNativeElement(): HTMLElement {\n      if (this.isDestroyed()) {\n         throw new TreeError(\n            \"Cannot get native element from a destroyed tree root\"\n         );\n      }\n      return this.rootController.getNativeElement();\n   }\n\n   public grow(\n      component: Type<UserlandComponent>,\n      options?: BranchOptions<UserlandComponent>\n   ): TreeBranch<UserlandComponent> {\n      if (this.isDestroyed()) {\n         throw new TreeError(\"Cannot grow a branch on a destroyed tree root\");\n      }\n      return new TreeBranch(this, { component, ...options });\n   }\n\n   public isDestroyed(): boolean {\n      return this.treeNodeBase.isDestroyed();\n   }\n\n   public plot(): TreePlot {\n      return this.treeNodeBase.plot();\n   }\n\n   public root(): this {\n      return this;\n   }\n\n   public traverse(\n      callback: (\n         node: TreeNode<TreeBranch<UserlandComponent>, NodeComponent>\n      ) => void\n   ): void {\n      callback(this);\n      this.treeNodeBase.traverse(callback);\n   }\n}\n"]}

package/esm2020/lib/core/tree-service/tree.service.mjs

@@ -0,0 +1,19 @@
+import { Injectable } from "@angular/core";
+import { config } from "../configuration/configuration";
+import { TreeRoot } from "../tree-root/tree-root";
+import * as i0 from "@angular/core";
+export class TreeService {
+    createEmptyTree(container, options = {}) {
+        container.clear();
+        const root = new TreeRoot(container);
+        config.setConfig(root, options);
+        return root;
+    }
+}
+TreeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: TreeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TreeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: TreeService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: TreeService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbGltYmxlLXRyZWUvc3JjL2xpYi9jb3JlL3RyZWUtc2VydmljZS90cmVlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBb0IsTUFBTSxlQUFlLENBQUM7QUFDN0QsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRXhELE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQzs7QUFHbEQsTUFBTSxPQUFPLFdBQVc7SUFDZCxlQUFlLENBQ25CLFNBQTJCLEVBQzNCLFVBQXVCLEVBQUU7UUFFekIsU0FBUyxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ2xCLE1BQU0sSUFBSSxHQUFHLElBQUksUUFBUSxDQUFZLFNBQVMsQ0FBQyxDQUFDO1FBQ2hELE1BQU0sQ0FBQyxTQUFTLENBQUMsSUFBSSxFQUFFLE9BQU8sQ0FBQyxDQUFDO1FBQ2hDLE9BQU8sSUFBSSxDQUFDO0lBQ2YsQ0FBQzs7eUdBVFMsV0FBVzs2R0FBWCxXQUFXLGNBREUsTUFBTTs0RkFDbkIsV0FBVztrQkFEdkIsVUFBVTttQkFBQyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlLCBWaWV3Q29udGFpbmVyUmVmIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcbmltcG9ydCB7IGNvbmZpZyB9IGZyb20gXCIuLi9jb25maWd1cmF0aW9uL2NvbmZpZ3VyYXRpb25cIjtcbmltcG9ydCB7IFRyZWVPcHRpb25zIH0gZnJvbSBcIi4uL2NvbmZpZ3VyYXRpb24vdHJlZS1vcHRpb25zLmludGVyZmFjZVwiO1xuaW1wb3J0IHsgVHJlZVJvb3QgfSBmcm9tIFwiLi4vdHJlZS1yb290L3RyZWUtcm9vdFwiO1xuXG5ASW5qZWN0YWJsZSh7IHByb3ZpZGVkSW46IFwicm9vdFwiIH0pXG5leHBvcnQgY2xhc3MgVHJlZVNlcnZpY2Uge1xuICAgcHVibGljIGNyZWF0ZUVtcHR5VHJlZTxDb21wb25lbnQ+KFxuICAgICAgY29udGFpbmVyOiBWaWV3Q29udGFpbmVyUmVmLFxuICAgICAgb3B0aW9uczogVHJlZU9wdGlvbnMgPSB7fVxuICAgKTogVHJlZVJvb3Q8Q29tcG9uZW50PiB7XG4gICAgICBjb250YWluZXIuY2xlYXIoKTtcbiAgICAgIGNvbnN0IHJvb3QgPSBuZXcgVHJlZVJvb3Q8Q29tcG9uZW50Pihjb250YWluZXIpO1xuICAgICAgY29uZmlnLnNldENvbmZpZyhyb290LCBvcHRpb25zKTtcbiAgICAgIHJldHVybiByb290O1xuICAgfVxufVxuIl19

package/esm2020/lib/errors/index.mjs

@@ -0,0 +1,2 @@
+export * from "./tree-error";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saW1ibGUtdHJlZS9zcmMvbGliL2Vycm9ycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL3RyZWUtZXJyb3JcIjtcbiJdfQ==

package/esm2020/lib/errors/tree-error.mjs

@@ -0,0 +1,3 @@
+export class TreeError extends Error {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZS1lcnJvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2xpbWJsZS10cmVlL3NyYy9saWIvZXJyb3JzL3RyZWUtZXJyb3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLFNBQVUsU0FBUSxLQUFLO0NBQUciLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgVHJlZUVycm9yIGV4dGVuZHMgRXJyb3Ige31cbiJdfQ==

package/esm2020/lib/events/drag/drag-end-event.mjs

@@ -0,0 +1,28 @@
+export class DragEndEvent {
+    constructor(source, endpoints) {
+        this._source = source;
+        this._oldParent = endpoints.oldParent;
+        this._oldIndex = endpoints.oldIndex;
+        this._newParent = endpoints.newParent;
+        this._newIndex = endpoints.newIndex;
+    }
+    type() {
+        return "drag end";
+    }
+    source() {
+        return this._source;
+    }
+    newIndex() {
+        return this._newIndex;
+    }
+    newParent() {
+        return this._newParent;
+    }
+    oldIndex() {
+        return this._oldIndex;
+    }
+    oldParent() {
+        return this._oldParent;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1lbmQtZXZlbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saW1ibGUtdHJlZS9zcmMvbGliL2V2ZW50cy9kcmFnL2RyYWctZW5kLWV2ZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU1BLE1BQU0sT0FBTyxZQUFZO0lBT3RCLFlBQ0csTUFBb0IsRUFDcEIsU0FLQztRQUVELElBQUksQ0FBQyxPQUFPLEdBQUcsTUFBTSxDQUFDO1FBQ3RCLElBQUksQ0FBQyxVQUFVLEdBQUcsU0FBUyxDQUFDLFNBQVMsQ0FBQztRQUN0QyxJQUFJLENBQUMsU0FBUyxHQUFHLFNBQVMsQ0FBQyxRQUFRLENBQUM7UUFDcEMsSUFBSSxDQUFDLFVBQVUsR0FBRyxTQUFTLENBQUMsU0FBUyxDQUFDO1FBQ3RDLElBQUksQ0FBQyxTQUFTLEdBQUcsU0FBUyxDQUFDLFFBQVEsQ0FBQztJQUN2QyxDQUFDO0lBRU0sSUFBSTtRQUNSLE9BQU8sVUFBVSxDQUFDO0lBQ3JCLENBQUM7SUFFTSxNQUFNO1FBQ1YsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDO0lBQ3ZCLENBQUM7SUFFTSxRQUFRO1FBQ1osT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDO0lBQ3pCLENBQUM7SUFFTSxTQUFTO1FBQ2IsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDO0lBQzFCLENBQUM7SUFFTSxRQUFRO1FBQ1osT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDO0lBQ3pCLENBQUM7SUFFTSxTQUFTO1FBQ2IsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDO0lBQzFCLENBQUM7Q0FDSCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5vZGVDb21wb25lbnQgfSBmcm9tIFwiLi4vLi4vY29tcG9uZW50cy9ub2RlLWNvbXBvbmVudC5pbnRlcmZhY2VcIjtcbmltcG9ydCB7IFRyZWVCcmFuY2ggfSBmcm9tIFwiLi4vLi4vY29yZVwiO1xuaW1wb3J0IHsgVHJlZU5vZGUgfSBmcm9tIFwiLi4vLi4vc3RydWN0dXJlXCI7XG5pbXBvcnQgeyBFdmVudENvbmR1aXQgfSBmcm9tIFwiLi4vLi4vc3RydWN0dXJlL2V2ZW50LWNvbmR1aXQuaW50ZXJmYWNlXCI7XG5pbXBvcnQgeyBUcmVlRXZlbnQgfSBmcm9tIFwiLi4vLi4vc3RydWN0dXJlL3RyZWUtZXZlbnQuaW50ZXJmYWNlXCI7XG5cbmV4cG9ydCBjbGFzcyBEcmFnRW5kRXZlbnQ8VD4gaW1wbGVtZW50cyBUcmVlRXZlbnQge1xuICAgcHJpdmF0ZSByZWFkb25seSBfc291cmNlOiBFdmVudENvbmR1aXQ7XG4gICBwcml2YXRlIHJlYWRvbmx5IF9uZXdQYXJlbnQ6IFRyZWVOb2RlPFRyZWVCcmFuY2g8VD4sIE5vZGVDb21wb25lbnQ+O1xuICAgcHJpdmF0ZSByZWFkb25seSBfbmV3SW5kZXg6IG51bWJlcjtcbiAgIHByaXZhdGUgcmVhZG9ubHkgX29sZFBhcmVudDogVHJlZU5vZGU8VHJlZUJyYW5jaDxUPiwgTm9kZUNvbXBvbmVudD47XG4gICBwcml2YXRlIHJlYWRvbmx5IF9vbGRJbmRleDogbnVtYmVyO1xuXG4gICBwdWJsaWMgY29uc3RydWN0b3IoXG4gICAgICBzb3VyY2U6IEV2ZW50Q29uZHVpdCxcbiAgICAgIGVuZHBvaW50czoge1xuICAgICAgICAgb2xkUGFyZW50OiBUcmVlTm9kZTxUcmVlQnJhbmNoPFQ+LCBOb2RlQ29tcG9uZW50PjtcbiAgICAgICAgIG9sZEluZGV4OiBudW1iZXI7XG4gICAgICAgICBuZXdQYXJlbnQ6IFRyZWVOb2RlPFRyZWVCcmFuY2g8VD4sIE5vZGVDb21wb25lbnQ+O1xuICAgICAgICAgbmV3SW5kZXg6IG51bWJlcjtcbiAgICAgIH1cbiAgICkge1xuICAgICAgdGhpcy5fc291cmNlID0gc291cmNlO1xuICAgICAgdGhpcy5fb2xkUGFyZW50ID0gZW5kcG9pbnRzLm9sZFBhcmVudDtcbiAgICAgIHRoaXMuX29sZEluZGV4ID0gZW5kcG9pbnRzLm9sZEluZGV4O1xuICAgICAgdGhpcy5fbmV3UGFyZW50ID0gZW5kcG9pbnRzLm5ld1BhcmVudDtcbiAgICAgIHRoaXMuX25ld0luZGV4ID0gZW5kcG9pbnRzLm5ld0luZGV4O1xuICAgfVxuXG4gICBwdWJsaWMgdHlwZSgpOiBcImRyYWcgZW5kXCIge1xuICAgICAgcmV0dXJuIFwiZHJhZyBlbmRcIjtcbiAgIH1cblxuICAgcHVibGljIHNvdXJjZSgpOiBFdmVudENvbmR1aXQge1xuICAgICAgcmV0dXJuIHRoaXMuX3NvdXJjZTtcbiAgIH1cblxuICAgcHVibGljIG5ld0luZGV4KCk6IG51bWJlciB7XG4gICAgICByZXR1cm4gdGhpcy5fbmV3SW5kZXg7XG4gICB9XG5cbiAgIHB1YmxpYyBuZXdQYXJlbnQoKTogVHJlZU5vZGU8VHJlZUJyYW5jaDxUPiwgTm9kZUNvbXBvbmVudD4ge1xuICAgICAgcmV0dXJuIHRoaXMuX25ld1BhcmVudDtcbiAgIH1cblxuICAgcHVibGljIG9sZEluZGV4KCk6IG51bWJlciB7XG4gICAgICByZXR1cm4gdGhpcy5fb2xkSW5kZXg7XG4gICB9XG5cbiAgIHB1YmxpYyBvbGRQYXJlbnQoKTogVHJlZU5vZGU8VHJlZUJyYW5jaDxUPiwgTm9kZUNvbXBvbmVudD4ge1xuICAgICAgcmV0dXJuIHRoaXMuX29sZFBhcmVudDtcbiAgIH1cbn1cbiJdfQ==

package/esm2020/lib/events/drag/drag-start-event.mjs

@@ -0,0 +1,12 @@
+export class DragStartEvent {
+    constructor(source) {
+        this._source = source;
+    }
+    type() {
+        return "drag start";
+    }
+    source() {
+        return this._source;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1zdGFydC1ldmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2xpbWJsZS10cmVlL3NyYy9saWIvZXZlbnRzL2RyYWcvZHJhZy1zdGFydC1ldmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxNQUFNLE9BQU8sY0FBYztJQUd4QixZQUFtQixNQUFvQjtRQUNwQyxJQUFJLENBQUMsT0FBTyxHQUFHLE1BQU0sQ0FBQztJQUN6QixDQUFDO0lBRU0sSUFBSTtRQUNSLE9BQU8sWUFBWSxDQUFDO0lBQ3ZCLENBQUM7SUFFTSxNQUFNO1FBQ1YsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDO0lBQ3ZCLENBQUM7Q0FDSCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEV2ZW50Q29uZHVpdCB9IGZyb20gXCIuLi8uLi9zdHJ1Y3R1cmUvZXZlbnQtY29uZHVpdC5pbnRlcmZhY2VcIjtcbmltcG9ydCB7IFRyZWVFdmVudCB9IGZyb20gXCIuLi8uLi9zdHJ1Y3R1cmUvdHJlZS1ldmVudC5pbnRlcmZhY2VcIjtcblxuZXhwb3J0IGNsYXNzIERyYWdTdGFydEV2ZW50IGltcGxlbWVudHMgVHJlZUV2ZW50IHtcbiAgIHByaXZhdGUgcmVhZG9ubHkgX3NvdXJjZTogRXZlbnRDb25kdWl0O1xuXG4gICBwdWJsaWMgY29uc3RydWN0b3Ioc291cmNlOiBFdmVudENvbmR1aXQpIHtcbiAgICAgIHRoaXMuX3NvdXJjZSA9IHNvdXJjZTtcbiAgIH1cblxuICAgcHVibGljIHR5cGUoKTogXCJkcmFnIHN0YXJ0XCIge1xuICAgICAgcmV0dXJuIFwiZHJhZyBzdGFydFwiO1xuICAgfVxuXG4gICBwdWJsaWMgc291cmNlKCk6IEV2ZW50Q29uZHVpdCB7XG4gICAgICByZXR1cm4gdGhpcy5fc291cmNlO1xuICAgfVxufVxuIl19

package/esm2020/lib/events/drag/drop-event.mjs

@@ -0,0 +1,20 @@
+export class DropEvent {
+    constructor(source, parent, index) {
+        this._source = source;
+        this._parent = parent;
+        this._index = index;
+    }
+    type() {
+        return "drag end";
+    }
+    source() {
+        return this._source;
+    }
+    index() {
+        return this._index;
+    }
+    parent() {
+        return this._parent;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/events/drag/index.mjs

@@ -0,0 +1,4 @@
+export * from "./drag-end-event";
+export * from "./drag-start-event";
+export * from "./drop-event";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saW1ibGUtdHJlZS9zcmMvbGliL2V2ZW50cy9kcmFnL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2RyYWctZW5kLWV2ZW50XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kcmFnLXN0YXJ0LWV2ZW50XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kcm9wLWV2ZW50XCI7XG4iXX0=

package/esm2020/lib/events/general/destruction-event.mjs

@@ -0,0 +1,12 @@
+export class DestructionEvent {
+    constructor(source) {
+        this._source = source;
+    }
+    type() {
+        return "destruction";
+    }
+    source() {
+        return this._source;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVzdHJ1Y3Rpb24tZXZlbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saW1ibGUtdHJlZS9zcmMvbGliL2V2ZW50cy9nZW5lcmFsL2Rlc3RydWN0aW9uLWV2ZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sT0FBTyxnQkFBZ0I7SUFHMUIsWUFBbUIsTUFBb0I7UUFDcEMsSUFBSSxDQUFDLE9BQU8sR0FBRyxNQUFNLENBQUM7SUFDekIsQ0FBQztJQUVNLElBQUk7UUFDUixPQUFPLGFBQWEsQ0FBQztJQUN4QixDQUFDO0lBRU0sTUFBTTtRQUNWLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQztJQUN2QixDQUFDO0NBQ0giLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFdmVudENvbmR1aXQgfSBmcm9tIFwiLi4vLi4vc3RydWN0dXJlL2V2ZW50LWNvbmR1aXQuaW50ZXJmYWNlXCI7XG5pbXBvcnQgeyBUcmVlRXZlbnQgfSBmcm9tIFwiLi4vLi4vc3RydWN0dXJlL3RyZWUtZXZlbnQuaW50ZXJmYWNlXCI7XG5cbmV4cG9ydCBjbGFzcyBEZXN0cnVjdGlvbkV2ZW50IGltcGxlbWVudHMgVHJlZUV2ZW50IHtcbiAgIHByaXZhdGUgcmVhZG9ubHkgX3NvdXJjZTogRXZlbnRDb25kdWl0O1xuXG4gICBwdWJsaWMgY29uc3RydWN0b3Ioc291cmNlOiBFdmVudENvbmR1aXQpIHtcbiAgICAgIHRoaXMuX3NvdXJjZSA9IHNvdXJjZTtcbiAgIH1cblxuICAgcHVibGljIHR5cGUoKTogXCJkZXN0cnVjdGlvblwiIHtcbiAgICAgIHJldHVybiBcImRlc3RydWN0aW9uXCI7XG4gICB9XG5cbiAgIHB1YmxpYyBzb3VyY2UoKTogRXZlbnRDb25kdWl0IHtcbiAgICAgIHJldHVybiB0aGlzLl9zb3VyY2U7XG4gICB9XG59XG4iXX0=

package/esm2020/lib/events/general/index.mjs

@@ -0,0 +1,2 @@
+export * from "./destruction-event";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saW1ibGUtdHJlZS9zcmMvbGliL2V2ZW50cy9nZW5lcmFsL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUJBQXFCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9kZXN0cnVjdGlvbi1ldmVudFwiO1xuIl19