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

package/fesm2020/limble-limble-tree.mjs

@@ -0,0 +1,1300 @@
+import * as i0 from '@angular/core';
+import { Injectable, NgModule, EventEmitter, Directive, Input, Output, Component, NgZone, ViewContainerRef, ViewChild, ViewChildren, createComponent, EnvironmentInjector, HostListener } from '@angular/core';
+import { BehaviorSubject, Subject, fromEvent, merge, map, filter, first } from 'rxjs';
+import * as i1 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import { throttleTime } from 'rxjs/operators';
+
+class TreeCollapser {
+    constructor() {
+        this.tempStorage = new Map();
+    }
+    collapse(treeBranch) {
+        if (treeBranch.branches().length === 0)
+            return;
+        const branches = [];
+        this.tempStorage.set(treeBranch, branches);
+        treeBranch.branches().forEach((branch) => {
+            branch.prune();
+            branches.push(branch);
+        });
+    }
+    expand(treeBranch) {
+        const branches = this.tempStorage.get(treeBranch);
+        if (branches === undefined)
+            return;
+        branches.forEach((branch) => {
+            branch.graftTo(treeBranch);
+        });
+        this.tempStorage.delete(treeBranch);
+        treeBranch.getContents().changeDetectorRef.detectChanges();
+    }
+    isCollapsed(treeBranch) {
+        return this.tempStorage.has(treeBranch);
+    }
+    storePrecollapsedNode(parent, branch) {
+        this.tempStorage.set(parent, (this.tempStorage.get(parent) ?? []).concat(branch));
+    }
+}
+const treeCollapser = new TreeCollapser();
+
+class TreeCollapseService {
+    collapse(treeBranch) {
+        treeCollapser.collapse(treeBranch);
+    }
+    expand(treeBranch) {
+        treeCollapser.expand(treeBranch);
+    }
+    isCollapsed(treeBranch) {
+        return treeCollapser.isCollapsed(treeBranch);
+    }
+}
+TreeCollapseService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: TreeCollapseService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TreeCollapseService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: TreeCollapseService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: TreeCollapseService, decorators: [{
+            type: Injectable
+        }] });
+
+class TreeCollapseModule {
+}
+TreeCollapseModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: TreeCollapseModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TreeCollapseModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.12", ngImport: i0, type: TreeCollapseModule });
+TreeCollapseModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: TreeCollapseModule, providers: [TreeCollapseService] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: TreeCollapseModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [TreeCollapseService]
+                }]
+        }] });
+
+class Configuration {
+    constructor() {
+        this.configStorage = new Map();
+        this.configStorage = new Map();
+    }
+    setConfig(root, options) {
+        this.configStorage.set(root, options);
+    }
+    getConfig(root) {
+        return this.configStorage.get(root);
+    }
+    delete(root) {
+        this.configStorage.delete(root);
+    }
+}
+const config = new Configuration();
+
+class TreeError extends Error {
+}
+
+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;
+    }
+}
+
+class DragStartEvent {
+    constructor(source) {
+        this._source = source;
+    }
+    type() {
+        return "drag start";
+    }
+    source() {
+        return this._source;
+    }
+}
+
+function assert(condition) {
+    if (condition) {
+        return;
+    }
+    throw new Error("Assertion Failed!");
+}
+
+var DragStates;
+(function (DragStates) {
+    DragStates[DragStates["Idle"] = 0] = "Idle";
+    DragStates[DragStates["Starting"] = 1] = "Starting";
+    DragStates[DragStates["Dragging"] = 2] = "Dragging";
+    DragStates[DragStates["Dropped"] = 3] = "Dropped";
+})(DragStates || (DragStates = {}));
+class DragState {
+    constructor() {
+        this._state = DragStates.Idle;
+        this.state$ = new BehaviorSubject(DragStates.Idle);
+        this.state$.subscribe((state) => {
+            this._state = state;
+        });
+        this.dragData = undefined;
+    }
+    getDragData() {
+        return this.dragData;
+    }
+    starting(treeBranch) {
+        assert(this._state === DragStates.Idle);
+        this.dragData = treeBranch;
+        this.state$.next(DragStates.Starting);
+    }
+    dragging() {
+        assert(this._state === DragStates.Starting);
+        this.state$.next(DragStates.Dragging);
+    }
+    dropped() {
+        assert(this._state === DragStates.Dragging);
+        this.state$.next(DragStates.Dropped);
+    }
+    restart() {
+        this.dragData = undefined;
+        this.state$.next(DragStates.Idle);
+    }
+    events() {
+        return this.state$;
+    }
+    state() {
+        return this._state;
+    }
+}
+const dragState = new DragState();
+
+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;
+    }
+}
+
+class DragAndDrop {
+    constructor() {
+        this.dragAborted$ = new Subject();
+    }
+    dragStart(treeBranch, event) {
+        if (!this.draggingAllowed(treeBranch)) {
+            event.preventDefault();
+            return;
+        }
+        treeBranch.dispatch(new DragStartEvent(treeBranch));
+        this.setDragEffects(treeBranch, event);
+        this.watchForDragend(treeBranch, event);
+        // We have to do a setTimeout because DOM changes are not allowed during a
+        // dragstart event.
+        setTimeout(() => {
+            dragState.starting(treeBranch);
+            treeBranch.prune();
+            dragState.dragging();
+        });
+    }
+    drop(parent, index) {
+        const treeBranch = dragState.getDragData();
+        if (treeBranch === undefined) {
+            throw new TreeError("Cannot get dragged branch");
+        }
+        this.graftDraggedBranch(treeBranch, parent, index);
+        treeBranch.dispatch(new DropEvent(treeBranch, parent, index));
+    }
+    getDragImageOffsets(event, element) {
+        const bounds = element.getBoundingClientRect();
+        const xOffset = event.clientX - bounds.left;
+        const yOffset = event.clientY - bounds.top;
+        return [xOffset, yOffset];
+    }
+    setDragEffects(treeBranch, event) {
+        const dataTransfer = event.dataTransfer;
+        if (!(dataTransfer instanceof DataTransfer)) {
+            throw new Error("bad drag event");
+        }
+        const nativeElement = treeBranch.getContents().location.nativeElement;
+        const [xOffset, yOffset] = this.getDragImageOffsets(event, nativeElement);
+        dataTransfer.setDragImage(nativeElement, xOffset, yOffset);
+    }
+    watchForDragend(treeBranch, event) {
+        const oldParent = treeBranch.parent();
+        const oldIndex = treeBranch.index();
+        if (oldParent === undefined || oldIndex === undefined) {
+            throw new Error("branch must have a parent");
+        }
+        event.target?.addEventListener("dragend", (dragend) => {
+            if (dragState.state() !== DragStates.Dropped) {
+                //The drag ended but a drop never occurred, so put the dragged branch back where it started.
+                this.dragAborted$.next(dragend);
+                this.graftDraggedBranch(treeBranch, oldParent, oldIndex);
+            }
+            dragState.restart();
+            const newParent = treeBranch.parent();
+            assert(newParent !== undefined);
+            const newIndex = treeBranch.index();
+            assert(newIndex !== undefined);
+            treeBranch.dispatch(new DragEndEvent(treeBranch, {
+                oldParent,
+                oldIndex,
+                newParent,
+                newIndex
+            }));
+        }, { once: true });
+    }
+    draggingAllowed(treeBranch) {
+        const allowDragging = config.getConfig(treeBranch.root())?.allowDragging ??
+            (() => true);
+        return allowDragging(treeBranch);
+    }
+    graftDraggedBranch(treeBranch, parent, index) {
+        treeBranch.graftTo(parent, index);
+        treeBranch.getContents().location.nativeElement.style.display = "block";
+        dragState.dropped();
+    }
+}
+const dragAndDrop = new DragAndDrop();
+
+class DragoverNoChangeDetectDirective {
+    constructor(ngZone, el) {
+        this.ngZone = ngZone;
+        this.el = el;
+        this.dragoverNoChangeDetect = new EventEmitter();
+        this.dragoverEventThrottle = 25;
+    }
+    ngOnInit() {
+        this.ngZone.runOutsideAngular(() => {
+            this.eventSubscription = fromEvent(this.el.nativeElement, "dragover")
+                .pipe(throttleTime(this.dragoverEventThrottle))
+                .subscribe(($event) => {
+                this.dragoverNoChangeDetect.emit($event);
+            });
+        });
+    }
+    ngOnDestroy() {
+        if (this.eventSubscription !== undefined) {
+            this.eventSubscription.unsubscribe();
+        }
+    }
+}
+DragoverNoChangeDetectDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DragoverNoChangeDetectDirective, deps: [{ token: i0.NgZone }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+DragoverNoChangeDetectDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.12", type: DragoverNoChangeDetectDirective, isStandalone: true, selector: "[dragoverNoChangeDetect]", inputs: { dragoverEventThrottle: "dragoverEventThrottle" }, outputs: { dragoverNoChangeDetect: "dragoverNoChangeDetect" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DragoverNoChangeDetectDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: "[dragoverNoChangeDetect]"
+                }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i0.ElementRef }]; }, propDecorators: { dragoverEventThrottle: [{
+                type: Input
+            }], dragoverNoChangeDetect: [{
+                type: Output
+            }] } });
+
+class DropzoneComponent {
+    constructor() {
+        this.dropped = new EventEmitter();
+        this.active = false;
+    }
+    dragenterHandler() {
+        this.active = true;
+    }
+    dragleaveHandler() {
+        this.active = false;
+    }
+    dragoverHandler(event) {
+        event.preventDefault();
+        event.dataTransfer.dropEffect = "move";
+    }
+    dropHandler(event) {
+        this.dropped.emit(event);
+    }
+}
+DropzoneComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DropzoneComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+DropzoneComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: DropzoneComponent, isStandalone: true, selector: "dropzone", inputs: { placement: "placement" }, outputs: { dropped: "dropped" }, ngImport: i0, template: "<div\n   class=\"dropzone\"\n   [ngClass]=\"{ active: active }\"\n   (dragenter)=\"dragenterHandler()\"\n   (dragleave)=\"dragleaveHandler()\"\n   (dragoverNoChangeDetect)=\"dragoverHandler($event)\"\n   (drop)=\"dropHandler($event)\"\n></div>\n", styles: [".dropzone{border-radius:8px;border:1px dashed #727374;background-color:#ededed;height:20px;margin:8px 0;transition:height .2s ease-out;animation:animation .2s ease-out}.dropzone.active{border-color:#289e49;border-width:2px;background-color:#d0e8d6;height:48px}@keyframes animation{0%{height:0px;opacity:0}to{height:20px;opacity:1}}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: DragoverNoChangeDetectDirective, selector: "[dragoverNoChangeDetect]", inputs: ["dragoverEventThrottle"], outputs: ["dragoverNoChangeDetect"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DropzoneComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: "dropzone", imports: [CommonModule, DragoverNoChangeDetectDirective], template: "<div\n   class=\"dropzone\"\n   [ngClass]=\"{ active: active }\"\n   (dragenter)=\"dragenterHandler()\"\n   (dragleave)=\"dragleaveHandler()\"\n   (dragoverNoChangeDetect)=\"dragoverHandler($event)\"\n   (drop)=\"dropHandler($event)\"\n></div>\n", styles: [".dropzone{border-radius:8px;border:1px dashed #727374;background-color:#ededed;height:20px;margin:8px 0;transition:height .2s ease-out;animation:animation .2s ease-out}.dropzone.active{border-color:#289e49;border-width:2px;background-color:#d0e8d6;height:48px}@keyframes animation{0%{height:0px;opacity:0}to{height:20px;opacity:1}}\n"] }]
+        }], propDecorators: { placement: [{
+                type: Input
+            }], dropped: [{
+                type: Output
+            }] } });
+
+class BranchComponent {
+    constructor(appRef) {
+        this.appRef = appRef;
+        this.branchesContainer = undefined;
+        this.contentContainer = undefined;
+        this.dropzones = undefined;
+        this.contentCreated = new EventEmitter();
+        this.showDropzones = new EventEmitter();
+        this.dropped = new EventEmitter();
+        this.showInnerDropzone = false;
+        this.showLateralDropzone = false;
+    }
+    ngAfterViewInit() {
+        if (this.contentContainer === undefined) {
+            throw new TreeError("Cannot get contentContainer");
+        }
+        if (this.contentToHost === undefined) {
+            throw new TreeError("'content' is a required input");
+        }
+        this.hostedContent = this.contentContainer.createComponent(this.contentToHost);
+        this.contentCreated.emit(this.hostedContent.instance);
+        if (this.dropzones === undefined) {
+            throw new Error("querylist not defined");
+        }
+        const inner = this.dropzones.get(0);
+        const lateral = this.dropzones.get(1);
+        if (inner === undefined || lateral == undefined) {
+            throw new Error("dropzones not defined");
+        }
+        merge(inner.dropped.pipe(map(() => "inner")), lateral.dropped.pipe(map(() => "lateral"))).subscribe(this.dropped);
+        this.hostedContent.changeDetectorRef.detectChanges();
+    }
+    getHostedContent() {
+        return this.hostedContent;
+    }
+    triggerChangeDetection() {
+        if (!NgZone.isInAngularZone()) {
+            this.appRef.tick();
+        }
+    }
+    dragoverHandler(event) {
+        const elementHeight = event.currentTarget.getBoundingClientRect().height;
+        if (event.offsetY < elementHeight / 2) {
+            this.showDropzones.emit("upper");
+        }
+        else {
+            this.showDropzones.emit("lower");
+        }
+    }
+    ngOnDestroy() {
+        //I'm not 100% sure why, but we have to remove any reference to the
+        //componentRef otherwise Angular will never release it for garbage
+        //collection.
+        this.hostedContent = undefined;
+    }
+}
+BranchComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: BranchComponent, deps: [{ token: i0.ApplicationRef }], target: i0.ɵɵFactoryTarget.Component });
+BranchComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: BranchComponent, isStandalone: true, selector: "branch", inputs: { contentToHost: "contentToHost" }, outputs: { contentCreated: "contentCreated", showDropzones: "showDropzones", dropped: "dropped" }, viewQueries: [{ propertyName: "branchesContainer", first: true, predicate: ["branchesContainer"], descendants: true, read: ViewContainerRef }, { propertyName: "contentContainer", first: true, predicate: ["contentContainer"], descendants: true, read: ViewContainerRef }, { propertyName: "dropzones", predicate: DropzoneComponent, descendants: true }], ngImport: i0, template: "<div class=\"content\" (dragoverNoChangeDetect)=\"dragoverHandler($event)\">\n   <div #contentContainer></div>\n</div>\n<div class=\"branches-container\">\n   <dropzone placement=\"inner\" [hidden]=\"!showInnerDropzone\"></dropzone>\n   <div #branchesContainer></div>\n</div>\n<dropzone placement=\"lateral\" [hidden]=\"!showLateralDropzone\"></dropzone>\n", styles: [".branches-container{margin-left:16px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: DropzoneComponent, selector: "dropzone", inputs: ["placement"], outputs: ["dropped"] }, { kind: "directive", type: DragoverNoChangeDetectDirective, selector: "[dragoverNoChangeDetect]", inputs: ["dragoverEventThrottle"], outputs: ["dragoverNoChangeDetect"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: BranchComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: "branch", imports: [CommonModule, DropzoneComponent, DragoverNoChangeDetectDirective], template: "<div class=\"content\" (dragoverNoChangeDetect)=\"dragoverHandler($event)\">\n   <div #contentContainer></div>\n</div>\n<div class=\"branches-container\">\n   <dropzone placement=\"inner\" [hidden]=\"!showInnerDropzone\"></dropzone>\n   <div #branchesContainer></div>\n</div>\n<dropzone placement=\"lateral\" [hidden]=\"!showLateralDropzone\"></dropzone>\n", styles: [".branches-container{margin-left:16px}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ApplicationRef }]; }, propDecorators: { branchesContainer: [{
+                type: ViewChild,
+                args: ["branchesContainer", { read: ViewContainerRef }]
+            }], contentContainer: [{
+                type: ViewChild,
+                args: ["contentContainer", { read: ViewContainerRef }]
+            }], dropzones: [{
+                type: ViewChildren,
+                args: [DropzoneComponent]
+            }], contentToHost: [{
+                type: Input
+            }], contentCreated: [{
+                type: Output
+            }], showDropzones: [{
+                type: Output
+            }], dropped: [{
+                type: Output
+            }] } });
+
+class GraftEvent {
+    constructor(source, relationship) {
+        this._source = source;
+        this._child = relationship.child;
+        this._parent = relationship.parent;
+        this._index = relationship.index;
+    }
+    child() {
+        return this._child;
+    }
+    type() {
+        return "graft";
+    }
+    index() {
+        return this._index;
+    }
+    parent() {
+        return this._parent;
+    }
+    source() {
+        return this._source;
+    }
+}
+
+class PruneEvent {
+    constructor(source, relationship) {
+        this._source = source;
+        this._child = relationship.child;
+        this._parent = relationship.parent;
+        this._index = relationship.index;
+    }
+    child() {
+        return this._child;
+    }
+    type() {
+        return "prune";
+    }
+    index() {
+        return this._index;
+    }
+    parent() {
+        return this._parent;
+    }
+    source() {
+        return this._source;
+    }
+}
+
+class TreeNodeBase {
+    constructor() {
+        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];
+    }
+    deleteBranch(index) {
+        if (index === undefined) {
+            this._branches.pop();
+            return;
+        }
+        this._branches.splice(index, 1);
+    }
+    destroy() {
+        this.subscriptions.forEach((sub) => {
+            sub.unsubscribe();
+        });
+    }
+    dispatch(event) {
+        this.events$.next(event);
+    }
+    events() {
+        return this.events$;
+    }
+    getBranch(index) {
+        return this._branches[index];
+    }
+    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.deleteBranch(index);
+    }
+    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);
+    }
+}
+
+class RootComponent {
+    constructor() {
+        this.branchesContainer = undefined;
+        this.dropzone = undefined;
+        this.afterViewInit = new EventEmitter();
+        this.dropped = new EventEmitter();
+        this.showInnerDropzone = false;
+    }
+    ngAfterViewInit() {
+        this.afterViewInit.emit();
+        if (this.dropzone === undefined) {
+            throw new Error("dropzone is not defined");
+        }
+        this.dropzone.dropped.subscribe(this.dropped);
+    }
+}
+RootComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: RootComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+RootComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: RootComponent, isStandalone: true, selector: "root", outputs: { afterViewInit: "afterViewInit", dropped: "dropped" }, viewQueries: [{ propertyName: "branchesContainer", first: true, predicate: ["branchesContainer"], descendants: true, read: ViewContainerRef }, { propertyName: "dropzone", first: true, predicate: DropzoneComponent, descendants: true }], ngImport: i0, template: "<div class=\"branches-container\">\n   <dropzone placement=\"inner\" [hidden]=\"!showInnerDropzone\"></dropzone>\n   <div #branchesContainer></div>\n</div>\n", styles: [".branches-container{min-width:64px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: DropzoneComponent, selector: "dropzone", inputs: ["placement"], outputs: ["dropped"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: RootComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: "root", imports: [CommonModule, DropzoneComponent], template: "<div class=\"branches-container\">\n   <dropzone placement=\"inner\" [hidden]=\"!showInnerDropzone\"></dropzone>\n   <div #branchesContainer></div>\n</div>\n", styles: [".branches-container{min-width:64px}\n"] }]
+        }], propDecorators: { branchesContainer: [{
+                type: ViewChild,
+                args: ["branchesContainer", { read: ViewContainerRef }]
+            }], dropzone: [{
+                type: ViewChild,
+                args: [DropzoneComponent]
+            }], afterViewInit: [{
+                type: Output
+            }], dropped: [{
+                type: Output
+            }] } });
+
+class TreeRoot {
+    constructor(viewContainerRef) {
+        this.viewContainerRef = viewContainerRef;
+        this.treeNodeBase = new TreeNodeBase();
+        this.rootComponentRef =
+            this.viewContainerRef.createComponent(RootComponent);
+        const viewInitSub = this.rootComponentRef.instance.afterViewInit.subscribe(() => {
+            const dropzone = this.rootComponentRef.instance.dropzone;
+            if (!dropzone) {
+                throw new Error("dropzone not defined");
+            }
+            dropzoneRenderer.registerDropzone(dropzone, this);
+        });
+        const droppedSub = this.rootComponentRef.instance.dropped.subscribe(() => {
+            dropzoneRenderer.handleDrop(this, "inner");
+        });
+        this.instanceSubscriptions = [viewInitSub, droppedSub];
+        this.rootComponentRef.changeDetectorRef.detectChanges();
+    }
+    branches() {
+        return this.treeNodeBase.branches();
+    }
+    deleteBranch(index) {
+        this.treeNodeBase.deleteBranch(index);
+    }
+    destroy() {
+        dropzoneRenderer.clearTreeFromRegistry(this);
+        this.branches().forEach((branch) => {
+            branch.destroy();
+        });
+        this.treeNodeBase.destroy();
+        this.instanceSubscriptions.forEach((sub) => {
+            sub.unsubscribe();
+        });
+        this.viewContainerRef.clear();
+        config.delete(this);
+    }
+    dispatch(event) {
+        this.treeNodeBase.dispatch(event);
+    }
+    events() {
+        return this.treeNodeBase.events();
+    }
+    getBranch(index) {
+        return this.treeNodeBase.getBranch(index);
+    }
+    getContents() {
+        return this.rootComponentRef;
+    }
+    grow(component, options) {
+        return new TreeBranch(this, { component, ...options });
+    }
+    plot() {
+        return this.treeNodeBase.plot();
+    }
+    root() {
+        return this;
+    }
+    traverse(callback) {
+        callback(this);
+        this.treeNodeBase.traverse(callback);
+    }
+}
+
+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" }]
+        }] });
+
+class TreeBranch {
+    constructor(parent, branchOptions) {
+        this.branchOptions = branchOptions;
+        this.detachedView = null;
+        this.treeNodeBase = new TreeNodeBase();
+        this.userlandComponent = this.branchOptions.component;
+        const parentBranchesContainer = parent.getContents().instance.branchesContainer;
+        assert(parentBranchesContainer !== undefined);
+        this.contents = createComponent(BranchComponent, {
+            environmentInjector: parentBranchesContainer.injector.get(EnvironmentInjector)
+        });
+        this.contents.instance.contentToHost = this.userlandComponent;
+        this.setIndentation(parent);
+        this.outputBindingSubscriptions = [];
+        this.instanceSubscriptions = this.getInstanceSubscriptions();
+        if (parent instanceof TreeBranch &&
+            parent.branchOptions.startCollapsed === true) {
+            treeCollapser.storePrecollapsedNode(parent, this);
+            this.detachedView = this.contents.hostView;
+        }
+        else {
+            parentBranchesContainer.insert(this.contents.hostView);
+            this.contents.changeDetectorRef.detectChanges();
+            this._parent = parent;
+            this.dispatch(new GraftEvent(this, {
+                parent: this._parent,
+                child: this,
+                index: this._parent.branches().length
+            }));
+        }
+    }
+    branches() {
+        return this.treeNodeBase.branches();
+    }
+    deleteBranch(index) {
+        this.treeNodeBase.deleteBranch(index);
+    }
+    destroy() {
+        if (treeCollapser.isCollapsed(this)) {
+            treeCollapser.expand(this);
+            dropzoneRenderer.clearTreeFromRegistry(this);
+        }
+        this.branches().forEach((branch) => {
+            branch.destroy();
+        });
+        const parent = this._parent;
+        const index = this.index();
+        if (index !== undefined && parent !== undefined) {
+            const container = parent.getContents().instance.branchesContainer;
+            assert(container !== undefined);
+            container.remove(index);
+            parent.deleteBranch(index);
+        }
+        this.treeNodeBase.destroy();
+        this.instanceSubscriptions.forEach((sub) => {
+            sub.unsubscribe();
+        });
+        this.outputBindingSubscriptions.forEach((sub) => {
+            sub.unsubscribe();
+        });
+    }
+    dispatch(event) {
+        this.treeNodeBase.dispatch(event);
+        this._parent?.dispatch(event);
+    }
+    events() {
+        return this.treeNodeBase.events();
+    }
+    getBranch(index) {
+        return this.treeNodeBase.getBranch(index);
+    }
+    getContents() {
+        return this.contents;
+    }
+    graftTo(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) {
+        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;
+    }
+    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() {
+        const parent = this._parent;
+        const index = this.index();
+        if (index === undefined || parent === undefined)
+            return;
+        const container = parent.getContents().instance.branchesContainer;
+        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 === undefined) {
+            return undefined;
+        }
+        if (parent instanceof TreeBranch) {
+            return parent.root();
+        }
+        if (parent instanceof TreeRoot) {
+            return parent;
+        }
+        throw new Error("unexpected parent type");
+    }
+    traverse(callback) {
+        callback(this);
+        this.treeNodeBase.traverse(callback);
+    }
+    getContentCreatedSub() {
+        const instance = this.contents.instance;
+        return instance.contentCreated.subscribe((userlandComponentInstance) => {
+            for (const [key, value] of Object.entries(this.branchOptions.inputBindings ?? {})) {
+                userlandComponentInstance[key] = value;
+            }
+            for (const [key, value] of Object.entries(this.branchOptions.outputBindings ?? {})) {
+                this.outputBindingSubscriptions.push(userlandComponentInstance[key].subscribe(value));
+            }
+            userlandComponentInstance.treeBranch = this;
+            const dropzones = instance.dropzones;
+            if (!dropzones) {
+                throw new Error("dropzones not defined");
+            }
+            dropzoneRenderer.registerDropzones(dropzones, this);
+        });
+    }
+    getInstanceSubscriptions() {
+        const droppedSub = this.contents.instance.dropped.subscribe((placement) => {
+            dropzoneRenderer.handleDrop(this, placement);
+        });
+        return [
+            this.getContentCreatedSub(),
+            this.getShowLowerZonesSub(),
+            this.getShowUpperZonesSub(),
+            droppedSub
+        ];
+    }
+    getShowLowerZonesSub() {
+        const instance = this.contents.instance;
+        return instance.showDropzones
+            .pipe(filter((direction) => direction === "lower"))
+            .subscribe(() => {
+            const currentDropzoneDisplayed = dropzoneRenderer.getCurrentDisplay();
+            if (currentDropzoneDisplayed?.treeBranch === this &&
+                currentDropzoneDisplayed.direction === "lower") {
+                return;
+            }
+            dropzoneRenderer.showLowerZones(this);
+            instance.triggerChangeDetection();
+        });
+    }
+    getShowUpperZonesSub() {
+        const instance = this.contents.instance;
+        return instance.showDropzones
+            .pipe(filter((direction) => direction === "upper"))
+            .subscribe(() => {
+            const currentDropzoneDisplayed = dropzoneRenderer.getCurrentDisplay();
+            if (currentDropzoneDisplayed?.treeBranch === this &&
+                currentDropzoneDisplayed.direction === "upper") {
+                return;
+            }
+            dropzoneRenderer.showUpperZones(this);
+            instance.triggerChangeDetection();
+        });
+    }
+    reattachView(index) {
+        assert(this._parent !== undefined);
+        assert(this.detachedView !== null);
+        const container = this._parent.getContents().instance.branchesContainer;
+        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.contents.location.nativeElement
+            .getElementsByClassName("branches-container")
+            .item(0);
+        assert(branchesContainerEl instanceof HTMLElement);
+        branchesContainerEl.style.marginLeft = `${options?.indentation ?? 16}px`;
+    }
+}
+
+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.getContents().instance;
+            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())?.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)?.allowDrop ?? (() => true);
+            return allowDrop(sourceNode, parent, index);
+        }
+        if (parent instanceof TreeBranch) {
+            const allowDrop = config.getConfig(parent.root())?.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.getContents().instance.showInnerDropzone = true;
+    }
+    showLateralZone(treeBranch) {
+        const index = treeBranch.index();
+        assert(index !== undefined);
+        if (!this.dropAllowed(treeBranch.parent(), index + 1))
+            return;
+        treeBranch.getContents().instance.showLateralDropzone = true;
+    }
+}
+const dropzoneRenderer = new DropzoneRenderer();
+
+class TreeDragAndDropService {
+    clearDropzones() {
+        dropzoneRenderer.clearCurrentDisplay();
+    }
+    dragStart(treeBranch, event) {
+        dragAndDrop.dragStart(treeBranch, event);
+    }
+    getCurrentlyDisplayedDropzoneFamily() {
+        return dropzoneRenderer.getCurrentDisplay();
+    }
+    showRootDropzone(root) {
+        dropzoneRenderer.showLowerZones(root);
+    }
+    state() {
+        return dragState.events();
+    }
+}
+TreeDragAndDropService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: TreeDragAndDropService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TreeDragAndDropService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: TreeDragAndDropService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: TreeDragAndDropService, decorators: [{
+            type: Injectable
+        }] });
+
+class DraggableDirective {
+    constructor(dragAndDropService, renderer, hostElement) {
+        this.dragAndDropService = dragAndDropService;
+        renderer.setAttribute(hostElement.nativeElement, "draggable", "true");
+        renderer.setStyle(hostElement.nativeElement, "cursor", "grab");
+    }
+    onDragstart(event) {
+        if (this.limbleTreeDraggable === undefined)
+            return;
+        this.dragAndDropService.dragStart(this.limbleTreeDraggable, event);
+    }
+}
+DraggableDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DraggableDirective, deps: [{ token: TreeDragAndDropService }, { token: i0.Renderer2 }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+DraggableDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.12", type: DraggableDirective, isStandalone: true, selector: "[limbleTreeDraggable]", inputs: { limbleTreeDraggable: "limbleTreeDraggable" }, host: { listeners: { "dragstart": "onDragstart($event)" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DraggableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[limbleTreeDraggable]",
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: TreeDragAndDropService }, { type: i0.Renderer2 }, { type: i0.ElementRef }]; }, propDecorators: { limbleTreeDraggable: [{
+                type: Input
+            }], onDragstart: [{
+                type: HostListener,
+                args: ["dragstart", ["$event"]]
+            }] } });
+
+class TreeDragAndDropModule {
+}
+TreeDragAndDropModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: TreeDragAndDropModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TreeDragAndDropModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.12", ngImport: i0, type: TreeDragAndDropModule, imports: [DraggableDirective, DragoverNoChangeDetectDirective], exports: [DraggableDirective, DragoverNoChangeDetectDirective] });
+TreeDragAndDropModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: TreeDragAndDropModule, providers: [TreeDragAndDropService] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: TreeDragAndDropModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [DraggableDirective, DragoverNoChangeDetectDirective],
+                    providers: [TreeDragAndDropService],
+                    exports: [DraggableDirective, DragoverNoChangeDetectDirective]
+                }]
+        }] });
+
+/**
+ * A shim to help with the transition from v0 to v1.
+ * @deprecated
+ */
+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,
+            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;
+        delete nodeData.nodes;
+        delete nodeData.collapsed;
+        delete nodeData.component;
+        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);
+        }
+    }
+}
+
+/** @deprecated */
+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
+            }] } });
+
+/** @deprecated */
+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]
+                }]
+        }] });
+
+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]
+                }]
+        }] });
+
+/*
+ * Public API Surface of limble-tree
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { DragEndEvent, DragStartEvent, DraggableDirective, DragoverNoChangeDetectDirective, DropEvent, GraftEvent, LegacyTree, LimbleTreeLegacyModule, LimbleTreeModule, LimbleTreeRootComponent, PruneEvent, TreeBranch, TreeCollapseModule, TreeCollapseService, TreeDragAndDropModule, TreeDragAndDropService, TreeError, TreeRoot, TreeService, config };
+//# sourceMappingURL=limble-limble-tree.mjs.map