slick-components 4.4.13 → 4.4.16

package/esm2020/slick-drop-down/slick-drop-down.module.mjs

@@ -0,0 +1,24 @@
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { FormsModule } from "@angular/forms";
+import { HttpClientModule } from "@angular/common/http";
+import { SlickValidationIndicatorModule } from "../slick-validation-indicator/slick-validation-indicator.module";
+import { SlickDropDownComponent } from "./slick-drop-down.component";
+import * as i0 from "@angular/core";
+export class SlickDropDownModule {
+}
+/** @nocollapse */ SlickDropDownModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDropDownModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ SlickDropDownModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDropDownModule, declarations: [SlickDropDownComponent], imports: [CommonModule, FormsModule, HttpClientModule, SlickValidationIndicatorModule], exports: [SlickDropDownComponent] });
+/** @nocollapse */ SlickDropDownModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDropDownModule, providers: [HttpClientModule], imports: [[CommonModule, FormsModule, HttpClientModule, SlickValidationIndicatorModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDropDownModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, FormsModule, HttpClientModule, SlickValidationIndicatorModule],
+                    declarations: [SlickDropDownComponent],
+                    exports: [SlickDropDownComponent],
+                    providers: [HttpClientModule]
+                }]
+        }] });
+export { SlickDropDownComponent };
+export { SlickDropDownButtonModel } from "./slick-drop-down-button.model";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xpY2stZHJvcC1kb3duLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2NvbXBvbmVudHMvc3JjL3NsaWNrLWRyb3AtZG93bi9zbGljay1kcm9wLWRvd24ubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUM3QyxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN4RCxPQUFPLEVBQUUsOEJBQThCLEVBQUUsTUFBTSxpRUFBaUUsQ0FBQztBQUNqSCxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQzs7QUFRckUsTUFBTSxPQUFPLG1CQUFtQjs7bUlBQW5CLG1CQUFtQjtvSUFBbkIsbUJBQW1CLGlCQUpoQixzQkFBc0IsYUFEM0IsWUFBWSxFQUFFLFdBQVcsRUFBRSxnQkFBZ0IsRUFBRSw4QkFBOEIsYUFFM0Usc0JBQXNCO29JQUdwQixtQkFBbUIsYUFGcEIsQ0FBQyxnQkFBZ0IsQ0FBQyxZQUhwQixDQUFDLFlBQVksRUFBRSxXQUFXLEVBQUUsZ0JBQWdCLEVBQUUsOEJBQThCLENBQUM7MkZBSzFFLG1CQUFtQjtrQkFOL0IsUUFBUTttQkFBQztvQkFDVCxPQUFPLEVBQUUsQ0FBQyxZQUFZLEVBQUUsV0FBVyxFQUFFLGdCQUFnQixFQUFFLDhCQUE4QixDQUFDO29CQUN0RixZQUFZLEVBQUUsQ0FBQyxzQkFBc0IsQ0FBQztvQkFDdEMsT0FBTyxFQUFFLENBQUMsc0JBQXNCLENBQUM7b0JBQ2pDLFNBQVMsRUFBRSxDQUFDLGdCQUFnQixDQUFDO2lCQUM3Qjs7QUFHRCxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsQ0FBQTtBQUNqQyxPQUFPLEVBQUUsd0JBQXdCLEVBQTZCLE1BQU0sZ0NBQWdDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gXCJAYW5ndWxhci9jb21tb25cIjtcclxuaW1wb3J0IHsgRm9ybXNNb2R1bGUgfSBmcm9tIFwiQGFuZ3VsYXIvZm9ybXNcIjtcclxuaW1wb3J0IHsgSHR0cENsaWVudE1vZHVsZSB9IGZyb20gXCJAYW5ndWxhci9jb21tb24vaHR0cFwiO1xyXG5pbXBvcnQgeyBTbGlja1ZhbGlkYXRpb25JbmRpY2F0b3JNb2R1bGUgfSBmcm9tIFwiLi4vc2xpY2stdmFsaWRhdGlvbi1pbmRpY2F0b3Ivc2xpY2stdmFsaWRhdGlvbi1pbmRpY2F0b3IubW9kdWxlXCI7XHJcbmltcG9ydCB7IFNsaWNrRHJvcERvd25Db21wb25lbnQgfSBmcm9tIFwiLi9zbGljay1kcm9wLWRvd24uY29tcG9uZW50XCI7XHJcblxyXG5ATmdNb2R1bGUoe1xyXG5cdGltcG9ydHM6IFtDb21tb25Nb2R1bGUsIEZvcm1zTW9kdWxlLCBIdHRwQ2xpZW50TW9kdWxlLCBTbGlja1ZhbGlkYXRpb25JbmRpY2F0b3JNb2R1bGVdLFxyXG5cdGRlY2xhcmF0aW9uczogW1NsaWNrRHJvcERvd25Db21wb25lbnRdLFxyXG5cdGV4cG9ydHM6IFtTbGlja0Ryb3BEb3duQ29tcG9uZW50XSxcclxuXHRwcm92aWRlcnM6IFtIdHRwQ2xpZW50TW9kdWxlXVxyXG59KVxyXG5leHBvcnQgY2xhc3MgU2xpY2tEcm9wRG93bk1vZHVsZSB7IH1cclxuXHJcbmV4cG9ydCB7IFNsaWNrRHJvcERvd25Db21wb25lbnQgfVxyXG5leHBvcnQgeyBTbGlja0Ryb3BEb3duQnV0dG9uTW9kZWwsIElTbGlja0Ryb3BEb3duQnV0dG9uTW9kZWwgfSBmcm9tIFwiLi9zbGljay1kcm9wLWRvd24tYnV0dG9uLm1vZGVsXCI7Il19

package/esm2020/slick-drop-down/slick-drop-down.service.mjs

@@ -0,0 +1,55 @@
+import { Injectable } from "@angular/core";
+import { SlickUtilsService } from "../utils/slick-utils.service";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class SlickDropDownService {
+    constructor(http) {
+        this.http = http;
+    }
+    getVisibleItems(items, idFieldName, textFieldName) {
+        let foundSomeText = false;
+        if (!items || items.length === 0)
+            return null;
+        let visibleItems = items.map((item) => {
+            let id = SlickUtilsService.getDeepObject(item, idFieldName);
+            if (id === null || id === undefined) {
+                console.debug("%c slick-drop-down: Id not found for dropdown item.  The idFieldName is '" + idFieldName + "'.  Is this correct?", 'background: red; color: white');
+                console.debug("First Item: ", items[0]);
+            }
+            let text = SlickUtilsService.getDeepObject(item, textFieldName);
+            if (text !== null && text !== undefined)
+                foundSomeText = true;
+            return {
+                id: id,
+                text: text ? text.toString() : null,
+                item: item
+            };
+        });
+        if (foundSomeText === false) {
+            console.error("%c slick-drop-down: Warning!  No text was found for dropdown item.  The textFieldName is '" + textFieldName + "'.  Is this correct?", 'background: red; color: white');
+            console.error("First Item: ", items[0]);
+        }
+        return visibleItems;
+    }
+    getSelectedItem(items, selectedId) {
+        if (!items || items.length === 0)
+            return null;
+        let selectedItem = items.find((item) => { return item.id === selectedId; });
+        if (selectedItem)
+            return selectedItem;
+        else
+            return null;
+    }
+    async getItemsFromServer(url) {
+        return Promise.resolve((await this.http.get(url).toPromise()));
+    }
+    getItemIndex(items, selectedId) {
+        return items.findIndex((item) => { return item.id === selectedId; });
+    }
+}
+/** @nocollapse */ SlickDropDownService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDropDownService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ SlickDropDownService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDropDownService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDropDownService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/slick-drop-list/slick-drop-list-grab.directive.mjs

@@ -0,0 +1,18 @@
+import { Directive } from "@angular/core";
+import * as i0 from "@angular/core";
+export class SlickDropListGrabDirective {
+    constructor(el) {
+        const dropListEl = el.nativeElement;
+        if (dropListEl.classList.contains("slick-drop-list-grab") === false)
+            dropListEl.classList.add("slick-drop-list-grab");
+    }
+}
+/** @nocollapse */ SlickDropListGrabDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDropListGrabDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ SlickDropListGrabDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.3", type: SlickDropListGrabDirective, selector: "[slick-drop-list-grab]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDropListGrabDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[slick-drop-list-grab]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xpY2stZHJvcC1saXN0LWdyYWIuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvY29tcG9uZW50cy9zcmMvc2xpY2stZHJvcC1saXN0L3NsaWNrLWRyb3AtbGlzdC1ncmFiLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFnRCxNQUFNLGVBQWUsQ0FBQzs7QUFNeEYsTUFBTSxPQUFPLDBCQUEwQjtJQUV0QyxZQUFZLEVBQWM7UUFDekIsTUFBTSxVQUFVLEdBQWdCLEVBQUUsQ0FBQyxhQUFhLENBQUM7UUFDakQsSUFBSSxVQUFVLENBQUMsU0FBUyxDQUFDLFFBQVEsQ0FBQyxzQkFBc0IsQ0FBQyxLQUFLLEtBQUs7WUFDbEUsVUFBVSxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsc0JBQXNCLENBQUMsQ0FBQztJQUVuRCxDQUFDOzswSUFQVywwQkFBMEI7OEhBQTFCLDBCQUEwQjsyRkFBMUIsMEJBQTBCO2tCQUh0QyxTQUFTO21CQUFDO29CQUNWLFFBQVEsRUFBRSx3QkFBd0I7aUJBQ2xDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBFbGVtZW50UmVmLCBBZnRlclZpZXdJbml0LCBPbkRlc3Ryb3ksIE9uSW5pdCB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcbmltcG9ydCB7IFNsaWNrVXRpbHNTZXJ2aWNlIH0gZnJvbSAnLi4vdXRpbHMvc2xpY2stdXRpbHMuc2VydmljZSc7XHJcblxyXG5ARGlyZWN0aXZlKHtcclxuXHRzZWxlY3RvcjogJ1tzbGljay1kcm9wLWxpc3QtZ3JhYl0nXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBTbGlja0Ryb3BMaXN0R3JhYkRpcmVjdGl2ZSB7XHJcblxyXG5cdGNvbnN0cnVjdG9yKGVsOiBFbGVtZW50UmVmKSB7XHJcblx0XHRjb25zdCBkcm9wTGlzdEVsID0gPEhUTUxFbGVtZW50PmVsLm5hdGl2ZUVsZW1lbnQ7XHJcblx0XHRpZiAoZHJvcExpc3RFbC5jbGFzc0xpc3QuY29udGFpbnMoXCJzbGljay1kcm9wLWxpc3QtZ3JhYlwiKSA9PT0gZmFsc2UpXHJcblx0XHRcdGRyb3BMaXN0RWwuY2xhc3NMaXN0LmFkZChcInNsaWNrLWRyb3AtbGlzdC1ncmFiXCIpO1xyXG5cclxuXHR9XHJcbn0iXX0=

package/esm2020/slick-drop-list/slick-drop-list-item.directive.mjs

@@ -0,0 +1,18 @@
+import { Directive } from "@angular/core";
+import * as i0 from "@angular/core";
+export class SlickDropListItemDirective {
+    constructor(el) {
+        const dropListEl = el.nativeElement;
+        if (dropListEl.classList.contains("slick-drop-list-item") === false)
+            dropListEl.classList.add("slick-drop-list-item");
+    }
+}
+/** @nocollapse */ SlickDropListItemDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDropListItemDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ SlickDropListItemDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.3", type: SlickDropListItemDirective, selector: "[slick-drop-list-item]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDropListItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[slick-drop-list-item]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xpY2stZHJvcC1saXN0LWl0ZW0uZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvY29tcG9uZW50cy9zcmMvc2xpY2stZHJvcC1saXN0L3NsaWNrLWRyb3AtbGlzdC1pdGVtLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFnRCxNQUFNLGVBQWUsQ0FBQzs7QUFNeEYsTUFBTSxPQUFPLDBCQUEwQjtJQUV0QyxZQUFZLEVBQWM7UUFDekIsTUFBTSxVQUFVLEdBQWdCLEVBQUUsQ0FBQyxhQUFhLENBQUM7UUFDakQsSUFBSSxVQUFVLENBQUMsU0FBUyxDQUFDLFFBQVEsQ0FBQyxzQkFBc0IsQ0FBQyxLQUFLLEtBQUs7WUFDbEUsVUFBVSxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsc0JBQXNCLENBQUMsQ0FBQztJQUVuRCxDQUFDOzswSUFQVywwQkFBMEI7OEhBQTFCLDBCQUEwQjsyRkFBMUIsMEJBQTBCO2tCQUh0QyxTQUFTO21CQUFDO29CQUNWLFFBQVEsRUFBRSx3QkFBd0I7aUJBQ2xDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBFbGVtZW50UmVmLCBBZnRlclZpZXdJbml0LCBPbkRlc3Ryb3ksIE9uSW5pdCB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcbmltcG9ydCB7IFNsaWNrVXRpbHNTZXJ2aWNlIH0gZnJvbSAnLi4vdXRpbHMvc2xpY2stdXRpbHMuc2VydmljZSc7XHJcblxyXG5ARGlyZWN0aXZlKHtcclxuXHRzZWxlY3RvcjogJ1tzbGljay1kcm9wLWxpc3QtaXRlbV0nXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBTbGlja0Ryb3BMaXN0SXRlbURpcmVjdGl2ZSB7XHJcblxyXG5cdGNvbnN0cnVjdG9yKGVsOiBFbGVtZW50UmVmKSB7XHJcblx0XHRjb25zdCBkcm9wTGlzdEVsID0gPEhUTUxFbGVtZW50PmVsLm5hdGl2ZUVsZW1lbnQ7XHJcblx0XHRpZiAoZHJvcExpc3RFbC5jbGFzc0xpc3QuY29udGFpbnMoXCJzbGljay1kcm9wLWxpc3QtaXRlbVwiKSA9PT0gZmFsc2UpXHJcblx0XHRcdGRyb3BMaXN0RWwuY2xhc3NMaXN0LmFkZChcInNsaWNrLWRyb3AtbGlzdC1pdGVtXCIpO1xyXG5cclxuXHR9XHJcbn0iXX0=

package/esm2020/slick-drop-list/slick-drop-list.directive.mjs

@@ -0,0 +1,215 @@
+import { Directive, EventEmitter, Output } from "@angular/core";
+import { SlickUtilsService } from '../utils/slick-utils.service';
+import * as i0 from "@angular/core";
+export class SlickDropListDirective {
+    constructor(el) {
+        this.onSlickDropListReorder = new EventEmitter();
+        this.onSlickDropListEnter = new EventEmitter();
+        this.onSlickDropListLeave = new EventEmitter();
+        this.uuid = SlickUtilsService.newGuid();
+        this.fnMouseDown = (e) => this.mouseDown(e);
+        this.fnMouseMove = (e) => this.mouseMove(e);
+        this.fnMouseUp = () => this.mouseUp();
+        this.el = el.nativeElement;
+        this.el.setAttribute("drop-list-uuid", this.uuid);
+    }
+    ngOnInit() {
+        this.el.style.position = "relative";
+        document.addEventListener("mousedown", this.fnMouseDown, true);
+    }
+    ngOnDestroy() {
+        document.removeEventListener("mousedown", this.fnMouseDown, true);
+        document.removeEventListener("mousemove", this.fnMouseMove, true);
+        document.removeEventListener("mouseup", this.fnMouseUp, true);
+    }
+    async mouseDown(e, target = null) {
+        this.isAdding = false;
+        this.isMoving = false;
+        if (e.button !== 0 || !e || !e.target)
+            return;
+        document.removeEventListener("mouseup", this.fnMouseUp, true);
+        document.removeEventListener("mousemove", this.fnMouseMove, true);
+        document.addEventListener("mouseup", this.fnMouseUp, true);
+        document.addEventListener("mousemove", this.fnMouseMove, true);
+        if (!target)
+            target = e.target;
+        const parent = SlickUtilsService.findParentByAttr(target, 'drop-list-uuid', this.uuid);
+        if (!parent)
+            return;
+        this.isMoving = true;
+        const grabEls = this.el.querySelectorAll(".slick-drop-list-grab");
+        if (grabEls.length > 0 && !SlickUtilsService.findParent(target, "slick-drop-list-grab"))
+            return true;
+        const dropListItem = SlickUtilsService.findParent(target, "slick-drop-list-item");
+        if (!dropListItem) {
+            console.error("Can't find item element");
+            return;
+        }
+        // Find which element the mouse is over
+        this.currentIdx = this.findElementIdx(e.y, false);
+        this.originalIdx = this.currentIdx;
+        this.startMove(dropListItem);
+    }
+    mouseMove(e) {
+        if (this.isAdding)
+            return;
+        const parent = SlickUtilsService.findParentByAttr(e.target, 'drop-list-uuid', this.uuid);
+        if (!parent) {
+            // If this isn't the parent, but we we're moving, that means we just left this parent
+            // Send a message which element was dragged out and reset everything else
+            if (this.isMoving && this.onSlickDropListLeave.observers.length > 0) {
+                this.isMoving = false;
+                const allItems = this.el.querySelectorAll(".slick-drop-list-item");
+                allItems.forEach(item => {
+                    item.classList.remove("slick-drop-list-item-animation");
+                    item.style.transform = "";
+                });
+                this.onSlickDropListLeave.emit(this.originalIdx);
+            }
+            return;
+        }
+        if (!this.isMoving && this.onSlickDropListEnter.observers.length === 0)
+            return;
+        // If the mouse was clicked outside of this droplist, but it has now moved inside this droplist, tell the parent where
+        // in the droplist it has moved.
+        // Since there is no way for a directive to have functions called via ViewChild, just assume that the page 
+        // has added the appropriate element at the appropriate place
+        if (!this.isMoving && this.onSlickDropListEnter) {
+            this.isAdding = true;
+            // Find which element the mouse is over
+            const idx = this.findElementIdx(e.y, false);
+            this.isAddingMouseEvent = e;
+            // The caller needs to call the ready function after adding the new record to the array
+            this.onSlickDropListEnter.emit({ idx: idx, ready: this.newItemReady.bind(this) });
+            return;
+        }
+        // Find which element the mouse is over
+        const dropListItems = this.el.querySelectorAll(".slick-drop-list-item");
+        for (let i = 0; i < dropListItems.length; i++) {
+            const dropListItem = dropListItems[i];
+            const boundingRect = dropListItem.getBoundingClientRect();
+            const topHalfTop = boundingRect.top;
+            const topHalfBottom = topHalfTop + (boundingRect.height / 2);
+            const bottomHalfTop = topHalfBottom + 1;
+            const bottomHalfBottom = boundingRect.bottom;
+            if (this.currentIdx !== i && e.y >= topHalfTop && e.y <= topHalfBottom) {
+                this.currentIdx = i;
+                this.redraw();
+                break;
+            }
+            if (this.currentIdx !== i + 1 && e.y >= bottomHalfTop && e.y <= bottomHalfBottom) {
+                this.currentIdx = i + 1;
+                this.redraw();
+                break;
+            }
+        }
+    }
+    mouseUp() {
+        document.removeEventListener("mouseup", this.fnMouseUp, true);
+        document.removeEventListener("mousemove", this.fnMouseMove, true);
+        if (!this.isMoving)
+            return;
+        this.isMoving = false;
+        // Remove the placeholder
+        this.placeholderEl.classList.remove("slick-drop-list-placeholder");
+        this.placeholderEl.classList.add("slick-drop-list-item");
+        this.placeholderEl.style.boxShadow = "";
+        this.placeholderEl.style.transform = "";
+        this.el.removeChild(this.placeholderEl);
+        // Add the placeholder back
+        const allItems = this.el.querySelectorAll(".slick-drop-list-item");
+        if (this.currentIdx === allItems.length)
+            this.el.appendChild(this.placeholderEl);
+        else
+            this.el.insertBefore(this.placeholderEl, allItems[this.currentIdx]);
+        this.placeholderEl = null;
+        allItems.forEach(item => {
+            item.classList.remove("slick-drop-list-item-animation");
+            item.style.transform = "";
+        });
+        if (this.onSlickDropListReorder)
+            this.onSlickDropListReorder.emit([this.originalIdx, this.currentIdx]);
+        this.originalIdx = null;
+        this.currentIdx = null;
+    }
+    redraw() {
+        const allChildren = this.el.querySelectorAll(".slick-drop-list-item");
+        let placeholderOffset = 0;
+        for (let i = 0; i < allChildren.length; i++) {
+            const item = allChildren[i];
+            if (i < this.currentIdx) {
+                item.style.transform = `translate3d(0px, 0px, 0px)`;
+            }
+            else {
+                item.style.transform = `translate3d(0px, ${this.placeholderHeight}px, 0px)`;
+                placeholderOffset += this.itemHeights[i];
+            }
+        }
+        this.placeholderEl.style.transform = `translate3d(0px, -${placeholderOffset}px, 0px)`;
+    }
+    newItemReady(idx) {
+        setTimeout(() => {
+            this.currentIdx = idx;
+            this.originalIdx = idx;
+            const dropListItem = this.el.querySelectorAll(".slick-drop-list-item").item(idx);
+            this.mouseDown(this.isAddingMouseEvent, dropListItem);
+        });
+    }
+    findElementIdx(mouseY, useTopAndBottom) {
+        const dropListItems = this.el.querySelectorAll(".slick-drop-list-item");
+        for (let i = 0; i < dropListItems.length; i++) {
+            const dropListItem = dropListItems[i];
+            const boundingRect = dropListItem.getBoundingClientRect();
+            if (useTopAndBottom) {
+                const topHalfTop = boundingRect.top;
+                const topHalfBottom = topHalfTop + (boundingRect.height / 2);
+                const bottomHalfTop = topHalfBottom + 1;
+                const bottomHalfBottom = boundingRect.bottom;
+                if (mouseY >= topHalfTop && mouseY <= topHalfBottom)
+                    return i;
+                if (mouseY >= bottomHalfTop && mouseY <= bottomHalfBottom)
+                    return i + 1;
+            }
+            else {
+                if (mouseY >= boundingRect.top && mouseY <= boundingRect.bottom)
+                    return i;
+            }
+        }
+    }
+    startMove(dropListItem) {
+        this.el.style.userSelect = "none";
+        this.placeholderEl = dropListItem;
+        this.placeholderEl.classList.add("slick-drop-list-placeholder");
+        this.placeholderEl.classList.remove("slick-drop-list-item");
+        this.placeholderEl.style.boxShadow = "4px 12px 6px rgba(0,0,0,.24)";
+        this.placeholderHeight = this.placeholderEl.getBoundingClientRect().height;
+        this.el.removeChild(this.placeholderEl);
+        this.el.appendChild(this.placeholderEl);
+        this.itemHeights = [];
+        this.el.querySelectorAll(".slick-drop-list-item").forEach(item => this.itemHeights.push(item.getBoundingClientRect().height));
+        this.redraw();
+        // Don't start the animation until after the first click because it looks weird
+        setTimeout(() => {
+            const allChildren = this.el.querySelectorAll(".slick-drop-list-item");
+            allChildren.forEach(item => item.classList.add("slick-drop-list-item-animation"));
+        });
+    }
+}
+/** @nocollapse */ SlickDropListDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDropListDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ SlickDropListDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.3", type: SlickDropListDirective, selector: "[slick-drop-list]", outputs: { onSlickDropListReorder: "onSlickDropListReorder", onSlickDropListEnter: "onSlickDropListEnter", onSlickDropListLeave: "onSlickDropListLeave" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDropListDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[slick-drop-list]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { onSlickDropListReorder: [{
+                type: Output,
+                args: ["onSlickDropListReorder"]
+            }], onSlickDropListEnter: [{
+                type: Output,
+                args: ["onSlickDropListEnter"]
+            }], onSlickDropListLeave: [{
+                type: Output,
+                args: ["onSlickDropListLeave"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slick-drop-list.directive.js","sourceRoot":"","sources":["../../../../projects/components/src/slick-drop-list/slick-drop-list.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, OnDestroy, OnInit, EventEmitter, Output } from \"@angular/core\";\r\nimport { SlickUtilsService } from '../utils/slick-utils.service';\r\n\r\n@Directive({\r\n\tselector: '[slick-drop-list]'\r\n})\r\nexport class SlickDropListDirective implements OnInit, OnDestroy {\r\n\t@Output(\"onSlickDropListReorder\") onSlickDropListReorder = new EventEmitter<number[]>();\r\n\t@Output(\"onSlickDropListEnter\") onSlickDropListEnter = new EventEmitter<any>();\r\n\t@Output(\"onSlickDropListLeave\") onSlickDropListLeave = new EventEmitter<number>();\r\n\r\n\tel: HTMLElement;\r\n\tuuid: string = SlickUtilsService.newGuid();\r\n\tfnMouseDown = (e) => this.mouseDown(e);\r\n\tfnMouseMove = (e) => this.mouseMove(e);\r\n\tfnMouseUp = () => this.mouseUp();\r\n\r\n\tisAdding: boolean;\r\n\tisAddingMouseEvent: MouseEvent;\r\n\tisMoving: boolean;\r\n\tplaceholderEl: HTMLElement;\r\n\tplaceholderHeight: number;\r\n\titemHeights: number[];\r\n\tcursorOffset: number;\r\n\toriginalIdx: number;\r\n\tcurrentIdx: number;\r\n\t\r\n\tconstructor(el: ElementRef) {\r\n\t\tthis.el = (<HTMLElement>el.nativeElement);\r\n\t\tthis.el.setAttribute(\"drop-list-uuid\", this.uuid);\r\n\t}\r\n\r\n\tngOnInit() {\r\n\t\tthis.el.style.position = \"relative\";\r\n\t\tdocument.addEventListener(\"mousedown\", this.fnMouseDown, true);\r\n\t}\r\n\r\n\tngOnDestroy() {\r\n\t\tdocument.removeEventListener(\"mousedown\", this.fnMouseDown, true);\r\n\t\tdocument.removeEventListener(\"mousemove\", this.fnMouseMove, true);\r\n\t\tdocument.removeEventListener(\"mouseup\", this.fnMouseUp, true);\r\n\t}\r\n\r\n\tasync mouseDown(e: MouseEvent, target: HTMLElement = null) {\r\n\t\tthis.isAdding = false;\r\n\t\tthis.isMoving = false;\r\n\r\n\t\tif (e.button !== 0 || !e || !e.target)\r\n\t\t\treturn;\r\n\r\n\t\tdocument.removeEventListener(\"mouseup\", this.fnMouseUp, true);\r\n\t\tdocument.removeEventListener(\"mousemove\", this.fnMouseMove, true);\r\n\t\tdocument.addEventListener(\"mouseup\", this.fnMouseUp, true);\r\n\t\tdocument.addEventListener(\"mousemove\", this.fnMouseMove, true);\r\n\r\n\t\tif (!target)\r\n\t\t\ttarget = <HTMLElement>e.target;\r\n\r\n\t\tconst parent = SlickUtilsService.findParentByAttr(target, 'drop-list-uuid', this.uuid);\r\n\t\tif (!parent)\r\n\t\t\treturn;\r\n\r\n\t\tthis.isMoving = true;\r\n\r\n\t\tconst grabEls = this.el.querySelectorAll(\".slick-drop-list-grab\");\r\n\t\tif (grabEls.length > 0 && !SlickUtilsService.findParent(target, \"slick-drop-list-grab\"))\r\n\t\t\treturn true;\r\n\r\n\t\tconst dropListItem = SlickUtilsService.findParent(target, \"slick-drop-list-item\");\r\n\t\tif (!dropListItem) {\r\n\t\t\tconsole.error(\"Can't find item element\");\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\t// Find which element the mouse is over\r\n\t\tthis.currentIdx = this.findElementIdx(e.y, false);\r\n\t\tthis.originalIdx = this.currentIdx;\r\n\r\n\t\tthis.startMove(dropListItem);\r\n\t}\r\n\r\n\tmouseMove(e: MouseEvent) {\r\n\t\tif (this.isAdding)\r\n\t\t\treturn;\r\n\r\n\t\tconst parent = SlickUtilsService.findParentByAttr(<HTMLElement>e.target, 'drop-list-uuid', this.uuid);\r\n\t\tif (!parent) {\r\n\t\t\t// If this isn't the parent, but we we're moving, that means we just left this parent\r\n\t\t\t// Send a message which element was dragged out and reset everything else\r\n\t\t\tif (this.isMoving && this.onSlickDropListLeave.observers.length > 0) {\r\n\t\t\t\tthis.isMoving = false;\r\n\t\t\t\tconst allItems = this.el.querySelectorAll<HTMLElement>(\".slick-drop-list-item\");\r\n\t\t\t\tallItems.forEach(item => {\r\n\t\t\t\t\titem.classList.remove(\"slick-drop-list-item-animation\");\r\n\t\t\t\t\titem.style.transform = \"\";\r\n\t\t\t\t});\r\n\r\n\t\t\t\tthis.onSlickDropListLeave.emit(this.originalIdx);\r\n\t\t\t}\r\n\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tif (!this.isMoving && this.onSlickDropListEnter.observers.length === 0)\r\n\t\t\treturn;\r\n\r\n\t\t// If the mouse was clicked outside of this droplist, but it has now moved inside this droplist, tell the parent where\r\n\t\t// in the droplist it has moved.\r\n\t\t// Since there is no way for a directive to have functions called via ViewChild, just assume that the page \r\n\t\t// has added the appropriate element at the appropriate place\r\n\t\tif (!this.isMoving && this.onSlickDropListEnter) {\r\n\t\t\tthis.isAdding = true;\r\n\r\n\t\t\t// Find which element the mouse is over\r\n\t\t\tconst idx = this.findElementIdx(e.y, false);\r\n\t\t\tthis.isAddingMouseEvent = e;\r\n\t\t\t// The caller needs to call the ready function after adding the new record to the array\r\n\t\t\tthis.onSlickDropListEnter.emit({ idx: idx, ready: this.newItemReady.bind(this) });\r\n\r\n\t\t\treturn;\r\n\t\t}\r\n\t\t\r\n\t\t// Find which element the mouse is over\r\n\t\tconst dropListItems = this.el.querySelectorAll<HTMLElement>(\".slick-drop-list-item\")\r\n\r\n\t\tfor (let i = 0; i < dropListItems.length; i++) {\r\n\t\t\tconst dropListItem = dropListItems[i];\r\n\t\t\tconst boundingRect = dropListItem.getBoundingClientRect();\r\n\r\n\t\t\tconst topHalfTop = boundingRect.top;\r\n\t\t\tconst topHalfBottom = topHalfTop + (boundingRect.height / 2);\r\n\t\t\tconst bottomHalfTop = topHalfBottom + 1;\r\n\t\t\tconst bottomHalfBottom = boundingRect.bottom;\r\n\r\n\t\t\tif (this.currentIdx !== i && e.y >= topHalfTop && e.y <= topHalfBottom) {\r\n\t\t\t\tthis.currentIdx = i;\r\n\t\t\t\tthis.redraw();\r\n\t\t\t\tbreak;\r\n\t\t\t}\r\n\r\n\t\t\tif (this.currentIdx !== i + 1 && e.y >= bottomHalfTop && e.y <= bottomHalfBottom) {\r\n\t\t\t\tthis.currentIdx = i + 1;\r\n\t\t\t\tthis.redraw();\r\n\t\t\t\tbreak;\r\n\t\t\t}\t\t\t\r\n\t\t}\r\n\t}\r\n\r\n\tmouseUp() {\r\n\t\tdocument.removeEventListener(\"mouseup\", this.fnMouseUp, true);\r\n\t\tdocument.removeEventListener(\"mousemove\", this.fnMouseMove, true);\r\n\r\n\t\tif (!this.isMoving)\r\n\t\t\treturn;\r\n\r\n\t\tthis.isMoving = false;\r\n\r\n\t\t// Remove the placeholder\r\n\t\tthis.placeholderEl.classList.remove(\"slick-drop-list-placeholder\");\r\n\t\tthis.placeholderEl.classList.add(\"slick-drop-list-item\");\r\n\t\tthis.placeholderEl.style.boxShadow = \"\";\r\n\t\tthis.placeholderEl.style.transform = \"\";\r\n\t\tthis.el.removeChild(this.placeholderEl);\r\n\r\n\t\t// Add the placeholder back\r\n\t\tconst allItems = this.el.querySelectorAll<HTMLElement>(\".slick-drop-list-item\");\r\n\t\tif (this.currentIdx === allItems.length)\r\n\t\t\tthis.el.appendChild(this.placeholderEl);\r\n\t\telse\r\n\t\t\tthis.el.insertBefore(this.placeholderEl, allItems[this.currentIdx]);\r\n\r\n\t\tthis.placeholderEl = null;\r\n\r\n\t\tallItems.forEach(item => {\r\n\t\t\titem.classList.remove(\"slick-drop-list-item-animation\");\r\n\t\t\titem.style.transform = \"\";\r\n\t\t});\r\n\r\n\t\tif (this.onSlickDropListReorder)\r\n\t\t\tthis.onSlickDropListReorder.emit([this.originalIdx, this.currentIdx]);\r\n\r\n\t\tthis.originalIdx = null;\r\n\t\tthis.currentIdx = null;\r\n\t}\r\n\r\n\tprivate redraw() {\r\n\t\tconst allChildren = this.el.querySelectorAll<HTMLElement>(\".slick-drop-list-item\");\r\n\t\tlet placeholderOffset = 0;\r\n\r\n\t\tfor (let i = 0; i < allChildren.length; i++) {\r\n\t\t\tconst item = allChildren[i];\r\n\r\n\t\t\tif (i < this.currentIdx) {\r\n\t\t\t\titem.style.transform = `translate3d(0px, 0px, 0px)`;\r\n\t\t\t}\r\n\t\t\telse {\r\n\t\t\t\titem.style.transform = `translate3d(0px, ${this.placeholderHeight}px, 0px)`;\r\n\t\t\t\tplaceholderOffset += this.itemHeights[i];\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tthis.placeholderEl.style.transform = `translate3d(0px, -${placeholderOffset}px, 0px)`;\r\n\t}\r\n\r\n\tnewItemReady(idx: number) {\r\n\t\tsetTimeout(() => {\r\n\t\t\tthis.currentIdx = idx;\r\n\t\t\tthis.originalIdx = idx;\r\n\r\n\t\t\tconst dropListItem = this.el.querySelectorAll<HTMLElement>(\".slick-drop-list-item\").item(idx);\r\n\t\t\tthis.mouseDown(this.isAddingMouseEvent, dropListItem);\r\n\t\t});\r\n\t}\r\n\r\n\tprivate findElementIdx(mouseY, useTopAndBottom: boolean): number {\r\n\t\tconst dropListItems = this.el.querySelectorAll<HTMLElement>(\".slick-drop-list-item\")\r\n\r\n\t\tfor (let i = 0; i < dropListItems.length; i++) {\r\n\t\t\tconst dropListItem = dropListItems[i];\r\n\t\t\tconst boundingRect = dropListItem.getBoundingClientRect();\r\n\r\n\t\t\tif (useTopAndBottom) {\r\n\t\t\t\tconst topHalfTop = boundingRect.top;\r\n\t\t\t\tconst topHalfBottom = topHalfTop + (boundingRect.height / 2);\r\n\t\t\t\tconst bottomHalfTop = topHalfBottom + 1;\r\n\t\t\t\tconst bottomHalfBottom = boundingRect.bottom;\r\n\r\n\t\t\t\tif (mouseY >= topHalfTop && mouseY <= topHalfBottom)\r\n\t\t\t\t\treturn i;\r\n\r\n\t\t\t\tif (mouseY >= bottomHalfTop && mouseY <= bottomHalfBottom)\r\n\t\t\t\t\treturn i + 1;\r\n\t\t\t}\r\n\t\t\telse {\r\n\t\t\t\tif (mouseY >= boundingRect.top && mouseY <= boundingRect.bottom)\r\n\t\t\t\t\treturn i;\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tprivate startMove(dropListItem: HTMLElement) {\r\n\t\tthis.el.style.userSelect = \"none\";\r\n\r\n\t\tthis.placeholderEl = <HTMLElement>dropListItem;\r\n\t\tthis.placeholderEl.classList.add(\"slick-drop-list-placeholder\");\r\n\t\tthis.placeholderEl.classList.remove(\"slick-drop-list-item\");\r\n\t\tthis.placeholderEl.style.boxShadow = \"4px 12px 6px rgba(0,0,0,.24)\"\r\n\r\n\t\tthis.placeholderHeight = this.placeholderEl.getBoundingClientRect().height;\r\n\r\n\t\tthis.el.removeChild(this.placeholderEl);\r\n\t\tthis.el.appendChild(this.placeholderEl);\r\n\r\n\t\tthis.itemHeights = [];\r\n\t\tthis.el.querySelectorAll<HTMLElement>(\".slick-drop-list-item\").forEach(item => this.itemHeights.push(item.getBoundingClientRect().height));\r\n\r\n\t\tthis.redraw();\r\n\r\n\t\t// Don't start the animation until after the first click because it looks weird\r\n\t\tsetTimeout(() => {\r\n\t\t\tconst allChildren = this.el.querySelectorAll<HTMLElement>(\".slick-drop-list-item\");\r\n\t\t\tallChildren.forEach(item => item.classList.add(\"slick-drop-list-item-animation\"));\r\n\t\t});\r\n\t}\r\n}"]}

package/esm2020/slick-drop-list/slick-drop-list.module.mjs

@@ -0,0 +1,23 @@
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { SlickDropListDirective } from "./slick-drop-list.directive";
+import { SlickDropListItemDirective } from "./slick-drop-list-item.directive";
+import { SlickDropListGrabDirective } from "./slick-drop-list-grab.directive";
+import * as i0 from "@angular/core";
+export class SlickDropListModule {
+}
+/** @nocollapse */ SlickDropListModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDropListModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ SlickDropListModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDropListModule, declarations: [SlickDropListDirective, SlickDropListItemDirective, SlickDropListGrabDirective], imports: [CommonModule], exports: [SlickDropListDirective, SlickDropListItemDirective, SlickDropListGrabDirective] });
+/** @nocollapse */ SlickDropListModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDropListModule, imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDropListModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    declarations: [SlickDropListDirective, SlickDropListItemDirective, SlickDropListGrabDirective],
+                    exports: [SlickDropListDirective, SlickDropListItemDirective, SlickDropListGrabDirective]
+                }]
+        }] });
+export { SlickDropListDirective };
+export { SlickDropListItemDirective };
+export { SlickDropListGrabDirective };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xpY2stZHJvcC1saXN0Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2NvbXBvbmVudHMvc3JjL3NsaWNrLWRyb3AtbGlzdC9zbGljay1kcm9wLWxpc3QubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ3JFLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQzlFLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLGtDQUFrQyxDQUFDOztBQU85RSxNQUFNLE9BQU8sbUJBQW1COzttSUFBbkIsbUJBQW1CO29JQUFuQixtQkFBbUIsaUJBSGhCLHNCQUFzQixFQUFFLDBCQUEwQixFQUFFLDBCQUEwQixhQURuRixZQUFZLGFBRVosc0JBQXNCLEVBQUUsMEJBQTBCLEVBQUUsMEJBQTBCO29JQUU1RSxtQkFBbUIsWUFKdEIsQ0FBQyxZQUFZLENBQUM7MkZBSVgsbUJBQW1CO2tCQUwvQixRQUFRO21CQUFDO29CQUNULE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztvQkFDdkIsWUFBWSxFQUFFLENBQUMsc0JBQXNCLEVBQUUsMEJBQTBCLEVBQUUsMEJBQTBCLENBQUM7b0JBQzlGLE9BQU8sRUFBRSxDQUFDLHNCQUFzQixFQUFFLDBCQUEwQixFQUFFLDBCQUEwQixDQUFDO2lCQUN6Rjs7QUFHRCxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsQ0FBQTtBQUNqQyxPQUFPLEVBQUUsMEJBQTBCLEVBQUUsQ0FBQTtBQUNyQyxPQUFPLEVBQUUsMEJBQTBCLEVBQUUsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSBcIkBhbmd1bGFyL2NvbW1vblwiO1xyXG5pbXBvcnQgeyBTbGlja0Ryb3BMaXN0RGlyZWN0aXZlIH0gZnJvbSBcIi4vc2xpY2stZHJvcC1saXN0LmRpcmVjdGl2ZVwiO1xyXG5pbXBvcnQgeyBTbGlja0Ryb3BMaXN0SXRlbURpcmVjdGl2ZSB9IGZyb20gXCIuL3NsaWNrLWRyb3AtbGlzdC1pdGVtLmRpcmVjdGl2ZVwiO1xyXG5pbXBvcnQgeyBTbGlja0Ryb3BMaXN0R3JhYkRpcmVjdGl2ZSB9IGZyb20gXCIuL3NsaWNrLWRyb3AtbGlzdC1ncmFiLmRpcmVjdGl2ZVwiO1xyXG5cclxuQE5nTW9kdWxlKHtcclxuXHRpbXBvcnRzOiBbQ29tbW9uTW9kdWxlXSxcclxuXHRkZWNsYXJhdGlvbnM6IFtTbGlja0Ryb3BMaXN0RGlyZWN0aXZlLCBTbGlja0Ryb3BMaXN0SXRlbURpcmVjdGl2ZSwgU2xpY2tEcm9wTGlzdEdyYWJEaXJlY3RpdmVdLFxyXG5cdGV4cG9ydHM6IFtTbGlja0Ryb3BMaXN0RGlyZWN0aXZlLCBTbGlja0Ryb3BMaXN0SXRlbURpcmVjdGl2ZSwgU2xpY2tEcm9wTGlzdEdyYWJEaXJlY3RpdmVdXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBTbGlja0Ryb3BMaXN0TW9kdWxlIHsgfVxyXG5cclxuZXhwb3J0IHsgU2xpY2tEcm9wTGlzdERpcmVjdGl2ZSB9IFxyXG5leHBvcnQgeyBTbGlja0Ryb3BMaXN0SXRlbURpcmVjdGl2ZSB9IFxyXG5leHBvcnQgeyBTbGlja0Ryb3BMaXN0R3JhYkRpcmVjdGl2ZSB9XHJcbiJdfQ==

package/esm2020/slick-email-viewer/slick-email-viewer-dialog.component.mjs

@@ -0,0 +1,81 @@
+import { Component, ViewChild, forwardRef } from "@angular/core";
+import { NG_VALUE_ACCESSOR } from "@angular/forms";
+import * as i0 from "@angular/core";
+import * as i1 from "../slick-dialog/slick-dialog.component";
+import * as i2 from "./slick-email-viewer.component";
+import * as i3 from "../slick-dialog/slick-dialog-footer.component";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/forms";
+export class SlickEmailViewerDialogComponent {
+    constructor(changeDetector) {
+        this.changeDetector = changeDetector;
+        this.isVisible = false;
+        this.propagateChange = (_) => { };
+    }
+    // this is the initial value set to the component
+    writeValue(obj) {
+        this.emailerModel = 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() { }
+    showDialog() {
+        this.isVisible = true;
+        this.changeDetector.detectChanges();
+        this.emailViewerDialogRef.showDialog();
+    }
+    onOk() {
+        this.isVisible = false;
+        this.emailViewerDialogRef.hideDialog();
+    }
+}
+/** @nocollapse */ SlickEmailViewerDialogComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickEmailViewerDialogComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ SlickEmailViewerDialogComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.3", type: SlickEmailViewerDialogComponent, selector: "slick-email-viewer-dialog", providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef((() => SlickEmailViewerDialogComponent)),
+            multi: true,
+        }
+    ], viewQueries: [{ propertyName: "emailViewerDialogRef", first: true, predicate: ["emailViewerDialogRef"], descendants: true }], ngImport: i0, template: `<slick-dialog *ngIf='isVisible' header='View Email' [width]='800' #emailViewerDialogRef>
+		<slick-email-viewer [(ngModel)]='emailerModel'></slick-email-viewer>
+
+		<slick-dialog-footer>
+			<div class="row">
+				<div class="col-12 text-center mb-2 mt-1">
+					<button type="button" style="width: 120px;" class="btn btn-outline-primary" (click)="onOk()">Ok</button>
+				</div>
+			</div>
+		</slick-dialog-footer>
+	</slick-dialog>`, isInline: true, components: [{ type: i1.SlickDialogComponent, selector: "slick-dialog", inputs: ["draggable", "resizable", "minimizable", "header", "showHeader", "noPadding", "top", "width", "height", "maxHeight", "cssClass", "key", "showOverlay", "disableScrollbar"], outputs: ["onClose"] }, { type: i2.SlickEmailViewerComponent, selector: "slick-email-viewer" }, { type: i3.SlickDialogFooterComponent, selector: "slick-dialog-footer" }], directives: [{ type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i5.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: SlickEmailViewerDialogComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'slick-email-viewer-dialog',
+                    template: `<slick-dialog *ngIf='isVisible' header='View Email' [width]='800' #emailViewerDialogRef>
+		<slick-email-viewer [(ngModel)]='emailerModel'></slick-email-viewer>
+
+		<slick-dialog-footer>
+			<div class="row">
+				<div class="col-12 text-center mb-2 mt-1">
+					<button type="button" style="width: 120px;" class="btn btn-outline-primary" (click)="onOk()">Ok</button>
+				</div>
+			</div>
+		</slick-dialog-footer>
+	</slick-dialog>`,
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef((() => SlickEmailViewerDialogComponent)),
+                            multi: true,
+                        }
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { emailViewerDialogRef: [{
+                type: ViewChild,
+                args: ["emailViewerDialogRef"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/slick-email-viewer/slick-email-viewer.component.mjs

@@ -0,0 +1,42 @@
+import { Component, forwardRef } from "@angular/core";
+import { NG_VALUE_ACCESSOR } from "@angular/forms";
+import { SlickUtilsService } from "../utils/slick-utils.service";
+import * as i0 from "@angular/core";
+import * as i1 from "../slick-file-list/slick-file-list.component";
+import * as i2 from "@angular/common";
+export class SlickEmailViewerComponent {
+    constructor() {
+        this.propagateChange = (_) => { };
+        this.uuid = SlickUtilsService.newGuid();
+    }
+    // this is the initial value set to the component
+    async writeValue(obj) {
+        this.emailerModel = 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 */ SlickEmailViewerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickEmailViewerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ SlickEmailViewerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.3", type: SlickEmailViewerComponent, selector: "slick-email-viewer", providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef((() => SlickEmailViewerComponent)),
+            multi: true,
+        }
+    ], ngImport: i0, template: "<div *ngIf=\"emailerModel\" id=\"slick-email-viewer_{{uuid}}\" class=\"slick-email-viewer\">\r\n\t<div class=\"row form-group\">\r\n\t\t<div class=\"col-12\">\r\n\t\t\t<label>To:&nbsp;</label><br />\r\n\t\t\t<div *ngFor=\"let emailAddress of emailerModel.toEmailAddresses; let idx = index;\" class=\"slick-email-viewer_email-address card\">{{emailAddress.displayName}} [{{emailAddress.emailAddress}}]</div>\r\n\t\t</div>\r\n\t</div>\r\n\t<div class=\"row form-group\">\r\n\t\t<div class=\"col-12\">\r\n\t\t\t<label>Subject:</label><br />\r\n\t\t\t<div class=\"slick-email-viewer_subject card\">{{emailerModel.subject}}</div>\r\n\t\t</div>\r\n\t</div>\r\n\r\n\t<div class=\"row form-group\">\r\n\t\t<div class=\"col-12\">\r\n\t\t\t<label>Body:</label><br />\r\n\t\t\t<div class=\"slick-email-viewer_body card\" [innerHTML]=\"emailerModel.body\"></div>\r\n\t\t\t\r\n\t\t</div>\r\n\t</div>\r\n\r\n\t<div *ngIf=\"emailerModel.attachments && emailerModel.attachments.length > 0\" class=\"row form-group\">\r\n\t\t<div class=\"col-12\">\r\n\t\t\t<label>Attachments:</label>\r\n\t\t\t<slick-file-list [(files)]=\"emailerModel.attachments\" [allowDelete]=\"false\"></slick-file-list>\r\n\t\t</div>\r\n\t</div>\r\n</div>\r\n", components: [{ type: i1.SlickFileListComponent, selector: "slick-file-list", inputs: ["files", "allowDelete", "showPhotoGallery", "showCheckboxes", "thumbnailSize", "confirmDelete"], outputs: ["filesEmitter", "onFileDelete", "onFileCheckChanged", "onFileClicked"] }], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickEmailViewerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'slick-email-viewer', providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef((() => SlickEmailViewerComponent)),
+                            multi: true,
+                        }
+                    ], template: "<div *ngIf=\"emailerModel\" id=\"slick-email-viewer_{{uuid}}\" class=\"slick-email-viewer\">\r\n\t<div class=\"row form-group\">\r\n\t\t<div class=\"col-12\">\r\n\t\t\t<label>To:&nbsp;</label><br />\r\n\t\t\t<div *ngFor=\"let emailAddress of emailerModel.toEmailAddresses; let idx = index;\" class=\"slick-email-viewer_email-address card\">{{emailAddress.displayName}} [{{emailAddress.emailAddress}}]</div>\r\n\t\t</div>\r\n\t</div>\r\n\t<div class=\"row form-group\">\r\n\t\t<div class=\"col-12\">\r\n\t\t\t<label>Subject:</label><br />\r\n\t\t\t<div class=\"slick-email-viewer_subject card\">{{emailerModel.subject}}</div>\r\n\t\t</div>\r\n\t</div>\r\n\r\n\t<div class=\"row form-group\">\r\n\t\t<div class=\"col-12\">\r\n\t\t\t<label>Body:</label><br />\r\n\t\t\t<div class=\"slick-email-viewer_body card\" [innerHTML]=\"emailerModel.body\"></div>\r\n\t\t\t\r\n\t\t</div>\r\n\t</div>\r\n\r\n\t<div *ngIf=\"emailerModel.attachments && emailerModel.attachments.length > 0\" class=\"row form-group\">\r\n\t\t<div class=\"col-12\">\r\n\t\t\t<label>Attachments:</label>\r\n\t\t\t<slick-file-list [(files)]=\"emailerModel.attachments\" [allowDelete]=\"false\"></slick-file-list>\r\n\t\t</div>\r\n\t</div>\r\n</div>\r\n" }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/slick-email-viewer/slick-email-viewer.module.mjs

@@ -0,0 +1,26 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from "@angular/core";
+import { FormsModule } from "@angular/forms";
+import { SlickEmailViewerComponent } from "./slick-email-viewer.component";
+import { SlickEmailViewerDialogComponent } from "./slick-email-viewer-dialog.component";
+import { SlickDialogModule } from "../slick-dialog/slick-dialog.module";
+import { SlickFileListModule } from "../slick-file-list/slick-file-list.module";
+import * as i0 from "@angular/core";
+export class SlickEmailViewerModule {
+}
+/** @nocollapse */ SlickEmailViewerModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickEmailViewerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ SlickEmailViewerModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickEmailViewerModule, declarations: [SlickEmailViewerComponent, SlickEmailViewerDialogComponent], imports: [CommonModule, FormsModule, SlickDialogModule, SlickFileListModule], exports: [CommonModule, FormsModule, SlickEmailViewerComponent, SlickEmailViewerDialogComponent] });
+/** @nocollapse */ SlickEmailViewerModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickEmailViewerModule, imports: [[CommonModule, FormsModule, SlickDialogModule, SlickFileListModule], CommonModule, FormsModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickEmailViewerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, FormsModule, SlickDialogModule, SlickFileListModule],
+                    declarations: [SlickEmailViewerComponent, SlickEmailViewerDialogComponent],
+                    exports: [CommonModule, FormsModule, SlickEmailViewerComponent, SlickEmailViewerDialogComponent]
+                }]
+        }] });
+export { SlickEmailViewerComponent };
+export { SlickEmailViewerDialogComponent };
+export { SlickEmailerModel } from "../slick-emailer/slick-emailer.model";
+export { SlickEmailerAddressModel } from "../slick-emailer/slick-emailer-address.model";
+//# sourceMappingURL=data:application/json;base64,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