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

package/esm2020/lib/extras/drag-and-drop/dropzone-renderer.mjs

@@ -0,0 +1,178 @@
+import { assert } from "../../../shared/assert";
+import { BranchComponent } from "../../components/branch/branch.component";
+import { dragAndDrop } from "./drag-and-drop";
+import { TreeBranch } from "../../core/tree-branch/tree-branch";
+import { TreeRoot } from "../../core/tree-root/tree-root";
+import { dragState, DragStates } from "./drag-state";
+import { filter, first } from "rxjs";
+import { config } from "../../core/configuration/configuration";
+import { PruneEvent } from "../../events";
+class DropzoneRenderer {
+    constructor() {
+        this.registry = new Map();
+        this.currentDisplay = null;
+        dragAndDrop.dragAborted$.subscribe(() => {
+            this.clearCurrentDisplay();
+        });
+        dragState
+            .events()
+            .pipe(filter((event) => event === DragStates.Starting))
+            .subscribe(() => {
+            const branch = dragState.getDragData();
+            assert(branch !== undefined);
+            let cursor = branch.parent()?.getBranch((branch.index() ?? 0) - 1);
+            let final = branch.parent();
+            while (cursor !== undefined) {
+                final = cursor;
+                cursor = cursor.branches().at(-1);
+            }
+            branch
+                .events()
+                .pipe(filter((event) => event instanceof PruneEvent), first())
+                .subscribe(() => {
+                assert(final instanceof TreeBranch || final instanceof TreeRoot);
+                this.showLowerZones(final);
+            });
+        });
+    }
+    clearCurrentDisplay() {
+        if (this.currentDisplay === null)
+            return;
+        for (const branch of this.registry.values()) {
+            const instance = branch.getComponentInstance();
+            instance.showInnerDropzone = false;
+            if (instance instanceof BranchComponent) {
+                instance.showLateralDropzone = false;
+            }
+        }
+        this.currentDisplay = null;
+    }
+    clearTreeFromRegistry(tree) {
+        const nodes = [];
+        tree.traverse((node) => nodes.push(node));
+        for (const [dropzoneComponent, treeNode] of this.registry) {
+            if (nodes.includes(treeNode)) {
+                this.registry.delete(dropzoneComponent);
+            }
+        }
+    }
+    getCurrentDisplay() {
+        if (this.currentDisplay === null)
+            return null;
+        return { ...this.currentDisplay };
+    }
+    getDropzoneLocation(dropzone) {
+        const branch = this.registry.get(dropzone);
+        const placement = dropzone.placement;
+        if (branch === undefined) {
+            throw new Error("dropzone not found in registry");
+        }
+        if (placement === undefined) {
+            throw new Error("dropzone has an undefined placement");
+        }
+        return [branch, placement];
+    }
+    handleDrop(treeNode, placement) {
+        if (placement === "inner") {
+            dragAndDrop.drop(treeNode, 0);
+        }
+        else if (treeNode instanceof TreeBranch && placement === "lateral") {
+            const currentParent = treeNode.parent();
+            const index = treeNode.index();
+            if (currentParent === undefined || index === undefined) {
+                throw new Error("branch must have a parent");
+            }
+            dragAndDrop.drop(currentParent, index + 1);
+        }
+        this.clearCurrentDisplay();
+    }
+    registerDropzone(dropzone, treeNode) {
+        this.registry.set(dropzone, treeNode);
+    }
+    registerDropzones(dropzones, treeBranch) {
+        for (const dropzone of dropzones) {
+            this.registry.set(dropzone, treeBranch);
+        }
+    }
+    showLowerZones(treeNode) {
+        this.clearCurrentDisplay();
+        this.showInnerZone(treeNode);
+        if (treeNode.branches().length === 0) {
+            this.loopThroughLowerZones(treeNode);
+        }
+        this.currentDisplay = { treeBranch: treeNode, direction: "lower" };
+    }
+    showUpperZones(treeBranch) {
+        this.clearCurrentDisplay();
+        this.loopThroughUpperZones(treeBranch);
+        this.currentDisplay = { treeBranch, direction: "upper" };
+    }
+    loopThroughLowerZones(treeNode) {
+        let cursor = treeNode;
+        while (cursor instanceof TreeBranch) {
+            this.showLateralZone(cursor);
+            const parent = cursor.parent();
+            const index = cursor.index();
+            assert(parent !== undefined && index !== undefined);
+            if (parent.branches().length > index + 1) {
+                return;
+            }
+            cursor = cursor.parent();
+        }
+    }
+    loopThroughUpperZones(treeBranch) {
+        let cursor = treeBranch
+            .parent()
+            ?.getBranch((treeBranch.index() ?? 0) - 1);
+        let final = treeBranch.parent();
+        while (cursor !== undefined) {
+            this.showLateralZone(cursor);
+            final = cursor;
+            cursor = cursor.branches().at(-1);
+        }
+        if (final !== undefined &&
+            (final instanceof TreeRoot || final instanceof TreeBranch)) {
+            this.showInnerZone(final);
+        }
+    }
+    nestingAllowed(treeNode) {
+        if (treeNode instanceof TreeRoot) {
+            return true;
+        }
+        if (treeNode instanceof TreeBranch) {
+            const allowNesting = config.getConfig(treeNode.root())?.dragAndDrop?.allowNesting ??
+                (() => true);
+            return allowNesting(treeNode);
+        }
+        throw new Error("unsupported treeNode type");
+    }
+    dropAllowed(parent, index) {
+        const sourceNode = dragState.getDragData();
+        assert(sourceNode instanceof TreeBranch);
+        if (parent instanceof TreeRoot) {
+            const allowDrop = config.getConfig(parent)?.dragAndDrop?.allowDrop ??
+                (() => true);
+            return allowDrop(sourceNode, parent, index);
+        }
+        if (parent instanceof TreeBranch) {
+            const allowDrop = config.getConfig(parent.root())?.dragAndDrop?.allowDrop ??
+                (() => true);
+            return allowDrop(sourceNode, parent, index);
+        }
+        throw new Error("unsupported treeNode type");
+    }
+    showInnerZone(treeNode) {
+        if (!this.nestingAllowed(treeNode) || !this.dropAllowed(treeNode, 0))
+            return;
+        treeNode.getComponentInstance().showInnerDropzone = true;
+    }
+    showLateralZone(treeBranch) {
+        const index = treeBranch.index();
+        assert(index !== undefined);
+        if (!this.dropAllowed(treeBranch.parent(), index + 1))
+            return;
+        treeBranch.getComponentInstance().showLateralDropzone = true;
+    }
+}
+export const dropzoneRenderer = new DropzoneRenderer();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dropzone-renderer.js","sourceRoot":"","sources":["../../../../../../projects/limble-tree/src/lib/extras/drag-and-drop/dropzone-renderer.ts"],"names":[],"mappings":"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","sourcesContent":["import { assert } from \"../../../shared/assert\";\nimport { BranchComponent } from \"../../components/branch/branch.component\";\nimport { DropzoneComponent } from \"../../components/dropzone/dropzone.component\";\nimport { NodeComponent } from \"../../components/node-component.interface\";\nimport { dragAndDrop } from \"./drag-and-drop\";\nimport { TreeBranch } from \"../../core/tree-branch/tree-branch\";\nimport { TreeRoot } from \"../../core/tree-root/tree-root\";\nimport { dragState, DragStates } from \"./drag-state\";\nimport { filter, first } from \"rxjs\";\nimport { config } from \"../../core/configuration/configuration\";\nimport { PruneEvent } from \"../../events\";\nimport { TreeNode } from \"../../structure\";\n\nclass DropzoneRenderer {\n   private currentDisplay: {\n      treeBranch: TreeBranch<any> | TreeRoot<any>;\n      direction: \"upper\" | \"lower\";\n   } | null;\n   private readonly registry: Map<\n      DropzoneComponent,\n      TreeBranch<any> | TreeRoot<any>\n   >;\n\n   public constructor() {\n      this.registry = new Map();\n      this.currentDisplay = null;\n      dragAndDrop.dragAborted$.subscribe(() => {\n         this.clearCurrentDisplay();\n      });\n      dragState\n         .events()\n         .pipe(filter((event) => event === DragStates.Starting))\n         .subscribe(() => {\n            const branch = dragState.getDragData();\n            assert(branch !== undefined);\n            let cursor = branch.parent()?.getBranch((branch.index() ?? 0) - 1);\n            let final = branch.parent();\n            while (cursor !== undefined) {\n               final = cursor;\n               cursor = cursor.branches().at(-1);\n            }\n            branch\n               .events()\n               .pipe(\n                  filter((event) => event instanceof PruneEvent),\n                  first()\n               )\n               .subscribe(() => {\n                  assert(\n                     final instanceof TreeBranch || final instanceof TreeRoot\n                  );\n                  this.showLowerZones(final);\n               });\n         });\n   }\n\n   public clearCurrentDisplay(): void {\n      if (this.currentDisplay === null) return;\n      for (const branch of this.registry.values()) {\n         const instance = branch.getComponentInstance();\n         instance.showInnerDropzone = false;\n         if (instance instanceof BranchComponent) {\n            instance.showLateralDropzone = false;\n         }\n      }\n      this.currentDisplay = null;\n   }\n\n   public clearTreeFromRegistry(tree: TreeRoot<any> | TreeBranch<any>): void {\n      const nodes: Array<TreeNode<TreeBranch<any>, NodeComponent>> = [];\n      tree.traverse((node) => nodes.push(node));\n      for (const [dropzoneComponent, treeNode] of this.registry) {\n         if (nodes.includes(treeNode)) {\n            this.registry.delete(dropzoneComponent);\n         }\n      }\n   }\n\n   public getCurrentDisplay(): {\n      treeBranch: TreeBranch<any> | TreeRoot<any>;\n      direction: \"upper\" | \"lower\";\n   } | null {\n      if (this.currentDisplay === null) return null;\n      return { ...this.currentDisplay };\n   }\n\n   public getDropzoneLocation<T>(\n      dropzone: DropzoneComponent\n   ): [TreeBranch<T> | TreeRoot<T>, \"inner\" | \"lateral\"] {\n      const branch = this.registry.get(dropzone);\n      const placement = dropzone.placement;\n      if (branch === undefined) {\n         throw new Error(\"dropzone not found in registry\");\n      }\n      if (placement === undefined) {\n         throw new Error(\"dropzone has an undefined placement\");\n      }\n      return [branch, placement];\n   }\n\n   public handleDrop<T>(\n      treeNode: TreeBranch<T> | TreeRoot<T>,\n      placement: \"inner\" | \"lateral\"\n   ): void {\n      if (placement === \"inner\") {\n         dragAndDrop.drop(treeNode, 0);\n      } else if (treeNode instanceof TreeBranch && placement === \"lateral\") {\n         const currentParent = treeNode.parent();\n         const index = treeNode.index();\n         if (currentParent === undefined || index === undefined) {\n            throw new Error(\"branch must have a parent\");\n         }\n         dragAndDrop.drop(currentParent, index + 1);\n      }\n      this.clearCurrentDisplay();\n   }\n\n   public registerDropzone<T>(\n      dropzone: DropzoneComponent,\n      treeNode: TreeBranch<T> | TreeRoot<T>\n   ): void {\n      this.registry.set(dropzone, treeNode);\n   }\n\n   public registerDropzones<T>(\n      dropzones: Iterable<DropzoneComponent>,\n      treeBranch: TreeBranch<T>\n   ): void {\n      for (const dropzone of dropzones) {\n         this.registry.set(dropzone, treeBranch);\n      }\n   }\n\n   public showLowerZones<T>(treeNode: TreeBranch<T> | TreeRoot<T>): void {\n      this.clearCurrentDisplay();\n      this.showInnerZone(treeNode);\n      if (treeNode.branches().length === 0) {\n         this.loopThroughLowerZones(treeNode);\n      }\n      this.currentDisplay = { treeBranch: treeNode, direction: \"lower\" };\n   }\n\n   public showUpperZones<T>(treeBranch: TreeBranch<T>): void {\n      this.clearCurrentDisplay();\n      this.loopThroughUpperZones(treeBranch);\n      this.currentDisplay = { treeBranch, direction: \"upper\" };\n   }\n\n   private loopThroughLowerZones<T>(\n      treeNode: TreeBranch<T> | TreeRoot<T>\n   ): void {\n      let cursor: TreeNode<TreeBranch<T>, NodeComponent> | undefined = treeNode;\n      while (cursor instanceof TreeBranch) {\n         this.showLateralZone(cursor);\n         const parent = cursor.parent();\n         const index = cursor.index();\n         assert(parent !== undefined && index !== undefined);\n         if (parent.branches().length > index + 1) {\n            return;\n         }\n         cursor = cursor.parent();\n      }\n   }\n\n   private loopThroughUpperZones<T>(treeBranch: TreeBranch<T>): void {\n      let cursor = treeBranch\n         .parent()\n         ?.getBranch((treeBranch.index() ?? 0) - 1);\n      let final = treeBranch.parent();\n      while (cursor !== undefined) {\n         this.showLateralZone(cursor);\n         final = cursor;\n         cursor = cursor.branches().at(-1);\n      }\n      if (\n         final !== undefined &&\n         (final instanceof TreeRoot || final instanceof TreeBranch)\n      ) {\n         this.showInnerZone(final);\n      }\n   }\n\n   private nestingAllowed(treeNode: unknown): boolean {\n      if (treeNode instanceof TreeRoot) {\n         return true;\n      }\n      if (treeNode instanceof TreeBranch) {\n         const allowNesting =\n            config.getConfig(treeNode.root())?.dragAndDrop?.allowNesting ??\n            ((): true => true);\n         return allowNesting(treeNode);\n      }\n      throw new Error(\"unsupported treeNode type\");\n   }\n\n   private dropAllowed(parent: unknown, index: number): boolean {\n      const sourceNode = dragState.getDragData();\n      assert(sourceNode instanceof TreeBranch);\n      if (parent instanceof TreeRoot) {\n         const allowDrop =\n            config.getConfig(parent)?.dragAndDrop?.allowDrop ??\n            ((): true => true);\n         return allowDrop(sourceNode, parent, index);\n      }\n      if (parent instanceof TreeBranch) {\n         const allowDrop =\n            config.getConfig(parent.root())?.dragAndDrop?.allowDrop ??\n            ((): true => true);\n         return allowDrop(sourceNode, parent, index);\n      }\n      throw new Error(\"unsupported treeNode type\");\n   }\n\n   private showInnerZone<T>(treeNode: TreeBranch<T> | TreeRoot<T>): void {\n      if (!this.nestingAllowed(treeNode) || !this.dropAllowed(treeNode, 0))\n         return;\n      treeNode.getComponentInstance().showInnerDropzone = true;\n   }\n\n   private showLateralZone<T>(treeBranch: TreeBranch<T>): void {\n      const index = treeBranch.index();\n      assert(index !== undefined);\n      if (!this.dropAllowed(treeBranch.parent(), index + 1)) return;\n      treeBranch.getComponentInstance().showLateralDropzone = true;\n   }\n}\n\nexport const dropzoneRenderer = new DropzoneRenderer();\n"]}

package/esm2020/lib/extras/drag-and-drop/index.mjs

@@ -0,0 +1,5 @@
+export * from "./drag-and-drop.module";
+export * from "./drag-and-drop.service";
+export * from "./draggable.directive";
+export * from "./dragover-no-change-detect";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saW1ibGUtdHJlZS9zcmMvbGliL2V4dHJhcy9kcmFnLWFuZC1kcm9wL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsNkJBQTZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9kcmFnLWFuZC1kcm9wLm1vZHVsZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vZHJhZy1hbmQtZHJvcC5zZXJ2aWNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kcmFnZ2FibGUuZGlyZWN0aXZlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kcmFnb3Zlci1uby1jaGFuZ2UtZGV0ZWN0XCI7XG4iXX0=

package/esm2020/lib/legacy/index.mjs

@@ -0,0 +1,7 @@
+export * from "./legacy-component-obj.interface";
+export * from "./legacy-tree-data.interface";
+export * from "./legacy-tree-options.interface";
+export * from "./legacy-tree";
+export * from "./limble-tree-root/limble-tree-root.component";
+export * from "./limble-tree-legacy.module";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saW1ibGUtdHJlZS9zcmMvbGliL2xlZ2FjeS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLCtDQUErQyxDQUFDO0FBQzlELGNBQWMsNkJBQTZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9sZWdhY3ktY29tcG9uZW50LW9iai5pbnRlcmZhY2VcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2xlZ2FjeS10cmVlLWRhdGEuaW50ZXJmYWNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9sZWdhY3ktdHJlZS1vcHRpb25zLmludGVyZmFjZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGVnYWN5LXRyZWVcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2xpbWJsZS10cmVlLXJvb3QvbGltYmxlLXRyZWUtcm9vdC5jb21wb25lbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2xpbWJsZS10cmVlLWxlZ2FjeS5tb2R1bGVcIjtcbiJdfQ==

package/esm2020/lib/legacy/legacy-component-obj.interface.mjs

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

package/esm2020/lib/legacy/legacy-tree-data.interface.mjs

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

package/esm2020/lib/legacy/legacy-tree-options.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGVnYWN5LXRyZWUtb3B0aW9ucy5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saW1ibGUtdHJlZS9zcmMvbGliL2xlZ2FjeS9sZWdhY3ktdHJlZS1vcHRpb25zLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVHJlZUJyYW5jaCwgVHJlZVJvb3QgfSBmcm9tIFwiLi4vY29yZVwiO1xuaW1wb3J0IHsgQ29tcG9uZW50T2JqIH0gZnJvbSBcIi4vbGVnYWN5LWNvbXBvbmVudC1vYmouaW50ZXJmYWNlXCI7XG5cbi8qKlxuICogQSBncm91cCBvZiBzZXR0aW5ncyBmb3IgY2hhbmdpbmcgdGhlIGZ1bmN0aW9uYWxpdHkgb2YgdGhlIHRyZWVcbiAqIEBkZXByZWNhdGVkXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgTGltYmxlVHJlZU9wdGlvbnMge1xuICAgLyoqIFRoZSBjb21wb25lbnQgb2JqZWN0IHRvIHVzZSBpZiBvbmUgaXMgbm90IHNwZWNpZmllZCBmb3IgYSBwYXJ0aWN1bGFyIG5vZGUgKi9cbiAgIGRlZmF1bHRDb21wb25lbnQ/OiBDb21wb25lbnRPYmo7XG5cbiAgIC8qKiBUaGUgbnVtYmVyIG9mIHBpeGVscyB0byBpbmRlbnQgZWFjaCBsZXZlbCBvZiB0aGUgdHJlZS4gRGVmYXVsdHMgdG8gNDUgKi9cbiAgIGluZGVudD86IG51bWJlcjtcblxuICAgLyoqXG4gICAgKiBXaGV0aGVyIHRvIGFsbG93IFwibmVzdGluZ1wiIChwbGFjaW5nIGEgbm9kZSBvbmUgbGV2ZWwgZGVlcGVyIHRoYW4gY3VycmVudGx5IGV4aXN0cyBvbiB0aGUgYnJhbmNoKS5cbiAgICAqIFdoZW4gdGhpcyBpcyBhIGJvb2xlYW4sIGl0IGFwcGxpZXMgdG8gYWxsIG5vZGVzLiBXaGVuIHRoaXMgaXMgYSBmdW5jdGlvbiwgdGhlIG5vZGUgaW4gcXVlc3Rpb25cbiAgICAqIGlzIHBhc3NlZCBpbi4gRGVmYXVsdHMgdG8gdHJ1ZS5cbiAgICAqL1xuICAgYWxsb3dOZXN0aW5nPzogYm9vbGVhbiB8ICg8VD4odHJlZUJyYW5jaDogVHJlZUJyYW5jaDxUPikgPT4gYm9vbGVhbik7XG5cbiAgIC8qKlxuICAgICogV2hldGhlciB0byBhbGxvdyBhIG5vZGUgdG8gYmUgZHJhZ2dlZC4gV2hlbiB0aGlzIGlzIGEgYm9vbGVhbiwgaXQgYXBwbGllcyB0byBhbGwgbm9kZXMuIFdoZW4gdGhpc1xuICAgICogaXMgYSBmdW5jdGlvbiwgdGhlIG5vZGUgaW4gcXVlc3Rpb24gaXMgcGFzc2VkIGluLiBEZWZhdWx0cyB0byB0cnVlLlxuICAgICovXG4gICBhbGxvd0RyYWdnaW5nPzogYm9vbGVhbiB8ICg8VD4odHJlZUJyYW5jaDogVHJlZUJyYW5jaDxUPikgPT4gYm9vbGVhbik7XG5cbiAgIC8qKiBBIGNhbGxiYWNrIHRvIGRldGVybWluZSB3aGV0aGVyIGEgc291cmNlTm9kZSBjYW4gYmUgZHJvcHBlZCBhdCBhIHBhcnRpY3VsYXIgbG9jYXRpb24uICovXG4gICBhbGxvd0Ryb3A/OiA8VD4oXG4gICAgICBzb3VyY2VOb2RlOiBUcmVlQnJhbmNoPFQ+LFxuICAgICAgcHJvcG9zZWRQYXJlbnQ6IFRyZWVCcmFuY2g8VD4gfCBUcmVlUm9vdDxUPixcbiAgICAgIHByb3Bvc2VkSW5kZXg6IG51bWJlclxuICAgKSA9PiBib29sZWFuO1xuXG4gICAvKipcbiAgICAqIFdoZW4gc2V0IHRvIHRydWUsIGxpc3QgbW9kZSB3aWxsIGVuZm9yY2UgYSBmbGF0IHRyZWUgc3RydWN0dXJlLCBtZWFuaW5nIHRoZXJlXG4gICAgKiBjYW4gb25seSBiZSBvbmUgbGV2ZWwgb2YgdGhlIHRyZWUuIGBhbGxvd05lc3RpbmdgIGlzIGF1dG9tYXRpY2FsbHkgc2V0IHRvIGBmYWxzZWAuXG4gICAgKlxuICAgICogVGhpcyBtb2RlIGNhbiBiZSB1c2VkIHdoZW4gdGhlIHNhbWUgZHluYW1pYyBkcmFnIGFuZCBkcm9wIGZ1bmN0aW9uYWxpdHkgb2ZcbiAgICAqIHRoZSB0cmVlIGlzIGRlc2lyZWQsIGJ1dCB0aGUgdHJlZSBzdHJ1Y3R1cmUgaXRzZWxmIGlzIG5vdCBuZWNlc3NhcnkuIFRoaXNcbiAgICAqIGFsc28gb3BlbnMgdXAgdGhlIHBhZ2luYXRpb24gQVBJIG9uIHRoZSBsaW1ibGUtdHJlZS1yb290IGNvbXBvbmVudC5cbiAgICAqL1xuICAgbGlzdE1vZGU/OiBib29sZWFuO1xufVxuIl19

package/esm2020/lib/legacy/legacy-tree.mjs

@@ -0,0 +1,73 @@
+import { TreeRoot, config } from "../core";
+import { TreeError } from "../errors";
+import { treeCollapser } from "../extras/collapse/collapse";
+/**
+ * A shim to help with the transition from v0 to v1.
+ * @deprecated
+ */
+export class LegacyTree {
+    /** Creates a v1 tree structure from a v0 data array and v0 tree options. */
+    createTreeFromLegacyArray(container, data, treeOptions = {}) {
+        const root = new TreeRoot(container);
+        config.setConfig(root, this.upgradeOptions(treeOptions));
+        for (const node of data) {
+            this.renderTreeNode(root, node, treeOptions);
+        }
+        return root;
+    }
+    upgradeOptions(legacyOptions) {
+        return {
+            indentation: legacyOptions.indent,
+            dragAndDrop: {
+                allowNesting: (branch) => {
+                    if (legacyOptions.listMode === true) {
+                        return false;
+                    }
+                    if (legacyOptions.allowNesting === undefined) {
+                        return true;
+                    }
+                    if (typeof legacyOptions.allowNesting === "boolean") {
+                        return legacyOptions.allowNesting;
+                    }
+                    return legacyOptions.allowNesting(branch);
+                },
+                allowDragging: (branch) => {
+                    if (legacyOptions.allowDragging === undefined) {
+                        return true;
+                    }
+                    if (typeof legacyOptions.allowDragging === "boolean") {
+                        return legacyOptions.allowDragging;
+                    }
+                    return legacyOptions.allowDragging(branch);
+                },
+                allowDrop: (source, parent, index) => {
+                    if (legacyOptions.allowDrop === undefined) {
+                        return true;
+                    }
+                    return legacyOptions.allowDrop(source, parent, index);
+                }
+            }
+        };
+    }
+    renderTreeNode(parent, node, options) {
+        const component = node.component?.class ?? options.defaultComponent?.class;
+        if (component === undefined) {
+            throw new TreeError("A component must be provided");
+        }
+        const bindings = (node.component?.bindings ??
+            options.defaultComponent?.bindings ??
+            {});
+        const nodeData = node;
+        const branch = parent.grow(component, {
+            inputBindings: bindings,
+            meta: { nodeData }
+        });
+        for (const childNode of node.nodes ?? []) {
+            this.renderTreeNode(branch, childNode, options);
+        }
+        if (node.collapsed === true) {
+            treeCollapser.collapse(branch);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/legacy/limble-tree-legacy.module.mjs

@@ -0,0 +1,20 @@
+import { NgModule } from "@angular/core";
+import { LegacyTree } from "./legacy-tree";
+import { LimbleTreeRootComponent } from "./limble-tree-root/limble-tree-root.component";
+import * as i0 from "@angular/core";
+/** @deprecated */
+export class LimbleTreeLegacyModule {
+}
+LimbleTreeLegacyModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: LimbleTreeLegacyModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+LimbleTreeLegacyModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.12", ngImport: i0, type: LimbleTreeLegacyModule, imports: [LimbleTreeRootComponent], exports: [LimbleTreeRootComponent] });
+LimbleTreeLegacyModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: LimbleTreeLegacyModule, providers: [LegacyTree], imports: [LimbleTreeRootComponent] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: LimbleTreeLegacyModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [LimbleTreeRootComponent],
+                    providers: [LegacyTree],
+                    exports: [LimbleTreeRootComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGltYmxlLXRyZWUtbGVnYWN5Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2xpbWJsZS10cmVlL3NyYy9saWIvbGVnYWN5L2xpbWJsZS10cmVlLWxlZ2FjeS5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLCtDQUErQyxDQUFDOztBQUV4RixrQkFBa0I7QUFPbEIsTUFBTSxPQUFPLHNCQUFzQjs7b0hBQXRCLHNCQUFzQjtxSEFBdEIsc0JBQXNCLFlBSnRCLHVCQUF1QixhQUV2Qix1QkFBdUI7cUhBRXZCLHNCQUFzQixhQUhyQixDQUFDLFVBQVUsQ0FBQyxZQURiLHVCQUF1Qjs0RkFJdkIsc0JBQXNCO2tCQU5sQyxRQUFRO21CQUFDO29CQUNQLFlBQVksRUFBRSxFQUFFO29CQUNoQixPQUFPLEVBQUUsQ0FBQyx1QkFBdUIsQ0FBQztvQkFDbEMsU0FBUyxFQUFFLENBQUMsVUFBVSxDQUFDO29CQUN2QixPQUFPLEVBQUUsQ0FBQyx1QkFBdUIsQ0FBQztpQkFDcEMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5pbXBvcnQgeyBMZWdhY3lUcmVlIH0gZnJvbSBcIi4vbGVnYWN5LXRyZWVcIjtcbmltcG9ydCB7IExpbWJsZVRyZWVSb290Q29tcG9uZW50IH0gZnJvbSBcIi4vbGltYmxlLXRyZWUtcm9vdC9saW1ibGUtdHJlZS1yb290LmNvbXBvbmVudFwiO1xuXG4vKiogQGRlcHJlY2F0ZWQgKi9cbkBOZ01vZHVsZSh7XG4gICBkZWNsYXJhdGlvbnM6IFtdLFxuICAgaW1wb3J0czogW0xpbWJsZVRyZWVSb290Q29tcG9uZW50XSxcbiAgIHByb3ZpZGVyczogW0xlZ2FjeVRyZWVdLFxuICAgZXhwb3J0czogW0xpbWJsZVRyZWVSb290Q29tcG9uZW50XVxufSlcbmV4cG9ydCBjbGFzcyBMaW1ibGVUcmVlTGVnYWN5TW9kdWxlIHt9XG4iXX0=

package/esm2020/lib/legacy/limble-tree-root/limble-tree-root.component.mjs

@@ -0,0 +1,78 @@
+import { Component, EventEmitter, Input, Output, ViewChild, ViewContainerRef } from "@angular/core";
+import { LegacyTree } from "../legacy-tree";
+import { TreeError } from "../../errors";
+import { filter } from "rxjs";
+import { DragEndEvent } from "../../events";
+import { assert } from "../../../shared/assert";
+import * as i0 from "@angular/core";
+/** @deprecated */
+export class LimbleTreeRootComponent {
+    constructor() {
+        this.itemsPerPage = Infinity;
+        this.page = 1;
+        this.treeChange = new EventEmitter();
+        this.treeDrop = new EventEmitter();
+        this.legacyTree = new LegacyTree();
+    }
+    ngAfterViewInit() {
+        this.update();
+    }
+    ngOnChanges() {
+        if (this.host !== undefined && this.data !== undefined) {
+            this.update();
+        }
+    }
+    ngOnDestroy() {
+        this.dropSubscription?.unsubscribe();
+        this.root?.destroy();
+    }
+    getRoot() {
+        return this.root;
+    }
+    update() {
+        if (this.data === undefined) {
+            throw new TreeError("LimbleTreeRootComponent's `data` input is required");
+        }
+        if (this.host === undefined) {
+            throw new TreeError("LimbleTreeRootComponent's `host` property is not defined");
+        }
+        this.root?.destroy();
+        this.dropSubscription?.unsubscribe();
+        const dataSlice = this.paginatedData();
+        this.root = this.legacyTree.createTreeFromLegacyArray(this.host, dataSlice, this.options);
+        this.dropSubscription = this.root
+            .events()
+            .pipe(filter((event) => event instanceof DragEndEvent))
+            .subscribe(this.treeDrop);
+        this.treeChange.emit(this.root);
+    }
+    paginatedData() {
+        assert(this.data !== undefined);
+        if (this.options?.listMode !== true) {
+            return this.data;
+        }
+        return this.data.slice((this.page - 1) * this.itemsPerPage, this.page * this.itemsPerPage);
+    }
+}
+LimbleTreeRootComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: LimbleTreeRootComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+LimbleTreeRootComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: LimbleTreeRootComponent, isStandalone: true, selector: "limble-tree-root", inputs: { data: "data", options: "options", itemsPerPage: "itemsPerPage", page: "page" }, outputs: { treeChange: "treeChange", treeDrop: "treeDrop" }, viewQueries: [{ propertyName: "host", first: true, predicate: ["host"], descendants: true, read: ViewContainerRef }], usesOnChanges: true, ngImport: i0, template: "<div #host></div>\n" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: LimbleTreeRootComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "limble-tree-root", standalone: true, template: "<div #host></div>\n" }]
+        }], ctorParameters: function () { return []; }, propDecorators: { data: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], itemsPerPage: [{
+                type: Input
+            }], page: [{
+                type: Input
+            }], host: [{
+                type: ViewChild,
+                args: ["host", { read: ViewContainerRef }]
+            }], treeChange: [{
+                type: Output
+            }], treeDrop: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/limble-tree.module.mjs

@@ -1,47 +1,21 @@
-import { NgModule } from "@angular/core";
-import { ComponentCreatorService } from "./singletons/component-creator.service";
-import { DropZoneComponent } from "./drop-zone/drop-zone.component";
-import { LimbleTreeBranchComponent } from "./limble-tree-branch/limble-tree-branch.component";
-import { CommonModule } from "@angular/common";
-import { LimbleTreeNodeComponent } from "./limble-tree-node/limble-tree-node.component";
-import { DragStateService } from "./singletons/drag-state.service";
-import { LimbleTreeRootComponent } from "./limble-tree-root/limble-tree-root.component";
-import { LimbleTreePlaceholderComponent } from "./limble-tree-placeholder/limble-tree-placeholder.component";
-import { GlobalEventsService } from "./singletons/global-events.service";
-import { DragoverNoChangeDetectDirective } from "./custom-event-bindings/dragover-no-change-detect.directive";
-import { DragleaveNoChangeDetectDirective } from "./custom-event-bindings/dragleave-no-change-detect.directive";
-import * as i0 from "@angular/core";
-import * as i1 from "@angular/common";
-export class LimbleTreeModule {
-}
-LimbleTreeModule.ɵfac = function LimbleTreeModule_Factory(t) { return new (t || LimbleTreeModule)(); };
-LimbleTreeModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: LimbleTreeModule });
-LimbleTreeModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [ComponentCreatorService, DragStateService, GlobalEventsService], imports: [CommonModule] });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LimbleTreeModule, [{
-        type: NgModule,
-        args: [{
-                declarations: [
-                    LimbleTreeBranchComponent,
-                    DropZoneComponent,
-                    LimbleTreeNodeComponent,
-                    LimbleTreeRootComponent,
-                    LimbleTreePlaceholderComponent,
-                    DragoverNoChangeDetectDirective,
-                    DragleaveNoChangeDetectDirective
-                ],
-                imports: [CommonModule],
-                exports: [LimbleTreeRootComponent],
-                providers: [ComponentCreatorService, DragStateService, GlobalEventsService]
-            }]
-    }], null, null); })();
-(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(LimbleTreeModule, { declarations: [LimbleTreeBranchComponent,
-        DropZoneComponent,
-        LimbleTreeNodeComponent,
-        LimbleTreeRootComponent,
-        LimbleTreePlaceholderComponent,
-        DragoverNoChangeDetectDirective,
-        DragleaveNoChangeDetectDirective], imports: [CommonModule], exports: [LimbleTreeRootComponent] }); })();
-i0.ɵɵsetComponentScope(LimbleTreeNodeComponent, [i1.NgIf, LimbleTreeBranchComponent,
-    DropZoneComponent,
-    DragoverNoChangeDetectDirective], []);
-//# sourceMappingURL=data:application/json;base64,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
+import { NgModule } from "@angular/core";
+import { TreeCollapseModule } from "./extras/collapse";
+import { TreeDragAndDropModule } from "./extras/drag-and-drop";
+import { TreeService } from "./core/tree-service/tree.service";
+import { LimbleTreeLegacyModule } from "./legacy";
+import * as i0 from "@angular/core";
+export class LimbleTreeModule {
+}
+LimbleTreeModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: LimbleTreeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+LimbleTreeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.12", ngImport: i0, type: LimbleTreeModule, imports: [LimbleTreeLegacyModule, TreeCollapseModule, TreeDragAndDropModule], exports: [LimbleTreeLegacyModule, TreeCollapseModule, TreeDragAndDropModule] });
+LimbleTreeModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: LimbleTreeModule, providers: [TreeService], imports: [LimbleTreeLegacyModule, TreeCollapseModule, TreeDragAndDropModule, LimbleTreeLegacyModule, TreeCollapseModule, TreeDragAndDropModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: LimbleTreeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [LimbleTreeLegacyModule, TreeCollapseModule, TreeDragAndDropModule],
+                    providers: [TreeService],
+                    exports: [LimbleTreeLegacyModule, TreeCollapseModule, TreeDragAndDropModule]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGltYmxlLXRyZWUubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvbGltYmxlLXRyZWUvc3JjL2xpYi9saW1ibGUtdHJlZS5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUN2RCxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUMvRCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFDL0QsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sVUFBVSxDQUFDOztBQVFsRCxNQUFNLE9BQU8sZ0JBQWdCOzs4R0FBaEIsZ0JBQWdCOytHQUFoQixnQkFBZ0IsWUFKaEIsc0JBQXNCLEVBQUUsa0JBQWtCLEVBQUUscUJBQXFCLGFBRWpFLHNCQUFzQixFQUFFLGtCQUFrQixFQUFFLHFCQUFxQjsrR0FFakUsZ0JBQWdCLGFBSGYsQ0FBQyxXQUFXLENBQUMsWUFEZCxzQkFBc0IsRUFBRSxrQkFBa0IsRUFBRSxxQkFBcUIsRUFFakUsc0JBQXNCLEVBQUUsa0JBQWtCLEVBQUUscUJBQXFCOzRGQUVqRSxnQkFBZ0I7a0JBTjVCLFFBQVE7bUJBQUM7b0JBQ1AsWUFBWSxFQUFFLEVBQUU7b0JBQ2hCLE9BQU8sRUFBRSxDQUFDLHNCQUFzQixFQUFFLGtCQUFrQixFQUFFLHFCQUFxQixDQUFDO29CQUM1RSxTQUFTLEVBQUUsQ0FBQyxXQUFXLENBQUM7b0JBQ3hCLE9BQU8sRUFBRSxDQUFDLHNCQUFzQixFQUFFLGtCQUFrQixFQUFFLHFCQUFxQixDQUFDO2lCQUM5RSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcbmltcG9ydCB7IFRyZWVDb2xsYXBzZU1vZHVsZSB9IGZyb20gXCIuL2V4dHJhcy9jb2xsYXBzZVwiO1xuaW1wb3J0IHsgVHJlZURyYWdBbmREcm9wTW9kdWxlIH0gZnJvbSBcIi4vZXh0cmFzL2RyYWctYW5kLWRyb3BcIjtcbmltcG9ydCB7IFRyZWVTZXJ2aWNlIH0gZnJvbSBcIi4vY29yZS90cmVlLXNlcnZpY2UvdHJlZS5zZXJ2aWNlXCI7XG5pbXBvcnQgeyBMaW1ibGVUcmVlTGVnYWN5TW9kdWxlIH0gZnJvbSBcIi4vbGVnYWN5XCI7XG5cbkBOZ01vZHVsZSh7XG4gICBkZWNsYXJhdGlvbnM6IFtdLFxuICAgaW1wb3J0czogW0xpbWJsZVRyZWVMZWdhY3lNb2R1bGUsIFRyZWVDb2xsYXBzZU1vZHVsZSwgVHJlZURyYWdBbmREcm9wTW9kdWxlXSxcbiAgIHByb3ZpZGVyczogW1RyZWVTZXJ2aWNlXSxcbiAgIGV4cG9ydHM6IFtMaW1ibGVUcmVlTGVnYWN5TW9kdWxlLCBUcmVlQ29sbGFwc2VNb2R1bGUsIFRyZWVEcmFnQW5kRHJvcE1vZHVsZV1cbn0pXG5leHBvcnQgY2xhc3MgTGltYmxlVHJlZU1vZHVsZSB7fVxuIl19

package/esm2020/lib/structure/branchable.interface.mjs

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

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

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

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

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

package/esm2020/lib/structure/graftable.interface.mjs

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

package/esm2020/lib/structure/index.mjs

@@ -0,0 +1,10 @@
+export * from "./branchable.interface";
+export * from "./component-container.interface";
+export * from "./event-conduit.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";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saW1ibGUtdHJlZS9zcmMvbGliL3N0cnVjdHVyZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsK0JBQStCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9icmFuY2hhYmxlLmludGVyZmFjZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29tcG9uZW50LWNvbnRhaW5lci5pbnRlcmZhY2VcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2V2ZW50LWNvbmR1aXQuaW50ZXJmYWNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9ncmFmdGFibGUuaW50ZXJmYWNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90cmVlLWJyYW5jaC1ub2RlLmludGVyZmFjZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdHJlZS1ldmVudC5pbnRlcmZhY2VcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3RyZWUtbm9kZS5pbnRlcmZhY2VcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3RyZWUtcGxvdFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdHJlZS1yZWxhdGlvbnNoaXAuaW50ZXJmYWNlXCI7XG4iXX0=

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZS1icmFuY2gtbm9kZS5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saW1ibGUtdHJlZS9zcmMvbGliL3N0cnVjdHVyZS90cmVlLWJyYW5jaC1ub2RlLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgR3JhZnRhYmxlIH0gZnJvbSBcIi4vZ3JhZnRhYmxlLmludGVyZmFjZVwiO1xuaW1wb3J0IHsgVHJlZU5vZGUgfSBmcm9tIFwiLi90cmVlLW5vZGUuaW50ZXJmYWNlXCI7XG5cbmV4cG9ydCB0eXBlIFRyZWVCcmFuY2hOb2RlPENvbnRlbnRzLCBDaGlsZHJlbiwgUGFyZW50Q29udGVudHM+ID0gVHJlZU5vZGU8XG4gICBDaGlsZHJlbixcbiAgIENvbnRlbnRzXG4+ICZcbiAgIEdyYWZ0YWJsZTxUcmVlTm9kZTxDaGlsZHJlbiwgUGFyZW50Q29udGVudHM+PiAmIHtcbiAgICAgIHBvc2l0aW9uOiAoKSA9PiBBcnJheTxudW1iZXI+O1xuICAgfTtcbiJdfQ==

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

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

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZS1ub2RlLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2xpbWJsZS10cmVlL3NyYy9saWIvc3RydWN0dXJlL3RyZWUtbm9kZS5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJyYW5jaGFibGUgfSBmcm9tIFwiLi9icmFuY2hhYmxlLmludGVyZmFjZVwiO1xuaW1wb3J0IHsgRXZlbnRDb25kdWl0IH0gZnJvbSBcIi4vZXZlbnQtY29uZHVpdC5pbnRlcmZhY2VcIjtcbmltcG9ydCB7IFRyZWVQbG90IH0gZnJvbSBcIi4vdHJlZS1wbG90XCI7XG5pbXBvcnQgeyBUcmVlUm9vdCB9IGZyb20gXCIuLi9jb3JlXCI7XG5pbXBvcnQgeyBDb21wb25lbnRDb250YWluZXIgfSBmcm9tIFwiLi9jb21wb25lbnQtY29udGFpbmVyLmludGVyZmFjZVwiO1xuXG5leHBvcnQgaW50ZXJmYWNlIFRyZWVOb2RlPENoaWxkcmVuLCBDb21wb25lbnQ+XG4gICBleHRlbmRzIEV2ZW50Q29uZHVpdCxcbiAgICAgIEJyYW5jaGFibGU8Q2hpbGRyZW4+LFxuICAgICAgQ29tcG9uZW50Q29udGFpbmVyPENvbXBvbmVudD4ge1xuICAgcGxvdDogKCkgPT4gVHJlZVBsb3Q7XG4gICB0cmF2ZXJzZTogKGNhbGxiYWNrOiAobm9kZTogQnJhbmNoYWJsZTxDaGlsZHJlbj4pID0+IHZvaWQpID0+IHZvaWQ7XG4gICByb290OiAoKSA9PiBUcmVlUm9vdDxhbnk+IHwgdW5kZWZpbmVkO1xuICAgaXNEZXN0cm95ZWQ6ICgpID0+IGJvb2xlYW47XG59XG4iXX0=

package/esm2020/lib/structure/tree-plot.mjs

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

package/esm2020/lib/structure/tree-relationship.interface.mjs

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

package/esm2020/limble-limble-tree.mjs

@@ -1,5 +1,5 @@
-/**
- * Generated bundle index. Do not edit.
- */
-export * from './public-api';
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGltYmxlLWxpbWJsZS10cmVlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcHJvamVjdHMvbGltYmxlLXRyZWUvc3JjL2xpbWJsZS1saW1ibGUtdHJlZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19