@limble/limble-tree 0.12.2 → 0.13.0

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

@@ -0,0 +1,467 @@
+import { Component, ElementRef, Input, ViewChild, ViewContainerRef } from "@angular/core";
+import { arraysAreEqual, isDraggingAllowed, isNestingAllowed, suddenTreeExit } from "../util";
+import { filter, first, skip, skipUntil } from "rxjs/operators";
+import { DropZone } from "../classes/DropZone";
+import { fromEvent, merge } from "rxjs";
+import { LimbleTreeBranchComponent } from "../limble-tree-branch/limble-tree-branch.component";
+import * as i0 from "@angular/core";
+import * as i1 from "../singletons/component-creator.service";
+import * as i2 from "../singletons/drag-state.service";
+import * as i3 from "../limble-tree-root/drop-zone.service";
+import * as i4 from "../limble-tree-root/tree.service";
+import * as i5 from "../singletons/global-events.service";
+import * as i6 from "../limble-tree-root/tree-construction-status.service";
+const _c0 = ["nodeHost"];
+const _c1 = ["draggableDiv"];
+const _c2 = ["nodeHostContainer"];
+const _c3 = ["innerBranch"];
+function LimbleTreeNodeComponent_drop_zone_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "drop-zone", 7);
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("dropZone", ctx_r0.dropZoneAbove);
+} }
+function LimbleTreeNodeComponent_ng_template_5_Template(rf, ctx) { }
+function LimbleTreeNodeComponent_limble_tree_branch_7_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "limble-tree-branch", 8, 9);
+} if (rf & 2) {
+    const ctx_r5 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("branch", ctx_r5.branch);
+} }
+function LimbleTreeNodeComponent_drop_zone_8_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "drop-zone", 7);
+} if (rf & 2) {
+    const ctx_r6 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("dropZone", ctx_r6.dropZoneBelow);
+} }
+export class LimbleTreeNodeComponent {
+    constructor(componentCreatorService, changeDetectorRef, dragStateService, dropZoneService, treeService, globalEventsService, ngZone, treeConstructionStatus) {
+        this.componentCreatorService = componentCreatorService;
+        this.changeDetectorRef = changeDetectorRef;
+        this.dragStateService = dragStateService;
+        this.dropZoneService = dropZoneService;
+        this.treeService = treeService;
+        this.globalEventsService = globalEventsService;
+        this.ngZone = ngZone;
+        this.treeConstructionStatus = treeConstructionStatus;
+        this.treeConstructionStatus.constructing();
+        if (this.treeService.treeOptions !== undefined &&
+            this.treeService.treeOptions.listMode !== true) {
+            this.renderInnerBranch = true;
+        }
+        else {
+            this.renderInnerBranch = false;
+        }
+        this.renderDropZoneBelow = false;
+        this.renderDropZoneAbove = false;
+        this.treeChangeSubscription = this.treeService.changes$
+            .pipe(
+        //The first one is the initial tree render, which we can ignore
+        skip(1))
+            .subscribe(() => {
+            this.treeChangeHandler();
+        });
+    }
+    treeChangeHandler() {
+        if (this.branch !== undefined &&
+            this.currentBranchCoordinates !== undefined &&
+            !arraysAreEqual(this.branch.getCoordinates(), this.currentBranchCoordinates)) {
+            this.updateDropZones();
+        }
+    }
+    ngOnInit() {
+        if (this.treeService.treeOptions?.allowDragging === false) {
+            return;
+        }
+        const parent = this.branch?.getParent();
+        if (parent?.data !== null) {
+            const parentData = parent?.data;
+            if (!isNestingAllowed(this.treeService.treeOptions, parentData)) {
+                this.renderInnerBranch = false;
+                return;
+            }
+        }
+        this.registerDropZones();
+        this.currentBranchCoordinates = this.branch?.getCoordinates();
+        this.ngZone.runOutsideAngular(() => {
+            if (this.dropZoneAbove === undefined ||
+                this.dropZoneBelow === undefined) {
+                throw new Error("Zones not registered");
+            }
+            merge(this.dropZoneAbove.getCommChannel(), this.dropZoneBelow.getCommChannel())
+                .pipe(filter((message) => message === "checkRendered"))
+                .subscribe(() => {
+                if (this.dropZoneAbove === undefined ||
+                    this.dropZoneBelow === undefined ||
+                    this.branch === undefined) {
+                    throw new Error("Zones not registered");
+                }
+                this.renderDropZoneAbove = this.dropZoneAbove.isRendered();
+                this.renderDropZoneBelow = this.dropZoneBelow.isRendered();
+            });
+        });
+    }
+    ngAfterViewInit() {
+        this.renderNode();
+        this.setDropZoneHosts();
+        this.checkForHandle();
+        this.treeConstructionStatus.doneConstructing();
+        this.changeDetectorRef.detectChanges();
+    }
+    ngOnDestroy() {
+        this.treeChangeSubscription.unsubscribe();
+        if (this.dropZoneAbove !== undefined) {
+            this.dropZoneService.removeDropZone(this.dropZoneAbove);
+        }
+        if (this.dropZoneBelow !== undefined) {
+            this.dropZoneService.removeDropZone(this.dropZoneBelow);
+        }
+        this.treeService.cleanupSignal$.next(true);
+    }
+    dragstartHandler(event) {
+        event.stopPropagation();
+        if (event.dataTransfer === null ||
+            this.branch === undefined ||
+            this.parentHost === undefined) {
+            throw new Error("failed to run dragstartHandler");
+        }
+        const draggedElement = event.target;
+        if (draggedElement.parentElement?.tagName !== "LIMBLE-TREE-NODE") {
+            //Don't drag stuff that isn't part of the tree
+            event.preventDefault();
+            return;
+        }
+        event.dataTransfer.effectAllowed = "move";
+        this.dragStateService.dragging(this.branch, this.parentHost);
+        const treeElement = draggedElement.closest("limble-tree-root");
+        if (treeElement === null) {
+            throw new Error("could not get root of tree");
+        }
+        this.ngZone.runOutsideAngular(() => {
+            //We have to use a setTimeout due to a bug in chrome: https://stackoverflow.com/a/20733870/8796651
+            setTimeout(() => {
+                draggedElement.classList.add("dragging");
+                if (this.treeService.treeData?.length === 1 &&
+                    this.branch?.getCoordinates().length === 1) {
+                    //We are dragging the only element in the tree, so we have to use the placeholder system
+                    this.treeService.placeholder$.next(true);
+                }
+            });
+            //We use this weird subscription/timeout combo in order to avoid a strange bug where the dragleave event
+            //does not fire if the user drags out of the tree too quickly. This issue would make the drop zone
+            //remain in the UI, potentially causing drop zones to appear in multiple trees at a time. This subscription
+            //waits for the dragover event on the tree to fire before rendering any drop zones. If the dragover
+            //event does not fire within a half second, we know the mouse left the tree too quickly, and we won't
+            //render the drop zone at all.
+            const dragSubscription = fromEvent(treeElement, "dragover")
+                .pipe(first())
+                .subscribe((dragoverEvent) => {
+                dragoverEvent.stopPropagation();
+                if (this.branch === undefined) {
+                    throw new Error("Could not show surrounding drop zones");
+                }
+                const parent = this.branch.getParent();
+                let parentData;
+                let parentNestingAllowed = true;
+                if (parent?.data !== null) {
+                    parentData = parent?.data;
+                    parentNestingAllowed = isNestingAllowed(this.treeService.treeOptions, parentData);
+                }
+                if (this.dropZoneAbove !== undefined && parentNestingAllowed) {
+                    this.dropZoneService.showDropZoneFamily(this.dropZoneAbove, {
+                        joinFamilies: true
+                    });
+                }
+            });
+            setTimeout(() => {
+                if (!dragSubscription.closed) {
+                    dragSubscription.unsubscribe();
+                }
+            }, 500);
+        });
+    }
+    dragendHandler(event) {
+        event?.stopPropagation();
+        if (this.draggableDiv === undefined) {
+            throw new Error("could not get draggable div");
+        }
+        this.draggableDiv.nativeElement.classList.remove("dragging");
+        if (this.dragStateService.getState() === "captured") {
+            if (this.treeService.captured === false) {
+                //Dropped in a different tree. Remove the one in this tree
+                if (this.branch === undefined) {
+                    throw new Error("could not get branch in dragendHandler");
+                }
+                this.treeService.cleanupSignal$.next(true);
+                this.treeService.captured = false;
+            }
+            this.dragStateService.release();
+        }
+        else {
+            //Wasn't dropped into a valid tree, so reset for next drag and
+            //don't do anything else.
+            this.dragStateService.release();
+            this.dropZoneService.clearVisibleZones();
+            this.dropZoneService.restoreFamilies();
+            if (this.treeService.treeData?.length === 1 &&
+                this.branch?.getCoordinates().length === 1) {
+                //We were dragging the only element in the tree, so we have to
+                //remove the placeholder that we added in the dragstart
+                this.treeService.placeholder$.next(false);
+            }
+        }
+    }
+    dragoverHandler(event) {
+        if (this.globalEventsService.scrolling === true) {
+            return;
+        }
+        if (this.branch === undefined) {
+            throw new Error("Can't get current branch during dragover event");
+        }
+        const data = this.dragStateService.getData();
+        if (data === undefined) {
+            //They might be dragging something that isn't a node. Just ignore it.
+            return;
+        }
+        const sourceBranch = data.branch;
+        //If trying to drop on self, return.
+        if (sourceBranch === this.branch ||
+            this.branch.getAncestors().includes(sourceBranch)) {
+            return;
+        }
+        const target = event.currentTarget.closest(".node-host-container");
+        if (!(target instanceof HTMLElement)) {
+            throw new Error("Failed to find node host container while dragging");
+        }
+        let topLine;
+        let bottomLine;
+        if (this.innerBranch?.renderDropZoneInside === false) {
+            topLine = target.offsetHeight / 2 - 6;
+            bottomLine = topLine;
+        }
+        else {
+            topLine = target.offsetHeight / 3 - 3; //an imaginary line 1/3 of the way down from the top of the element;
+            bottomLine = topLine * 2; //an imaginary line 1/3 of the way up from the bottom of the element;
+        }
+        const parent = this.branch.getParent();
+        let parentData;
+        let parentNestingAllowed = true;
+        if (parent?.data !== null) {
+            parentData = parent?.data;
+            parentNestingAllowed = isNestingAllowed(this.treeService.treeOptions, parentData);
+        }
+        /** The y-coordinates of the mouse in relation to the node it is hovering over */
+        const offsetY = event.clientY - target.getBoundingClientRect().top;
+        const activeDropZone = this.dropZoneService.getActiveDropZone();
+        if (offsetY < topLine &&
+            this.dropZoneAbove !== undefined &&
+            parentNestingAllowed &&
+            (activeDropZone === null ||
+                !DropZone.dropZoneLocationsAreEqual(activeDropZone, this.dropZoneAbove))) {
+            const index = this.branch.getIndex();
+            if (index === undefined || index === null) {
+                throw new Error("can't get branch index");
+            }
+            this.dropZoneService.showDropZoneFamily(this.dropZoneAbove, {
+                activateLowestInsteadOfFounder: true
+            });
+            if (suddenTreeExit(event)) {
+                this.dropZoneService.clearVisibleZones();
+            }
+        }
+        else if (offsetY < bottomLine &&
+            offsetY > topLine &&
+            this.innerBranch?.renderDropZoneInside === true &&
+            this.innerBranch?.dropZoneInside !== undefined &&
+            (activeDropZone === null ||
+                !DropZone.dropZoneLocationsAreEqual(activeDropZone, this.innerBranch.dropZoneInside))) {
+            this.dropZoneService.showDropZoneFamily(this.innerBranch.dropZoneInside);
+            if (suddenTreeExit(event)) {
+                this.dropZoneService.clearVisibleZones();
+            }
+        }
+        else if (offsetY >= bottomLine &&
+            this.dropZoneBelow !== undefined &&
+            parentNestingAllowed &&
+            (activeDropZone === null ||
+                !DropZone.dropZoneLocationsAreEqual(activeDropZone, this.dropZoneBelow)) &&
+            this.branch.getChildren().length === 0) {
+            const index = this.branch.getIndex();
+            if (index === undefined || index === null) {
+                throw new Error("can't get branch index");
+            }
+            this.dropZoneService.showDropZoneFamily(this.dropZoneBelow);
+            if (suddenTreeExit(event)) {
+                this.dropZoneService.clearVisibleZones();
+            }
+        }
+    }
+    renderNode() {
+        if (this.nodeHost === undefined || this.branch === undefined) {
+            throw new Error("Failed to render tree node");
+        }
+        let component = this.branch.data.component;
+        if (component === undefined) {
+            component = this.treeService.treeOptions?.defaultComponent;
+        }
+        if (component === undefined) {
+            throw new Error("limbleTree requires a component to render");
+        }
+        const componentRef = this.componentCreatorService.appendComponent(component.class, this.nodeHost);
+        componentRef.instance.nodeData = this.branch.data;
+        for (const binding in component.bindings) {
+            componentRef.instance[binding] = component.bindings[binding];
+        }
+    }
+    registerDropZones() {
+        this.addDropZoneAbove();
+        this.addDropZoneBelow();
+    }
+    addDropZoneAbove() {
+        if (this.branch === undefined) {
+            throw new Error("failed to register drop zone above");
+        }
+        const parent = this.branch.getParent();
+        const currentCoordinates = this.branch.getCoordinates();
+        const index = currentCoordinates[currentCoordinates.length - 1];
+        this.dropZoneAbove = new DropZone([...(parent?.getCoordinates() ?? [])], index);
+        this.dropZoneService.addDropZone(this.dropZoneAbove);
+    }
+    addDropZoneBelow() {
+        if (this.branch === undefined) {
+            throw new Error("failed to register drop zone below");
+        }
+        const parent = this.branch.getParent();
+        const currentCoordinates = this.branch.getCoordinates();
+        const index = currentCoordinates[currentCoordinates.length - 1];
+        this.dropZoneBelow = new DropZone([...(parent?.getCoordinates() ?? [])], index + 1);
+        this.dropZoneService.addDropZone(this.dropZoneBelow);
+    }
+    updateDropZones() {
+        this.currentBranchCoordinates = this.branch?.getCoordinates();
+        this.updateDropZoneAbove();
+        this.updateDropZoneBelow();
+        this.updateDropZoneInside();
+        this.setDropZoneHosts();
+    }
+    updateDropZoneAbove() {
+        if (this.branch === undefined || this.dropZoneAbove === undefined) {
+            throw new Error("failed to update drop zone above");
+        }
+        const parent = this.branch.getParent();
+        const currentCoordinates = this.branch.getCoordinates();
+        const index = currentCoordinates[currentCoordinates.length - 1];
+        const location = this.dropZoneAbove.getLocation();
+        location.setParentCoordinates([...(parent?.getCoordinates() ?? [])]);
+        location.setInsertIndex(index);
+    }
+    updateDropZoneBelow() {
+        if (this.branch === undefined || this.dropZoneBelow === undefined) {
+            throw new Error("failed to update drop zone below");
+        }
+        const parent = this.branch.getParent();
+        const currentCoordinates = this.branch.getCoordinates();
+        const index = currentCoordinates[currentCoordinates.length - 1];
+        const location = this.dropZoneBelow.getLocation();
+        location.setParentCoordinates([...(parent?.getCoordinates() ?? [])]);
+        location.setInsertIndex(index + 1);
+    }
+    updateDropZoneInside() {
+        if (this.innerBranch?.dropZoneInside === undefined) {
+            return;
+        }
+        if (this.branch === undefined) {
+            throw new Error("failed to update drop zone inside");
+        }
+        const location = this.innerBranch.dropZoneInside.getLocation();
+        location.setParentCoordinates([...this.branch.getCoordinates()]);
+    }
+    setDropZoneHosts() {
+        if (this.dropZoneAbove === undefined ||
+            this.dropZoneBelow === undefined) {
+            return;
+        }
+        this.dropZoneAbove.setHost(this.parentHost);
+        this.dropZoneBelow.setHost(this.parentHost);
+    }
+    checkForHandle() {
+        if (this.nodeHostContainer === undefined ||
+            this.draggableDiv === undefined) {
+            return;
+        }
+        const nodeHostContainerElement = this.nodeHostContainer.nativeElement;
+        const handle = nodeHostContainerElement.querySelector(".limble-tree-handle");
+        const draggableDivElement = this.draggableDiv.nativeElement;
+        if (!isDraggingAllowed(this.treeService.treeOptions, this.branch?.data)) {
+            draggableDivElement.setAttribute("draggable", "false");
+        }
+        else if (handle === null) {
+            draggableDivElement.setAttribute("draggable", "true");
+        }
+        else {
+            handle.addEventListener("mousedown", () => {
+                draggableDivElement.setAttribute("draggable", "true");
+                //For some reason mouseup doesn't fire after a drag, so we use this observable sequence instead.
+                const dragging = this.dragStateService.state$.pipe(filter((state) => state === "dragging"), first());
+                this.dragStateService.state$
+                    .pipe(skipUntil(dragging), filter((state) => state === "idle"), first())
+                    .subscribe(() => {
+                    draggableDivElement.setAttribute("draggable", "false");
+                });
+            });
+        }
+    }
+}
+LimbleTreeNodeComponent.ɵfac = function LimbleTreeNodeComponent_Factory(t) { return new (t || LimbleTreeNodeComponent)(i0.ɵɵdirectiveInject(i1.ComponentCreatorService), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i2.DragStateService), i0.ɵɵdirectiveInject(i3.DropZoneService), i0.ɵɵdirectiveInject(i4.TreeService), i0.ɵɵdirectiveInject(i5.GlobalEventsService), i0.ɵɵdirectiveInject(i0.NgZone), i0.ɵɵdirectiveInject(i6.TreeConstructionStatus)); };
+LimbleTreeNodeComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LimbleTreeNodeComponent, selectors: [["limble-tree-node"]], viewQuery: function LimbleTreeNodeComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(_c0, 5, ViewContainerRef);
+        i0.ɵɵviewQuery(_c1, 5, ElementRef);
+        i0.ɵɵviewQuery(_c2, 5, ElementRef);
+        i0.ɵɵviewQuery(_c3, 5, LimbleTreeBranchComponent);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.nodeHost = _t.first);
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.draggableDiv = _t.first);
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.nodeHostContainer = _t.first);
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.innerBranch = _t.first);
+    } }, inputs: { branch: "branch", parentHost: "parentHost" }, decls: 9, vars: 4, consts: [[3, "dropZone", 4, "ngIf"], [1, "limble-parent-container", 3, "dragstart", "dragend"], ["draggableDiv", ""], [1, "node-host-container", 3, "dragoverEventThrottle", "dragoverNoChangeDetect"], ["nodeHostContainer", ""], ["nodeHost", ""], [3, "branch", 4, "ngIf"], [3, "dropZone"], [3, "branch"], ["innerBranch", ""]], template: function LimbleTreeNodeComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵtemplate(0, LimbleTreeNodeComponent_drop_zone_0_Template, 1, 1, "drop-zone", 0);
+        i0.ɵɵelementStart(1, "div", 1, 2);
+        i0.ɵɵlistener("dragstart", function LimbleTreeNodeComponent_Template_div_dragstart_1_listener($event) { return ctx.dragstartHandler($event); })("dragend", function LimbleTreeNodeComponent_Template_div_dragend_1_listener($event) { return ctx.dragendHandler($event); });
+        i0.ɵɵelementStart(3, "div", 3, 4);
+        i0.ɵɵlistener("dragoverNoChangeDetect", function LimbleTreeNodeComponent_Template_div_dragoverNoChangeDetect_3_listener($event) { return ctx.dragoverHandler($event); });
+        i0.ɵɵtemplate(5, LimbleTreeNodeComponent_ng_template_5_Template, 0, 0, "ng-template", null, 5, i0.ɵɵtemplateRefExtractor);
+        i0.ɵɵelementEnd();
+        i0.ɵɵtemplate(7, LimbleTreeNodeComponent_limble_tree_branch_7_Template, 2, 1, "limble-tree-branch", 6);
+        i0.ɵɵelementEnd();
+        i0.ɵɵtemplate(8, LimbleTreeNodeComponent_drop_zone_8_Template, 1, 1, "drop-zone", 0);
+    } if (rf & 2) {
+        i0.ɵɵproperty("ngIf", ctx.renderDropZoneAbove === true);
+        i0.ɵɵadvance(3);
+        i0.ɵɵproperty("dragoverEventThrottle", 10);
+        i0.ɵɵadvance(4);
+        i0.ɵɵproperty("ngIf", ctx.branch !== undefined && ctx.renderInnerBranch === true);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngIf", ctx.renderDropZoneBelow === true);
+    } }, styles: [".dragging[_ngcontent-%COMP%]{position:absolute;transition:transform .01s;transform:translate(-9999px)}"] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LimbleTreeNodeComponent, [{
+        type: Component,
+        args: [{ selector: "limble-tree-node", template: "<drop-zone\n   *ngIf=\"renderDropZoneAbove === true\"\n   [dropZone]=\"dropZoneAbove\"\n></drop-zone>\n<div\n   (dragstart)=\"dragstartHandler($event)\"\n   (dragend)=\"dragendHandler($event)\"\n   class=\"limble-parent-container\"\n   #draggableDiv\n>\n   <div\n      class=\"node-host-container\"\n      (dragoverNoChangeDetect)=\"dragoverHandler($event)\"\n      [dragoverEventThrottle]=\"10\"\n      #nodeHostContainer\n   >\n      <ng-template #nodeHost></ng-template>\n   </div>\n   <limble-tree-branch\n      *ngIf=\"branch !== undefined && renderInnerBranch === true\"\n      [branch]=\"branch\"\n      #innerBranch\n   ></limble-tree-branch>\n</div>\n<drop-zone\n   *ngIf=\"renderDropZoneBelow === true\"\n   [dropZone]=\"dropZoneBelow\"\n></drop-zone>\n", styles: [".dragging{position:absolute;transition:transform .01s;transform:translate(-9999px)}\n"] }]
+    }], function () { return [{ type: i1.ComponentCreatorService }, { type: i0.ChangeDetectorRef }, { type: i2.DragStateService }, { type: i3.DropZoneService }, { type: i4.TreeService }, { type: i5.GlobalEventsService }, { type: i0.NgZone }, { type: i6.TreeConstructionStatus }]; }, { branch: [{
+            type: Input
+        }], nodeHost: [{
+            type: ViewChild,
+            args: ["nodeHost", { read: ViewContainerRef }]
+        }], draggableDiv: [{
+            type: ViewChild,
+            args: ["draggableDiv", { read: ElementRef }]
+        }], nodeHostContainer: [{
+            type: ViewChild,
+            args: ["nodeHostContainer", { read: ElementRef }]
+        }], parentHost: [{
+            type: Input
+        }], innerBranch: [{
+            type: ViewChild,
+            args: ["innerBranch", { read: LimbleTreeBranchComponent }]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"limble-tree-node.component.js","sourceRoot":"","sources":["../../../../../projects/limble-tree/src/lib/limble-tree-node/limble-tree-node.component.ts","../../../../../projects/limble-tree/src/lib/limble-tree-node/limble-tree-node.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n   AfterViewInit,\n   ChangeDetectorRef,\n   Component,\n   ElementRef,\n   Input,\n   NgZone,\n   OnDestroy,\n   OnInit,\n   ViewChild,\n   ViewContainerRef\n} from \"@angular/core\";\nimport { ComponentCreatorService } from \"../singletons/component-creator.service\";\nimport { DropZoneService } from \"../limble-tree-root/drop-zone.service\";\nimport { DragStateService } from \"../singletons/drag-state.service\";\nimport { LimbleTreeNode, TreeService } from \"../limble-tree-root/tree.service\";\nimport { Branch, BranchCoordinates } from \"../classes/Branch\";\nimport {\n   arraysAreEqual,\n   isDraggingAllowed,\n   isNestingAllowed,\n   suddenTreeExit\n} from \"../util\";\nimport { filter, first, skip, skipUntil } from \"rxjs/operators\";\nimport { GlobalEventsService } from \"../singletons/global-events.service\";\nimport { DropZone } from \"../classes/DropZone\";\nimport { fromEvent, merge, Subscription } from \"rxjs\";\nimport { LimbleTreeBranchComponent } from \"../limble-tree-branch/limble-tree-branch.component\";\nimport { TreeConstructionStatus } from \"../limble-tree-root/tree-construction-status.service\";\n\n@Component({\n   selector: \"limble-tree-node\",\n   templateUrl: \"./limble-tree-node.component.html\",\n   styleUrls: [\"./limble-tree-node.component.scss\"]\n})\nexport class LimbleTreeNodeComponent\n   implements OnInit, AfterViewInit, OnDestroy\n{\n   @Input() branch: Branch<any> | undefined;\n   @ViewChild(\"nodeHost\", { read: ViewContainerRef }) private nodeHost:\n      | ViewContainerRef\n      | undefined;\n   public dropZoneAbove: DropZone | undefined;\n   public renderDropZoneAbove: boolean;\n   public dropZoneBelow: DropZone | undefined;\n   public renderDropZoneBelow: boolean;\n   public renderInnerBranch: Boolean;\n   @ViewChild(\"draggableDiv\", { read: ElementRef }) private draggableDiv:\n      | ElementRef<HTMLElement>\n      | undefined;\n   @ViewChild(\"nodeHostContainer\", { read: ElementRef })\n   private nodeHostContainer: ElementRef<HTMLElement> | undefined;\n   private currentBranchCoordinates: BranchCoordinates | undefined;\n   private readonly treeChangeSubscription: Subscription;\n   @Input() parentHost: ViewContainerRef | undefined;\n   @ViewChild(\"innerBranch\", { read: LimbleTreeBranchComponent })\n   private innerBranch: LimbleTreeBranchComponent | undefined;\n\n   constructor(\n      private readonly componentCreatorService: ComponentCreatorService,\n      private readonly changeDetectorRef: ChangeDetectorRef,\n      private readonly dragStateService: DragStateService,\n      private readonly dropZoneService: DropZoneService,\n      private readonly treeService: TreeService,\n      private readonly globalEventsService: GlobalEventsService,\n      private readonly ngZone: NgZone,\n      private readonly treeConstructionStatus: TreeConstructionStatus\n   ) {\n      this.treeConstructionStatus.constructing();\n      if (\n         this.treeService.treeOptions !== undefined &&\n         this.treeService.treeOptions.listMode !== true\n      ) {\n         this.renderInnerBranch = true;\n      } else {\n         this.renderInnerBranch = false;\n      }\n      this.renderDropZoneBelow = false;\n      this.renderDropZoneAbove = false;\n      this.treeChangeSubscription = this.treeService.changes$\n         .pipe(\n            //The first one is the initial tree render, which we can ignore\n            skip(1)\n         )\n         .subscribe(() => {\n            this.treeChangeHandler();\n         });\n   }\n\n   private treeChangeHandler() {\n      if (\n         this.branch !== undefined &&\n         this.currentBranchCoordinates !== undefined &&\n         !arraysAreEqual(\n            this.branch.getCoordinates(),\n            this.currentBranchCoordinates\n         )\n      ) {\n         this.updateDropZones();\n      }\n   }\n\n   ngOnInit() {\n      if (this.treeService.treeOptions?.allowDragging === false) {\n         return;\n      }\n      const parent = this.branch?.getParent();\n      if (parent?.data !== null) {\n         const parentData = parent?.data as LimbleTreeNode;\n         if (!isNestingAllowed(this.treeService.treeOptions, parentData)) {\n            this.renderInnerBranch = false;\n            return;\n         }\n      }\n      this.registerDropZones();\n      this.currentBranchCoordinates = this.branch?.getCoordinates();\n      this.ngZone.runOutsideAngular(() => {\n         if (\n            this.dropZoneAbove === undefined ||\n            this.dropZoneBelow === undefined\n         ) {\n            throw new Error(\"Zones not registered\");\n         }\n         merge(\n            this.dropZoneAbove.getCommChannel(),\n            this.dropZoneBelow.getCommChannel()\n         )\n            .pipe(filter((message) => message === \"checkRendered\"))\n            .subscribe(() => {\n               if (\n                  this.dropZoneAbove === undefined ||\n                  this.dropZoneBelow === undefined ||\n                  this.branch === undefined\n               ) {\n                  throw new Error(\"Zones not registered\");\n               }\n               this.renderDropZoneAbove = this.dropZoneAbove.isRendered();\n               this.renderDropZoneBelow = this.dropZoneBelow.isRendered();\n            });\n      });\n   }\n\n   ngAfterViewInit() {\n      this.renderNode();\n      this.setDropZoneHosts();\n      this.checkForHandle();\n      this.treeConstructionStatus.doneConstructing();\n      this.changeDetectorRef.detectChanges();\n   }\n\n   ngOnDestroy() {\n      this.treeChangeSubscription.unsubscribe();\n      if (this.dropZoneAbove !== undefined) {\n         this.dropZoneService.removeDropZone(this.dropZoneAbove);\n      }\n      if (this.dropZoneBelow !== undefined) {\n         this.dropZoneService.removeDropZone(this.dropZoneBelow);\n      }\n      this.treeService.cleanupSignal$.next(true);\n   }\n\n   public dragstartHandler(event: DragEvent): void {\n      event.stopPropagation();\n      if (\n         event.dataTransfer === null ||\n         this.branch === undefined ||\n         this.parentHost === undefined\n      ) {\n         throw new Error(\"failed to run dragstartHandler\");\n      }\n      const draggedElement = event.target as HTMLElement;\n      if (draggedElement.parentElement?.tagName !== \"LIMBLE-TREE-NODE\") {\n         //Don't drag stuff that isn't part of the tree\n         event.preventDefault();\n         return;\n      }\n      event.dataTransfer.effectAllowed = \"move\";\n      this.dragStateService.dragging(this.branch, this.parentHost);\n      const treeElement = draggedElement.closest(\"limble-tree-root\");\n      if (treeElement === null) {\n         throw new Error(\"could not get root of tree\");\n      }\n      this.ngZone.runOutsideAngular(() => {\n         //We have to use a setTimeout due to a bug in chrome: https://stackoverflow.com/a/20733870/8796651\n         setTimeout(() => {\n            draggedElement.classList.add(\"dragging\");\n            if (\n               this.treeService.treeData?.length === 1 &&\n               this.branch?.getCoordinates().length === 1\n            ) {\n               //We are dragging the only element in the tree, so we have to use the placeholder system\n               this.treeService.placeholder$.next(true);\n            }\n         });\n         //We use this weird subscription/timeout combo in order to avoid a strange bug where the dragleave event\n         //does not fire if the user drags out of the tree too quickly. This issue would make the drop zone\n         //remain in the UI, potentially causing drop zones to appear in multiple trees at a time. This subscription\n         //waits for the dragover event on the tree to fire before rendering any drop zones. If the dragover\n         //event does not fire within a half second, we know the mouse left the tree too quickly, and we won't\n         //render the drop zone at all.\n         const dragSubscription = fromEvent(treeElement, \"dragover\")\n            .pipe(first())\n            .subscribe((dragoverEvent) => {\n               dragoverEvent.stopPropagation();\n               if (this.branch === undefined) {\n                  throw new Error(\"Could not show surrounding drop zones\");\n               }\n               const parent = this.branch.getParent();\n               let parentData: LimbleTreeNode;\n               let parentNestingAllowed = true;\n               if (parent?.data !== null) {\n                  parentData = parent?.data as LimbleTreeNode;\n                  parentNestingAllowed = isNestingAllowed(\n                     this.treeService.treeOptions,\n                     parentData\n                  );\n               }\n               if (this.dropZoneAbove !== undefined && parentNestingAllowed) {\n                  this.dropZoneService.showDropZoneFamily(this.dropZoneAbove, {\n                     joinFamilies: true\n                  });\n               }\n            });\n         setTimeout(() => {\n            if (!dragSubscription.closed) {\n               dragSubscription.unsubscribe();\n            }\n         }, 500);\n      });\n   }\n\n   public dragendHandler(event?: DragEvent): void {\n      event?.stopPropagation();\n      if (this.draggableDiv === undefined) {\n         throw new Error(\"could not get draggable div\");\n      }\n      this.draggableDiv.nativeElement.classList.remove(\"dragging\");\n      if (this.dragStateService.getState() === \"captured\") {\n         if (this.treeService.captured === false) {\n            //Dropped in a different tree. Remove the one in this tree\n            if (this.branch === undefined) {\n               throw new Error(\"could not get branch in dragendHandler\");\n            }\n            this.treeService.cleanupSignal$.next(true);\n            this.treeService.captured = false;\n         }\n         this.dragStateService.release();\n      } else {\n         //Wasn't dropped into a valid tree, so reset for next drag and\n         //don't do anything else.\n         this.dragStateService.release();\n         this.dropZoneService.clearVisibleZones();\n         this.dropZoneService.restoreFamilies();\n         if (\n            this.treeService.treeData?.length === 1 &&\n            this.branch?.getCoordinates().length === 1\n         ) {\n            //We were dragging the only element in the tree, so we have to\n            //remove the placeholder that we added in the dragstart\n            this.treeService.placeholder$.next(false);\n         }\n      }\n   }\n\n   public dragoverHandler(event: DragEvent) {\n      if (this.globalEventsService.scrolling === true) {\n         return;\n      }\n      if (this.branch === undefined) {\n         throw new Error(\"Can't get current branch during dragover event\");\n      }\n      const data = this.dragStateService.getData();\n      if (data === undefined) {\n         //They might be dragging something that isn't a node. Just ignore it.\n         return;\n      }\n      const sourceBranch = data.branch;\n      //If trying to drop on self, return.\n      if (\n         sourceBranch === this.branch ||\n         this.branch.getAncestors().includes(sourceBranch)\n      ) {\n         return;\n      }\n      const target = (event.currentTarget as HTMLElement).closest(\n         \".node-host-container\"\n      );\n      if (!(target instanceof HTMLElement)) {\n         throw new Error(\"Failed to find node host container while dragging\");\n      }\n      let topLine: number;\n      let bottomLine: number;\n      if (this.innerBranch?.renderDropZoneInside === false) {\n         topLine = target.offsetHeight / 2 - 6;\n         bottomLine = topLine;\n      } else {\n         topLine = target.offsetHeight / 3 - 3; //an imaginary line 1/3 of the way down from the top of the element;\n         bottomLine = topLine * 2; //an imaginary line 1/3 of the way up from the bottom of the element;\n      }\n      const parent = this.branch.getParent();\n      let parentData: LimbleTreeNode;\n      let parentNestingAllowed = true;\n      if (parent?.data !== null) {\n         parentData = parent?.data as LimbleTreeNode;\n         parentNestingAllowed = isNestingAllowed(\n            this.treeService.treeOptions,\n            parentData\n         );\n      }\n      /** The y-coordinates of the mouse in relation to the node it is hovering over */\n      const offsetY = event.clientY - target.getBoundingClientRect().top;\n      const activeDropZone = this.dropZoneService.getActiveDropZone();\n      if (\n         offsetY < topLine &&\n         this.dropZoneAbove !== undefined &&\n         parentNestingAllowed &&\n         (activeDropZone === null ||\n            !DropZone.dropZoneLocationsAreEqual(\n               activeDropZone,\n               this.dropZoneAbove\n            ))\n      ) {\n         const index = this.branch.getIndex();\n         if (index === undefined || index === null) {\n            throw new Error(\"can't get branch index\");\n         }\n         this.dropZoneService.showDropZoneFamily(this.dropZoneAbove, {\n            activateLowestInsteadOfFounder: true\n         });\n         if (suddenTreeExit(event)) {\n            this.dropZoneService.clearVisibleZones();\n         }\n      } else if (\n         offsetY < bottomLine &&\n         offsetY > topLine &&\n         this.innerBranch?.renderDropZoneInside === true &&\n         this.innerBranch?.dropZoneInside !== undefined &&\n         (activeDropZone === null ||\n            !DropZone.dropZoneLocationsAreEqual(\n               activeDropZone,\n               this.innerBranch.dropZoneInside\n            ))\n      ) {\n         this.dropZoneService.showDropZoneFamily(\n            this.innerBranch.dropZoneInside\n         );\n         if (suddenTreeExit(event)) {\n            this.dropZoneService.clearVisibleZones();\n         }\n      } else if (\n         offsetY >= bottomLine &&\n         this.dropZoneBelow !== undefined &&\n         parentNestingAllowed &&\n         (activeDropZone === null ||\n            !DropZone.dropZoneLocationsAreEqual(\n               activeDropZone,\n               this.dropZoneBelow\n            )) &&\n         this.branch.getChildren().length === 0\n      ) {\n         const index = this.branch.getIndex();\n         if (index === undefined || index === null) {\n            throw new Error(\"can't get branch index\");\n         }\n         this.dropZoneService.showDropZoneFamily(this.dropZoneBelow);\n         if (suddenTreeExit(event)) {\n            this.dropZoneService.clearVisibleZones();\n         }\n      }\n   }\n\n   private renderNode() {\n      if (this.nodeHost === undefined || this.branch === undefined) {\n         throw new Error(\"Failed to render tree node\");\n      }\n      let component = this.branch.data.component;\n      if (component === undefined) {\n         component = this.treeService.treeOptions?.defaultComponent;\n      }\n      if (component === undefined) {\n         throw new Error(\"limbleTree requires a component to render\");\n      }\n      const componentRef = this.componentCreatorService.appendComponent<any>(\n         component.class,\n         this.nodeHost\n      );\n      componentRef.instance.nodeData = this.branch.data;\n      for (const binding in component.bindings) {\n         componentRef.instance[binding] = component.bindings[binding];\n      }\n   }\n\n   private registerDropZones(): void {\n      this.addDropZoneAbove();\n      this.addDropZoneBelow();\n   }\n\n   private addDropZoneAbove(): void {\n      if (this.branch === undefined) {\n         throw new Error(\"failed to register drop zone above\");\n      }\n      const parent = this.branch.getParent();\n      const currentCoordinates = this.branch.getCoordinates();\n      const index = currentCoordinates[currentCoordinates.length - 1];\n      this.dropZoneAbove = new DropZone(\n         [...(parent?.getCoordinates() ?? [])],\n         index\n      );\n      this.dropZoneService.addDropZone(this.dropZoneAbove);\n   }\n\n   private addDropZoneBelow(): void {\n      if (this.branch === undefined) {\n         throw new Error(\"failed to register drop zone below\");\n      }\n      const parent = this.branch.getParent();\n      const currentCoordinates = this.branch.getCoordinates();\n      const index = currentCoordinates[currentCoordinates.length - 1];\n      this.dropZoneBelow = new DropZone(\n         [...(parent?.getCoordinates() ?? [])],\n         index + 1\n      );\n      this.dropZoneService.addDropZone(this.dropZoneBelow);\n   }\n\n   private updateDropZones(): void {\n      this.currentBranchCoordinates = this.branch?.getCoordinates();\n      this.updateDropZoneAbove();\n      this.updateDropZoneBelow();\n      this.updateDropZoneInside();\n      this.setDropZoneHosts();\n   }\n\n   private updateDropZoneAbove(): void {\n      if (this.branch === undefined || this.dropZoneAbove === undefined) {\n         throw new Error(\"failed to update drop zone above\");\n      }\n      const parent = this.branch.getParent();\n      const currentCoordinates = this.branch.getCoordinates();\n      const index = currentCoordinates[currentCoordinates.length - 1];\n      const location = this.dropZoneAbove.getLocation();\n      location.setParentCoordinates([...(parent?.getCoordinates() ?? [])]);\n      location.setInsertIndex(index);\n   }\n\n   private updateDropZoneBelow(): void {\n      if (this.branch === undefined || this.dropZoneBelow === undefined) {\n         throw new Error(\"failed to update drop zone below\");\n      }\n      const parent = this.branch.getParent();\n      const currentCoordinates = this.branch.getCoordinates();\n      const index = currentCoordinates[currentCoordinates.length - 1];\n      const location = this.dropZoneBelow.getLocation();\n      location.setParentCoordinates([...(parent?.getCoordinates() ?? [])]);\n      location.setInsertIndex(index + 1);\n   }\n\n   private updateDropZoneInside(): void {\n      if (this.innerBranch?.dropZoneInside === undefined) {\n         return;\n      }\n      if (this.branch === undefined) {\n         throw new Error(\"failed to update drop zone inside\");\n      }\n      const location = this.innerBranch.dropZoneInside.getLocation();\n      location.setParentCoordinates([...this.branch.getCoordinates()]);\n   }\n\n   private setDropZoneHosts() {\n      if (\n         this.dropZoneAbove === undefined ||\n         this.dropZoneBelow === undefined\n      ) {\n         return;\n      }\n      this.dropZoneAbove.setHost(this.parentHost);\n      this.dropZoneBelow.setHost(this.parentHost);\n   }\n\n   private checkForHandle(): void {\n      if (\n         this.nodeHostContainer === undefined ||\n         this.draggableDiv === undefined\n      ) {\n         return;\n      }\n      const nodeHostContainerElement = this.nodeHostContainer.nativeElement;\n      const handle = nodeHostContainerElement.querySelector(\n         \".limble-tree-handle\"\n      );\n      const draggableDivElement = this.draggableDiv.nativeElement;\n      if (!isDraggingAllowed(this.treeService.treeOptions, this.branch?.data)) {\n         draggableDivElement.setAttribute(\"draggable\", \"false\");\n      } else if (handle === null) {\n         draggableDivElement.setAttribute(\"draggable\", \"true\");\n      } else {\n         handle.addEventListener(\"mousedown\", () => {\n            draggableDivElement.setAttribute(\"draggable\", \"true\");\n            //For some reason mouseup doesn't fire after a drag, so we use this observable sequence instead.\n            const dragging = this.dragStateService.state$.pipe(\n               filter((state) => state === \"dragging\"),\n               first()\n            );\n            this.dragStateService.state$\n               .pipe(\n                  skipUntil(dragging),\n                  filter((state) => state === \"idle\"),\n                  first()\n               )\n               .subscribe(() => {\n                  draggableDivElement.setAttribute(\"draggable\", \"false\");\n               });\n         });\n      }\n   }\n}\n","<drop-zone\n   *ngIf=\"renderDropZoneAbove === true\"\n   [dropZone]=\"dropZoneAbove\"\n></drop-zone>\n<div\n   (dragstart)=\"dragstartHandler($event)\"\n   (dragend)=\"dragendHandler($event)\"\n   class=\"limble-parent-container\"\n   #draggableDiv\n>\n   <div\n      class=\"node-host-container\"\n      (dragoverNoChangeDetect)=\"dragoverHandler($event)\"\n      [dragoverEventThrottle]=\"10\"\n      #nodeHostContainer\n   >\n      <ng-template #nodeHost></ng-template>\n   </div>\n   <limble-tree-branch\n      *ngIf=\"branch !== undefined && renderInnerBranch === true\"\n      [branch]=\"branch\"\n      #innerBranch\n   ></limble-tree-branch>\n</div>\n<drop-zone\n   *ngIf=\"renderDropZoneBelow === true\"\n   [dropZone]=\"dropZoneBelow\"\n></drop-zone>\n"]}

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

@@ -62,14 +62,9 @@ LimbleTreePlaceholderComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ ty
         i0.ɵɵelementEnd();
     } if (rf & 2) {
         i0.ɵɵproperty("dropZone", ctx.dropZone);
-    } }, directives: [i4.DropZoneComponent, i5.DragoverNoChangeDetectDirective], styles: [".placeholder[_ngcontent-%COMP%]{width:100%;height:20px}"], changeDetection: 0 });
+    } }, dependencies: [i4.DropZoneComponent, i5.DragoverNoChangeDetectDirective], styles: [".placeholder[_ngcontent-%COMP%]{width:100%;height:20px}"], changeDetection: 0 });
 (function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LimbleTreePlaceholderComponent, [{
         type: Component,
-        args: [{
-                selector: "limble-tree-placeholder",
-                templateUrl: "./limble-tree-placeholder.component.html",
-                styleUrls: ["./limble-tree-placeholder.component.scss"],
-                changeDetection: ChangeDetectionStrategy.OnPush
-            }]
+        args: [{ selector: "limble-tree-placeholder", changeDetection: ChangeDetectionStrategy.OnPush, template: "<drop-zone [dropZone]=\"dropZone\"></drop-zone>\n<div class=\"placeholder\" (dragoverNoChangeDetect)=\"dragoverHandler()\"></div>\n", styles: [".placeholder{width:100%;height:20px}\n"] }]
     }], function () { return [{ type: i1.DropZoneService }, { type: i0.ChangeDetectorRef }, { type: i2.TreeService }, { type: i3.TreeConstructionStatus }]; }, null); })();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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