@limble/limble-tree 0.12.2 → 0.13.0

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

@@ -0,0 +1,172 @@
+import { Component, EventEmitter, Input, NgZone, Output, ViewChild, ViewContainerRef } from "@angular/core";
+import { DropZoneService } from "./drop-zone.service";
+import { TreeService } from "./tree.service";
+import { isElementDescendant, isFirefox } from "../util";
+import { first } from "rxjs/operators";
+import { TreeConstructionStatus } from "./tree-construction-status.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./tree.service";
+import * as i2 from "./drop-zone.service";
+import * as i3 from "../singletons/drag-state.service";
+import * as i4 from "../singletons/global-events.service";
+import * as i5 from "@angular/common";
+import * as i6 from "../limble-tree-placeholder/limble-tree-placeholder.component";
+import * as i7 from "../custom-event-bindings/dragover-no-change-detect.directive";
+import * as i8 from "../custom-event-bindings/dragleave-no-change-detect.directive";
+const _c0 = ["host"];
+function LimbleTreeRootComponent_limble_tree_placeholder_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "limble-tree-placeholder");
+} }
+function LimbleTreeRootComponent_ng_template_2_Template(rf, ctx) { }
+export class LimbleTreeRootComponent {
+    constructor(treeService, dropZoneService, dragStateService, globalEventsService, ngZone, changeDetectorRef, el) {
+        this.treeService = treeService;
+        this.dropZoneService = dropZoneService;
+        this.dragStateService = dragStateService;
+        this.globalEventsService = globalEventsService;
+        this.ngZone = ngZone;
+        this.changeDetectorRef = changeDetectorRef;
+        this.el = el;
+        this.treeChange = new EventEmitter();
+        this.treeDrop = new EventEmitter();
+        this.changesSubscription = this.treeService.changes$.subscribe(() => {
+            //"In dev mode, Angular performs an additional check after each change
+            //detection run, to ensure the bindings haven’t changed." We use a timeout here
+            //to preclude the possibility of causing a binding to update in the parent
+            //component after change detection runs but before the additional check.
+            //See https://angular.io/errors/NG0100 for details.
+            setTimeout(() => {
+                this.treeChange.emit();
+            });
+        });
+        this.dropSubscription = this.treeService.drops$.subscribe((drop) => {
+            setTimeout(() => {
+                this.treeDrop.emit(drop);
+            });
+        });
+        this.placeholder = false;
+        this.treeService.placeholder$.subscribe((value) => {
+            this.placeholder = value;
+            if (!NgZone.isInAngularZone()) {
+                this.changeDetectorRef.detectChanges();
+            }
+        });
+    }
+    ngAfterViewInit() {
+        if (this.options?.listMode !== true &&
+            (this.itemsPerPage !== undefined || this.page !== undefined)) {
+            console.warn("pagination is only allowed in listMode; `itemsPerPage` and `page` inputs will be ignored");
+        }
+        this.update();
+        this.changeDetectorRef.detectChanges();
+        this.ngZone.runOutsideAngular(() => {
+            //this is for mac os - without this dragover handler drop events aren't firing correctly
+            this.el.nativeElement.addEventListener("dragover", (event) => {
+                event.preventDefault();
+            });
+        });
+    }
+    ngOnChanges() {
+        if (this.host !== undefined && this.data !== undefined) {
+            this.update();
+        }
+    }
+    /** Rebuild the tree */
+    update() {
+        if (this.host === undefined) {
+            throw new Error("Failed to render limble tree. Failure occurred at root.");
+        }
+        if (this.data === undefined) {
+            throw new Error(`limbleTree requires a data object`);
+        }
+        this.treeService.init(this.host, this.data, this.options, this.itemsPerPage, this.page);
+        //We check for firefox here because there is a bug in Firefox that causes the
+        //custom scrolling to break. See https://bugzilla.mozilla.org/show_bug.cgi?id=505521#c80
+        if (!isFirefox()) {
+            this.globalEventsService.addScrolling();
+        }
+    }
+    dragoverHandler(event) {
+        if (event.dataTransfer === null) {
+            return;
+        }
+        event.stopPropagation();
+        event.preventDefault();
+        event.dataTransfer.dropEffect = "move";
+    }
+    dragleaveHandler(event) {
+        const currentTarget = event.currentTarget;
+        const relatedTarget = event.relatedTarget;
+        if (!(currentTarget instanceof Node) ||
+            !(relatedTarget instanceof Node) ||
+            isElementDescendant(currentTarget, relatedTarget) !== false) {
+            //event came from deeper in the tree. Ignore it.
+            return;
+        }
+        //Mouse has left the tree, so clear the drop zones
+        this.dropZoneService.clearVisibleZones();
+        this.changeDetectorRef.detectChanges();
+    }
+    dropHandler(event) {
+        event.stopPropagation();
+        if (this.dragStateService.getState() !== "droppable") {
+            return;
+        }
+        const sourceBranch = this.dragStateService.capture();
+        if (sourceBranch === undefined) {
+            throw new Error("failed to get current branch in dragendHandler");
+        }
+        const dropZone = this.dropZoneService.getActiveDropZone();
+        if (dropZone === null) {
+            throw new Error("failed to get active drop zone at drop handler");
+        }
+        this.treeService.captured = true;
+        this.dragStateService.state$
+            .pipe(first((message) => message === "idle"))
+            .subscribe(() => {
+            this.treeService.captured = false;
+        });
+        this.dropZoneService.clearVisibleZones();
+        this.treeService.drop(sourceBranch, dropZone.getFullInsertCoordinates());
+    }
+    ngOnDestroy() {
+        this.changesSubscription.unsubscribe();
+        this.dropSubscription.unsubscribe();
+    }
+}
+LimbleTreeRootComponent.ɵfac = function LimbleTreeRootComponent_Factory(t) { return new (t || LimbleTreeRootComponent)(i0.ɵɵdirectiveInject(i1.TreeService), i0.ɵɵdirectiveInject(i2.DropZoneService), i0.ɵɵdirectiveInject(i3.DragStateService), i0.ɵɵdirectiveInject(i4.GlobalEventsService), i0.ɵɵdirectiveInject(i0.NgZone), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef)); };
+LimbleTreeRootComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LimbleTreeRootComponent, selectors: [["limble-tree-root"]], viewQuery: function LimbleTreeRootComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(_c0, 5, ViewContainerRef);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.host = _t.first);
+    } }, inputs: { data: "data", options: "options", itemsPerPage: "itemsPerPage", page: "page" }, outputs: { treeChange: "treeChange", treeDrop: "treeDrop" }, features: [i0.ɵɵProvidersFeature([TreeService, DropZoneService, TreeConstructionStatus]), i0.ɵɵNgOnChangesFeature], decls: 4, vars: 1, consts: [[1, "tree-event-host", 3, "dragoverNoChangeDetect", "dragleaveNoChangeDetect", "drop"], [4, "ngIf"], ["host", ""]], template: function LimbleTreeRootComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "div", 0);
+        i0.ɵɵlistener("dragoverNoChangeDetect", function LimbleTreeRootComponent_Template_div_dragoverNoChangeDetect_0_listener($event) { return ctx.dragoverHandler($event); })("dragleaveNoChangeDetect", function LimbleTreeRootComponent_Template_div_dragleaveNoChangeDetect_0_listener($event) { return ctx.dragleaveHandler($event); })("drop", function LimbleTreeRootComponent_Template_div_drop_0_listener($event) { return ctx.dropHandler($event); });
+        i0.ɵɵtemplate(1, LimbleTreeRootComponent_limble_tree_placeholder_1_Template, 1, 0, "limble-tree-placeholder", 1);
+        i0.ɵɵtemplate(2, LimbleTreeRootComponent_ng_template_2_Template, 0, 0, "ng-template", null, 2, i0.ɵɵtemplateRefExtractor);
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngIf", ctx.placeholder === true);
+    } }, dependencies: [i5.NgIf, i6.LimbleTreePlaceholderComponent, i7.DragoverNoChangeDetectDirective, i8.DragleaveNoChangeDetectDirective] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LimbleTreeRootComponent, [{
+        type: Component,
+        args: [{ selector: "limble-tree-root", providers: [TreeService, DropZoneService, TreeConstructionStatus], template: "<div\n   (dragoverNoChangeDetect)=\"dragoverHandler($event)\"\n   (dragleaveNoChangeDetect)=\"dragleaveHandler($event)\"\n   (drop)=\"dropHandler($event)\"\n   class=\"tree-event-host\"\n>\n   <limble-tree-placeholder\n      *ngIf=\"placeholder === true\"\n   ></limble-tree-placeholder>\n   <ng-template #host></ng-template>\n</div>\n" }]
+    }], function () { return [{ type: i1.TreeService }, { type: i2.DropZoneService }, { type: i3.DragStateService }, { type: i4.GlobalEventsService }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }, { type: i0.ElementRef }]; }, { 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,{"version":3,"file":"limble-tree-root.component.js","sourceRoot":"","sources":["../../../../../projects/limble-tree/src/lib/limble-tree-root/limble-tree-root.component.ts","../../../../../projects/limble-tree/src/lib/limble-tree-root/limble-tree-root.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n   AfterViewInit,\n   ChangeDetectorRef,\n   Component,\n   ElementRef,\n   EventEmitter,\n   Input,\n   NgZone,\n   OnChanges,\n   OnDestroy,\n   Output,\n   ViewChild,\n   ViewContainerRef\n} from \"@angular/core\";\nimport { Subscription } from \"rxjs\";\nimport { DropZoneService } from \"./drop-zone.service\";\nimport {\n   LimbleTreeData,\n   LimbleTreeOptions,\n   TreeDrop\n} from \"../limble-tree-root/tree.service\";\nimport { TreeService } from \"./tree.service\";\nimport { isElementDescendant, isFirefox } from \"../util\";\nimport { DragStateService } from \"../singletons/drag-state.service\";\nimport { GlobalEventsService } from \"../singletons/global-events.service\";\nimport { first } from \"rxjs/operators\";\nimport { TreeConstructionStatus } from \"./tree-construction-status.service\";\n\n@Component({\n   selector: \"limble-tree-root\",\n   templateUrl: \"./limble-tree-root.component.html\",\n   styleUrls: [\"./limble-tree-root.component.scss\"],\n   providers: [TreeService, DropZoneService, TreeConstructionStatus]\n})\nexport class LimbleTreeRootComponent\n   implements AfterViewInit, OnChanges, OnDestroy\n{\n   @Input() data: LimbleTreeData | undefined;\n   @Input() options: LimbleTreeOptions | undefined;\n   @Input() itemsPerPage: number | undefined;\n   @Input() page: number | undefined;\n\n   @ViewChild(\"host\", { read: ViewContainerRef }) private host:\n      | ViewContainerRef\n      | undefined;\n\n   @Output() readonly treeChange = new EventEmitter<null>();\n\n   @Output() readonly treeDrop = new EventEmitter<TreeDrop>();\n\n   private readonly changesSubscription: Subscription;\n   private readonly dropSubscription: Subscription;\n   public placeholder: boolean;\n\n   constructor(\n      private readonly treeService: TreeService,\n      private readonly dropZoneService: DropZoneService,\n      private readonly dragStateService: DragStateService,\n      private readonly globalEventsService: GlobalEventsService,\n      private readonly ngZone: NgZone,\n      private readonly changeDetectorRef: ChangeDetectorRef,\n      private readonly el: ElementRef<Element>\n   ) {\n      this.changesSubscription = this.treeService.changes$.subscribe(() => {\n         //\"In dev mode, Angular performs an additional check after each change\n         //detection run, to ensure the bindings haven’t changed.\" We use a timeout here\n         //to preclude the possibility of causing a binding to update in the parent\n         //component after change detection runs but before the additional check.\n         //See https://angular.io/errors/NG0100 for details.\n         setTimeout(() => {\n            this.treeChange.emit();\n         });\n      });\n      this.dropSubscription = this.treeService.drops$.subscribe((drop) => {\n         setTimeout(() => {\n            this.treeDrop.emit(drop);\n         });\n      });\n      this.placeholder = false;\n      this.treeService.placeholder$.subscribe((value) => {\n         this.placeholder = value;\n         if (!NgZone.isInAngularZone()) {\n            this.changeDetectorRef.detectChanges();\n         }\n      });\n   }\n\n   ngAfterViewInit() {\n      if (\n         this.options?.listMode !== true &&\n         (this.itemsPerPage !== undefined || this.page !== undefined)\n      ) {\n         console.warn(\n            \"pagination is only allowed in listMode; `itemsPerPage` and `page` inputs will be ignored\"\n         );\n      }\n      this.update();\n      this.changeDetectorRef.detectChanges();\n\n      this.ngZone.runOutsideAngular(() => {\n         //this is for mac os - without this dragover handler drop events aren't firing correctly\n         this.el.nativeElement.addEventListener(\"dragover\", (event) => {\n            event.preventDefault();\n         });\n      });\n   }\n\n   ngOnChanges() {\n      if (this.host !== undefined && this.data !== undefined) {\n         this.update();\n      }\n   }\n\n   /** Rebuild the tree */\n   public update() {\n      if (this.host === undefined) {\n         throw new Error(\n            \"Failed to render limble tree. Failure occurred at root.\"\n         );\n      }\n      if (this.data === undefined) {\n         throw new Error(`limbleTree requires a data object`);\n      }\n      this.treeService.init(\n         this.host,\n         this.data,\n         this.options,\n         this.itemsPerPage,\n         this.page\n      );\n      //We check for firefox here because there is a bug in Firefox that causes the\n      //custom scrolling to break. See https://bugzilla.mozilla.org/show_bug.cgi?id=505521#c80\n      if (!isFirefox()) {\n         this.globalEventsService.addScrolling();\n      }\n   }\n\n   public dragoverHandler(event: DragEvent) {\n      if (event.dataTransfer === null) {\n         return;\n      }\n      event.stopPropagation();\n      event.preventDefault();\n      event.dataTransfer.dropEffect = \"move\";\n   }\n\n   public dragleaveHandler(event: DragEvent) {\n      const currentTarget = event.currentTarget;\n      const relatedTarget = event.relatedTarget;\n      if (\n         !(currentTarget instanceof Node) ||\n         !(relatedTarget instanceof Node) ||\n         isElementDescendant(currentTarget, relatedTarget) !== false\n      ) {\n         //event came from deeper in the tree. Ignore it.\n         return;\n      }\n      //Mouse has left the tree, so clear the drop zones\n      this.dropZoneService.clearVisibleZones();\n      this.changeDetectorRef.detectChanges();\n   }\n\n   public dropHandler(event: DragEvent) {\n      event.stopPropagation();\n      if (this.dragStateService.getState() !== \"droppable\") {\n         return;\n      }\n      const sourceBranch = this.dragStateService.capture();\n      if (sourceBranch === undefined) {\n         throw new Error(\"failed to get current branch in dragendHandler\");\n      }\n      const dropZone = this.dropZoneService.getActiveDropZone();\n      if (dropZone === null) {\n         throw new Error(\"failed to get active drop zone at drop handler\");\n      }\n      this.treeService.captured = true;\n      this.dragStateService.state$\n         .pipe(first((message) => message === \"idle\"))\n         .subscribe(() => {\n            this.treeService.captured = false;\n         });\n      this.dropZoneService.clearVisibleZones();\n      this.treeService.drop(sourceBranch, dropZone.getFullInsertCoordinates());\n   }\n\n   ngOnDestroy() {\n      this.changesSubscription.unsubscribe();\n      this.dropSubscription.unsubscribe();\n   }\n}\n","<div\n   (dragoverNoChangeDetect)=\"dragoverHandler($event)\"\n   (dragleaveNoChangeDetect)=\"dragleaveHandler($event)\"\n   (drop)=\"dropHandler($event)\"\n   class=\"tree-event-host\"\n>\n   <limble-tree-placeholder\n      *ngIf=\"placeholder === true\"\n   ></limble-tree-placeholder>\n   <ng-template #host></ng-template>\n</div>\n"]}

package/{esm2015/lib/limble-tree-root/tree-construction-status.service.js → esm2020/lib/limble-tree-root/tree-construction-status.service.mjs}

@@ -30,4 +30,4 @@ TreeConstructionStatus.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: T
 (function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TreeConstructionStatus, [{
         type: Injectable
     }], function () { return []; }, null); })();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZS1jb25zdHJ1Y3Rpb24tc3RhdHVzLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saW1ibGUtdHJlZS9zcmMvbGliL2xpbWJsZS10cmVlLXJvb3QvdHJlZS1jb25zdHJ1Y3Rpb24tc3RhdHVzLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sTUFBTSxDQUFDOztBQUd2QyxNQUFNLE9BQU8sc0JBQXNCO0lBS2hDO1FBQ0csSUFBSSxDQUFDLFVBQVUsR0FBRyxDQUFDLENBQUM7UUFDcEIsSUFBSSxDQUFDLE9BQU8sR0FBRyxLQUFLLENBQUM7UUFDckIsSUFBSSxDQUFDLE9BQU8sR0FBRyxJQUFJLGVBQWUsQ0FBQyxJQUFJLENBQUMsWUFBWSxFQUFFLENBQUMsQ0FBQztJQUMzRCxDQUFDO0lBRU0sWUFBWTtRQUNoQixJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7UUFDbEIsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ2YsQ0FBQztJQUVNLGdCQUFnQjtRQUNwQixJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7UUFDbEIsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ2YsQ0FBQztJQUVNLFlBQVk7UUFDaEIsT0FBTyxJQUFJLENBQUMsT0FBTyxLQUFLLElBQUksSUFBSSxJQUFJLENBQUMsVUFBVSxLQUFLLENBQUMsQ0FBQztJQUN6RCxDQUFDO0lBRU0sS0FBSyxDQUFDLEdBQVk7UUFDdEIsSUFBSSxDQUFDLE9BQU8sR0FBRyxHQUFHLENBQUM7SUFDdEIsQ0FBQztJQUVNLElBQUk7UUFDUixJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsWUFBWSxFQUFFLENBQUMsQ0FBQztJQUMxQyxDQUFDOzs0RkEvQlMsc0JBQXNCOzRFQUF0QixzQkFBc0IsV0FBdEIsc0JBQXNCO3VGQUF0QixzQkFBc0I7Y0FEbEMsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuaW1wb3J0IHsgQmVoYXZpb3JTdWJqZWN0IH0gZnJvbSBcInJ4anNcIjtcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIFRyZWVDb25zdHJ1Y3Rpb25TdGF0dXMge1xuICAgcHJpdmF0ZSBiZWluZ0J1aWx0OiBudW1iZXI7XG4gICBwcml2YXRlIGlzUmVhZHk6IGJvb2xlYW47XG4gICBwdWJsaWMgcmVhZG9ubHkgc3RhYmxlJDogQmVoYXZpb3JTdWJqZWN0PGJvb2xlYW4+O1xuXG4gICBwdWJsaWMgY29uc3RydWN0b3IoKSB7XG4gICAgICB0aGlzLmJlaW5nQnVpbHQgPSAwO1xuICAgICAgdGhpcy5pc1JlYWR5ID0gZmFsc2U7XG4gICAgICB0aGlzLnN0YWJsZSQgPSBuZXcgQmVoYXZpb3JTdWJqZWN0KHRoaXMudHJlZUlzU3RhYmxlKCkpO1xuICAgfVxuXG4gICBwdWJsaWMgY29uc3RydWN0aW5nKCk6IHZvaWQge1xuICAgICAgdGhpcy5iZWluZ0J1aWx0Kys7XG4gICAgICB0aGlzLmVtaXQoKTtcbiAgIH1cblxuICAgcHVibGljIGRvbmVDb25zdHJ1Y3RpbmcoKTogdm9pZCB7XG4gICAgICB0aGlzLmJlaW5nQnVpbHQtLTtcbiAgICAgIHRoaXMuZW1pdCgpO1xuICAgfVxuXG4gICBwdWJsaWMgdHJlZUlzU3RhYmxlKCk6IGJvb2xlYW4ge1xuICAgICAgcmV0dXJuIHRoaXMuaXNSZWFkeSA9PT0gdHJ1ZSAmJiB0aGlzLmJlaW5nQnVpbHQgPT09IDA7XG4gICB9XG5cbiAgIHB1YmxpYyByZWFkeSh2YWw6IGJvb2xlYW4pOiB2b2lkIHtcbiAgICAgIHRoaXMuaXNSZWFkeSA9IHZhbDtcbiAgIH1cblxuICAgcHVibGljIGVtaXQoKTogdm9pZCB7XG4gICAgICB0aGlzLnN0YWJsZSQubmV4dCh0aGlzLnRyZWVJc1N0YWJsZSgpKTtcbiAgIH1cbn1cbiJdfQ==

package/esm2020/lib/limble-tree-root/tree.service.mjs

@@ -0,0 +1,297 @@
+import { Injectable } from "@angular/core";
+import { Branch } from "../classes/Branch";
+import { LimbleTreeNodeComponent } from "../limble-tree-node/limble-tree-node.component";
+import { BehaviorSubject, EMPTY, Subject } from "rxjs";
+import { arraysAreEqual } from "../util";
+import { debounce, debounceTime, filter, tap } from "rxjs/operators";
+import * as i0 from "@angular/core";
+import * as i1 from "../singletons/component-creator.service";
+import * as i2 from "./drop-zone.service";
+import * as i3 from "../singletons/drag-state.service";
+import * as i4 from "./tree-construction-status.service";
+/** The default value for the `indent` option */
+export const INDENT = 45;
+export class TreeService {
+    constructor(componentCreatorService, dropZoneService, dragStateService, treeConstructionStatus) {
+        this.componentCreatorService = componentCreatorService;
+        this.dropZoneService = dropZoneService;
+        this.dragStateService = dragStateService;
+        this.treeConstructionStatus = treeConstructionStatus;
+        this.changes$ = new Subject();
+        this.drops$ = new Subject();
+        this.treeModel = new Branch(null);
+        this.placeholder = false;
+        this.captured = false;
+        this.cleanupSignal$ = new Subject();
+        let rebuild = false;
+        let treeIsStable = false;
+        const treeIsStable$ = this.treeConstructionStatus.stable$.pipe(tap((value) => {
+            treeIsStable = value;
+        }), filter((value) => value === true));
+        this.cleanupSignal$
+            .pipe(tap((value) => {
+            rebuild = value;
+        }), debounce(() => {
+            if (treeIsStable === true) {
+                //If tree is stable, continue right away
+                return EMPTY;
+            }
+            //If tree is not stable, wait for it to become so.
+            return treeIsStable$;
+        }), 
+        //We use this timed debounce to throttle chained destruction of components
+        debounceTime(5))
+            .subscribe(() => {
+            this.cleanup(rebuild);
+            rebuild = false;
+        });
+        this.placeholder$ = new BehaviorSubject(false);
+        this.placeholder$.subscribe((value) => {
+            this.placeholder = value;
+        });
+    }
+    drop(source, targetCoordinates) {
+        //prep
+        const sourceParent = source.getParent();
+        if (sourceParent === null) {
+            throw new Error("can't drop root of tree");
+        }
+        const sourceIndex = source.getIndex();
+        if (sourceIndex === undefined || sourceIndex === null) {
+            throw new Error("Cannot move the hidden root node");
+        }
+        let targetParentCoordinates;
+        let newIndex;
+        if (this.placeholder === true) {
+            targetParentCoordinates = [];
+            newIndex = 0;
+        }
+        else {
+            targetParentCoordinates = [...targetCoordinates];
+            newIndex = targetParentCoordinates.pop();
+        }
+        if (newIndex === undefined) {
+            throw new Error("target coordinates are empty");
+        }
+        const targetParent = this.treeModel.getDescendant(targetParentCoordinates);
+        if (targetParent === undefined) {
+            throw new Error("could not get to target");
+        }
+        const target = this.dropZoneService.getDropZone(targetCoordinates);
+        const targetIndex = target?.getLocation().insertIndex;
+        const targetHost = target?.getHost();
+        const sourceHost = this.dragStateService.getData()?.parentContainer;
+        if (this.placeholder === true) {
+            this.placeholder$.next(false);
+        }
+        //Change the treeModel
+        targetParent.insertChild(source, newIndex);
+        //Prepare to update the view
+        if (targetHost === undefined ||
+            sourceHost === undefined ||
+            targetIndex === undefined) {
+            //Hitting this means there is a bug, but not a fatal one.
+            //Just render the whole tree again.
+            console.warn("Could not perform a precise update. Re-rendering the entire tree instead");
+            this.render();
+            this.changes$.next(null);
+            return;
+        }
+        //Update the view
+        const nodesInSource = sourceHost.length;
+        const componentRef = this.componentCreatorService.appendComponent(LimbleTreeNodeComponent, targetHost, newIndex);
+        componentRef.instance.branch = source;
+        componentRef.instance.parentHost = targetHost;
+        if (targetIndex < sourceIndex &&
+            sourceHost.length > nodesInSource &&
+            arraysAreEqual(sourceParent.getCoordinates(), targetParentCoordinates)) {
+            sourceHost.remove(sourceIndex + 1);
+        }
+        else {
+            sourceHost.remove(sourceIndex);
+        }
+        //Update the tree data
+        this.rebuildTreeData();
+        //Publish drop data
+        this.drops$.next({
+            target: source.data,
+            oldParent: sourceParent.data,
+            oldIndex: sourceIndex,
+            newParent: targetParent.data,
+            newIndex: newIndex
+        });
+        this.cleanupSignal$.next(false);
+    }
+    /** Initializes the service and renders the tree.
+     * @param host - The ViewContainerRef into which the tree will be rendered.
+     * @param data - The data array that was passed in to LimbleTreeRoot, which is
+     * the users' representation of the tree
+     * @param options - The options object that was passed in to LimbleTreeRoot
+     */
+    init(host, data, options, itemsPerPage, page) {
+        this.host = host;
+        this.originalData = data;
+        this.treeOptions = this.processOptions(options, itemsPerPage, page);
+        if (this.treeOptions.listMode === true) {
+            let start = this.treeOptions.itemsPerPage * (this.treeOptions.page - 1);
+            if (isNaN(start)) {
+                //This catches the case where itemsPerPage was not passed by the user,
+                //causing `start` to equal infinity*0, which is NaN.
+                start = 0;
+            }
+            const end = start + this.treeOptions.itemsPerPage;
+            this.treeData = this.originalData.slice(start, end);
+        }
+        else {
+            this.treeData = [...this.originalData];
+        }
+        this.render();
+    }
+    cleanup(rebuild = false) {
+        if (rebuild) {
+            this.rebuildTreeData();
+        }
+        if (this.treeData?.length === 0) {
+            //We do a full render here because it isn't actually any slower
+            //when there are no nodes, and it is a little more straightforward
+            this.render();
+        }
+        else {
+            this.changes$.next(null);
+            this.dropZoneService.update();
+        }
+    }
+    /** Renders the entire tree from root to leaves */
+    render() {
+        if (this.host === undefined ||
+            this.treeData === undefined ||
+            this.treeOptions === undefined) {
+            throw new Error("TreeModel not initialized");
+        }
+        this.treeConstructionStatus.ready(false);
+        this.host.clear();
+        this.dropZoneService.restart();
+        this.placeholder$.next(false);
+        this.treeModel = new Branch(null);
+        if (this.treeData.length === 0) {
+            //Tree is empty, but we have to to have something there so other trees' items can be dropped into it
+            this.placeholder$.next(true);
+        }
+        else {
+            for (const node of this.treeData) {
+                const branch = new Branch(node);
+                this.treeModel.appendChild(branch);
+            }
+            for (const branch of this.treeModel.getChildren()) {
+                const componentRef = this.componentCreatorService.appendComponent(LimbleTreeNodeComponent, this.host);
+                componentRef.instance.branch = branch;
+                componentRef.instance.parentHost = this.host;
+                //The LimbleTreeNodeComponent will (indirectly) call the `renderBranch` method of this service to render
+                //its own children
+            }
+        }
+        this.treeConstructionStatus.ready(true);
+        this.changes$.next(null);
+        this.dropZoneService.init(this.treeModel, this.treeOptions);
+    }
+    /** Renders a branch of the tree and all of its descendants */
+    renderBranch(host, branch) {
+        if (this.treeModel === undefined) {
+            throw new Error("TreeModel not initialized");
+        }
+        host.clear();
+        branch.clearChildren();
+        for (const node of branch.data?.nodes ?? []) {
+            const newBranch = new Branch(node);
+            branch.appendChild(newBranch);
+            const componentRef = this.componentCreatorService.appendComponent(LimbleTreeNodeComponent, host);
+            componentRef.instance.branch = newBranch;
+            componentRef.instance.parentHost = host;
+            //The LimbleTreeNodeComponent will (indirectly) call the `renderBranch` method of this service to render
+            //its own children
+        }
+    }
+    processOptions(options = {}, itemsPerPage = Infinity, page = 1) {
+        if (options.listMode === true &&
+            options.allowNesting !== undefined &&
+            options.allowNesting !== false) {
+            console.warn("The value of `allowNesting` will be ignored; it must be false when `listMode` is true");
+        }
+        const result = {
+            defaultComponent: options.defaultComponent,
+            indent: options.indent ?? INDENT,
+            allowNesting: options.listMode !== true && (options.allowNesting ?? true),
+            allowDragging: options.allowDragging ?? true,
+            allowDrop: options.allowDrop ?? (() => true),
+            listMode: options.listMode ?? false,
+            itemsPerPage: options.listMode ? itemsPerPage : undefined,
+            page: options.listMode ? page : undefined
+        };
+        return result;
+    }
+    rebuildTreeData() {
+        if (this.originalData === undefined ||
+            this.treeData === undefined ||
+            this.treeOptions === undefined ||
+            this.host === undefined) {
+            throw new Error("Tree data not initialized");
+        }
+        this.treeData = [];
+        for (const branch of this.treeModel.getChildren()) {
+            this.treeData.push(this.rebuildBranch(branch));
+        }
+        if (this.treeOptions.listMode === true &&
+            this.treeOptions.itemsPerPage < Infinity) {
+            const itemsPerPage = this.treeOptions.itemsPerPage;
+            const start = itemsPerPage * (this.treeOptions.page - 1);
+            this.originalData.splice(start, itemsPerPage, ...this.treeData);
+            if (this.treeData.length !== itemsPerPage) {
+                let action = false;
+                if (this.treeData.length < itemsPerPage &&
+                    start + itemsPerPage <= this.originalData.length) {
+                    //The current page does not have enough nodes. Add some to the view from the next page.
+                    const count = itemsPerPage - this.treeData.length;
+                    for (let index = itemsPerPage - 1; index < itemsPerPage + count - 1; index++) {
+                        const branch = new Branch(this.originalData[start + index]);
+                        this.treeModel.appendChild(branch);
+                        const componentRef = this.componentCreatorService.appendComponent(LimbleTreeNodeComponent, this.host);
+                        componentRef.instance.branch = branch;
+                        componentRef.instance.parentHost = this.host;
+                    }
+                    action = true;
+                }
+                else if (this.treeData.length > itemsPerPage) {
+                    //The current page has too many nodes. Remove some of them from the view.
+                    const count = this.treeData.length - itemsPerPage;
+                    for (let index = itemsPerPage + count - 1; index >= itemsPerPage; index--) {
+                        this.treeModel.removeChild(index);
+                        this.host.remove(index);
+                    }
+                    action = true;
+                }
+                if (action === true) {
+                    const end = start + itemsPerPage;
+                    this.treeData = this.originalData.slice(start, end);
+                }
+            }
+        }
+        else {
+            this.originalData.length = 0;
+            this.originalData.push(...this.treeData);
+        }
+    }
+    rebuildBranch(branch) {
+        const temp = branch.data;
+        temp.nodes = [];
+        for (const child of branch.getChildren()) {
+            temp.nodes.push(this.rebuildBranch(child));
+        }
+        return temp;
+    }
+}
+TreeService.ɵfac = function TreeService_Factory(t) { return new (t || TreeService)(i0.ɵɵinject(i1.ComponentCreatorService), i0.ɵɵinject(i2.DropZoneService), i0.ɵɵinject(i3.DragStateService), i0.ɵɵinject(i4.TreeConstructionStatus)); };
+TreeService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: TreeService, factory: TreeService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TreeService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.ComponentCreatorService }, { type: i2.DropZoneService }, { type: i3.DragStateService }, { type: i4.TreeConstructionStatus }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree.service.js","sourceRoot":"","sources":["../../../../../projects/limble-tree/src/lib/limble-tree-root/tree.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Type, ViewContainerRef } from \"@angular/core\";\nimport { ComponentCreatorService } from \"../singletons/component-creator.service\";\nimport { DropZoneService } from \"./drop-zone.service\";\nimport { Branch, BranchCoordinates } from \"../classes/Branch\";\nimport { LimbleTreeNodeComponent } from \"../limble-tree-node/limble-tree-node.component\";\nimport { DragStateService } from \"../singletons/drag-state.service\";\nimport { BehaviorSubject, EMPTY, Subject } from \"rxjs\";\nimport { arraysAreEqual } from \"../util\";\nimport { debounce, debounceTime, filter, tap } from \"rxjs/operators\";\nimport { TreeConstructionStatus } from \"./tree-construction-status.service\";\n\n/** An object describing a node of the tree */\nexport interface LimbleTreeNode {\n   /** A list of nodes to be rendered \"under\" this one, one level deeper in the tree. */\n   nodes?: LimbleTreeData;\n   // /** A custom data object that will be passed into the component as an `Input()` binding called `nodeData` */\n   // data: unknown;\n   /** An object that describes the component which will represent this node in the visual tree */\n   component?: ComponentObj;\n   collapsed?: boolean;\n   [index: string]: unknown;\n}\n\n/** An object that the limble-tree-root component uses to build the tree */\nexport type LimbleTreeData = Array<LimbleTreeNode>;\n\n/** A group of settings for changing the functionality of the tree */\nexport interface LimbleTreeOptions {\n   /** The component object to use if one is not specified for a particular node */\n   defaultComponent?: ComponentObj;\n   /** The number of pixels to indent each level of the tree. Defaults to 45 */\n   indent?: number;\n   /**\n    * Whether to allow \"nesting\" (placing a node one level deeper than currently exists on the branch).\n    * When this is a boolean, it applies to all nodes. When this is a function, the node in question\n    * is passed in. Defaults to true.\n    */\n   allowNesting?: boolean | ((nodeData: LimbleTreeNode) => boolean);\n   /**\n    * Whether to allow a node to be dragged. When this is a boolean, it applies to all nodes. When this\n    * is a function, the node in question is passed in. Defaults to true.\n    */\n   allowDragging?: boolean | ((nodeData: LimbleTreeNode) => boolean);\n   /** A callback to determine whether a sourceNode can be dropped at a particular location. */\n   allowDrop?: (\n      sourceNode: LimbleTreeNode,\n      proposedParent: LimbleTreeNode | null,\n      proposedIndex: number\n   ) => boolean;\n   /** When set to true, list mode will enforce a flat tree structure, meaning there\n    * can only be one level of the tree. `allowNesting` is automatically set to `false`\n    * and any children will be deleted.\n    *\n    * This mode can be used when the same dynamic drag and drop functionality of\n    * the tree is desired, but the tree structure itself is not necessary. This\n    * also opens up the pagination API on the limble-tree-root component. See the\n    * README for details on pagination.\n    */\n   listMode?: boolean;\n}\n\n/** An object that references the component to be rendered and its bindings */\nexport interface ComponentObj {\n   /** The component class */\n   class: Type<unknown>;\n   /** The bindings (inputs and outputs) of the class */\n   bindings?: {\n      [index: string]: unknown;\n   };\n}\n\n/** The default value for the `indent` option */\nexport const INDENT = 45;\n\n/** An options object with default values loaded where applicable */\nexport interface ProcessedOptionsBase extends LimbleTreeOptions {\n   defaultComponent?: ComponentObj;\n   indent: number;\n   allowNesting: boolean | ((nodeData: LimbleTreeNode) => boolean);\n   allowDragging: boolean | ((nodeData: LimbleTreeNode) => boolean);\n   allowDrop: (\n      sourceNode: LimbleTreeNode,\n      proposedParent: LimbleTreeNode | null,\n      proposedIndex: number\n   ) => boolean;\n   listMode: boolean;\n   itemsPerPage: number | undefined;\n   page: number | undefined;\n}\n\nexport interface ProcessedOptionsWithPagination extends ProcessedOptionsBase {\n   listMode: true;\n   itemsPerPage: number;\n   page: number;\n}\n\nexport interface ProcessedOptionsWithoutPagination\n   extends ProcessedOptionsBase {\n   listMode: false;\n   itemsPerPage: undefined;\n   page: undefined;\n}\n\nexport type ProcessedOptions =\n   | ProcessedOptionsWithPagination\n   | ProcessedOptionsWithoutPagination;\n\n/** the value emitted from the root component after a node is dropped */\nexport interface TreeDrop {\n   /** The node that was dropped */\n   target: LimbleTreeNode;\n   /** the target's parent before the drag and drop, or null if it was a top-level node */\n   oldParent: LimbleTreeNode | null;\n   /** the index of the node before the drag and drop relative to its old siblings */\n   oldIndex: number;\n   /** the target's parent after the drag and drop, or null if it is now a top-level node */\n   newParent: LimbleTreeNode | null;\n   /** the index of the node after the drag and drop relative to its new siblings */\n   newIndex: number;\n}\n\n@Injectable()\nexport class TreeService {\n   public readonly changes$: Subject<null>;\n   public readonly drops$: Subject<TreeDrop>;\n   public host: ViewContainerRef | undefined;\n   public treeData: LimbleTreeData | undefined;\n   /** This should never be reassigned. It is assigned in init() and no where else. We need to keep the reference from breaking. */\n   private originalData: LimbleTreeData | undefined;\n   public treeOptions: ProcessedOptions | undefined;\n   public treeModel: Branch<any>;\n   private placeholder: boolean;\n   public captured: boolean;\n   public readonly cleanupSignal$: Subject<boolean>;\n   public placeholder$: BehaviorSubject<boolean>;\n\n   constructor(\n      private readonly componentCreatorService: ComponentCreatorService,\n      private readonly dropZoneService: DropZoneService,\n      private readonly dragStateService: DragStateService,\n      private readonly treeConstructionStatus: TreeConstructionStatus\n   ) {\n      this.changes$ = new Subject();\n      this.drops$ = new Subject();\n      this.treeModel = new Branch(null);\n      this.placeholder = false;\n      this.captured = false;\n      this.cleanupSignal$ = new Subject();\n      let rebuild = false;\n      let treeIsStable = false;\n      const treeIsStable$ = this.treeConstructionStatus.stable$.pipe(\n         tap((value) => {\n            treeIsStable = value;\n         }),\n         filter((value) => value === true)\n      );\n      this.cleanupSignal$\n         .pipe(\n            tap((value) => {\n               rebuild = value;\n            }),\n            debounce(() => {\n               if (treeIsStable === true) {\n                  //If tree is stable, continue right away\n                  return EMPTY;\n               }\n               //If tree is not stable, wait for it to become so.\n               return treeIsStable$;\n            }),\n            //We use this timed debounce to throttle chained destruction of components\n            debounceTime(5)\n         )\n         .subscribe(() => {\n            this.cleanup(rebuild);\n            rebuild = false;\n         });\n      this.placeholder$ = new BehaviorSubject<boolean>(false);\n      this.placeholder$.subscribe((value) => {\n         this.placeholder = value;\n      });\n   }\n\n   public drop(source: Branch<any>, targetCoordinates: BranchCoordinates) {\n      //prep\n      const sourceParent = source.getParent();\n      if (sourceParent === null) {\n         throw new Error(\"can't drop root of tree\");\n      }\n      const sourceIndex = source.getIndex();\n      if (sourceIndex === undefined || sourceIndex === null) {\n         throw new Error(\"Cannot move the hidden root node\");\n      }\n      let targetParentCoordinates: BranchCoordinates;\n      let newIndex: number | undefined;\n      if (this.placeholder === true) {\n         targetParentCoordinates = [];\n         newIndex = 0;\n      } else {\n         targetParentCoordinates = [...targetCoordinates];\n         newIndex = targetParentCoordinates.pop();\n      }\n      if (newIndex === undefined) {\n         throw new Error(\"target coordinates are empty\");\n      }\n      const targetParent = this.treeModel.getDescendant(\n         targetParentCoordinates\n      );\n      if (targetParent === undefined) {\n         throw new Error(\"could not get to target\");\n      }\n      const target = this.dropZoneService.getDropZone(targetCoordinates);\n      const targetIndex = target?.getLocation().insertIndex;\n      const targetHost = target?.getHost();\n      const sourceHost = this.dragStateService.getData()?.parentContainer;\n      if (this.placeholder === true) {\n         this.placeholder$.next(false);\n      }\n      //Change the treeModel\n      targetParent.insertChild(source, newIndex);\n      //Prepare to update the view\n      if (\n         targetHost === undefined ||\n         sourceHost === undefined ||\n         targetIndex === undefined\n      ) {\n         //Hitting this means there is a bug, but not a fatal one.\n         //Just render the whole tree again.\n         console.warn(\n            \"Could not perform a precise update. Re-rendering the entire tree instead\"\n         );\n         this.render();\n         this.changes$.next(null);\n         return;\n      }\n      //Update the view\n      const nodesInSource = sourceHost.length;\n      const componentRef = this.componentCreatorService.appendComponent(\n         LimbleTreeNodeComponent,\n         targetHost,\n         newIndex\n      );\n      componentRef.instance.branch = source;\n      componentRef.instance.parentHost = targetHost;\n      if (\n         targetIndex < sourceIndex &&\n         sourceHost.length > nodesInSource &&\n         arraysAreEqual(sourceParent.getCoordinates(), targetParentCoordinates)\n      ) {\n         sourceHost.remove(sourceIndex + 1);\n      } else {\n         sourceHost.remove(sourceIndex);\n      }\n      //Update the tree data\n      this.rebuildTreeData();\n      //Publish drop data\n      this.drops$.next({\n         target: source.data,\n         oldParent: sourceParent.data as LimbleTreeNode,\n         oldIndex: sourceIndex,\n         newParent: targetParent.data,\n         newIndex: newIndex\n      });\n      this.cleanupSignal$.next(false);\n   }\n\n   /** Initializes the service and renders the tree.\n    * @param host - The ViewContainerRef into which the tree will be rendered.\n    * @param data - The data array that was passed in to LimbleTreeRoot, which is\n    * the users' representation of the tree\n    * @param options - The options object that was passed in to LimbleTreeRoot\n    */\n   public init(\n      host: ViewContainerRef,\n      data: LimbleTreeData,\n      options?: LimbleTreeOptions,\n      itemsPerPage?: number,\n      page?: number\n   ): void {\n      this.host = host;\n      this.originalData = data;\n      this.treeOptions = this.processOptions(options, itemsPerPage, page);\n      if (this.treeOptions.listMode === true) {\n         let start =\n            this.treeOptions.itemsPerPage * (this.treeOptions.page - 1);\n         if (isNaN(start)) {\n            //This catches the case where itemsPerPage was not passed by the user,\n            //causing `start` to equal infinity*0, which is NaN.\n            start = 0;\n         }\n         const end = start + this.treeOptions.itemsPerPage;\n         this.treeData = this.originalData.slice(start, end);\n      } else {\n         this.treeData = [...this.originalData];\n      }\n      this.render();\n   }\n\n   private cleanup(rebuild = false): void {\n      if (rebuild) {\n         this.rebuildTreeData();\n      }\n      if (this.treeData?.length === 0) {\n         //We do a full render here because it isn't actually any slower\n         //when there are no nodes, and it is a little more straightforward\n         this.render();\n      } else {\n         this.changes$.next(null);\n         this.dropZoneService.update();\n      }\n   }\n\n   /** Renders the entire tree from root to leaves */\n   private render() {\n      if (\n         this.host === undefined ||\n         this.treeData === undefined ||\n         this.treeOptions === undefined\n      ) {\n         throw new Error(\"TreeModel not initialized\");\n      }\n      this.treeConstructionStatus.ready(false);\n      this.host.clear();\n      this.dropZoneService.restart();\n      this.placeholder$.next(false);\n      this.treeModel = new Branch(null);\n      if (this.treeData.length === 0) {\n         //Tree is empty, but we have to to have something there so other trees' items can be dropped into it\n         this.placeholder$.next(true);\n      } else {\n         for (const node of this.treeData) {\n            const branch = new Branch(node);\n            this.treeModel.appendChild(branch);\n         }\n         for (const branch of this.treeModel.getChildren()) {\n            const componentRef = this.componentCreatorService.appendComponent<LimbleTreeNodeComponent>(\n               LimbleTreeNodeComponent,\n               this.host\n            );\n            componentRef.instance.branch = branch;\n            componentRef.instance.parentHost = this.host;\n            //The LimbleTreeNodeComponent will (indirectly) call the `renderBranch` method of this service to render\n            //its own children\n         }\n      }\n      this.treeConstructionStatus.ready(true);\n      this.changes$.next(null);\n      this.dropZoneService.init(this.treeModel, this.treeOptions);\n   }\n\n   /** Renders a branch of the tree and all of its descendants */\n   public renderBranch(host: ViewContainerRef, branch: Branch<any>) {\n      if (this.treeModel === undefined) {\n         throw new Error(\"TreeModel not initialized\");\n      }\n      host.clear();\n      branch.clearChildren();\n      for (const node of branch.data?.nodes ?? []) {\n         const newBranch = new Branch(node);\n         branch.appendChild(newBranch);\n         const componentRef = this.componentCreatorService.appendComponent<LimbleTreeNodeComponent>(\n            LimbleTreeNodeComponent,\n            host\n         );\n         componentRef.instance.branch = newBranch;\n         componentRef.instance.parentHost = host;\n         //The LimbleTreeNodeComponent will (indirectly) call the `renderBranch` method of this service to render\n         //its own children\n      }\n   }\n\n   private processOptions(\n      options: LimbleTreeOptions = {},\n      itemsPerPage: number = Infinity,\n      page: number = 1\n   ): ProcessedOptions {\n      if (\n         options.listMode === true &&\n         options.allowNesting !== undefined &&\n         options.allowNesting !== false\n      ) {\n         console.warn(\n            \"The value of `allowNesting` will be ignored; it must be false when `listMode` is true\"\n         );\n      }\n      const result: ProcessedOptionsBase = {\n         defaultComponent: options.defaultComponent,\n         indent: options.indent ?? INDENT,\n         allowNesting:\n            options.listMode !== true && (options.allowNesting ?? true),\n         allowDragging: options.allowDragging ?? true,\n         allowDrop: options.allowDrop ?? (() => true),\n         listMode: options.listMode ?? false,\n         itemsPerPage: options.listMode ? itemsPerPage : undefined,\n         page: options.listMode ? page : undefined\n      };\n      return result as ProcessedOptions;\n   }\n\n   private rebuildTreeData(): void {\n      if (\n         this.originalData === undefined ||\n         this.treeData === undefined ||\n         this.treeOptions === undefined ||\n         this.host === undefined\n      ) {\n         throw new Error(\"Tree data not initialized\");\n      }\n      this.treeData = [];\n      for (const branch of this.treeModel.getChildren()) {\n         this.treeData.push(this.rebuildBranch(branch));\n      }\n      if (\n         this.treeOptions.listMode === true &&\n         this.treeOptions.itemsPerPage < Infinity\n      ) {\n         const itemsPerPage = this.treeOptions.itemsPerPage;\n         const start = itemsPerPage * (this.treeOptions.page - 1);\n         this.originalData.splice(start, itemsPerPage, ...this.treeData);\n         if (this.treeData.length !== itemsPerPage) {\n            let action = false;\n            if (\n               this.treeData.length < itemsPerPage &&\n               start + itemsPerPage <= this.originalData.length\n            ) {\n               //The current page does not have enough nodes. Add some to the view from the next page.\n               const count = itemsPerPage - this.treeData.length;\n               for (\n                  let index = itemsPerPage - 1;\n                  index < itemsPerPage + count - 1;\n                  index++\n               ) {\n                  const branch = new Branch(this.originalData[start + index]);\n                  this.treeModel.appendChild(branch);\n                  const componentRef = this.componentCreatorService.appendComponent<LimbleTreeNodeComponent>(\n                     LimbleTreeNodeComponent,\n                     this.host\n                  );\n                  componentRef.instance.branch = branch;\n                  componentRef.instance.parentHost = this.host;\n               }\n               action = true;\n            } else if (this.treeData.length > itemsPerPage) {\n               //The current page has too many nodes. Remove some of them from the view.\n               const count = this.treeData.length - itemsPerPage;\n               for (\n                  let index = itemsPerPage + count - 1;\n                  index >= itemsPerPage;\n                  index--\n               ) {\n                  this.treeModel.removeChild(index);\n                  this.host.remove(index);\n               }\n               action = true;\n            }\n            if (action === true) {\n               const end = start + itemsPerPage;\n               this.treeData = this.originalData.slice(start, end);\n            }\n         }\n      } else {\n         this.originalData.length = 0;\n         this.originalData.push(...this.treeData);\n      }\n   }\n\n   private rebuildBranch(branch: Branch<any>): LimbleTreeNode {\n      const temp: LimbleTreeNode = branch.data;\n      temp.nodes = [];\n      for (const child of branch.getChildren()) {\n         temp.nodes.push(this.rebuildBranch(child));\n      }\n      return temp;\n   }\n}\n"]}

package/{esm2015/lib/limble-tree.module.js → esm2020/lib/limble-tree.module.mjs}

@@ -16,7 +16,7 @@ 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]] });
+LimbleTreeModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [ComponentCreatorService, DragStateService, GlobalEventsService], imports: [CommonModule] });
 (function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LimbleTreeModule, [{
         type: NgModule,
         args: [{
@@ -41,7 +41,7 @@ LimbleTreeModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [Compo
         LimbleTreePlaceholderComponent,
         DragoverNoChangeDetectDirective,
         DragleaveNoChangeDetectDirective], imports: [CommonModule], exports: [LimbleTreeRootComponent] }); })();
-i0.ɵɵsetComponentScope(LimbleTreeNodeComponent, [i1.NgIf, DropZoneComponent,
-    DragoverNoChangeDetectDirective,
-    LimbleTreeBranchComponent], []);
-//# sourceMappingURL=data:application/json;base64,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
+i0.ɵɵsetComponentScope(LimbleTreeNodeComponent, [i1.NgIf, LimbleTreeBranchComponent,
+    DropZoneComponent,
+    DragoverNoChangeDetectDirective], []);
+//# sourceMappingURL=data:application/json;base64,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