slick-components 4.4.13 → 4.4.16

package/esm2020/slick-tree-view/slick-tree-view.component.mjs

@@ -0,0 +1,293 @@
+import { Component, Input, Output, EventEmitter, ViewChild } from "@angular/core";
+import { SlickTreeNodeModel } from './slick-tree-node.model';
+import { SlickSleepService } from "../utils/slick-sleep.service";
+import { SlickUtilsService } from "../utils/slick-utils.service";
+import { SlickConfirmDialogResults } from '../slick-confirm-dialog/slick-confirm-dialog.module';
+import * as i0 from "@angular/core";
+import * as i1 from "../slick-confirm-dialog/slick-confirm-dialog.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+class SlickTreeViewDisplayModel {
+    constructor(node, level) {
+        this.uuid = node.uuid;
+        this.parentUuid = node.parentUuid;
+        this.node = node;
+        this.text = node.text;
+        this.level = level;
+        this.expanded = node.expanded;
+        this.editingText = false;
+        this.indentArray = [];
+        for (let i = 0; i < this.level; i++)
+            this.indentArray.push(true);
+    }
+}
+export class SlickTreeViewComponent {
+    constructor() {
+        this.nodesChange = new EventEmitter();
+        this.showRootNode = true;
+        this.expandOnClick = true;
+        this.onNodeSelected = new EventEmitter();
+        this.onNodeChanged = new EventEmitter();
+        this.onNodeAdded = new EventEmitter();
+        this.onNodeDeleted = new EventEmitter();
+        this.fnDocumentClick = (e) => this.documentClick(e);
+        this.fnContextMenu = (e) => this.contextMenu(e);
+        this.uuid = SlickUtilsService.newGuid();
+        this.newUuid = null;
+    }
+    ngOnInit() {
+        document.addEventListener("click", this.fnDocumentClick, true);
+        this.slickTreeViewRef.nativeElement.addEventListener("contextmenu", this.fnContextMenu, true);
+    }
+    ngOnDestroy() {
+        document.removeEventListener("click", this.fnDocumentClick, true);
+        this.slickTreeViewRef.nativeElement.removeEventListener("contextmenu", this.fnContextMenu, true);
+    }
+    ngOnChanges(changes) {
+        this.expandOnClick = (this.expandOnClick.toString().toLowerCase() === 'false') ? false : true;
+        this.showRootNode = (this.showRootNode.toString().toLowerCase() === 'false') ? false : true;
+        this.rootNodeUuid = this.rootNodeUuid || null;
+        if (changes.nodes)
+            this.refreshDisplay();
+    }
+    async documentClick(e) {
+        if (e.target && SlickUtilsService.checkParentClassExists(e.target, "slick-tree-view_node-text-edit"))
+            return;
+        if (e.target && SlickUtilsService.checkParentClassExists(e.target, "slick-tree-view_context-menu"))
+            return;
+        const contextMenuElement = this.contextMenuRef.nativeElement;
+        contextMenuElement.classList.remove("menu-visible");
+        contextMenuElement.classList.add("menu-hidden");
+        this.processNewNode();
+        this.displayNodes = this.displayNodes.map(displayNode => {
+            if (displayNode.editingText) {
+                displayNode.editingText = false;
+                if (this.onNodeChanged && displayNode.text !== displayNode.node.text) {
+                    displayNode.node.text = displayNode.text;
+                    this.onNodeChanged.emit(displayNode.node);
+                }
+            }
+            return displayNode;
+        });
+    }
+    onTextKeydown(e, displayNode) {
+        // Esc
+        if (e.keyCode === 27) {
+            displayNode.editingText = false;
+            displayNode.node.text = displayNode.text;
+            this.processNewNode();
+        }
+        // Enter or tab
+        if (e.keyCode === 13 || e.keyCode === 9) {
+            displayNode.editingText = false;
+            this.processNewNode();
+            if (this.onNodeChanged && displayNode.text !== displayNode.node.text) {
+                displayNode.node.text = displayNode.text;
+                this.onNodeChanged.emit(displayNode.node);
+            }
+        }
+    }
+    contextMenu(e) {
+        if (!e || !e.target)
+            return;
+        if (!SlickUtilsService.checkParentIdExists(e.target, `slick-tree-view_${this.uuid}`))
+            return;
+        const contextNodeElement = SlickUtilsService.findParent(e.target, "slick-tree-view-node");
+        if (!contextNodeElement)
+            return;
+        e.preventDefault();
+        this.contextNodeUuid = contextNodeElement.getAttribute("data-uuid");
+        const node = this.nodes.find(x => x.uuid === this.contextNodeUuid);
+        this.contextMenuShowAdd = node.canAddChildren;
+        this.contextMenuShowDelete = node.canDelete;
+        this.contextMenuShowEditText = node.canEditText;
+        // If there's nothing to do, don't even show the context menu
+        if (this.contextMenuShowAdd === false && this.contextMenuShowDelete === false && this.contextMenuShowEditText === false)
+            return;
+        const contextMenuElement = this.contextMenuRef.nativeElement;
+        const top = (contextNodeElement.offsetTop + contextNodeElement.offsetHeight - 5);
+        const indentationElement = contextNodeElement.querySelector(".slick-tree-view_indentation");
+        const iconElement = contextNodeElement.querySelector(".slick-tree-view_icon");
+        const indentationWidth = (indentationElement) ? indentationElement.offsetWidth : 0;
+        const iconWidth = (iconElement) ? iconElement.offsetWidth : 0;
+        const left = indentationWidth + iconWidth + 2;
+        contextMenuElement.style.top = top + "px";
+        contextMenuElement.style.left = left + "px";
+        contextMenuElement.classList.add("menu-visible");
+        contextMenuElement.classList.remove("menu-hidden");
+    }
+    async addNode() {
+        // Hide the context menu
+        const contextMenuElement = this.contextMenuRef.nativeElement;
+        contextMenuElement.classList.remove("menu-visible");
+        contextMenuElement.classList.add("menu-hidden");
+        if (!this.contextNodeUuid)
+            return;
+        const parentNodeIdx = this.nodes.findIndex(x => x.uuid === this.contextNodeUuid);
+        const parentNode = this.nodes[parentNodeIdx];
+        // Since we want to add this one to the top, pass null as the parent
+        var newNode = new SlickTreeNodeModel(null, "New Folder");
+        newNode.parentUuid = parentNode.uuid;
+        parentNode.expanded = true;
+        this.nodes.splice(parentNodeIdx, 0, newNode);
+        this.refreshDisplay();
+        const displayNode = this.displayNodes.find(x => x.uuid === newNode.uuid);
+        this.editText(displayNode);
+        this.newUuid = newNode.uuid;
+    }
+    async deleteNode() {
+        // Hide the context menu
+        const contextMenuElement = this.contextMenuRef.nativeElement;
+        contextMenuElement.classList.remove("menu-visible");
+        contextMenuElement.classList.add("menu-hidden");
+        if (!this.contextNodeUuid)
+            return;
+        const node = this.nodes.find(x => x.uuid === this.contextNodeUuid);
+        this.deleteNodeName = node.text;
+        const confirmResult = await this.deleteNodeConfirmRef.confirm();
+        if (confirmResult === SlickConfirmDialogResults.Cancel)
+            return;
+        const removedNodes = this.deleteRecursive(node);
+        this.refreshDisplay();
+        if (this.onNodeDeleted)
+            this.onNodeDeleted.emit(removedNodes);
+        if (this.nodesChange)
+            this.nodesChange.emit(this.nodes);
+    }
+    editNodeText() {
+        // Hide the context menu
+        const contextMenuElement = this.contextMenuRef.nativeElement;
+        contextMenuElement.classList.remove("menu-visible");
+        contextMenuElement.classList.add("menu-hidden");
+        if (!this.contextNodeUuid)
+            return;
+        const displayNode = this.displayNodes.find(x => x.uuid === this.contextNodeUuid);
+        this.editText(displayNode);
+        if (this.nodesChange)
+            this.nodesChange.emit(this.nodes);
+    }
+    selectNode(displayNode) {
+        if (this.selectedUuid === displayNode.uuid)
+            return;
+        this.selectedUuid = displayNode.uuid;
+        if (displayNode.node.expandOnClick === true)
+            this.expandNode(displayNode);
+        if (this.onNodeSelected)
+            this.onNodeSelected.emit(displayNode.node);
+    }
+    expandNode(displayNode) {
+        displayNode.node.expanded = true;
+        this.refreshDisplay();
+    }
+    collapseNode(displayNode) {
+        displayNode.node.expanded = false;
+        this.refreshDisplay();
+    }
+    async editText(displayNode) {
+        if (!displayNode.node.canEditText)
+            return;
+        displayNode.editingText = true;
+        await SlickSleepService.sleep();
+        const textbox = document.querySelector(`.slick-tree-view_node-text-edit_${displayNode.uuid}`);
+        if (textbox) {
+            textbox.focus();
+            textbox.select();
+        }
+    }
+    refreshDisplay() {
+        this.displayNodes = [];
+        if (!this.nodes || this.nodes.length === 0)
+            return;
+        let rootNode;
+        if (this.rootNodeUuid)
+            rootNode = this.nodes.find(x => x.uuid === this.rootNodeUuid);
+        else
+            rootNode = this.nodes.find(x => x.parentUuid === null);
+        // Always expand the root node
+        rootNode.expanded = true;
+        // If we aren't showing the root node, start at -1 for the indent level
+        this.populateDisplayNodes(rootNode, (this.showRootNode) ? 0 : -1);
+        if (this.showRootNode === false)
+            this.displayNodes = this.displayNodes.filter(x => x.parentUuid !== null);
+    }
+    populateDisplayNodes(node, level) {
+        if (level >= 100) {
+            console.error("Exceeeded max of 100 levels deep.  Possible infinite recursion.");
+            return;
+        }
+        const displayNode = new SlickTreeViewDisplayModel(node, level);
+        if (node.expandOnClick === null || node.expandOnClick === undefined)
+            node.expandOnClick = this.expandOnClick;
+        if (displayNode.parentUuid === null)
+            displayNode.node.canDelete = false;
+        if (displayNode.uuid === this.newUuid)
+            displayNode.editingText = true;
+        this.displayNodes.push(displayNode);
+        const childNodes = this.nodes.filter(x => x.parentUuid === node.uuid) || [];
+        displayNode.hasChildNodes = (childNodes.length > 0);
+        if (node.expanded === true)
+            childNodes.forEach(childNode => {
+                if (!childNode.hidden)
+                    this.populateDisplayNodes(childNode, level + 1);
+            });
+    }
+    deleteRecursive(node) {
+        let removedNodes = [];
+        const childNodes = this.nodes.filter(x => x.parentUuid === node.uuid) || [];
+        childNodes.forEach(childNode => {
+            removedNodes = removedNodes.concat(this.deleteRecursive(childNode));
+        });
+        removedNodes.push(node);
+        this.nodes = this.nodes.filter(x => x.uuid !== node.uuid);
+        return removedNodes;
+    }
+    processNewNode() {
+        if (!this.newUuid)
+            return;
+        const newNode = this.nodes.find(x => x.uuid === this.newUuid);
+        const displayNode = this.displayNodes.find(x => x.uuid == this.newUuid);
+        // Do this so that we don't trigger the node update
+        newNode.text = displayNode.text;
+        this.newUuid = null;
+        if (!newNode)
+            return;
+        if (this.onNodeAdded)
+            this.onNodeAdded.emit(newNode);
+        if (this.nodesChange)
+            this.nodesChange.emit(this.nodes);
+    }
+}
+/** @nocollapse */ SlickTreeViewComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickTreeViewComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ SlickTreeViewComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.3", type: SlickTreeViewComponent, selector: "slick-tree-view", inputs: { nodes: "nodes", showRootNode: "showRootNode", rootNodeUuid: "rootNodeUuid", expandOnClick: "expandOnClick" }, outputs: { nodesChange: "nodesChange", onNodeSelected: "onNodeSelected", onNodeChanged: "onNodeChanged", onNodeAdded: "onNodeAdded", onNodeDeleted: "onNodeDeleted" }, viewQueries: [{ propertyName: "slickTreeViewRef", first: true, predicate: ["slickTreeViewRef"], descendants: true, static: true }, { propertyName: "contextMenuRef", first: true, predicate: ["contextMenuRef"], descendants: true }, { propertyName: "deleteNodeConfirmRef", first: true, predicate: ["deleteNodeConfirmRef"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div #slickTreeViewRef id=\"slick-tree-view_{{uuid}}\" class=\"slick-tree-view position-relative pr-2\">\r\n\t<div class=\"d-flex slick-tree-view-node\" [attr.data-uuid]=\"displayNode.uuid\" *ngFor=\"let displayNode of displayNodes\">\r\n\t\t<div class=\"slick-tree-view_indentation\">\r\n\t\t\t<i *ngFor=\"let indent of displayNode.indentArray\" class=\"far fa-caret-right mr-1\" style=\"opacity: 0\"></i>\r\n\t\t\t<i *ngIf=\"!displayNode.hasChildNodes\" class=\"far fa-caret-right mr-1\" style=\"opacity: 0\"></i>\r\n\t\t\t<i *ngIf=\"displayNode.hasChildNodes && !displayNode.expanded\" class=\"far fa-caret-right mr-1\" style=\"cursor: pointer\" (click)=\"expandNode(displayNode)\"></i>\r\n\t\t\t<i *ngIf=\"displayNode.hasChildNodes && displayNode.expanded\" class=\"far fa-caret-down mr-1\" style=\"cursor: pointer\" (click)=\"collapseNode(displayNode)\"></i>\r\n\t\t</div>\r\n\t\t<div class=\"d-flex px-1\" [ngClass]=\"{'bg-success text-white' : displayNode.uuid === selectedUuid }\">\r\n\t\t\t<div *ngIf=\"displayNode.node.iconClass || displayNode.node.iconUrl\" class=\"mr-1 slick-tree-view_icon\">\r\n\t\t\t\t<i *ngIf=\"displayNode.node.iconClass\" [style.color]=\"displayNode.node.iconColor\" [ngClass]=\"displayNode.node.iconClass\"></i>\r\n\t\t\t</div>\r\n\t\t\t<div *ngIf=\"!displayNode.editingText\" style=\"cursor: pointer\" (click)=\"selectNode(displayNode)\" (dblclick)=\"editText(displayNode)\">{{displayNode.text}}</div>\r\n\t\t\t<div *ngIf=\"displayNode.editingText\" class=\"slick-tree-view_node-text-edit\"><input type=\"text\" class=\"form-control slick-tree-view_node-text-edit_{{displayNode.uuid}}\" [(ngModel)]=\"displayNode.text\" (keydown)=\"onTextKeydown($event, displayNode)\" /></div>\r\n\t\t</div>\r\n\t</div>\r\n\r\n\t<div #contextMenuRef class='slick-tree-view_context-menu dropdown-menu p-0 show menu-hidden'>\r\n\t\t<div *ngIf=\"contextMenuShowAdd\" class=\"px-2 dropdown-item\" (click)=\"addNode()\">Add</div>\r\n\t\t<div *ngIf=\"contextMenuShowDelete\" class=\"px-2 dropdown-item\" (click)=\"deleteNode()\">Delete</div>\r\n\t\t<div *ngIf=\"contextMenuShowEditText\" class=\"px-2 dropdown-item\" (click)=\"editNodeText()\">Edit Name</div>\r\n\t</div>\r\n</div>\r\n\r\n<slick-confirm-dialog #deleteNodeConfirmRef>\r\n\tAre you sure you want to delete {{deleteNodeName}}?\r\n</slick-confirm-dialog>", components: [{ type: i1.SlickConfirmDialogComponent, selector: "slick-confirm-dialog", inputs: ["width", "okButtonText", "cancelButtonText", "showOkButton", "showCancelButton"] }], directives: [{ type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickTreeViewComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'slick-tree-view', template: "<div #slickTreeViewRef id=\"slick-tree-view_{{uuid}}\" class=\"slick-tree-view position-relative pr-2\">\r\n\t<div class=\"d-flex slick-tree-view-node\" [attr.data-uuid]=\"displayNode.uuid\" *ngFor=\"let displayNode of displayNodes\">\r\n\t\t<div class=\"slick-tree-view_indentation\">\r\n\t\t\t<i *ngFor=\"let indent of displayNode.indentArray\" class=\"far fa-caret-right mr-1\" style=\"opacity: 0\"></i>\r\n\t\t\t<i *ngIf=\"!displayNode.hasChildNodes\" class=\"far fa-caret-right mr-1\" style=\"opacity: 0\"></i>\r\n\t\t\t<i *ngIf=\"displayNode.hasChildNodes && !displayNode.expanded\" class=\"far fa-caret-right mr-1\" style=\"cursor: pointer\" (click)=\"expandNode(displayNode)\"></i>\r\n\t\t\t<i *ngIf=\"displayNode.hasChildNodes && displayNode.expanded\" class=\"far fa-caret-down mr-1\" style=\"cursor: pointer\" (click)=\"collapseNode(displayNode)\"></i>\r\n\t\t</div>\r\n\t\t<div class=\"d-flex px-1\" [ngClass]=\"{'bg-success text-white' : displayNode.uuid === selectedUuid }\">\r\n\t\t\t<div *ngIf=\"displayNode.node.iconClass || displayNode.node.iconUrl\" class=\"mr-1 slick-tree-view_icon\">\r\n\t\t\t\t<i *ngIf=\"displayNode.node.iconClass\" [style.color]=\"displayNode.node.iconColor\" [ngClass]=\"displayNode.node.iconClass\"></i>\r\n\t\t\t</div>\r\n\t\t\t<div *ngIf=\"!displayNode.editingText\" style=\"cursor: pointer\" (click)=\"selectNode(displayNode)\" (dblclick)=\"editText(displayNode)\">{{displayNode.text}}</div>\r\n\t\t\t<div *ngIf=\"displayNode.editingText\" class=\"slick-tree-view_node-text-edit\"><input type=\"text\" class=\"form-control slick-tree-view_node-text-edit_{{displayNode.uuid}}\" [(ngModel)]=\"displayNode.text\" (keydown)=\"onTextKeydown($event, displayNode)\" /></div>\r\n\t\t</div>\r\n\t</div>\r\n\r\n\t<div #contextMenuRef class='slick-tree-view_context-menu dropdown-menu p-0 show menu-hidden'>\r\n\t\t<div *ngIf=\"contextMenuShowAdd\" class=\"px-2 dropdown-item\" (click)=\"addNode()\">Add</div>\r\n\t\t<div *ngIf=\"contextMenuShowDelete\" class=\"px-2 dropdown-item\" (click)=\"deleteNode()\">Delete</div>\r\n\t\t<div *ngIf=\"contextMenuShowEditText\" class=\"px-2 dropdown-item\" (click)=\"editNodeText()\">Edit Name</div>\r\n\t</div>\r\n</div>\r\n\r\n<slick-confirm-dialog #deleteNodeConfirmRef>\r\n\tAre you sure you want to delete {{deleteNodeName}}?\r\n</slick-confirm-dialog>" }]
+        }], ctorParameters: function () { return []; }, propDecorators: { nodes: [{
+                type: Input
+            }], nodesChange: [{
+                type: Output
+            }], showRootNode: [{
+                type: Input
+            }], rootNodeUuid: [{
+                type: Input
+            }], expandOnClick: [{
+                type: Input
+            }], onNodeSelected: [{
+                type: Output
+            }], onNodeChanged: [{
+                type: Output
+            }], onNodeAdded: [{
+                type: Output
+            }], onNodeDeleted: [{
+                type: Output
+            }], slickTreeViewRef: [{
+                type: ViewChild,
+                args: ["slickTreeViewRef", { static: true }]
+            }], contextMenuRef: [{
+                type: ViewChild,
+                args: ["contextMenuRef"]
+            }], deleteNodeConfirmRef: [{
+                type: ViewChild,
+                args: ["deleteNodeConfirmRef"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slick-tree-view.component.js","sourceRoot":"","sources":["../../../../projects/components/src/slick-tree-view/slick-tree-view.component.ts","../../../../projects/components/src/slick-tree-view/slick-tree-view.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnChanges, SimpleChanges, Output, EventEmitter, OnDestroy, OnInit, ViewChild, ElementRef } from \"@angular/core\";\r\nimport { ISlickTreeNodeModel, SlickTreeNodeModel } from './slick-tree-node.model';\r\nimport { SlickSleepService } from \"../utils/slick-sleep.service\";\r\nimport { SlickUtilsService } from \"../utils/slick-utils.service\";\r\nimport { SlickConfirmDialogComponent, SlickConfirmDialogResults } from '../slick-confirm-dialog/slick-confirm-dialog.module';\r\n\r\nclass SlickTreeViewDisplayModel {\r\n\tconstructor(node: ISlickTreeNodeModel, level: number) {\r\n\t\tthis.uuid = node.uuid;\r\n\t\tthis.parentUuid = node.parentUuid;\r\n\t\tthis.node = node;\r\n\t\tthis.text = node.text;\r\n\t\tthis.level = level;\r\n\t\tthis.expanded = node.expanded;\r\n\t\tthis.editingText = false;\r\n\r\n\t\tthis.indentArray = [];\r\n\t\tfor (let i = 0; i < this.level; i++)\r\n\t\t\tthis.indentArray.push(true);\r\n\t}\r\n\r\n\tnode: ISlickTreeNodeModel;\r\n\tuuid: string;\r\n\ttext: string;\r\n\tparentUuid: string;\r\n\tlevel: number;\r\n\tindentArray: boolean[];\r\n\texpanded: boolean;\r\n\thasChildNodes: boolean;\r\n\teditingText: boolean;\r\n}\r\n\r\n@Component({\r\n\tselector: 'slick-tree-view',\r\n\ttemplateUrl: 'slick-tree-view.component.html'\r\n})\r\nexport class SlickTreeViewComponent implements OnChanges, OnInit, OnDestroy {\r\n\t@Input() nodes: ISlickTreeNodeModel[];\r\n\t@Output() nodesChange: EventEmitter<ISlickTreeNodeModel[]> = new EventEmitter();\r\n\t@Input() showRootNode: boolean = true;\r\n\t@Input() rootNodeUuid: string;\r\n\t@Input() expandOnClick: boolean = true;\r\n\t@Output() onNodeSelected = new EventEmitter<ISlickTreeNodeModel>();\r\n\t@Output() onNodeChanged = new EventEmitter<ISlickTreeNodeModel>();\r\n\t@Output() onNodeAdded = new EventEmitter<ISlickTreeNodeModel>();\r\n\t@Output() onNodeDeleted = new EventEmitter<ISlickTreeNodeModel[]>();\r\n\r\n\t@ViewChild(\"slickTreeViewRef\", { static: true }) slickTreeViewRef: ElementRef;\r\n\t@ViewChild(\"contextMenuRef\") contextMenuRef: ElementRef;\r\n\t@ViewChild(\"deleteNodeConfirmRef\") deleteNodeConfirmRef: SlickConfirmDialogComponent;\r\n\r\n\tfnDocumentClick = (e) => this.documentClick(e);\r\n\tfnContextMenu = (e) => this.contextMenu(e);\r\n\r\n\tcontextNodeUuid: string;\r\n\r\n\tuuid: string = SlickUtilsService.newGuid();\r\n\tdisplayNodes: SlickTreeViewDisplayModel[];\r\n\tselectedUuid: string;\r\n\tnewUuid: string = null;\r\n\tdeleteNodeName: string;\r\n\r\n\tcontextMenuShowAdd: boolean;\r\n\tcontextMenuShowDelete: boolean;\r\n\tcontextMenuShowEditText: boolean;\r\n\r\n\tconstructor() { }\r\n\r\n\tngOnInit() {\r\n\t\tdocument.addEventListener(\"click\", this.fnDocumentClick, true);\r\n\t\tthis.slickTreeViewRef.nativeElement.addEventListener(\"contextmenu\", this.fnContextMenu, true);\r\n\t}\r\n\r\n\tngOnDestroy() {\r\n\t\tdocument.removeEventListener(\"click\", this.fnDocumentClick, true);\r\n\t\tthis.slickTreeViewRef.nativeElement.removeEventListener(\"contextmenu\", this.fnContextMenu, true);\r\n\t}\r\n\r\n\tngOnChanges(changes: SimpleChanges) {\r\n\t\tthis.expandOnClick = (this.expandOnClick.toString().toLowerCase() === 'false') ? false : true;\r\n\t\tthis.showRootNode = (this.showRootNode.toString().toLowerCase() === 'false') ? false : true;\r\n\t\tthis.rootNodeUuid = this.rootNodeUuid || null;\r\n\r\n\t\tif (changes.nodes)\r\n\t\t\tthis.refreshDisplay();\r\n\r\n\t}\r\n\r\n\tprivate async documentClick(e: MouseEvent) {\r\n\t\tif (e.target && SlickUtilsService.checkParentClassExists(<HTMLElement>e.target, \"slick-tree-view_node-text-edit\"))\r\n\t\t\treturn;\r\n\r\n\t\tif (e.target && SlickUtilsService.checkParentClassExists(<HTMLElement>e.target, \"slick-tree-view_context-menu\"))\r\n\t\t\treturn;\r\n\r\n\t\tconst contextMenuElement = <HTMLElement>this.contextMenuRef.nativeElement;\r\n\t\tcontextMenuElement.classList.remove(\"menu-visible\");\r\n\t\tcontextMenuElement.classList.add(\"menu-hidden\");\r\n\r\n\t\tthis.processNewNode();\r\n\r\n\t\tthis.displayNodes = this.displayNodes.map(displayNode => {\r\n\t\t\tif (displayNode.editingText) {\r\n\t\t\t\tdisplayNode.editingText = false;\r\n\t\t\t\tif (this.onNodeChanged && displayNode.text !== displayNode.node.text) {\r\n\t\t\t\t\tdisplayNode.node.text = displayNode.text;\r\n\t\t\t\t\tthis.onNodeChanged.emit(displayNode.node);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\treturn displayNode;\r\n\t\t});\r\n\t}\r\n\r\n\tonTextKeydown(e: KeyboardEvent, displayNode: SlickTreeViewDisplayModel) {\r\n\t\t// Esc\r\n\t\tif (e.keyCode === 27) {\r\n\t\t\tdisplayNode.editingText = false;\r\n\t\t\tdisplayNode.node.text = displayNode.text;\r\n\t\t\tthis.processNewNode();\r\n\t\t}\r\n\r\n\t\t// Enter or tab\r\n\t\tif (e.keyCode === 13 || e.keyCode === 9) {\r\n\t\t\tdisplayNode.editingText = false;\r\n\t\t\tthis.processNewNode();\r\n\t\t\tif (this.onNodeChanged && displayNode.text !== displayNode.node.text) {\r\n\t\t\t\tdisplayNode.node.text = displayNode.text;\r\n\t\t\t\tthis.onNodeChanged.emit(displayNode.node);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tcontextMenu(e: MouseEvent) {\r\n\t\tif (!e || !e.target)\r\n\t\t\treturn;\r\n\r\n\t\tif (!SlickUtilsService.checkParentIdExists(<HTMLElement>e.target, `slick-tree-view_${this.uuid}`))\r\n\t\t\treturn;\r\n\r\n\t\tconst contextNodeElement = <HTMLDivElement>SlickUtilsService.findParent(<HTMLElement>e.target, \"slick-tree-view-node\");\r\n\t\tif (!contextNodeElement)\r\n\t\t\treturn;\r\n\r\n\t\te.preventDefault();\r\n\r\n\t\tthis.contextNodeUuid = contextNodeElement.getAttribute(\"data-uuid\");\r\n\r\n\t\tconst node = this.nodes.find(x => x.uuid === this.contextNodeUuid);\r\n\t\tthis.contextMenuShowAdd = node.canAddChildren;\r\n\t\tthis.contextMenuShowDelete = node.canDelete;\r\n\t\tthis.contextMenuShowEditText = node.canEditText;\r\n\r\n\t\t// If there's nothing to do, don't even show the context menu\r\n\t\tif (this.contextMenuShowAdd === false && this.contextMenuShowDelete === false && this.contextMenuShowEditText === false)\r\n\t\t\treturn;\r\n\r\n\t\tconst contextMenuElement = <HTMLElement>this.contextMenuRef.nativeElement;\r\n\t\tconst top = (contextNodeElement.offsetTop + contextNodeElement.offsetHeight - 5);\r\n\r\n\t\tconst indentationElement = <HTMLDivElement>contextNodeElement.querySelector(\".slick-tree-view_indentation\");\r\n\t\tconst iconElement = <HTMLDivElement>contextNodeElement.querySelector(\".slick-tree-view_icon\");\r\n\t\tconst indentationWidth = (indentationElement) ? indentationElement.offsetWidth : 0;\r\n\t\tconst iconWidth = (iconElement) ? iconElement.offsetWidth : 0;\r\n\t\tconst left = indentationWidth + iconWidth + 2;\r\n\r\n\t\tcontextMenuElement.style.top = top + \"px\";\r\n\t\tcontextMenuElement.style.left = left + \"px\";\r\n\t\tcontextMenuElement.classList.add(\"menu-visible\");\r\n\t\tcontextMenuElement.classList.remove(\"menu-hidden\");\r\n\t}\r\n\r\n\tasync addNode() {\r\n\t\t// Hide the context menu\r\n\t\tconst contextMenuElement = <HTMLElement>this.contextMenuRef.nativeElement;\r\n\t\tcontextMenuElement.classList.remove(\"menu-visible\");\r\n\t\tcontextMenuElement.classList.add(\"menu-hidden\");\r\n\r\n\t\tif (!this.contextNodeUuid)\r\n\t\t\treturn;\r\n\r\n\t\tconst parentNodeIdx = this.nodes.findIndex(x => x.uuid === this.contextNodeUuid);\r\n\t\tconst parentNode = this.nodes[parentNodeIdx]\r\n\t\t// Since we want to add this one to the top, pass null as the parent\r\n\t\tvar newNode = new SlickTreeNodeModel(null, \"New Folder\");\r\n\t\tnewNode.parentUuid = parentNode.uuid;\r\n\t\tparentNode.expanded = true;\r\n\t\tthis.nodes.splice(parentNodeIdx, 0, newNode);\r\n\r\n\t\tthis.refreshDisplay();\r\n\r\n\t\tconst displayNode = this.displayNodes.find(x => x.uuid === newNode.uuid);\r\n\t\tthis.editText(displayNode);\r\n\r\n\t\tthis.newUuid = newNode.uuid;\r\n\t}\r\n\r\n\tasync deleteNode() {\r\n\t\t// Hide the context menu\r\n\t\tconst contextMenuElement = <HTMLElement>this.contextMenuRef.nativeElement;\r\n\t\tcontextMenuElement.classList.remove(\"menu-visible\");\r\n\t\tcontextMenuElement.classList.add(\"menu-hidden\");\r\n\r\n\t\tif (!this.contextNodeUuid)\r\n\t\t\treturn;\r\n\r\n\t\tconst node = this.nodes.find(x => x.uuid === this.contextNodeUuid);\r\n\r\n\t\tthis.deleteNodeName = node.text;\r\n\r\n\t\tconst confirmResult = await this.deleteNodeConfirmRef.confirm();\r\n\r\n\t\tif (confirmResult === SlickConfirmDialogResults.Cancel)\r\n\t\t\treturn;\r\n\r\n\t\tconst removedNodes = this.deleteRecursive(node);\r\n\r\n\t\tthis.refreshDisplay();\r\n\r\n\t\tif (this.onNodeDeleted)\r\n\t\t\tthis.onNodeDeleted.emit(removedNodes);\r\n\r\n\t\tif (this.nodesChange) \r\n\t\t\tthis.nodesChange.emit(this.nodes);\t\t\r\n\t}\r\n\r\n\teditNodeText() {\r\n\t\t// Hide the context menu\r\n\t\tconst contextMenuElement = <HTMLElement>this.contextMenuRef.nativeElement;\r\n\t\tcontextMenuElement.classList.remove(\"menu-visible\");\r\n\t\tcontextMenuElement.classList.add(\"menu-hidden\");\r\n\r\n\t\tif (!this.contextNodeUuid)\r\n\t\t\treturn;\r\n\r\n\t\tconst displayNode = this.displayNodes.find(x => x.uuid === this.contextNodeUuid);\r\n\t\tthis.editText(displayNode);\r\n\r\n\t\tif (this.nodesChange) \r\n\t\t\tthis.nodesChange.emit(this.nodes);\t\t\r\n\t}\r\n\r\n\tselectNode(displayNode: SlickTreeViewDisplayModel) {\r\n\t\tif (this.selectedUuid === displayNode.uuid)\r\n\t\t\treturn;\r\n\r\n\t\tthis.selectedUuid = displayNode.uuid;\r\n\t\tif (displayNode.node.expandOnClick === true)\r\n\t\t\tthis.expandNode(displayNode);\r\n\r\n\t\tif (this.onNodeSelected)\r\n\t\t\tthis.onNodeSelected.emit(displayNode.node);\r\n\t}\r\n\r\n\texpandNode(displayNode: SlickTreeViewDisplayModel) {\r\n\t\tdisplayNode.node.expanded = true;\r\n\t\tthis.refreshDisplay();\r\n\t}\r\n\r\n\tcollapseNode(displayNode: SlickTreeViewDisplayModel) {\r\n\t\tdisplayNode.node.expanded = false;\r\n\t\tthis.refreshDisplay();\r\n\t}\r\n\r\n\tasync editText(displayNode: SlickTreeViewDisplayModel) {\r\n\t\tif (!displayNode.node.canEditText)\r\n\t\t\treturn;\r\n\r\n\t\tdisplayNode.editingText = true;\r\n\r\n\t\tawait SlickSleepService.sleep();\r\n\t\tconst textbox = <HTMLInputElement>document.querySelector(`.slick-tree-view_node-text-edit_${displayNode.uuid}`);\r\n\t\tif (textbox) {\r\n\t\t\ttextbox.focus();\r\n\t\t\ttextbox.select();\r\n\t\t}\r\n\t}\r\n\r\n\tprivate refreshDisplay() {\r\n\t\tthis.displayNodes = [];\r\n\r\n\t\tif (!this.nodes || this.nodes.length === 0)\r\n\t\t\treturn;\r\n\r\n\t\tlet rootNode: ISlickTreeNodeModel;\r\n\t\tif (this.rootNodeUuid)\r\n\t\t\trootNode = this.nodes.find(x => x.uuid === this.rootNodeUuid);\r\n\t\telse\r\n\t\t\trootNode = this.nodes.find(x => x.parentUuid === null);\r\n\t\t// Always expand the root node\r\n\t\trootNode.expanded = true;\r\n\r\n\t\t// If we aren't showing the root node, start at -1 for the indent level\r\n\t\tthis.populateDisplayNodes(rootNode, (this.showRootNode) ? 0 : -1);\r\n\r\n\t\tif (this.showRootNode === false) \r\n\t\t\tthis.displayNodes = this.displayNodes.filter(x => x.parentUuid !== null);\t\t\r\n\t}\r\n\r\n\tprivate populateDisplayNodes(node: ISlickTreeNodeModel, level: number) {\r\n\t\tif (level >= 100) {\r\n\t\t\tconsole.error(\"Exceeeded max of 100 levels deep.  Possible infinite recursion.\");\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tconst displayNode = new SlickTreeViewDisplayModel(node, level);\r\n\r\n\t\tif (node.expandOnClick === null || node.expandOnClick === undefined)\r\n\t\t\tnode.expandOnClick = this.expandOnClick;\r\n\r\n\t\tif (displayNode.parentUuid === null)\r\n\t\t\tdisplayNode.node.canDelete = false;\r\n\r\n\t\tif (displayNode.uuid === this.newUuid) \r\n\t\t\tdisplayNode.editingText = true;\r\n\t\t\r\n\t\tthis.displayNodes.push(displayNode);\r\n\r\n\t\tconst childNodes = this.nodes.filter(x => x.parentUuid === node.uuid) || [];\r\n\t\tdisplayNode.hasChildNodes = (childNodes.length > 0);\r\n\r\n\t\tif (node.expanded === true)\r\n\t\t\tchildNodes.forEach(childNode => {\r\n\t\t\t\tif (!childNode.hidden)\r\n\t\t\t\t\tthis.populateDisplayNodes(childNode, level + 1)\r\n\t\t\t});\r\n\t}\r\n\r\n\tprivate deleteRecursive(node: ISlickTreeNodeModel): ISlickTreeNodeModel[] {\r\n\t\tlet removedNodes: ISlickTreeNodeModel[] = [];\r\n\r\n\t\tconst childNodes = this.nodes.filter(x => x.parentUuid === node.uuid) || [];\r\n\r\n\t\tchildNodes.forEach(childNode => {\r\n\t\t\tremovedNodes = removedNodes.concat(this.deleteRecursive(childNode))\r\n\t\t});\r\n\r\n\t\tremovedNodes.push(node);\r\n\r\n\t\tthis.nodes = this.nodes.filter(x => x.uuid !== node.uuid);\r\n\r\n\t\treturn removedNodes;\r\n\t}\r\n\r\n\tprivate processNewNode() {\r\n\t\tif (!this.newUuid)\r\n\t\t\treturn;\r\n\r\n\t\tconst newNode = this.nodes.find(x => x.uuid === this.newUuid);\r\n\t\tconst displayNode = this.displayNodes.find(x => x.uuid == this.newUuid);\r\n\t\t// Do this so that we don't trigger the node update\r\n\t\t newNode.text = displayNode.text;\r\n\r\n\t\tthis.newUuid = null;\r\n\r\n\t\tif (!newNode) \r\n\t\t\treturn;\t\t\r\n\r\n\t\tif (this.onNodeAdded)\r\n\t\t\tthis.onNodeAdded.emit(newNode);\r\n\r\n\t\tif (this.nodesChange)\r\n\t\t\tthis.nodesChange.emit(this.nodes);\r\n\t}\r\n}\r\n","<div #slickTreeViewRef id=\"slick-tree-view_{{uuid}}\" class=\"slick-tree-view position-relative pr-2\">\r\n\t<div class=\"d-flex slick-tree-view-node\" [attr.data-uuid]=\"displayNode.uuid\" *ngFor=\"let displayNode of displayNodes\">\r\n\t\t<div class=\"slick-tree-view_indentation\">\r\n\t\t\t<i *ngFor=\"let indent of displayNode.indentArray\" class=\"far fa-caret-right mr-1\" style=\"opacity: 0\"></i>\r\n\t\t\t<i *ngIf=\"!displayNode.hasChildNodes\" class=\"far fa-caret-right mr-1\" style=\"opacity: 0\"></i>\r\n\t\t\t<i *ngIf=\"displayNode.hasChildNodes && !displayNode.expanded\" class=\"far fa-caret-right mr-1\" style=\"cursor: pointer\" (click)=\"expandNode(displayNode)\"></i>\r\n\t\t\t<i *ngIf=\"displayNode.hasChildNodes && displayNode.expanded\" class=\"far fa-caret-down mr-1\" style=\"cursor: pointer\" (click)=\"collapseNode(displayNode)\"></i>\r\n\t\t</div>\r\n\t\t<div class=\"d-flex px-1\" [ngClass]=\"{'bg-success text-white' : displayNode.uuid === selectedUuid }\">\r\n\t\t\t<div *ngIf=\"displayNode.node.iconClass || displayNode.node.iconUrl\" class=\"mr-1 slick-tree-view_icon\">\r\n\t\t\t\t<i *ngIf=\"displayNode.node.iconClass\" [style.color]=\"displayNode.node.iconColor\" [ngClass]=\"displayNode.node.iconClass\"></i>\r\n\t\t\t</div>\r\n\t\t\t<div *ngIf=\"!displayNode.editingText\" style=\"cursor: pointer\" (click)=\"selectNode(displayNode)\" (dblclick)=\"editText(displayNode)\">{{displayNode.text}}</div>\r\n\t\t\t<div *ngIf=\"displayNode.editingText\" class=\"slick-tree-view_node-text-edit\"><input type=\"text\" class=\"form-control slick-tree-view_node-text-edit_{{displayNode.uuid}}\" [(ngModel)]=\"displayNode.text\" (keydown)=\"onTextKeydown($event, displayNode)\" /></div>\r\n\t\t</div>\r\n\t</div>\r\n\r\n\t<div #contextMenuRef class='slick-tree-view_context-menu dropdown-menu p-0 show menu-hidden'>\r\n\t\t<div *ngIf=\"contextMenuShowAdd\" class=\"px-2 dropdown-item\" (click)=\"addNode()\">Add</div>\r\n\t\t<div *ngIf=\"contextMenuShowDelete\" class=\"px-2 dropdown-item\" (click)=\"deleteNode()\">Delete</div>\r\n\t\t<div *ngIf=\"contextMenuShowEditText\" class=\"px-2 dropdown-item\" (click)=\"editNodeText()\">Edit Name</div>\r\n\t</div>\r\n</div>\r\n\r\n<slick-confirm-dialog #deleteNodeConfirmRef>\r\n\tAre you sure you want to delete {{deleteNodeName}}?\r\n</slick-confirm-dialog>"]}

package/esm2020/slick-tree-view/slick-tree-view.module.mjs

@@ -0,0 +1,22 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from "@angular/core";
+import { FormsModule } from "@angular/forms";
+import { SlickConfirmDialogModule } from "../slick-confirm-dialog/slick-confirm-dialog.module";
+import { SlickTreeViewComponent } from "./slick-tree-view.component";
+import * as i0 from "@angular/core";
+export class SlickTreeViewModule {
+}
+/** @nocollapse */ SlickTreeViewModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickTreeViewModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ SlickTreeViewModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickTreeViewModule, declarations: [SlickTreeViewComponent], imports: [CommonModule, FormsModule, SlickConfirmDialogModule], exports: [CommonModule, FormsModule, SlickTreeViewComponent] });
+/** @nocollapse */ SlickTreeViewModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickTreeViewModule, imports: [[CommonModule, FormsModule, SlickConfirmDialogModule], CommonModule, FormsModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickTreeViewModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, FormsModule, SlickConfirmDialogModule],
+                    declarations: [SlickTreeViewComponent],
+                    exports: [CommonModule, FormsModule, SlickTreeViewComponent]
+                }]
+        }] });
+export { SlickTreeViewComponent };
+export { SlickTreeNodeModel } from "./slick-tree-node.model";
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/slick-type-ahead/slick-type-ahead.directive.mjs

@@ -0,0 +1,164 @@
+import { Directive, Input, Output, EventEmitter, forwardRef } from "@angular/core";
+import { NG_VALUE_ACCESSOR } from "@angular/forms";
+import { SlickSleepService } from "../utils/slick-sleep.service";
+import { SlickUtilsService } from "../utils/slick-utils.service";
+import * as i0 from "@angular/core";
+export class SlickTypeAheadDirective {
+    constructor(el) {
+        this.el = el;
+        this.slickTypeAheadChange = new EventEmitter();
+        this.fnKeyDown = (e) => this.keyDown(e);
+        this.propagateChange = (_) => { };
+    }
+    ngOnInit() {
+        this.el.nativeElement.addEventListener('keydown', this.fnKeyDown);
+    }
+    ngOnChanges() {
+    }
+    ngOnDestroy() {
+        this.el.nativeElement.removeEventListener('keydown', this.fnKeyDown);
+    }
+    async keyDown(e) {
+        if (e.altKey || e.ctrlKey)
+            return;
+        var valid = (e.keyCode > 47 && e.keyCode < 58) || // number keys
+            e.keyCode === 32 || e.keyCode === 13 ||
+            e.keyCode === 8 || e.keyCode === 9 || // spacebar, return & tab key(s) (if you want to allow carriage returns)
+            (e.keyCode > 64 && e.keyCode < 91) || // letter keys
+            (e.keyCode > 95 && e.keyCode < 112) || // numpad keys
+            (e.keyCode > 185 && e.keyCode < 193) || // ;=,-./` (in order)
+            (e.keyCode > 218 && e.keyCode < 223); // [\]' (in order)
+        if (!valid) {
+            return;
+        }
+        e.stopPropagation();
+        await SlickSleepService.sleep();
+        // Tab/enter
+        if (e.which === 9) {
+            this.propagateChange(this.suggestedItem);
+            this.createSelection(this.el.nativeElement, this.el.nativeElement.value, 0);
+            if (this.slickTypeAheadChange) {
+                if (this.filteredItems && this.filteredItems.length > 0)
+                    this.slickTypeAheadChange.emit(this.filteredItems[0]);
+                else
+                    this.slickTypeAheadChange.emit(this.el.nativeElement.value);
+            }
+            return false;
+        }
+        if (e.which === 8) {
+            if (this.el.nativeElement.value.length > 0) {
+                var cursorLoc = this.el.nativeElement.selectionStart;
+                if (cursorLoc > 0) {
+                    var valSubstr = this.el.nativeElement.value.substring(0, cursorLoc - 1);
+                    valSubstr += this.el.nativeElement.value.substring(cursorLoc);
+                    this.el.nativeElement.value = valSubstr;
+                }
+            }
+        }
+        if (!this.el.nativeElement.value)
+            return;
+        // Esc
+        if (e.which === 27) {
+            this.filteredItems = null;
+            this.suggestedItem = null;
+            return false;
+        }
+        this.suggestedItem = null;
+        let val = this.el.nativeElement.value.toLowerCase();
+        if (!this.slickTypeAheadField && !this.slickTypeAheadFields) {
+            this.filteredItems = this.slickTypeAhead.filter(x => x.toLowerCase().indexOf(val) === 0);
+            if (this.filteredItems && this.filteredItems.length > 0)
+                this.suggestedItem = this.filteredItems[0];
+        }
+        else {
+            if (this.slickTypeAheadField) {
+                this.filteredItems = this.slickTypeAhead.filter(x => ((SlickUtilsService.getDeepObject(x, this.slickTypeAheadField)) ? SlickUtilsService.getDeepObject(x, this.slickTypeAheadField).toLowerCase().indexOf(val) === 0 : false));
+                if (this.filteredItems && this.filteredItems.length > 0)
+                    this.suggestedItem = SlickUtilsService.getDeepObject(this.filteredItems[0], this.slickTypeAheadField);
+            }
+            else {
+                let fields = this.slickTypeAheadFields.split("|");
+                this.filteredItems = null;
+                fields.forEach(field => {
+                    if (!this.filteredItems || this.filteredItems.length === 0) {
+                        this.filteredItems = this.slickTypeAhead.filter(x => ((SlickUtilsService.getDeepObject(x, field)) ? SlickUtilsService.getDeepObject(x, field).toLowerCase().indexOf(val) === 0 : false));
+                        if (this.filteredItems && this.filteredItems.length > 0) {
+                            this.suggestedItem = SlickUtilsService.getDeepObject(this.filteredItems[0], field);
+                        }
+                    }
+                });
+            }
+        }
+        if (this.suggestedItem) {
+            var len = this.el.nativeElement.value.length;
+            this.el.nativeElement.value = this.suggestedItem;
+            this.createSelection(this.el.nativeElement, len, this.suggestedItem.length);
+        }
+        else {
+            this.suggestedItem = this.el.nativeElement.value;
+        }
+    }
+    createSelection(field, start, end) {
+        if (field.createTextRange) {
+            var selRange = field.createTextRange();
+            selRange.collapse(true);
+            selRange.moveStart('character', start);
+            selRange.moveEnd('character', end);
+            selRange.select();
+            field.focus();
+        }
+        else if (field.setSelectionRange) {
+            field.focus();
+            field.setSelectionRange(start, end);
+        }
+        else if (typeof field.selectionStart != 'undefined') {
+            field.selectionStart = start;
+            field.selectionEnd = end;
+            field.focus();
+        }
+    }
+    // this is the initial value set to the component
+    writeValue(obj) {
+    }
+    // registers 'fn' that will be fired when changes are made
+    // this is how we emit the changes back to the form
+    registerOnChange(fn) {
+        this.propagateChange = fn;
+    }
+    // not used, used for touch input
+    registerOnTouched() { }
+}
+/** @nocollapse */ SlickTypeAheadDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickTypeAheadDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ SlickTypeAheadDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.3", type: SlickTypeAheadDirective, selector: "[slick-type-ahead]", inputs: { slickTypeAhead: ["slick-type-ahead", "slickTypeAhead"], slickTypeAheadField: ["slick-type-ahead-field-id", "slickTypeAheadField"], slickTypeAheadFields: ["slick-type-ahead-field-ids", "slickTypeAheadFields"] }, outputs: { slickTypeAheadChange: "slick-type-ahead-change" }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef((() => SlickTypeAheadDirective)),
+            multi: true,
+        }
+    ], usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickTypeAheadDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[slick-type-ahead]',
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef((() => SlickTypeAheadDirective)),
+                            multi: true,
+                        }
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { slickTypeAhead: [{
+                type: Input,
+                args: ["slick-type-ahead"]
+            }], slickTypeAheadField: [{
+                type: Input,
+                args: ["slick-type-ahead-field-id"]
+            }], slickTypeAheadFields: [{
+                type: Input,
+                args: ["slick-type-ahead-field-ids"]
+            }], slickTypeAheadChange: [{
+                type: Output,
+                args: ["slick-type-ahead-change"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slick-type-ahead.directive.js","sourceRoot":"","sources":["../../../../projects/components/src/slick-type-ahead/slick-type-ahead.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Input, Output, EventEmitter, OnChanges, OnInit, OnDestroy, ElementRef, forwardRef } from \"@angular/core\";\r\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from \"@angular/forms\";\r\nimport { SlickSleepService } from \"../utils/slick-sleep.service\";\r\nimport { SlickUtilsService } from \"../utils/slick-utils.service\";\r\n\r\n@Directive({\r\n\tselector: '[slick-type-ahead]',\r\n\tproviders: [\r\n\t\t{\r\n\t\t\tprovide: NG_VALUE_ACCESSOR,\r\n\t\t\tuseExisting: forwardRef(() => SlickTypeAheadDirective),\r\n\t\t\tmulti: true,\r\n\t\t}]\r\n})\r\nexport class SlickTypeAheadDirective implements OnChanges, ControlValueAccessor {\r\n\t@Input(\"slick-type-ahead\") slickTypeAhead: any[];\r\n\t@Input(\"slick-type-ahead-field-id\") slickTypeAheadField: string;\r\n\t@Input(\"slick-type-ahead-field-ids\") slickTypeAheadFields: string;\r\n\t@Output(\"slick-type-ahead-change\") slickTypeAheadChange: EventEmitter<any> = new EventEmitter();\r\n\r\n\tprivate fnKeyDown = (e) => this.keyDown(e);\r\n\r\n\tprivate filteredItems: string[];\r\n\tprivate suggestedItem: string;\r\n\r\n\tconstructor(private el: ElementRef) {\r\n\r\n\t}\r\n\r\n\tngOnInit() {\r\n\t\tthis.el.nativeElement.addEventListener('keydown', this.fnKeyDown);\r\n\t}\r\n\r\n\tngOnChanges() {\r\n\t}\r\n\r\n\tngOnDestroy() {\r\n\t\tthis.el.nativeElement.removeEventListener('keydown', this.fnKeyDown);\r\n\t}\r\n\r\n\tasync keyDown(e: KeyboardEvent) {\r\n\t\tif (e.altKey || e.ctrlKey)\r\n\t\t\treturn;\r\n\r\n\t\tvar valid =\r\n\t\t\t(e.keyCode > 47 && e.keyCode < 58) || // number keys\r\n\t\t\te.keyCode === 32 || e.keyCode === 13 ||\r\n\t\t\te.keyCode === 8 || e.keyCode === 9 || // spacebar, return & tab key(s) (if you want to allow carriage returns)\r\n\t\t\t(e.keyCode > 64 && e.keyCode < 91) || // letter keys\r\n\t\t\t(e.keyCode > 95 && e.keyCode < 112) || // numpad keys\r\n\t\t\t(e.keyCode > 185 && e.keyCode < 193) || // ;=,-./` (in order)\r\n\t\t\t(e.keyCode > 218 && e.keyCode < 223);   // [\\]' (in order)\r\n\r\n\t\tif (!valid) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\te.stopPropagation();\r\n\r\n\t\tawait SlickSleepService.sleep();\r\n\t\t// Tab/enter\r\n\t\tif (e.which === 9) {\r\n\t\t\tthis.propagateChange(this.suggestedItem);\r\n\t\t\tthis.createSelection(this.el.nativeElement, this.el.nativeElement.value, 0);\r\n\r\n\t\t\tif (this.slickTypeAheadChange) {\r\n\t\t\t\tif (this.filteredItems && this.filteredItems.length > 0)\r\n\t\t\t\t\tthis.slickTypeAheadChange.emit(this.filteredItems[0])\r\n\t\t\t\telse\r\n\t\t\t\t\tthis.slickTypeAheadChange.emit(this.el.nativeElement.value);\r\n\t\t\t}\r\n\r\n\t\t\treturn false;\r\n\t\t}\r\n\r\n\t\tif (e.which === 8) {\r\n\t\t\tif (this.el.nativeElement.value.length > 0) {\r\n\t\t\t\tvar cursorLoc = this.el.nativeElement.selectionStart;\r\n\t\t\t\tif (cursorLoc > 0) {\r\n\t\t\t\t\tvar valSubstr = this.el.nativeElement.value.substring(0, cursorLoc - 1);\r\n\t\t\t\t\tvalSubstr += this.el.nativeElement.value.substring(cursorLoc);\r\n\t\t\t\t\tthis.el.nativeElement.value = valSubstr;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tif (!this.el.nativeElement.value)\r\n\t\t\treturn;\r\n\r\n\t\t// Esc\r\n\t\tif (e.which === 27) {\r\n\t\t\tthis.filteredItems = null;\r\n\t\t\tthis.suggestedItem = null;\r\n\r\n\t\t\treturn false;\r\n\t\t}\r\n\r\n\t\tthis.suggestedItem = null;\r\n\t\tlet val = this.el.nativeElement.value.toLowerCase();\r\n\t\t\r\n\t\tif (!this.slickTypeAheadField && !this.slickTypeAheadFields) {\r\n\t\t\tthis.filteredItems = this.slickTypeAhead.filter(x => x.toLowerCase().indexOf(val) === 0);\r\n\r\n\t\t\tif (this.filteredItems && this.filteredItems.length > 0)\r\n\t\t\t\tthis.suggestedItem = this.filteredItems[0];\r\n\t\t}\r\n\t\telse {\r\n\t\t\tif (this.slickTypeAheadField) {\r\n\t\t\t\tthis.filteredItems = this.slickTypeAhead.filter(x => ((SlickUtilsService.getDeepObject(x, this.slickTypeAheadField)) ? SlickUtilsService.getDeepObject(x, this.slickTypeAheadField).toLowerCase().indexOf(val) === 0 : false))\r\n\r\n\t\t\t\tif (this.filteredItems && this.filteredItems.length > 0)\r\n\t\t\t\t\tthis.suggestedItem = SlickUtilsService.getDeepObject(this.filteredItems[0], this.slickTypeAheadField)\r\n\t\t\t}\r\n\t\t\telse {\r\n\t\t\t\tlet fields = this.slickTypeAheadFields.split(\"|\");\r\n\t\t\t\tthis.filteredItems = null;\r\n\t\t\t\tfields.forEach(field => {\r\n\t\t\t\t\tif (!this.filteredItems || this.filteredItems.length === 0) {\r\n\t\t\t\t\t\tthis.filteredItems = this.slickTypeAhead.filter(x => ((SlickUtilsService.getDeepObject(x, field)) ? SlickUtilsService.getDeepObject(x, field).toLowerCase().indexOf(val) === 0 : false))\r\n\t\t\t\t\t\tif (this.filteredItems && this.filteredItems.length > 0) {\r\n\t\t\t\t\t\t\tthis.suggestedItem = SlickUtilsService.getDeepObject(this.filteredItems[0], field);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tif (this.suggestedItem) {\r\n\t\t\tvar len = this.el.nativeElement.value.length;\r\n\t\t\tthis.el.nativeElement.value = this.suggestedItem;\r\n\t\t\tthis.createSelection(this.el.nativeElement, len, this.suggestedItem.length)\r\n\t\t}\r\n\t\telse {\r\n\t\t\tthis.suggestedItem = this.el.nativeElement.value;\r\n\t\t}\r\n\t}\r\n\r\n\tprivate createSelection(field: any, start: number, end: number) {\r\n\t\tif (field.createTextRange) {\r\n\t\t\tvar selRange = field.createTextRange();\r\n\t\t\tselRange.collapse(true);\r\n\t\t\tselRange.moveStart('character', start);\r\n\t\t\tselRange.moveEnd('character', end);\r\n\t\t\tselRange.select();\r\n\t\t\tfield.focus();\r\n\t\t} else if (field.setSelectionRange) {\r\n\t\t\tfield.focus();\r\n\t\t\tfield.setSelectionRange(start, end);\r\n\t\t} else if (typeof field.selectionStart != 'undefined') {\r\n\t\t\tfield.selectionStart = start;\r\n\t\t\tfield.selectionEnd = end;\r\n\t\t\tfield.focus();\r\n\t\t}\r\n\t}\r\n\r\n\tpropagateChange = (_: any) => { };\r\n\r\n\t// this is the initial value set to the component\r\n\tpublic writeValue(obj: any) {\r\n\t}\r\n\r\n\t// registers 'fn' that will be fired when changes are made\r\n\t// this is how we emit the changes back to the form\r\n\tpublic registerOnChange(fn: any) {\r\n\t\tthis.propagateChange = fn;\r\n\t}\r\n\r\n\t// not used, used for touch input\r\n\tpublic registerOnTouched() { }\r\n\r\n}\r\n"]}

package/esm2020/slick-type-ahead/slick-type-ahead.module.mjs

@@ -0,0 +1,18 @@
+import { NgModule } from "@angular/core";
+import { SlickTypeAheadDirective } from "./slick-type-ahead.directive";
+import * as i0 from "@angular/core";
+export class SlickTypeAheadModule {
+}
+/** @nocollapse */ SlickTypeAheadModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickTypeAheadModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ SlickTypeAheadModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickTypeAheadModule, declarations: [SlickTypeAheadDirective], exports: [SlickTypeAheadDirective] });
+/** @nocollapse */ SlickTypeAheadModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickTypeAheadModule, imports: [[]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickTypeAheadModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    declarations: [SlickTypeAheadDirective],
+                    exports: [SlickTypeAheadDirective]
+                }]
+        }] });
+export { SlickTypeAheadDirective };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xpY2stdHlwZS1haGVhZC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9jb21wb25lbnRzL3NyYy9zbGljay10eXBlLWFoZWFkL3NsaWNrLXR5cGUtYWhlYWQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sOEJBQThCLENBQUM7O0FBT3ZFLE1BQU0sT0FBTyxvQkFBb0I7O29JQUFwQixvQkFBb0I7cUlBQXBCLG9CQUFvQixpQkFIakIsdUJBQXVCLGFBQzVCLHVCQUF1QjtxSUFFckIsb0JBQW9CLFlBSnZCLEVBQUU7MkZBSUMsb0JBQW9CO2tCQUxoQyxRQUFRO21CQUFDO29CQUNULE9BQU8sRUFBRSxFQUFFO29CQUNYLFlBQVksRUFBRSxDQUFDLHVCQUF1QixDQUFDO29CQUN2QyxPQUFPLEVBQUUsQ0FBQyx1QkFBdUIsQ0FBQztpQkFDbEM7O0FBRUQsT0FBTyxFQUFFLHVCQUF1QixFQUFFLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcbmltcG9ydCB7IFNsaWNrVHlwZUFoZWFkRGlyZWN0aXZlIH0gZnJvbSBcIi4vc2xpY2stdHlwZS1haGVhZC5kaXJlY3RpdmVcIjtcclxuXHJcbkBOZ01vZHVsZSh7XHJcblx0aW1wb3J0czogW10sXHJcblx0ZGVjbGFyYXRpb25zOiBbU2xpY2tUeXBlQWhlYWREaXJlY3RpdmVdLFxyXG5cdGV4cG9ydHM6IFtTbGlja1R5cGVBaGVhZERpcmVjdGl2ZV1cclxufSlcclxuZXhwb3J0IGNsYXNzIFNsaWNrVHlwZUFoZWFkTW9kdWxlIHsgfVxyXG5leHBvcnQgeyBTbGlja1R5cGVBaGVhZERpcmVjdGl2ZSB9XHJcbiJdfQ==