@limble/limble-tree 2.0.0 → 4.0.0

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

@@ -0,0 +1,176 @@
+import { assert } from "../../../shared";
+import { BranchComponent } from "../../components";
+import { dragState, DragStates } from "./drag-state";
+import { dragAndDrop } from "./drag-and-drop";
+import { TreeBranch, TreeRoot, config } from "../../core";
+import { filter, first } from "rxjs";
+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 !== undefined);
+                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\";\nimport { BranchComponent, type DropzoneComponent } from \"../../components\";\nimport { dragState, DragStates } from \"./drag-state\";\nimport { dragAndDrop } from \"./drag-and-drop\";\nimport { TreeBranch, type TreeNode, TreeRoot, config } from \"../../core\";\nimport { filter, first } from \"rxjs\";\nimport { PruneEvent } from \"../../events\";\n\nclass DropzoneRenderer {\n   private currentDisplay: {\n      treeBranch: TreeNode<any>;\n      direction: \"upper\" | \"lower\";\n   } | null;\n   private readonly registry: Map<DropzoneComponent, TreeNode<any>>;\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(final !== undefined);\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: TreeNode<any>): void {\n      const nodes: Array<TreeNode<any>> = [];\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: TreeNode<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   ): [TreeNode<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: TreeNode<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: TreeNode<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: TreeNode<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>(treeNode: TreeNode<T>): void {\n      let cursor: TreeNode<T> | 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<T>(treeNode: TreeNode<T>): 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: TreeNode<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/esm2022/lib/legacy/legacy-tree.mjs

@@ -0,0 +1,73 @@
+import { TreeRoot, config } from "../core";
+import { TreeError } from "../errors";
+import { treeCollapser } from "../extras/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGVnYWN5LXRyZWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saW1ibGUtdHJlZS9zcmMvbGliL2xlZ2FjeS9sZWdhY3ktdHJlZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsUUFBUSxFQUFxQyxNQUFNLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFNOUUsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUN0QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFbkQ7OztHQUdHO0FBQ0gsTUFBTSxPQUFPLFVBQVU7SUFDcEIsNEVBQTRFO0lBQ3JFLHlCQUF5QixDQUM3QixTQUEyQixFQUMzQixJQUFvQixFQUNwQixjQUF1QyxFQUFFO1FBRXpDLE1BQU0sSUFBSSxHQUFHLElBQUksUUFBUSxDQUFZLFNBQVMsQ0FBQyxDQUFDO1FBQ2hELE1BQU0sQ0FBQyxTQUFTLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxjQUFjLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQztRQUN6RCxLQUFLLE1BQU0sSUFBSSxJQUFJLElBQUksRUFBRSxDQUFDO1lBQ3ZCLElBQUksQ0FBQyxjQUFjLENBQUMsSUFBSSxFQUFFLElBQUksRUFBRSxXQUFXLENBQUMsQ0FBQztRQUNoRCxDQUFDO1FBQ0QsT0FBTyxJQUFJLENBQUM7SUFDZixDQUFDO0lBRU0sY0FBYyxDQUFDLGFBQXNDO1FBQ3pELE9BQU87WUFDSixXQUFXLEVBQUUsYUFBYSxDQUFDLE1BQU07WUFDakMsV0FBVyxFQUFFO2dCQUNWLFlBQVksRUFBRSxDQUFDLE1BQU0sRUFBVyxFQUFFO29CQUMvQixJQUFJLGFBQWEsQ0FBQyxRQUFRLEtBQUssSUFBSSxFQUFFLENBQUM7d0JBQ25DLE9BQU8sS0FBSyxDQUFDO29CQUNoQixDQUFDO29CQUNELElBQUksYUFBYSxDQUFDLFlBQVksS0FBSyxTQUFTLEVBQUUsQ0FBQzt3QkFDNUMsT0FBTyxJQUFJLENBQUM7b0JBQ2YsQ0FBQztvQkFDRCxJQUFJLE9BQU8sYUFBYSxDQUFDLFlBQVksS0FBSyxTQUFTLEVBQUUsQ0FBQzt3QkFDbkQsT0FBTyxhQUFhLENBQUMsWUFBWSxDQUFDO29CQUNyQyxDQUFDO29CQUNELE9BQU8sYUFBYSxDQUFDLFlBQVksQ0FBQyxNQUFhLENBQUMsQ0FBQztnQkFDcEQsQ0FBQztnQkFDRCxhQUFhLEVBQUUsQ0FBQyxNQUFNLEVBQVcsRUFBRTtvQkFDaEMsSUFBSSxhQUFhLENBQUMsYUFBYSxLQUFLLFNBQVMsRUFBRSxDQUFDO3dCQUM3QyxPQUFPLElBQUksQ0FBQztvQkFDZixDQUFDO29CQUNELElBQUksT0FBTyxhQUFhLENBQUMsYUFBYSxLQUFLLFNBQVMsRUFBRSxDQUFDO3dCQUNwRCxPQUFPLGFBQWEsQ0FBQyxhQUFhLENBQUM7b0JBQ3RDLENBQUM7b0JBQ0QsT0FBTyxhQUFhLENBQUMsYUFBYSxDQUFDLE1BQWEsQ0FBQyxDQUFDO2dCQUNyRCxDQUFDO2dCQUNELFNBQVMsRUFBRSxDQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFXLEVBQUU7b0JBQzNDLElBQUksYUFBYSxDQUFDLFNBQVMsS0FBSyxTQUFTLEVBQUUsQ0FBQzt3QkFDekMsT0FBTyxJQUFJLENBQUM7b0JBQ2YsQ0FBQztvQkFDRCxPQUFPLGFBQWEsQ0FBQyxTQUFTLENBQzNCLE1BQWEsRUFDYixNQUFhLEVBQ2IsS0FBSyxDQUNQLENBQUM7Z0JBQ0wsQ0FBQzthQUNIO1NBQ0gsQ0FBQztJQUNMLENBQUM7SUFFTyxjQUFjLENBQ25CLE1BQW1DLEVBQ25DLElBQW9CLEVBQ3BCLE9BQWdDO1FBRWhDLE1BQU0sU0FBUyxHQUNaLElBQUksQ0FBQyxTQUFTLEVBQUUsS0FBSyxJQUFJLE9BQU8sQ0FBQyxnQkFBZ0IsRUFBRSxLQUFLLENBQUM7UUFDNUQsSUFBSSxTQUFTLEtBQUssU0FBUyxFQUFFLENBQUM7WUFDM0IsTUFBTSxJQUFJLFNBQVMsQ0FBQyw4QkFBOEIsQ0FBQyxDQUFDO1FBQ3ZELENBQUM7UUFDRCxNQUFNLFFBQVEsR0FBRyxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsUUFBUTtZQUN2QyxPQUFPLENBQUMsZ0JBQWdCLEVBQUUsUUFBUTtZQUNsQyxFQUFFLENBQTBDLENBQUM7UUFDaEQsTUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDO1FBQ3RCLE1BQU0sTUFBTSxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsU0FBb0IsRUFBRTtZQUM5QyxhQUFhLEVBQUUsUUFBUTtZQUN2QixJQUFJLEVBQUUsRUFBRSxRQUFRLEVBQUU7U0FDcEIsQ0FBQyxDQUFDO1FBQ0gsS0FBSyxNQUFNLFNBQVMsSUFBSSxJQUFJLENBQUMsS0FBSyxJQUFJLEVBQUUsRUFBRSxDQUFDO1lBQ3hDLElBQUksQ0FBQyxjQUFjLENBQUMsTUFBTSxFQUFFLFNBQVMsRUFBRSxPQUFPLENBQUMsQ0FBQztRQUNuRCxDQUFDO1FBQ0QsSUFBSSxJQUFJLENBQUMsU0FBUyxLQUFLLElBQUksRUFBRSxDQUFDO1lBQzNCLGFBQWEsQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDbEMsQ0FBQztJQUNKLENBQUM7Q0FDSCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgVHlwZSwgVmlld0NvbnRhaW5lclJlZiB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5pbXBvcnQgeyBUcmVlUm9vdCwgdHlwZSBUcmVlQnJhbmNoLCB0eXBlIFRyZWVPcHRpb25zLCBjb25maWcgfSBmcm9tIFwiLi4vY29yZVwiO1xuaW1wb3J0IHR5cGUgeyBMaW1ibGVUcmVlT3B0aW9ucyBhcyBMZWdhY3lMaW1ibGVUcmVlT3B0aW9ucyB9IGZyb20gXCIuL2xlZ2FjeS10cmVlLW9wdGlvbnMuaW50ZXJmYWNlXCI7XG5pbXBvcnQgdHlwZSB7XG4gICBMaW1ibGVUcmVlRGF0YSxcbiAgIExpbWJsZVRyZWVOb2RlXG59IGZyb20gXCIuL2xlZ2FjeS10cmVlLWRhdGEuaW50ZXJmYWNlXCI7XG5pbXBvcnQgeyBUcmVlRXJyb3IgfSBmcm9tIFwiLi4vZXJyb3JzXCI7XG5pbXBvcnQgeyB0cmVlQ29sbGFwc2VyIH0gZnJvbSBcIi4uL2V4dHJhcy9jb2xsYXBzZVwiO1xuXG4vKipcbiAqIEEgc2hpbSB0byBoZWxwIHdpdGggdGhlIHRyYW5zaXRpb24gZnJvbSB2MCB0byB2MS5cbiAqIEBkZXByZWNhdGVkXG4gKi9cbmV4cG9ydCBjbGFzcyBMZWdhY3lUcmVlIHtcbiAgIC8qKiBDcmVhdGVzIGEgdjEgdHJlZSBzdHJ1Y3R1cmUgZnJvbSBhIHYwIGRhdGEgYXJyYXkgYW5kIHYwIHRyZWUgb3B0aW9ucy4gKi9cbiAgIHB1YmxpYyBjcmVhdGVUcmVlRnJvbUxlZ2FjeUFycmF5PENvbXBvbmVudD4oXG4gICAgICBjb250YWluZXI6IFZpZXdDb250YWluZXJSZWYsXG4gICAgICBkYXRhOiBMaW1ibGVUcmVlRGF0YSxcbiAgICAgIHRyZWVPcHRpb25zOiBMZWdhY3lMaW1ibGVUcmVlT3B0aW9ucyA9IHt9XG4gICApOiBUcmVlUm9vdDxDb21wb25lbnQ+IHtcbiAgICAgIGNvbnN0IHJvb3QgPSBuZXcgVHJlZVJvb3Q8Q29tcG9uZW50Pihjb250YWluZXIpO1xuICAgICAgY29uZmlnLnNldENvbmZpZyhyb290LCB0aGlzLnVwZ3JhZGVPcHRpb25zKHRyZWVPcHRpb25zKSk7XG4gICAgICBmb3IgKGNvbnN0IG5vZGUgb2YgZGF0YSkge1xuICAgICAgICAgdGhpcy5yZW5kZXJUcmVlTm9kZShyb290LCBub2RlLCB0cmVlT3B0aW9ucyk7XG4gICAgICB9XG4gICAgICByZXR1cm4gcm9vdDtcbiAgIH1cblxuICAgcHVibGljIHVwZ3JhZGVPcHRpb25zKGxlZ2FjeU9wdGlvbnM6IExlZ2FjeUxpbWJsZVRyZWVPcHRpb25zKTogVHJlZU9wdGlvbnMge1xuICAgICAgcmV0dXJuIHtcbiAgICAgICAgIGluZGVudGF0aW9uOiBsZWdhY3lPcHRpb25zLmluZGVudCxcbiAgICAgICAgIGRyYWdBbmREcm9wOiB7XG4gICAgICAgICAgICBhbGxvd05lc3Rpbmc6IChicmFuY2gpOiBib29sZWFuID0+IHtcbiAgICAgICAgICAgICAgIGlmIChsZWdhY3lPcHRpb25zLmxpc3RNb2RlID09PSB0cnVlKSB7XG4gICAgICAgICAgICAgICAgICByZXR1cm4gZmFsc2U7XG4gICAgICAgICAgICAgICB9XG4gICAgICAgICAgICAgICBpZiAobGVnYWN5T3B0aW9ucy5hbGxvd05lc3RpbmcgPT09IHVuZGVmaW5lZCkge1xuICAgICAgICAgICAgICAgICAgcmV0dXJuIHRydWU7XG4gICAgICAgICAgICAgICB9XG4gICAgICAgICAgICAgICBpZiAodHlwZW9mIGxlZ2FjeU9wdGlvbnMuYWxsb3dOZXN0aW5nID09PSBcImJvb2xlYW5cIikge1xuICAgICAgICAgICAgICAgICAgcmV0dXJuIGxlZ2FjeU9wdGlvbnMuYWxsb3dOZXN0aW5nO1xuICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgICAgcmV0dXJuIGxlZ2FjeU9wdGlvbnMuYWxsb3dOZXN0aW5nKGJyYW5jaCBhcyBhbnkpO1xuICAgICAgICAgICAgfSxcbiAgICAgICAgICAgIGFsbG93RHJhZ2dpbmc6IChicmFuY2gpOiBib29sZWFuID0+IHtcbiAgICAgICAgICAgICAgIGlmIChsZWdhY3lPcHRpb25zLmFsbG93RHJhZ2dpbmcgPT09IHVuZGVmaW5lZCkge1xuICAgICAgICAgICAgICAgICAgcmV0dXJuIHRydWU7XG4gICAgICAgICAgICAgICB9XG4gICAgICAgICAgICAgICBpZiAodHlwZW9mIGxlZ2FjeU9wdGlvbnMuYWxsb3dEcmFnZ2luZyA9PT0gXCJib29sZWFuXCIpIHtcbiAgICAgICAgICAgICAgICAgIHJldHVybiBsZWdhY3lPcHRpb25zLmFsbG93RHJhZ2dpbmc7XG4gICAgICAgICAgICAgICB9XG4gICAgICAgICAgICAgICByZXR1cm4gbGVnYWN5T3B0aW9ucy5hbGxvd0RyYWdnaW5nKGJyYW5jaCBhcyBhbnkpO1xuICAgICAgICAgICAgfSxcbiAgICAgICAgICAgIGFsbG93RHJvcDogKHNvdXJjZSwgcGFyZW50LCBpbmRleCk6IGJvb2xlYW4gPT4ge1xuICAgICAgICAgICAgICAgaWYgKGxlZ2FjeU9wdGlvbnMuYWxsb3dEcm9wID09PSB1bmRlZmluZWQpIHtcbiAgICAgICAgICAgICAgICAgIHJldHVybiB0cnVlO1xuICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgICAgcmV0dXJuIGxlZ2FjeU9wdGlvbnMuYWxsb3dEcm9wKFxuICAgICAgICAgICAgICAgICAgc291cmNlIGFzIGFueSxcbiAgICAgICAgICAgICAgICAgIHBhcmVudCBhcyBhbnksXG4gICAgICAgICAgICAgICAgICBpbmRleFxuICAgICAgICAgICAgICAgKTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgIH1cbiAgICAgIH07XG4gICB9XG5cbiAgIHByaXZhdGUgcmVuZGVyVHJlZU5vZGU8VD4oXG4gICAgICBwYXJlbnQ6IFRyZWVSb290PFQ+IHwgVHJlZUJyYW5jaDxUPixcbiAgICAgIG5vZGU6IExpbWJsZVRyZWVOb2RlLFxuICAgICAgb3B0aW9uczogTGVnYWN5TGltYmxlVHJlZU9wdGlvbnNcbiAgICk6IHZvaWQge1xuICAgICAgY29uc3QgY29tcG9uZW50ID1cbiAgICAgICAgIG5vZGUuY29tcG9uZW50Py5jbGFzcyA/PyBvcHRpb25zLmRlZmF1bHRDb21wb25lbnQ/LmNsYXNzO1xuICAgICAgaWYgKGNvbXBvbmVudCA9PT0gdW5kZWZpbmVkKSB7XG4gICAgICAgICB0aHJvdyBuZXcgVHJlZUVycm9yKFwiQSBjb21wb25lbnQgbXVzdCBiZSBwcm92aWRlZFwiKTtcbiAgICAgIH1cbiAgICAgIGNvbnN0IGJpbmRpbmdzID0gKG5vZGUuY29tcG9uZW50Py5iaW5kaW5ncyA/P1xuICAgICAgICAgb3B0aW9ucy5kZWZhdWx0Q29tcG9uZW50Py5iaW5kaW5ncyA/P1xuICAgICAgICAge30pIGFzIHsgW0sgaW4ga2V5b2YgVF0/OiBUW0tdIHwgdW5kZWZpbmVkIH07XG4gICAgICBjb25zdCBub2RlRGF0YSA9IG5vZGU7XG4gICAgICBjb25zdCBicmFuY2ggPSBwYXJlbnQuZ3Jvdyhjb21wb25lbnQgYXMgVHlwZTxUPiwge1xuICAgICAgICAgaW5wdXRCaW5kaW5nczogYmluZGluZ3MsXG4gICAgICAgICBtZXRhOiB7IG5vZGVEYXRhIH1cbiAgICAgIH0pO1xuICAgICAgZm9yIChjb25zdCBjaGlsZE5vZGUgb2Ygbm9kZS5ub2RlcyA/PyBbXSkge1xuICAgICAgICAgdGhpcy5yZW5kZXJUcmVlTm9kZShicmFuY2gsIGNoaWxkTm9kZSwgb3B0aW9ucyk7XG4gICAgICB9XG4gICAgICBpZiAobm9kZS5jb2xsYXBzZWQgPT09IHRydWUpIHtcbiAgICAgICAgIHRyZWVDb2xsYXBzZXIuY29sbGFwc2UoYnJhbmNoKTtcbiAgICAgIH1cbiAgIH1cbn1cbiJdfQ==

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

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

package/esm2022/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";
+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();
+    }
+    ngOnChanges() {
+        if (this.host !== undefined && this.data !== undefined) {
+            this.update();
+        }
+    }
+    ngAfterViewInit() {
+        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);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: LimbleTreeRootComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.0", 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: "17.3.0", ngImport: i0, type: LimbleTreeRootComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "limble-tree-root", standalone: true, template: "<div #host></div>\n" }]
+        }], ctorParameters: () => [], 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 → esm2022}/lib/limble-tree.module.mjs

@@ -9,11 +9,11 @@ import * as i0 from "@angular/core";
  * components, directives, and services provided by Limble Tree.
  */
 export class LimbleTreeModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: LimbleTreeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.0", ngImport: i0, type: LimbleTreeModule, imports: [LimbleTreeLegacyModule, TreeCollapseModule, TreeDragAndDropModule], exports: [LimbleTreeLegacyModule, TreeCollapseModule, TreeDragAndDropModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: LimbleTreeModule, providers: [TreeService], imports: [LimbleTreeLegacyModule, TreeCollapseModule, TreeDragAndDropModule, LimbleTreeLegacyModule, TreeCollapseModule, TreeDragAndDropModule] }); }
 }
-LimbleTreeModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LimbleTreeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-LimbleTreeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: LimbleTreeModule, imports: [LimbleTreeLegacyModule, TreeCollapseModule, TreeDragAndDropModule], exports: [LimbleTreeLegacyModule, TreeCollapseModule, TreeDragAndDropModule] });
-LimbleTreeModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LimbleTreeModule, providers: [TreeService], imports: [LimbleTreeLegacyModule, TreeCollapseModule, TreeDragAndDropModule, LimbleTreeLegacyModule, TreeCollapseModule, TreeDragAndDropModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LimbleTreeModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: LimbleTreeModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [],
@@ -22,4 +22,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
                     exports: [LimbleTreeLegacyModule, TreeCollapseModule, TreeDragAndDropModule]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/shared/assert.mjs

@@ -0,0 +1,7 @@
+export function assert(condition) {
+    if (condition) {
+        return;
+    }
+    throw new Error("Assertion Failed!");
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXNzZXJ0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvbGltYmxlLXRyZWUvc3JjL3NoYXJlZC9hc3NlcnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxVQUFVLE1BQU0sQ0FBQyxTQUFrQjtJQUN0QyxJQUFJLFNBQVMsRUFBRSxDQUFDO1FBQ2IsT0FBTztJQUNWLENBQUM7SUFDRCxNQUFNLElBQUksS0FBSyxDQUFDLG1CQUFtQixDQUFDLENBQUM7QUFDeEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBmdW5jdGlvbiBhc3NlcnQoY29uZGl0aW9uOiB1bmtub3duKTogYXNzZXJ0cyBjb25kaXRpb24ge1xuICAgaWYgKGNvbmRpdGlvbikge1xuICAgICAgcmV0dXJuO1xuICAgfVxuICAgdGhyb3cgbmV3IEVycm9yKFwiQXNzZXJ0aW9uIEZhaWxlZCFcIik7XG59XG4iXX0=