@limble/limble-tree 0.12.2 → 0.13.0

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

@@ -0,0 +1,110 @@
+import { Component, Input, ViewChild, ViewContainerRef } from "@angular/core";
+import { DropZone } from "../classes/DropZone";
+import { filter } from "rxjs/operators";
+import { isNestingAllowed } from "../util";
+import * as i0 from "@angular/core";
+import * as i1 from "../limble-tree-root/tree.service";
+import * as i2 from "../limble-tree-root/drop-zone.service";
+import * as i3 from "../limble-tree-root/tree-construction-status.service";
+import * as i4 from "@angular/common";
+import * as i5 from "../drop-zone/drop-zone.component";
+const _c0 = ["children"];
+function LimbleTreeBranchComponent_drop_zone_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "drop-zone", 3);
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("dropZone", ctx_r0.dropZoneInside);
+} }
+function LimbleTreeBranchComponent_ng_template_3_Template(rf, ctx) { }
+export class LimbleTreeBranchComponent {
+    constructor(treeService, changeDetectorRef, dropZoneService, treeConstructionStatus, ngZone) {
+        this.treeService = treeService;
+        this.changeDetectorRef = changeDetectorRef;
+        this.dropZoneService = dropZoneService;
+        this.treeConstructionStatus = treeConstructionStatus;
+        this.ngZone = ngZone;
+        this.treeConstructionStatus.constructing();
+        this.indent = this.treeService.treeOptions?.indent;
+        this.renderDropZoneInside = false;
+    }
+    ngOnInit() {
+        this.addDropZoneInside();
+        this.ngZone.runOutsideAngular(() => {
+            if (this.dropZoneInside === undefined) {
+                throw new Error("drop zone inside is not defined");
+            }
+            this.dropZoneInside
+                .getCommChannel()
+                .pipe(filter((message) => message === "checkRendered"))
+                .subscribe(() => {
+                if (this.dropZoneInside === undefined ||
+                    this.branch === undefined) {
+                    throw new Error("Zones not registered");
+                }
+                if (isNestingAllowed(this.treeService.treeOptions, this.branch.data)) {
+                    this.renderDropZoneInside = this.dropZoneInside.isRendered();
+                }
+            });
+        });
+    }
+    ngAfterViewInit() {
+        this.reRender();
+        this.setDropZoneHost();
+        this.treeConstructionStatus.doneConstructing();
+        this.changeDetectorRef.detectChanges();
+    }
+    ngOnDestroy() {
+        if (this.dropZoneInside !== undefined) {
+            this.dropZoneService.removeDropZone(this.dropZoneInside);
+        }
+        this.treeService.cleanupSignal$.next(true);
+    }
+    addDropZoneInside() {
+        if (this.branch === undefined) {
+            throw new Error("failed to register drop zone inside");
+        }
+        this.dropZoneInside = new DropZone([...this.branch.getCoordinates()], 0);
+        this.dropZoneService.addDropZone(this.dropZoneInside);
+    }
+    reRender() {
+        if (this.children === undefined || this.branch === undefined) {
+            throw new Error("Failed to render limble tree branch");
+        }
+        this.treeService.renderBranch(this.children, this.branch);
+    }
+    setDropZoneHost() {
+        if (this.children === undefined || this.dropZoneInside === undefined) {
+            throw new Error("Failed to add drop zone host");
+        }
+        this.dropZoneInside.setHost(this.children);
+    }
+}
+LimbleTreeBranchComponent.ɵfac = function LimbleTreeBranchComponent_Factory(t) { return new (t || LimbleTreeBranchComponent)(i0.ɵɵdirectiveInject(i1.TreeService), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i2.DropZoneService), i0.ɵɵdirectiveInject(i3.TreeConstructionStatus), i0.ɵɵdirectiveInject(i0.NgZone)); };
+LimbleTreeBranchComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LimbleTreeBranchComponent, selectors: [["limble-tree-branch"]], viewQuery: function LimbleTreeBranchComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(_c0, 5, ViewContainerRef);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.children = _t.first);
+    } }, inputs: { branch: "branch" }, decls: 5, vars: 4, consts: [[3, "dropZone", 4, "ngIf"], [1, "limble-child-nodes", 3, "hidden"], ["children", ""], [3, "dropZone"]], template: function LimbleTreeBranchComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "div");
+        i0.ɵɵtemplate(1, LimbleTreeBranchComponent_drop_zone_1_Template, 1, 1, "drop-zone", 0);
+        i0.ɵɵelementStart(2, "span", 1);
+        i0.ɵɵtemplate(3, LimbleTreeBranchComponent_ng_template_3_Template, 0, 0, "ng-template", null, 2, i0.ɵɵtemplateRefExtractor);
+        i0.ɵɵelementEnd()();
+    } if (rf & 2) {
+        i0.ɵɵstyleProp("margin-left", ctx.indent, "px");
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngIf", ctx.renderDropZoneInside);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("hidden", ctx.branch && ctx.branch.data.collapsed);
+    } }, dependencies: [i4.NgIf, i5.DropZoneComponent] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LimbleTreeBranchComponent, [{
+        type: Component,
+        args: [{ selector: "limble-tree-branch", template: "<div [style.marginLeft.px]=\"indent\">\n   <drop-zone\n      *ngIf=\"renderDropZoneInside\"\n      [dropZone]=\"dropZoneInside\"\n   ></drop-zone>\n   <span [hidden]=\"branch && branch.data.collapsed\" class=\"limble-child-nodes\">\n      <ng-template #children></ng-template>\n   </span>\n</div>\n" }]
+    }], function () { return [{ type: i1.TreeService }, { type: i0.ChangeDetectorRef }, { type: i2.DropZoneService }, { type: i3.TreeConstructionStatus }, { type: i0.NgZone }]; }, { branch: [{
+            type: Input
+        }], children: [{
+            type: ViewChild,
+            args: ["children", { read: ViewContainerRef }]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"limble-tree-branch.component.js","sourceRoot":"","sources":["../../../../../projects/limble-tree/src/lib/limble-tree-branch/limble-tree-branch.component.ts","../../../../../projects/limble-tree/src/lib/limble-tree-branch/limble-tree-branch.component.html"],"names":[],"mappings":"AAAA,OAAO,EAGJ,SAAS,EACT,KAAK,EAIL,SAAS,EACT,gBAAgB,EAClB,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;;;;;;;;;ICdxC,+BAGa;;;IADV,gDAA2B;;;ADqBjC,MAAM,OAAO,yBAAyB;IAanC,YACW,WAAwB,EACf,iBAAoC,EACpC,eAAgC,EAChC,sBAA8C,EAC9C,MAAc;QAJvB,gBAAW,GAAX,WAAW,CAAa;QACf,sBAAiB,GAAjB,iBAAiB,CAAmB;QACpC,oBAAe,GAAf,eAAe,CAAiB;QAChC,2BAAsB,GAAtB,sBAAsB,CAAwB;QAC9C,WAAM,GAAN,MAAM,CAAQ;QAE/B,IAAI,CAAC,sBAAsB,CAAC,YAAY,EAAE,CAAC;QAC3C,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,MAAM,CAAC;QACnD,IAAI,CAAC,oBAAoB,GAAG,KAAK,CAAC;IACrC,CAAC;IAEM,QAAQ;QACZ,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACzB,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAChC,IAAI,IAAI,CAAC,cAAc,KAAK,SAAS,EAAE;gBACpC,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;aACrD;YACD,IAAI,CAAC,cAAc;iBACf,cAAc,EAAE;iBAChB,IAAI,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,KAAK,eAAe,CAAC,CAAC;iBACtD,SAAS,CAAC,GAAG,EAAE;gBACb,IACG,IAAI,CAAC,cAAc,KAAK,SAAS;oBACjC,IAAI,CAAC,MAAM,KAAK,SAAS,EAC1B;oBACC,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;iBAC1C;gBACD,IACG,gBAAgB,CACb,IAAI,CAAC,WAAW,CAAC,WAAW,EAC5B,IAAI,CAAC,MAAM,CAAC,IAAI,CAClB,EACF;oBACC,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,cAAc,CAAC,UAAU,EAAE,CAAC;iBAC/D;YACJ,CAAC,CAAC,CAAC;QACT,CAAC,CAAC,CAAC;IACN,CAAC;IAEM,eAAe;QACnB,IAAI,CAAC,QAAQ,EAAE,CAAC;QAChB,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,sBAAsB,CAAC,gBAAgB,EAAE,CAAC;QAC/C,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,CAAC;IAC1C,CAAC;IAEM,WAAW;QACf,IAAI,IAAI,CAAC,cAAc,KAAK,SAAS,EAAE;YACpC,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;SAC3D;QACD,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC9C,CAAC;IAEO,iBAAiB;QACtB,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,EAAE;YAC5B,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;SACzD;QACD,IAAI,CAAC,cAAc,GAAG,IAAI,QAAQ,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QACzE,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACzD,CAAC;IAEM,QAAQ;QACZ,IAAI,IAAI,CAAC,QAAQ,KAAK,SAAS,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,EAAE;YAC3D,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;SACzD;QACD,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAC7D,CAAC;IAEO,eAAe;QACpB,IAAI,IAAI,CAAC,QAAQ,KAAK,SAAS,IAAI,IAAI,CAAC,cAAc,KAAK,SAAS,EAAE;YACnE,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;SAClD;QACD,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC9C,CAAC;;kGAvFS,yBAAyB;4EAAzB,yBAAyB;+BAIJ,gBAAgB;;;;;QC5BlD,2BAAoC;QACjC,sFAGa;QACb,+BAA4E;QACzE,2HAAqC;QACxC,iBAAO,EAAA;;QAPL,+CAA8B;QAE5B,eAA0B;QAA1B,+CAA0B;QAGxB,eAA0C;QAA1C,gEAA0C;;uFDmBtC,yBAAyB;cALrC,SAAS;2BACG,oBAAoB;sLAMrB,MAAM;kBAAd,KAAK;YAE6C,QAAQ;kBAA1D,SAAS;mBAAC,UAAU,EAAE,EAAE,IAAI,EAAE,gBAAgB,EAAE","sourcesContent":["import {\n   AfterViewInit,\n   ChangeDetectorRef,\n   Component,\n   Input,\n   NgZone,\n   OnDestroy,\n   OnInit,\n   ViewChild,\n   ViewContainerRef\n} from \"@angular/core\";\nimport { TreeService } from \"../limble-tree-root/tree.service\";\nimport type { Branch } from \"../classes/Branch\";\nimport { DropZone } from \"../classes/DropZone\";\nimport { filter } from \"rxjs/operators\";\nimport { isNestingAllowed } from \"../util\";\nimport { DropZoneService } from \"../limble-tree-root/drop-zone.service\";\nimport { TreeConstructionStatus } from \"../limble-tree-root/tree-construction-status.service\";\n\n@Component({\n   selector: \"limble-tree-branch\",\n   templateUrl: \"./limble-tree-branch.component.html\",\n   styleUrls: [\"./limble-tree-branch.component.scss\"]\n})\nexport class LimbleTreeBranchComponent\n   implements AfterViewInit, OnInit, OnDestroy {\n   @Input() branch: Branch<any> | undefined;\n\n   @ViewChild(\"children\", { read: ViewContainerRef }) children:\n      | ViewContainerRef\n      | undefined;\n\n   public dropZoneInside: DropZone | undefined;\n   public renderDropZoneInside: boolean;\n\n   public readonly indent;\n\n   constructor(\n      private treeService: TreeService,\n      private readonly changeDetectorRef: ChangeDetectorRef,\n      private readonly dropZoneService: DropZoneService,\n      private readonly treeConstructionStatus: TreeConstructionStatus,\n      private readonly ngZone: NgZone\n   ) {\n      this.treeConstructionStatus.constructing();\n      this.indent = this.treeService.treeOptions?.indent;\n      this.renderDropZoneInside = false;\n   }\n\n   public ngOnInit() {\n      this.addDropZoneInside();\n      this.ngZone.runOutsideAngular(() => {\n         if (this.dropZoneInside === undefined) {\n            throw new Error(\"drop zone inside is not defined\");\n         }\n         this.dropZoneInside\n            .getCommChannel()\n            .pipe(filter((message) => message === \"checkRendered\"))\n            .subscribe(() => {\n               if (\n                  this.dropZoneInside === undefined ||\n                  this.branch === undefined\n               ) {\n                  throw new Error(\"Zones not registered\");\n               }\n               if (\n                  isNestingAllowed(\n                     this.treeService.treeOptions,\n                     this.branch.data\n                  )\n               ) {\n                  this.renderDropZoneInside = this.dropZoneInside.isRendered();\n               }\n            });\n      });\n   }\n\n   public ngAfterViewInit() {\n      this.reRender();\n      this.setDropZoneHost();\n      this.treeConstructionStatus.doneConstructing();\n      this.changeDetectorRef.detectChanges();\n   }\n\n   public ngOnDestroy() {\n      if (this.dropZoneInside !== undefined) {\n         this.dropZoneService.removeDropZone(this.dropZoneInside);\n      }\n      this.treeService.cleanupSignal$.next(true);\n   }\n\n   private addDropZoneInside() {\n      if (this.branch === undefined) {\n         throw new Error(\"failed to register drop zone inside\");\n      }\n      this.dropZoneInside = new DropZone([...this.branch.getCoordinates()], 0);\n      this.dropZoneService.addDropZone(this.dropZoneInside);\n   }\n\n   public reRender() {\n      if (this.children === undefined || this.branch === undefined) {\n         throw new Error(\"Failed to render limble tree branch\");\n      }\n      this.treeService.renderBranch(this.children, this.branch);\n   }\n\n   private setDropZoneHost() {\n      if (this.children === undefined || this.dropZoneInside === undefined) {\n         throw new Error(\"Failed to add drop zone host\");\n      }\n      this.dropZoneInside.setHost(this.children);\n   }\n}\n","<div [style.marginLeft.px]=\"indent\">\n   <drop-zone\n      *ngIf=\"renderDropZoneInside\"\n      [dropZone]=\"dropZoneInside\"\n   ></drop-zone>\n   <span [hidden]=\"branch && branch.data.collapsed\" class=\"limble-child-nodes\">\n      <ng-template #children></ng-template>\n   </span>\n</div>\n"]}