slick-components 4.4.13 → 4.4.16

package/esm2020/slick-auto-complete/slick-auto-complete-list-item-template.directive.mjs

@@ -0,0 +1,22 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SlickAutoCompleteListItemTemplateDirective {
+    constructor(template) {
+        this.template = template;
+    }
+}
+/** @nocollapse */ SlickAutoCompleteListItemTemplateDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickAutoCompleteListItemTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ SlickAutoCompleteListItemTemplateDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.3", type: SlickAutoCompleteListItemTemplateDirective, selector: "[slickAutoCompleteListItemTemplate]", inputs: { type: "type", name: ["slickAutoCompleteListItemTemplate", "name"] }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickAutoCompleteListItemTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[slickAutoCompleteListItemTemplate]',
+                    host: {}
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; }, propDecorators: { type: [{
+                type: Input
+            }], name: [{
+                type: Input,
+                args: ['slickAutoCompleteListItemTemplate']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xpY2stYXV0by1jb21wbGV0ZS1saXN0LWl0ZW0tdGVtcGxhdGUuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvY29tcG9uZW50cy9zcmMvc2xpY2stYXV0by1jb21wbGV0ZS9zbGljay1hdXRvLWNvbXBsZXRlLWxpc3QtaXRlbS10ZW1wbGF0ZS5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQXFFLE1BQU0sZUFBZSxDQUFDOztBQVNwSCxNQUFNLE9BQU8sMENBQTBDO0lBSXRELFlBQW1CLFFBQTBCO1FBQTFCLGFBQVEsR0FBUixRQUFRLENBQWtCO0lBQUksQ0FBQzs7MEpBSnRDLDBDQUEwQzs4SUFBMUMsMENBQTBDOzJGQUExQywwQ0FBMEM7a0JBTHRELFNBQVM7bUJBQUM7b0JBQ1YsUUFBUSxFQUFFLHFDQUFxQztvQkFDL0MsSUFBSSxFQUFFLEVBQ0w7aUJBQ0Q7a0dBRVMsSUFBSTtzQkFBWixLQUFLO2dCQUNzQyxJQUFJO3NCQUEvQyxLQUFLO3VCQUFDLG1DQUFtQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgSW5wdXQsIFRlbXBsYXRlUmVmLCBPbkluaXQsIE9uRGVzdHJveSwgRW1iZWRkZWRWaWV3UmVmLCBWaWV3Q29udGFpbmVyUmVmIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XHJcbmltcG9ydCB7IENvbXBvbmVudCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5cclxuQERpcmVjdGl2ZSh7XHJcblx0c2VsZWN0b3I6ICdbc2xpY2tBdXRvQ29tcGxldGVMaXN0SXRlbVRlbXBsYXRlXScsXHJcblx0aG9zdDoge1xyXG5cdH1cclxufSlcclxuZXhwb3J0IGNsYXNzIFNsaWNrQXV0b0NvbXBsZXRlTGlzdEl0ZW1UZW1wbGF0ZURpcmVjdGl2ZSB7XHJcblx0QElucHV0KCkgdHlwZTogc3RyaW5nO1xyXG5cdEBJbnB1dCgnc2xpY2tBdXRvQ29tcGxldGVMaXN0SXRlbVRlbXBsYXRlJykgbmFtZTogc3RyaW5nO1xyXG5cclxuXHRjb25zdHJ1Y3RvcihwdWJsaWMgdGVtcGxhdGU6IFRlbXBsYXRlUmVmPGFueT4pIHsgfVxyXG59XHJcblxyXG4iXX0=

package/esm2020/slick-auto-complete/slick-auto-complete.component.mjs

@@ -0,0 +1,375 @@
+import { Component, ViewChild, ContentChild, Input, Output, EventEmitter, forwardRef } from "@angular/core";
+import { NG_VALUE_ACCESSOR } from "@angular/forms";
+import { SlickAutoCompleteListItemTemplateDirective } from "./slick-auto-complete-list-item-template.directive";
+import { SlickUtilsService } from "../utils/slick-utils.service";
+import { SlickSleepService } from "../utils/slick-sleep.service";
+import * as i0 from "@angular/core";
+import * as i1 from "../utils/slick-function-lock.service";
+import * as i2 from "@angular/common";
+export class SlickAutoCompleteComponent {
+    constructor(slickFunctionLockService) {
+        this.slickFunctionLockService = slickFunctionLockService;
+        this.delay = 300;
+        this.selectFirst = true;
+        this.listHeight = "300px";
+        this.listWidth = '100%';
+        this.allowFreeformText = true;
+        this.showNoItemsFoundDisplay = true;
+        this.onRefresh = new EventEmitter();
+        this.onSelect = new EventEmitter();
+        this.onFreeformTextSelect = new EventEmitter();
+        this.fnDocumentClick = (e) => this.documentClick(e);
+        this.fnKeyDown = (e) => this.keyDown(e);
+        this.lastInputValue = "";
+        this.forcedCollapse = false;
+        // This is necessary so that the scroll and resize events can add and remove the event properly,
+        // as well as getting the correct ES6 function
+        this.fnReposition = () => this.reposition();
+        this.selectedIndex = -1;
+        this.showAutoComplete = false;
+        this.autoCompleteVisiblity = false;
+        this.expanded = true;
+        this.loading = false;
+        this.propagateChange = (_) => { };
+        this.uuid = SlickUtilsService.newGuid();
+    }
+    async ngOnInit() {
+        await SlickSleepService.sleep();
+        // Remove this from the inline version and put it on the body so that it doesn't hide behind the bottom
+        // of a div when it expands beyond the bottom.
+        this.autoCompleteRef.nativeElement.remove(this.autoCompleteRef);
+        document.body.appendChild(this.autoCompleteRef.nativeElement);
+        this.inputRef.addEventListener("keydown", this.fnKeyDown);
+    }
+    ngOnDestroy() {
+        // Since angular has no way to use the third parameter, I'm doing this in raw js
+        document.removeEventListener("click", this.fnDocumentClick, true);
+        this.inputRef.removeEventListener("keydown", this.fnKeyDown);
+        clearTimeout(this.delayTimeout);
+        this.delayTimeout = null;
+        this.collapse();
+        // Is okay if this fails.  It just means it was already removed.
+        try {
+            document.body.removeChild(this.autoCompleteRef.nativeElement);
+        }
+        catch { }
+    }
+    ngOnChanges(changes) {
+        if (changes.allowFreeformText)
+            this.allowFreeformText = (this.allowFreeformText.toString().toLowerCase() === 'false') ? false : true;
+        if (changes.showNoItemsFoundDisplay)
+            this.showNoItemsFoundDisplay = (this.showNoItemsFoundDisplay.toString().toLowerCase() === 'false') ? false : true;
+        if (changes.items) {
+            if (this.items && this.items.length === 0 && this.showNoItemsFoundDisplay === false)
+                this.collapse();
+        }
+    }
+    documentClick(e) {
+        if (!this.expanded || !e.target)
+            return;
+        if (SlickUtilsService.checkParentIdExists(e.target, "slick-auto-complete_" + this.uuid) === false) {
+            clearInterval(this.waitForItemsInterval);
+            this.slickFunctionLockService.release("AUTO_COMPLETE_WAIT_FOR_ITEMS");
+            this.collapse();
+        }
+        if (this.allowFreeformText && this.onFreeformTextSelect)
+            this.onFreeformTextSelect.emit(this.inputRef.value);
+    }
+    onItemClick(index) {
+        this.selectItem(index);
+        this.collapse();
+    }
+    async keyDown(event) {
+        // alt
+        if (event.keyCode === 18)
+            return;
+        clearInterval(this.waitForItemsInterval);
+        this.slickFunctionLockService.release("AUTO_COMPLETE_WAIT_FOR_ITEMS");
+        // If we're just tabbing through, don't even do anything
+        if (!this.lastInputValue && (event.keyCode === 9 || event.keyCode === 13))
+            return;
+        await SlickSleepService.sleep();
+        if (this.lastInputValue !== this.inputRef.value) {
+            this.lastInputValue = this.inputRef.value;
+            this.forcedCollapse = false;
+            if (!this.lastInputValue) {
+                this.propagateChange(null);
+                this.collapse();
+            }
+            clearTimeout(this.delayTimeout);
+            this.delayTimeout = null;
+            if (this.inputRef.value === '') {
+                this.items = null;
+                this.collapse();
+                return true;
+            }
+            else {
+                this.delayTimeout = setTimeout(async () => {
+                    (this.selectFirst === true) ? this.selectedIndex = 0 : this.selectedIndex = -1;
+                    this.delayTimeout = null;
+                    this.items = null;
+                    this.expand();
+                    await this.refreshItems(true);
+                }, this.delay);
+            }
+        }
+        if (event.keyCode === 9 || event.keyCode === 13) {
+            if (this.delayTimeout && this.selectFirst) {
+                clearTimeout(this.delayTimeout);
+                this.delayTimeout = null;
+                this.items = null;
+                this.collapse();
+                if (this.selectFirst === true && !this.forcedCollapse) {
+                    await this.refreshItems(false);
+                    this.selectedIndex = -1;
+                    if (!this.items && !this.inputRef.value && this.onSelect) {
+                        this.onSelect.emit(null);
+                    }
+                    else if (this.items && this.items.length > 0) {
+                        this.selectedIndex = 0;
+                        this.selectItem(this.selectedIndex);
+                    }
+                    else {
+                        if (this.allowFreeformText && this.onFreeformTextSelect)
+                            this.onFreeformTextSelect.emit(this.inputRef.value);
+                    }
+                }
+                else {
+                    if (this.allowFreeformText && this.onFreeformTextSelect)
+                        this.onFreeformTextSelect.emit(this.inputRef.value);
+                }
+            }
+            else {
+                clearTimeout(this.delayTimeout);
+                if (!this.items && !this.inputRef.value && this.onSelect) {
+                    this.onSelect.emit(null);
+                }
+                else if (this.items && this.items.length > 0 && this.expanded && !this.forcedCollapse) {
+                    this.selectItem(this.selectedIndex);
+                }
+                else {
+                    if (this.allowFreeformText && this.onFreeformTextSelect) {
+                        this.onFreeformTextSelect.emit(this.inputRef.value);
+                    }
+                }
+                this.collapse();
+            }
+        }
+        // Esc
+        if (event.which === 27) {
+            this.forcedCollapse = true;
+            this.collapse();
+            return false;
+        }
+        // Arrowup
+        if (event.which === 38) {
+            if (this.selectedIndex === null || this.selectedIndex === undefined)
+                this.selectedIndex = 0;
+            if (this.selectedIndex > 0)
+                this.selectedIndex--;
+            return false;
+        }
+        // Arrowdown
+        if (event.which === 40) {
+            event.stopPropagation();
+            if (this.selectedIndex === null || this.selectedIndex === undefined)
+                this.selectedIndex = -1;
+            if (!this.expanded) {
+                this.expand();
+                return false;
+            }
+            if (this.selectedIndex < this.items.length - 1)
+                this.selectedIndex++;
+            return false;
+        }
+    }
+    // this is the initial value set to the component
+    writeValue(obj) {
+        if (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() { }
+    async selectItem(index) {
+        if (index < 0 || !this.items || this.items.length === 0) {
+            this.selectedItem = null;
+        }
+        else {
+            this.selectedItem = this.items[index];
+            if (this.displayTextFieldName) {
+                const text = SlickUtilsService.getDeepObject(this.selectedItem, this.displayTextFieldName);
+                if (text) {
+                    this.inputRef.value = text;
+                    this.lastInputValue = this.inputRef.value;
+                }
+            }
+        }
+        this.propagateChange(this.selectedItem);
+        if (this.onSelect)
+            this.onSelect.emit(this.selectedItem);
+        // Call to update the model for the textbox
+        await SlickSleepService.sleep();
+        let evt = document.createEvent('Event');
+        evt.initEvent('input', true, false);
+        this.inputRef.dispatchEvent(evt);
+    }
+    async expand() {
+        this.reposition();
+        // If the flag to show items is false, don't display "Loading..."
+        if (this.showNoItemsFoundDisplay === false && (!this.items || this.items.length === 0)) {
+            this.showAutoComplete = false;
+            this.autoCompleteVisiblity = false;
+            this.expanded = false;
+            return;
+        }
+        this.showAutoComplete = true;
+        this.autoCompleteRef.nativeElement.style.display = "inline-block";
+        await SlickSleepService.sleep();
+        this.autoCompleteVisiblity = true;
+        this.expanded = true;
+        this.inputRef.classList.add("slick-auto-complete_remove-bottom-left-border-radius");
+        this.inputRef.classList.add("slick-auto-complete_remove-bottom-right-border-radius");
+        // This is necessary, otherwise `this` in the reposition function will be window
+        // and not the component.
+        // Since angular has no way to use the third parameter, I'm doing this in raw js
+        document.addEventListener("click", this.fnDocumentClick, true);
+    }
+    collapse() {
+        let inputGroupPrepend = SlickUtilsService.getClosestSibling(this.inputRef, "input-group-prepend");
+        if (inputGroupPrepend)
+            inputGroupPrepend.classList.remove("slick-auto-complete_remove-bottom-left-border-radius");
+        this.inputRef.classList.remove("slick-auto-complete_remove-bottom-left-border-radius");
+        this.inputRef.classList.remove("slick-auto-complete_remove-bottom-right-border-radius");
+        this.autoCompleteVisiblity = false;
+        this.expanded = false;
+        this.autoCompleteRef.nativeElement.style.display = "none";
+        // Since angular has no way to use the third parameter, I'm doing this in raw js
+        document.removeEventListener("click", this.fnDocumentClick, true);
+    }
+    reposition() {
+        let rect = this.inputRef.getBoundingClientRect();
+        let inputLeft = rect.left;
+        let inputTop = rect.top;
+        let inputHeight = this.inputRef.offsetHeight;
+        let inputWidth = this.inputRef.offsetWidth;
+        let inputGroupPrepend = SlickUtilsService.getClosestSibling(this.inputRef, "input-group-prepend");
+        if (inputGroupPrepend) {
+            inputLeft = inputGroupPrepend.getBoundingClientRect().left;
+            inputWidth = inputWidth += inputGroupPrepend.offsetWidth;
+            inputGroupPrepend.classList.add("slick-auto-complete_remove-bottom-left-border-radius");
+        }
+        this.left = inputLeft + "px";
+        this.top = (inputTop + inputHeight + 1) + "px";
+        if (this.listWidth === '100%')
+            this.width = inputWidth + "px";
+        else if (this.listWidth === 'auto')
+            this.width = "auto";
+        else
+            this.width = this.listWidth;
+    }
+    async refreshItems(expand) {
+        return new Promise(async (resolve) => {
+            await this.slickFunctionLockService.lock("AUTO_COMPLETE_WAIT_FOR_ITEMS");
+            clearInterval(this.waitForItemsInterval);
+            this.items = null;
+            if (!this.onRefresh || !this.inputRef.value) {
+                this.items = [];
+                this.slickFunctionLockService.release("AUTO_COMPLETE_WAIT_FOR_ITEMS");
+                resolve();
+            }
+            else {
+                this.loading = true;
+                if (this.showNoItemsFoundDisplay === false)
+                    this.collapse();
+                // Call the users refresh method to get a fresh list of items
+                this.onRefresh.emit(this.inputRef.value);
+                // Wait for the list to refresh
+                let timeoutCheck = 1000;
+                this.waitForItemsInterval = setInterval(() => {
+                    // If we've timedout, got a response or they started typing something else, stop the interval
+                    if (timeoutCheck <= 0 || this.items) {
+                        clearInterval(this.waitForItemsInterval);
+                        if (timeoutCheck <= 0) {
+                            console.error("Timed out waiting for list in auto complete");
+                            this.items = [];
+                            if (this.showNoItemsFoundDisplay === false)
+                                this.collapse();
+                        }
+                        this.loading = false;
+                        if (expand)
+                            this.expand();
+                        this.slickFunctionLockService.release("AUTO_COMPLETE_WAIT_FOR_ITEMS");
+                        resolve();
+                    }
+                    timeoutCheck--;
+                }, 100);
+            }
+        });
+    }
+}
+/** @nocollapse */ SlickAutoCompleteComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickAutoCompleteComponent, deps: [{ token: i1.SlickFunctionLockService }], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ SlickAutoCompleteComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.3", type: SlickAutoCompleteComponent, selector: "slick-auto-complete", inputs: { inputRef: "inputRef", items: "items", delay: "delay", selectFirst: "selectFirst", displayTextFieldName: "displayTextFieldName", listHeight: "listHeight", listWidth: "listWidth", allowFreeformText: "allowFreeformText", showNoItemsFoundDisplay: "showNoItemsFoundDisplay" }, outputs: { onRefresh: "onRefresh", onSelect: "onSelect", onFreeformTextSelect: "onFreeformTextSelect" }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef((() => SlickAutoCompleteComponent)),
+            multi: true
+        }
+    ], queries: [{ propertyName: "listItemTemplateRef", first: true, predicate: SlickAutoCompleteListItemTemplateDirective, descendants: true, static: true }], viewQueries: [{ propertyName: "autoCompleteRef", first: true, predicate: ["autoCompleteRef"], descendants: true, static: true }], usesOnChanges: true, ngImport: i0, template: "<div #autoCompleteRef id=\"slick-auto-complete_{{uuid}}\" class='slick-auto-complete dropdown-menu' [style.width]=\"width\" [style.minWidth]=\"width\" [style.visibility]=\"(expanded === true) ? 'visible' : 'hidden'\" [style.opacity]=\"(expanded === true) ? '1' : '0'\" [style.max-height]=\"listHeight\" [style.left]=\"left\" [style.top]=\"top\">\r\n\t<div *ngIf=\"loading\" style=\"font-size: .8rem\" class=\"ml-3\">Loading...</div>\r\n\t<div *ngIf=\"!loading && items?.length === 0\" style=\"font-size: .8rem\" class=\"ml-3\">\r\n\t\tNo items found\r\n\t</div>\r\n\t<div *ngIf=\"!loading && items?.length > 0\">\r\n\t\t<div *ngFor=\"let item of items; let index = index;\" (click)=\"onItemClick(index)\" [class.card-header]=\"selectedIndex === index\" class=\"dropdown-item\">\r\n\t\t\t<ng-container *ngTemplateOutlet=\"listItemTemplateRef.template, context: { $implicit: item, index: index }\">\r\n\t\t\t</ng-container>\r\n\t\t</div>\r\n\t</div>\r\n</div>\r\n", directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickAutoCompleteComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'slick-auto-complete', providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef((() => SlickAutoCompleteComponent)),
+                            multi: true
+                        }
+                    ], template: "<div #autoCompleteRef id=\"slick-auto-complete_{{uuid}}\" class='slick-auto-complete dropdown-menu' [style.width]=\"width\" [style.minWidth]=\"width\" [style.visibility]=\"(expanded === true) ? 'visible' : 'hidden'\" [style.opacity]=\"(expanded === true) ? '1' : '0'\" [style.max-height]=\"listHeight\" [style.left]=\"left\" [style.top]=\"top\">\r\n\t<div *ngIf=\"loading\" style=\"font-size: .8rem\" class=\"ml-3\">Loading...</div>\r\n\t<div *ngIf=\"!loading && items?.length === 0\" style=\"font-size: .8rem\" class=\"ml-3\">\r\n\t\tNo items found\r\n\t</div>\r\n\t<div *ngIf=\"!loading && items?.length > 0\">\r\n\t\t<div *ngFor=\"let item of items; let index = index;\" (click)=\"onItemClick(index)\" [class.card-header]=\"selectedIndex === index\" class=\"dropdown-item\">\r\n\t\t\t<ng-container *ngTemplateOutlet=\"listItemTemplateRef.template, context: { $implicit: item, index: index }\">\r\n\t\t\t</ng-container>\r\n\t\t</div>\r\n\t</div>\r\n</div>\r\n" }]
+        }], ctorParameters: function () { return [{ type: i1.SlickFunctionLockService }]; }, propDecorators: { inputRef: [{
+                type: Input,
+                args: ["inputRef"]
+            }], items: [{
+                type: Input,
+                args: ["items"]
+            }], delay: [{
+                type: Input,
+                args: ["delay"]
+            }], selectFirst: [{
+                type: Input,
+                args: ["selectFirst"]
+            }], displayTextFieldName: [{
+                type: Input,
+                args: ["displayTextFieldName"]
+            }], listHeight: [{
+                type: Input,
+                args: ["listHeight"]
+            }], listWidth: [{
+                type: Input,
+                args: ["listWidth"]
+            }], allowFreeformText: [{
+                type: Input,
+                args: ["allowFreeformText"]
+            }], showNoItemsFoundDisplay: [{
+                type: Input,
+                args: ["showNoItemsFoundDisplay"]
+            }], onRefresh: [{
+                type: Output,
+                args: ["onRefresh"]
+            }], onSelect: [{
+                type: Output,
+                args: ["onSelect"]
+            }], onFreeformTextSelect: [{
+                type: Output,
+                args: ["onFreeformTextSelect"]
+            }], autoCompleteRef: [{
+                type: ViewChild,
+                args: ["autoCompleteRef", { static: true }]
+            }], listItemTemplateRef: [{
+                type: ContentChild,
+                args: [SlickAutoCompleteListItemTemplateDirective, { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slick-auto-complete.component.js","sourceRoot":"","sources":["../../../../projects/components/src/slick-auto-complete/slick-auto-complete.component.ts","../../../../projects/components/src/slick-auto-complete/slick-auto-complete.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAoD,SAAS,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,UAAU,EAA2C,MAAM,eAAe,CAAC;AACvM,OAAO,EAA2C,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAC5F,OAAO,EAAE,0CAA0C,EAAE,MAAM,oDAAoD,CAAC;AAChH,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAEjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;;;;AAYjE,MAAM,OAAO,0BAA0B;IAwCtC,YAAoB,wBAAkD;QAAlD,6BAAwB,GAAxB,wBAAwB,CAA0B;QArCtD,UAAK,GAAW,GAAG,CAAC;QACd,gBAAW,GAAY,IAAI,CAAC;QAE7B,eAAU,GAAG,OAAO,CAAC;QACtB,cAAS,GAAW,MAAM,CAAC;QACnB,sBAAiB,GAAG,IAAI,CAAC;QACnB,4BAAuB,GAAG,IAAI,CAAC;QAC5C,cAAS,GAAyB,IAAI,YAAY,EAAU,CAAC;QAC9D,aAAQ,GAAsB,IAAI,YAAY,EAAO,CAAC;QAC1C,yBAAoB,GAAyB,IAAI,YAAY,EAAU,CAAC;QAKxG,oBAAe,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;QAC/C,cAAS,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QAK3B,mBAAc,GAAW,EAAE,CAAC;QAC5B,mBAAc,GAAG,KAAK,CAAC;QAE/B,gGAAgG;QAChG,8CAA8C;QACtC,iBAAY,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;QAM/C,kBAAa,GAAW,CAAC,CAAC,CAAC;QAC3B,qBAAgB,GAAY,KAAK,CAAC;QAClC,0BAAqB,GAAY,KAAK,CAAC;QACvC,aAAQ,GAAY,IAAI,CAAC;QACzB,YAAO,GAAY,KAAK,CAAC;QA6LzB,oBAAe,GAAG,CAAC,CAAM,EAAE,EAAE,GAAG,CAAC,CAAC;QA1LjC,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC,OAAO,EAAE,CAAC;IACzC,CAAC;IAED,KAAK,CAAC,QAAQ;QACb,MAAM,iBAAiB,CAAC,KAAK,EAAE,CAAC;QAChC,uGAAuG;QACvG,8CAA8C;QAC9C,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAChE,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC;QAE9D,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;IAC3D,CAAC;IAED,WAAW;QACV,gFAAgF;QAChF,QAAQ,CAAC,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC;QAClE,IAAI,CAAC,QAAQ,CAAC,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QAE7D,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAChC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QAEzB,IAAI,CAAC,QAAQ,EAAE,CAAC;QAEhB,gEAAgE;QAChE,IAAI;YACH,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC;SAC9D;QACD,MAAM,GAAG;IACV,CAAC;IAED,WAAW,CAAC,OAAsB;QACjC,IAAI,OAAO,CAAC,iBAAiB;YAC5B,IAAI,CAAC,iBAAiB,GAAG,CAAC,IAAI,CAAC,iBAAiB,CAAC,QAAQ,EAAE,CAAC,WAAW,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;QAEvG,IAAI,OAAO,CAAC,uBAAuB;YAClC,IAAI,CAAC,uBAAuB,GAAG,CAAC,IAAI,CAAC,uBAAuB,CAAC,QAAQ,EAAE,CAAC,WAAW,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;QAEnH,IAAI,OAAO,CAAC,KAAK,EAAE;YAClB,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,IAAI,CAAC,uBAAuB,KAAK,KAAK;gBAClF,IAAI,CAAC,QAAQ,EAAE,CAAC;SACjB;IACF,CAAC;IAEO,aAAa,CAAC,CAAa;QAClC,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC,MAAM;YAC9B,OAAO;QAER,IAAI,iBAAiB,CAAC,mBAAmB,CAAc,CAAC,CAAC,MAAM,EAAE,sBAAsB,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,KAAK,EAAE;YAC/G,aAAa,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;YACzC,IAAI,CAAC,wBAAwB,CAAC,OAAO,CAAC,8BAA8B,CAAC,CAAC;YACtE,IAAI,CAAC,QAAQ,EAAE,CAAC;SAChB;QAED,IAAI,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,oBAAoB;YACtD,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAEtD,CAAC;IAED,WAAW,CAAC,KAAK;QAChB,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACvB,IAAI,CAAC,QAAQ,EAAE,CAAC;IACjB,CAAC;IAEO,KAAK,CAAC,OAAO,CAAC,KAAoB;QACzC,MAAM;QACN,IAAI,KAAK,CAAC,OAAO,KAAK,EAAE;YACvB,OAAO;QAER,aAAa,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;QACzC,IAAI,CAAC,wBAAwB,CAAC,OAAO,CAAC,8BAA8B,CAAC,CAAC;QAEtE,wDAAwD;QACxD,IAAI,CAAC,IAAI,CAAC,cAAc,IAAI,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC,IAAI,KAAK,CAAC,OAAO,KAAK,EAAE,CAAC;YACxE,OAAO;QAER,MAAM,iBAAiB,CAAC,KAAK,EAAE,CAAC;QAEhC,IAAI,IAAI,CAAC,cAAc,KAAK,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE;YAChD,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;YAC1C,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;YAE5B,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE;gBACzB,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;gBAC3B,IAAI,CAAC,QAAQ,EAAE,CAAC;aAChB;YAED,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YAChC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;YACzB,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,KAAK,EAAE,EAAE;gBAC/B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;gBAClB,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAChB,OAAO,IAAI,CAAC;aACZ;iBACI;gBACJ,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,KAAK,IAAI,EAAE;oBACzC,CAAC,IAAI,CAAC,WAAW,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC;oBAC/E,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;oBACzB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;oBAClB,IAAI,CAAC,MAAM,EAAE,CAAC;oBACd,MAAM,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;gBAC/B,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;aACf;SACD;QAED,IAAI,KAAK,CAAC,OAAO,KAAK,CAAC,IAAI,KAAK,CAAC,OAAO,KAAK,EAAE,EAAE;YAChD,IAAI,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,WAAW,EAAE;gBAC1C,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;gBAChC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;gBACzB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;gBAClB,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAEhB,IAAI,IAAI,CAAC,WAAW,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE;oBACtD,MAAM,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;oBAC/B,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC;oBAExB,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,IAAI,IAAI,CAAC,QAAQ,EAAE;wBACzD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;qBACzB;yBACI,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;wBAC7C,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC;wBACvB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;qBACpC;yBACI;wBACJ,IAAI,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,oBAAoB;4BACtD,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;qBACrD;iBACD;qBACI;oBACJ,IAAI,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,oBAAoB;wBACtD,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;iBACrD;aACD;iBACI;gBACJ,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;gBAChC,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,IAAI,IAAI,CAAC,QAAQ,EAAE;oBACzD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;iBACzB;qBACI,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE;oBACtF,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;iBACpC;qBACI;oBACJ,IAAI,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,oBAAoB,EAAE;wBACxD,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;qBACpD;iBACD;gBACD,IAAI,CAAC,QAAQ,EAAE,CAAC;aAChB;SACD;QAED,MAAM;QACN,IAAI,KAAK,CAAC,KAAK,KAAK,EAAE,EAAE;YACvB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;YAC3B,IAAI,CAAC,QAAQ,EAAE,CAAC;YAEhB,OAAO,KAAK,CAAC;SACb;QAED,UAAU;QACV,IAAI,KAAK,CAAC,KAAK,KAAK,EAAE,EAAE;YACvB,IAAI,IAAI,CAAC,aAAa,KAAK,IAAI,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS;gBAClE,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC;YAExB,IAAI,IAAI,CAAC,aAAa,GAAG,CAAC;gBACzB,IAAI,CAAC,aAAa,EAAE,CAAC;YAEtB,OAAO,KAAK,CAAC;SACb;QAED,YAAY;QACZ,IAAI,KAAK,CAAC,KAAK,KAAK,EAAE,EAAE;YACvB,KAAK,CAAC,eAAe,EAAE,CAAC;YACxB,IAAI,IAAI,CAAC,aAAa,KAAK,IAAI,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS;gBAClE,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC;YAEzB,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;gBACnB,IAAI,CAAC,MAAM,EAAE,CAAC;gBACd,OAAO,KAAK,CAAC;aACb;YAED,IAAI,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC;gBAC7C,IAAI,CAAC,aAAa,EAAE,CAAC;YAEtB,OAAO,KAAK,CAAC;SACb;IACF,CAAC;IAID,iDAAiD;IACjD,UAAU,CAAC,GAAQ;QAClB,IAAI,GAAG,EAAE;SACR;IACF,CAAC;IAED,0DAA0D;IAC1D,mDAAmD;IACnD,gBAAgB,CAAC,EAAO;QACvB,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;IAC3B,CAAC;IAED,iCAAiC;IACjC,iBAAiB,KAAK,CAAC;IAEvB,KAAK,CAAC,UAAU,CAAC,KAAa;QAC7B,IAAI,KAAK,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;YACxD,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;SACzB;aACI;YACJ,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACtC,IAAI,IAAI,CAAC,oBAAoB,EAAE;gBAC9B,MAAM,IAAI,GAAG,iBAAiB,CAAC,aAAa,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,oBAAoB,CAAC,CAAC;gBAC3F,IAAI,IAAI,EAAE;oBACT,IAAI,CAAC,QAAQ,CAAC,KAAK,GAAG,IAAI,CAAC;oBAC3B,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;iBAC1C;aACD;SACD;QAED,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACxC,IAAI,IAAI,CAAC,QAAQ;YAChB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACvC,2CAA2C;QAC3C,MAAM,iBAAiB,CAAC,KAAK,EAAE,CAAC;QAChC,IAAI,GAAG,GAAG,QAAQ,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QACxC,GAAG,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;QACpC,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;IAClC,CAAC;IAEO,KAAK,CAAC,MAAM;QACnB,IAAI,CAAC,UAAU,EAAE,CAAC;QAElB,iEAAiE;QACjE,IAAI,IAAI,CAAC,uBAAuB,KAAK,KAAK,IAAI,CAAC,CAAC,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,EAAE;YACvF,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;YAC9B,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC;YACnC,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;YACtB,OAAO;SACP;QAED,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAC7B,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,KAAK,CAAC,OAAO,GAAG,cAAc,CAAC;QAClE,MAAM,iBAAiB,CAAC,KAAK,EAAE,CAAC;QAChC,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;QAClC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QAErB,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,sDAAsD,CAAC,CAAC;QACpF,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,uDAAuD,CAAC,CAAC;QAErF,gFAAgF;QAChF,yBAAyB;QACzB,gFAAgF;QAChF,QAAQ,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC;IAChE,CAAC;IAEO,QAAQ;QACf,IAAI,iBAAiB,GAAG,iBAAiB,CAAC,iBAAiB,CAAC,IAAI,CAAC,QAAQ,EAAE,qBAAqB,CAAC,CAAC;QAClG,IAAI,iBAAiB;YACpB,iBAAiB,CAAC,SAAS,CAAC,MAAM,CAAC,sDAAsD,CAAC,CAAC;QAE5F,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,MAAM,CAAC,sDAAsD,CAAC,CAAC;QACvF,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,MAAM,CAAC,uDAAuD,CAAC,CAAC;QAExF,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC;QACnC,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC;QAE1D,gFAAgF;QAChF,QAAQ,CAAC,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC;IACnE,CAAC;IAEO,UAAU;QACjB,IAAI,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,qBAAqB,EAAE,CAAC;QACjD,IAAI,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC;QAC1B,IAAI,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC;QACxB,IAAI,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC;QAC7C,IAAI,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC;QAE3C,IAAI,iBAAiB,GAAG,iBAAiB,CAAC,iBAAiB,CAAC,IAAI,CAAC,QAAQ,EAAE,qBAAqB,CAAC,CAAC;QAClG,IAAI,iBAAiB,EAAE;YACtB,SAAS,GAAG,iBAAiB,CAAC,qBAAqB,EAAE,CAAC,IAAI,CAAC;YAC3D,UAAU,GAAG,UAAU,IAAI,iBAAiB,CAAC,WAAW,CAAC;YACzD,iBAAiB,CAAC,SAAS,CAAC,GAAG,CAAC,sDAAsD,CAAC,CAAC;SACxF;QAED,IAAI,CAAC,IAAI,GAAG,SAAS,GAAG,IAAI,CAAC;QAC7B,IAAI,CAAC,GAAG,GAAG,CAAC,QAAQ,GAAG,WAAW,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;QAC/C,IAAI,IAAI,CAAC,SAAS,KAAK,MAAM;YAC5B,IAAI,CAAC,KAAK,GAAG,UAAU,GAAG,IAAI,CAAC;aAC3B,IAAI,IAAI,CAAC,SAAS,KAAK,MAAM;YACjC,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC;;YAEpB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC;IAC9B,CAAC;IAEO,KAAK,CAAC,YAAY,CAAC,MAAe;QACzC,OAAO,IAAI,OAAO,CAAO,KAAK,EAAE,OAAO,EAAE,EAAE;YAC1C,MAAM,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,8BAA8B,CAAC,CAAC;YACzE,aAAa,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;YACzC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;YAElB,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE;gBAC5C,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;gBAChB,IAAI,CAAC,wBAAwB,CAAC,OAAO,CAAC,8BAA8B,CAAC,CAAC;gBACtE,OAAO,EAAE,CAAC;aACV;iBACI;gBACJ,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;gBACpB,IAAI,IAAI,CAAC,uBAAuB,KAAK,KAAK;oBACzC,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACjB,6DAA6D;gBAC7D,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;gBAEzC,+BAA+B;gBAC/B,IAAI,YAAY,GAAG,IAAI,CAAC;gBACxB,IAAI,CAAC,oBAAoB,GAAG,WAAW,CAAC,GAAG,EAAE;oBAC5C,6FAA6F;oBAC7F,IAAI,YAAY,IAAI,CAAC,IAAI,IAAI,CAAC,KAAK,EAAE;wBACpC,aAAa,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;wBACzC,IAAI,YAAY,IAAI,CAAC,EAAE;4BACtB,OAAO,CAAC,KAAK,CAAC,6CAA6C,CAAC,CAAC;4BAC7D,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;4BAChB,IAAI,IAAI,CAAC,uBAAuB,KAAK,KAAK;gCACzC,IAAI,CAAC,QAAQ,EAAE,CAAC;yBACjB;wBACD,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;wBACrB,IAAI,MAAM;4BACT,IAAI,CAAC,MAAM,EAAE,CAAC;wBACf,IAAI,CAAC,wBAAwB,CAAC,OAAO,CAAC,8BAA8B,CAAC,CAAC;wBACtE,OAAO,EAAE,CAAC;qBACV;oBAED,YAAY,EAAE,CAAC;gBAChB,CAAC,EAAE,GAAG,CAAC,CAAC;aACR;QACF,CAAC,CAAC,CAAA;IACH,CAAC;;0IAxXW,0BAA0B;8HAA1B,0BAA0B,ibAP3B;QACV;YACC,OAAO,EAAE,iBAAiB;YAC1B,WAAW,EAAE,UAAU,EAAC,GAAG,EAAE,CAAC,0BAA0B,EAAC;YACzD,KAAK,EAAE,IAAI;SACX;KAAC,2EAiBW,0CAA0C,qNChCzD,m8BAYA;2FDKa,0BAA0B;kBAVtC,SAAS;+BACC,qBAAqB,aAEpB;wBACV;4BACC,OAAO,EAAE,iBAAiB;4BAC1B,WAAW,EAAE,UAAU,EAAC,GAAG,EAAE,2BAA2B,EAAC;4BACzD,KAAK,EAAE,IAAI;yBACX;qBAAC;+GAGgB,QAAQ;sBAA1B,KAAK;uBAAC,UAAU;gBACD,KAAK;sBAApB,KAAK;uBAAC,OAAO;gBACE,KAAK;sBAApB,KAAK;uBAAC,OAAO;gBACQ,WAAW;sBAAhC,KAAK;uBAAC,aAAa;gBACW,oBAAoB;sBAAlD,KAAK;uBAAC,sBAAsB;gBACR,UAAU;sBAA9B,KAAK;uBAAC,YAAY;gBACC,SAAS;sBAA5B,KAAK;uBAAC,WAAW;gBACU,iBAAiB;sBAA5C,KAAK;uBAAC,mBAAmB;gBACQ,uBAAuB;sBAAxD,KAAK;uBAAC,yBAAyB;gBACX,SAAS;sBAA7B,MAAM;uBAAC,WAAW;gBACC,QAAQ;sBAA3B,MAAM;uBAAC,UAAU;gBACc,oBAAoB;sBAAnD,MAAM;uBAAC,sBAAsB;gBAEkB,eAAe;sBAA9D,SAAS;uBAAC,iBAAiB,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;gBAC8B,mBAAmB;sBAA9F,YAAY;uBAAC,0CAA0C,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE","sourcesContent":["import { Component, ChangeDetectorRef, OnInit, OnDestroy, ElementRef, ViewChild, ContentChild, Input, Output, EventEmitter, forwardRef, OnChanges, SimpleChanges, AfterViewInit } from \"@angular/core\";\r\nimport { Form, FormsModule, ControlValueAccessor, NG_VALUE_ACCESSOR } from \"@angular/forms\";\r\nimport { SlickAutoCompleteListItemTemplateDirective } from \"./slick-auto-complete-list-item-template.directive\";\r\nimport { SlickUtilsService } from \"../utils/slick-utils.service\";\r\nimport { SlickFunctionLockService } from \"../utils/slick-function-lock.service\";\r\nimport { SlickSleepService } from \"../utils/slick-sleep.service\";\r\n\r\n@Component({\r\n\tselector: 'slick-auto-complete',\r\n\ttemplateUrl: 'slick-auto-complete.component.html',\r\n\tproviders: [\r\n\t\t{\r\n\t\t\tprovide: NG_VALUE_ACCESSOR,\r\n\t\t\tuseExisting: forwardRef(() => SlickAutoCompleteComponent),\r\n\t\t\tmulti: true\r\n\t\t}]\r\n})\r\nexport class SlickAutoCompleteComponent implements OnInit, OnDestroy, OnChanges, ControlValueAccessor {\r\n\t@Input(\"inputRef\") inputRef: HTMLInputElement;\r\n\t@Input(\"items\") items: any[];\r\n\t@Input(\"delay\") delay: number = 300;\r\n\t@Input(\"selectFirst\") selectFirst: boolean = true;\r\n\t@Input(\"displayTextFieldName\") displayTextFieldName: string;\r\n\t@Input(\"listHeight\") listHeight = \"300px\";\r\n\t@Input(\"listWidth\") listWidth: string = '100%';\r\n\t@Input(\"allowFreeformText\") allowFreeformText = true;\r\n\t@Input(\"showNoItemsFoundDisplay\") showNoItemsFoundDisplay = true;\r\n\t@Output(\"onRefresh\") onRefresh: EventEmitter<string> = new EventEmitter<string>();\r\n\t@Output(\"onSelect\") onSelect: EventEmitter<any> = new EventEmitter<any>();\r\n\t@Output(\"onFreeformTextSelect\") onFreeformTextSelect: EventEmitter<string> = new EventEmitter<string>();\r\n\r\n\t@ViewChild(\"autoCompleteRef\", { static: true }) autoCompleteRef: ElementRef;\r\n\t@ContentChild(SlickAutoCompleteListItemTemplateDirective, { static: true }) listItemTemplateRef: SlickAutoCompleteListItemTemplateDirective;\r\n\r\n\tfnDocumentClick = (e) => this.documentClick(e);\r\n\tfnKeyDown = (e) => this.keyDown(e);\r\n\r\n\tprivate selectedItem: any;\r\n\tprivate delayTimeout: NodeJS.Timer;\r\n\tprivate waitForItemsInterval: NodeJS.Timer;\r\n\tprivate lastInputValue: string = \"\";\r\n\tprivate forcedCollapse = false;\r\n\r\n\t// This is necessary so that the scroll and resize events can add and remove the event properly,\r\n\t// as well as getting the correct ES6 function\r\n\tprivate fnReposition = () => this.reposition();\r\n\r\n\tuuid: string;\r\n\tleft: string;\r\n\ttop: string;\r\n\twidth: string;\r\n\tselectedIndex: number = -1;\r\n\tshowAutoComplete: boolean = false;\r\n\tautoCompleteVisiblity: boolean = false;\r\n\texpanded: boolean = true;\r\n\tloading: boolean = false;\r\n\r\n\tconstructor(private slickFunctionLockService: SlickFunctionLockService) {\r\n\t\tthis.uuid = SlickUtilsService.newGuid();\r\n\t}\r\n\r\n\tasync ngOnInit() {\r\n\t\tawait SlickSleepService.sleep();\r\n\t\t// Remove this from the inline version and put it on the body so that it doesn't hide behind the bottom\r\n\t\t// of a div when it expands beyond the bottom.\r\n\t\tthis.autoCompleteRef.nativeElement.remove(this.autoCompleteRef);\r\n\t\tdocument.body.appendChild(this.autoCompleteRef.nativeElement);\r\n\r\n\t\tthis.inputRef.addEventListener(\"keydown\", this.fnKeyDown);\r\n\t}\r\n\r\n\tngOnDestroy() {\r\n\t\t// Since angular has no way to use the third parameter, I'm doing this in raw js\r\n\t\tdocument.removeEventListener(\"click\", this.fnDocumentClick, true);\r\n\t\tthis.inputRef.removeEventListener(\"keydown\", this.fnKeyDown);\r\n\r\n\t\tclearTimeout(this.delayTimeout);\r\n\t\tthis.delayTimeout = null;\r\n\r\n\t\tthis.collapse();\r\n\r\n\t\t// Is okay if this fails.  It just means it was already removed.\r\n\t\ttry {\r\n\t\t\tdocument.body.removeChild(this.autoCompleteRef.nativeElement);\r\n\t\t}\r\n\t\tcatch { }\r\n\t}\r\n\r\n\tngOnChanges(changes: SimpleChanges) {\t\t\r\n\t\tif (changes.allowFreeformText) \r\n\t\t\tthis.allowFreeformText = (this.allowFreeformText.toString().toLowerCase() === 'false') ? false : true;\t\t\r\n\r\n\t\tif (changes.showNoItemsFoundDisplay)\r\n\t\t\tthis.showNoItemsFoundDisplay = (this.showNoItemsFoundDisplay.toString().toLowerCase() === 'false') ? false : true;\t\t\r\n\r\n\t\tif (changes.items) {\r\n\t\t\tif (this.items && this.items.length === 0 && this.showNoItemsFoundDisplay === false)\r\n\t\t\t\tthis.collapse();\r\n\t\t}\r\n\t}\r\n\r\n\tprivate documentClick(e: MouseEvent) {\r\n\t\tif (!this.expanded || !e.target)\r\n\t\t\treturn;\r\n\r\n\t\tif (SlickUtilsService.checkParentIdExists(<HTMLElement>e.target, \"slick-auto-complete_\" + this.uuid) === false) {\r\n\t\t\tclearInterval(this.waitForItemsInterval);\r\n\t\t\tthis.slickFunctionLockService.release(\"AUTO_COMPLETE_WAIT_FOR_ITEMS\");\r\n\t\t\tthis.collapse();\r\n\t\t}\r\n\r\n\t\tif (this.allowFreeformText && this.onFreeformTextSelect)\r\n\t\t\tthis.onFreeformTextSelect.emit(this.inputRef.value);\r\n\r\n\t}\r\n\r\n\tonItemClick(index) {\r\n\t\tthis.selectItem(index);\r\n\t\tthis.collapse();\r\n\t}\r\n\r\n\tprivate async keyDown(event: KeyboardEvent) {\r\n\t\t// alt\r\n\t\tif (event.keyCode === 18)\r\n\t\t\treturn;\r\n\r\n\t\tclearInterval(this.waitForItemsInterval);\r\n\t\tthis.slickFunctionLockService.release(\"AUTO_COMPLETE_WAIT_FOR_ITEMS\");\r\n\r\n\t\t// If we're just tabbing through, don't even do anything\r\n\t\tif (!this.lastInputValue && (event.keyCode === 9 || event.keyCode === 13))\r\n\t\t\treturn;\r\n\r\n\t\tawait SlickSleepService.sleep();\r\n\r\n\t\tif (this.lastInputValue !== this.inputRef.value) {\r\n\t\t\tthis.lastInputValue = this.inputRef.value;\r\n\t\t\tthis.forcedCollapse = false;\r\n\r\n\t\t\tif (!this.lastInputValue) {\r\n\t\t\t\tthis.propagateChange(null);\r\n\t\t\t\tthis.collapse();\r\n\t\t\t}\r\n\r\n\t\t\tclearTimeout(this.delayTimeout);\r\n\t\t\tthis.delayTimeout = null;\r\n\t\t\tif (this.inputRef.value === '') {\r\n\t\t\t\tthis.items = null;\r\n\t\t\t\tthis.collapse();\r\n\t\t\t\treturn true;\r\n\t\t\t}\r\n\t\t\telse {\r\n\t\t\t\tthis.delayTimeout = setTimeout(async () => {\r\n\t\t\t\t\t(this.selectFirst === true) ? this.selectedIndex = 0 : this.selectedIndex = -1;\r\n\t\t\t\t\tthis.delayTimeout = null;\r\n\t\t\t\t\tthis.items = null;\r\n\t\t\t\t\tthis.expand();\r\n\t\t\t\t\tawait this.refreshItems(true);\r\n\t\t\t\t}, this.delay);\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tif (event.keyCode === 9 || event.keyCode === 13) {\r\n\t\t\tif (this.delayTimeout && this.selectFirst) {\r\n\t\t\t\tclearTimeout(this.delayTimeout);\r\n\t\t\t\tthis.delayTimeout = null;\r\n\t\t\t\tthis.items = null;\r\n\t\t\t\tthis.collapse();\r\n\r\n\t\t\t\tif (this.selectFirst === true && !this.forcedCollapse) {\r\n\t\t\t\t\tawait this.refreshItems(false);\r\n\t\t\t\t\tthis.selectedIndex = -1;\r\n\r\n\t\t\t\t\tif (!this.items && !this.inputRef.value && this.onSelect) {\r\n\t\t\t\t\t\tthis.onSelect.emit(null);\r\n\t\t\t\t\t}\r\n\t\t\t\t\telse if (this.items && this.items.length > 0) {\r\n\t\t\t\t\t\tthis.selectedIndex = 0;\r\n\t\t\t\t\t\tthis.selectItem(this.selectedIndex);\r\n\t\t\t\t\t}\r\n\t\t\t\t\telse {\r\n\t\t\t\t\t\tif (this.allowFreeformText && this.onFreeformTextSelect) \r\n\t\t\t\t\t\t\tthis.onFreeformTextSelect.emit(this.inputRef.value);\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\telse {\r\n\t\t\t\t\tif (this.allowFreeformText && this.onFreeformTextSelect) \r\n\t\t\t\t\t\tthis.onFreeformTextSelect.emit(this.inputRef.value);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\telse {\r\n\t\t\t\tclearTimeout(this.delayTimeout);\r\n\t\t\t\tif (!this.items && !this.inputRef.value && this.onSelect) {\r\n\t\t\t\t\tthis.onSelect.emit(null);\r\n\t\t\t\t}\r\n\t\t\t\telse if (this.items && this.items.length > 0 && this.expanded && !this.forcedCollapse) {\r\n\t\t\t\t\tthis.selectItem(this.selectedIndex);\r\n\t\t\t\t}\r\n\t\t\t\telse {\r\n\t\t\t\t\tif (this.allowFreeformText && this.onFreeformTextSelect) {\r\n\t\t\t\t\t\tthis.onFreeformTextSelect.emit(this.inputRef.value);\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\tthis.collapse();\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t// Esc\r\n\t\tif (event.which === 27) {\r\n\t\t\tthis.forcedCollapse = true;\r\n\t\t\tthis.collapse();\r\n\r\n\t\t\treturn false;\r\n\t\t}\r\n\r\n\t\t// Arrowup\r\n\t\tif (event.which === 38) {\r\n\t\t\tif (this.selectedIndex === null || this.selectedIndex === undefined)\r\n\t\t\t\tthis.selectedIndex = 0;\r\n\r\n\t\t\tif (this.selectedIndex > 0)\r\n\t\t\t\tthis.selectedIndex--;\r\n\r\n\t\t\treturn false;\r\n\t\t}\r\n\r\n\t\t// Arrowdown\r\n\t\tif (event.which === 40) {\r\n\t\t\tevent.stopPropagation();\r\n\t\t\tif (this.selectedIndex === null || this.selectedIndex === undefined)\r\n\t\t\t\tthis.selectedIndex = -1;\r\n\r\n\t\t\tif (!this.expanded) {\r\n\t\t\t\tthis.expand();\r\n\t\t\t\treturn false;\r\n\t\t\t}\r\n\r\n\t\t\tif (this.selectedIndex < this.items.length - 1)\r\n\t\t\t\tthis.selectedIndex++;\r\n\r\n\t\t\treturn false;\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\twriteValue(obj: any) {\r\n\t\tif (obj) {\r\n\t\t}\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\tregisterOnChange(fn: any) {\r\n\t\tthis.propagateChange = fn;\r\n\t}\r\n\r\n\t// not used, used for touch input\r\n\tregisterOnTouched() { }\r\n\r\n\tasync selectItem(index: number) {\r\n\t\tif (index < 0 || !this.items || this.items.length === 0) {\r\n\t\t\tthis.selectedItem = null;\r\n\t\t}\r\n\t\telse {\r\n\t\t\tthis.selectedItem = this.items[index];\r\n\t\t\tif (this.displayTextFieldName) {\r\n\t\t\t\tconst text = SlickUtilsService.getDeepObject(this.selectedItem, this.displayTextFieldName);\r\n\t\t\t\tif (text) {\r\n\t\t\t\t\tthis.inputRef.value = text;\r\n\t\t\t\t\tthis.lastInputValue = this.inputRef.value;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tthis.propagateChange(this.selectedItem);\r\n\t\tif (this.onSelect)\r\n\t\t\tthis.onSelect.emit(this.selectedItem);\r\n\t\t// Call to update the model for the textbox\r\n\t\tawait SlickSleepService.sleep();\r\n\t\tlet evt = document.createEvent('Event');\r\n\t\tevt.initEvent('input', true, false);\r\n\t\tthis.inputRef.dispatchEvent(evt);\r\n\t}\r\n\r\n\tprivate async expand() {\r\n\t\tthis.reposition();\r\n\r\n\t\t// If the flag to show items is false, don't display \"Loading...\"\r\n\t\tif (this.showNoItemsFoundDisplay === false && (!this.items || this.items.length === 0)) {\r\n\t\t\tthis.showAutoComplete = false;\r\n\t\t\tthis.autoCompleteVisiblity = false;\r\n\t\t\tthis.expanded = false;\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tthis.showAutoComplete = true;\r\n\t\tthis.autoCompleteRef.nativeElement.style.display = \"inline-block\";\r\n\t\tawait SlickSleepService.sleep();\r\n\t\tthis.autoCompleteVisiblity = true;\r\n\t\tthis.expanded = true;\r\n\r\n\t\tthis.inputRef.classList.add(\"slick-auto-complete_remove-bottom-left-border-radius\");\r\n\t\tthis.inputRef.classList.add(\"slick-auto-complete_remove-bottom-right-border-radius\");\r\n\r\n\t\t// This is necessary, otherwise `this` in the reposition function will be window\r\n\t\t// and not the component.\r\n\t\t// Since angular has no way to use the third parameter, I'm doing this in raw js\r\n\t\tdocument.addEventListener(\"click\", this.fnDocumentClick, true);\r\n\t}\r\n\r\n\tprivate collapse() {\r\n\t\tlet inputGroupPrepend = SlickUtilsService.getClosestSibling(this.inputRef, \"input-group-prepend\");\r\n\t\tif (inputGroupPrepend)\r\n\t\t\tinputGroupPrepend.classList.remove(\"slick-auto-complete_remove-bottom-left-border-radius\");\r\n\r\n\t\tthis.inputRef.classList.remove(\"slick-auto-complete_remove-bottom-left-border-radius\");\r\n\t\tthis.inputRef.classList.remove(\"slick-auto-complete_remove-bottom-right-border-radius\");\r\n\r\n\t\tthis.autoCompleteVisiblity = false;\r\n\t\tthis.expanded = false;\r\n\t\tthis.autoCompleteRef.nativeElement.style.display = \"none\";\r\n\r\n\t\t// Since angular has no way to use the third parameter, I'm doing this in raw js\r\n\t\tdocument.removeEventListener(\"click\", this.fnDocumentClick, true);\r\n\t}\r\n\r\n\tprivate reposition() {\r\n\t\tlet rect = this.inputRef.getBoundingClientRect();\r\n\t\tlet inputLeft = rect.left;\r\n\t\tlet inputTop = rect.top;\r\n\t\tlet inputHeight = this.inputRef.offsetHeight;\r\n\t\tlet inputWidth = this.inputRef.offsetWidth;\r\n\r\n\t\tlet inputGroupPrepend = SlickUtilsService.getClosestSibling(this.inputRef, \"input-group-prepend\");\r\n\t\tif (inputGroupPrepend) {\r\n\t\t\tinputLeft = inputGroupPrepend.getBoundingClientRect().left;\r\n\t\t\tinputWidth = inputWidth += inputGroupPrepend.offsetWidth;\r\n\t\t\tinputGroupPrepend.classList.add(\"slick-auto-complete_remove-bottom-left-border-radius\");\r\n\t\t}\r\n\r\n\t\tthis.left = inputLeft + \"px\";\r\n\t\tthis.top = (inputTop + inputHeight + 1) + \"px\";\r\n\t\tif (this.listWidth === '100%')\r\n\t\t\tthis.width = inputWidth + \"px\";\r\n\t\telse if (this.listWidth === 'auto')\r\n\t\t\tthis.width = \"auto\";\r\n\t\telse\r\n\t\t\tthis.width = this.listWidth;\r\n\t}\r\n\r\n\tprivate async refreshItems(expand: boolean): Promise<void> {\r\n\t\treturn new Promise<void>(async (resolve) => {\r\n\t\t\tawait this.slickFunctionLockService.lock(\"AUTO_COMPLETE_WAIT_FOR_ITEMS\");\r\n\t\t\tclearInterval(this.waitForItemsInterval);\r\n\t\t\tthis.items = null;\r\n\r\n\t\t\tif (!this.onRefresh || !this.inputRef.value) {\r\n\t\t\t\tthis.items = [];\r\n\t\t\t\tthis.slickFunctionLockService.release(\"AUTO_COMPLETE_WAIT_FOR_ITEMS\");\r\n\t\t\t\tresolve();\r\n\t\t\t}\r\n\t\t\telse {\r\n\t\t\t\tthis.loading = true;\r\n\t\t\t\tif (this.showNoItemsFoundDisplay === false)\r\n\t\t\t\t\tthis.collapse();\r\n\t\t\t\t// Call the users refresh method to get a fresh list of items\r\n\t\t\t\tthis.onRefresh.emit(this.inputRef.value);\r\n\r\n\t\t\t\t// Wait for the list to refresh\r\n\t\t\t\tlet timeoutCheck = 1000;\r\n\t\t\t\tthis.waitForItemsInterval = setInterval(() => {\r\n\t\t\t\t\t// If we've timedout, got a response or they started typing something else, stop the interval\r\n\t\t\t\t\tif (timeoutCheck <= 0 || this.items) {\r\n\t\t\t\t\t\tclearInterval(this.waitForItemsInterval);\r\n\t\t\t\t\t\tif (timeoutCheck <= 0) {\r\n\t\t\t\t\t\t\tconsole.error(\"Timed out waiting for list in auto complete\");\r\n\t\t\t\t\t\t\tthis.items = [];\r\n\t\t\t\t\t\t\tif (this.showNoItemsFoundDisplay === false)\r\n\t\t\t\t\t\t\t\tthis.collapse();\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tthis.loading = false;\r\n\t\t\t\t\t\tif (expand)\r\n\t\t\t\t\t\t\tthis.expand();\r\n\t\t\t\t\t\tthis.slickFunctionLockService.release(\"AUTO_COMPLETE_WAIT_FOR_ITEMS\");\r\n\t\t\t\t\t\tresolve();\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\ttimeoutCheck--;\r\n\t\t\t\t}, 100);\r\n\t\t\t}\r\n\t\t})\r\n\t}\r\n\r\n}","<div #autoCompleteRef id=\"slick-auto-complete_{{uuid}}\" class='slick-auto-complete dropdown-menu' [style.width]=\"width\" [style.minWidth]=\"width\" [style.visibility]=\"(expanded === true) ? 'visible' : 'hidden'\" [style.opacity]=\"(expanded === true) ? '1' : '0'\" [style.max-height]=\"listHeight\" [style.left]=\"left\" [style.top]=\"top\">\r\n\t<div *ngIf=\"loading\" style=\"font-size: .8rem\" class=\"ml-3\">Loading...</div>\r\n\t<div *ngIf=\"!loading && items?.length === 0\" style=\"font-size: .8rem\" class=\"ml-3\">\r\n\t\tNo items found\r\n\t</div>\r\n\t<div *ngIf=\"!loading && items?.length > 0\">\r\n\t\t<div *ngFor=\"let item of items; let index = index;\" (click)=\"onItemClick(index)\" [class.card-header]=\"selectedIndex === index\" class=\"dropdown-item\">\r\n\t\t\t<ng-container *ngTemplateOutlet=\"listItemTemplateRef.template, context: { $implicit: item, index: index }\">\r\n\t\t\t</ng-container>\r\n\t\t</div>\r\n\t</div>\r\n</div>\r\n"]}

package/esm2020/slick-auto-complete/slick-auto-complete.module.mjs

@@ -0,0 +1,24 @@
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { FormsModule } from '@angular/forms';
+import { SlickAutoCompleteComponent } from "./slick-auto-complete.component";
+import { SlickAutoCompleteListItemTemplateDirective } from "./slick-auto-complete-list-item-template.directive";
+import { SlickFunctionLockService } from "../utils/slick-function-lock.service";
+import * as i0 from "@angular/core";
+export class SlickAutoCompleteModule {
+}
+/** @nocollapse */ SlickAutoCompleteModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickAutoCompleteModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ SlickAutoCompleteModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickAutoCompleteModule, declarations: [SlickAutoCompleteComponent, SlickAutoCompleteListItemTemplateDirective], imports: [CommonModule, FormsModule], exports: [SlickAutoCompleteComponent, SlickAutoCompleteListItemTemplateDirective] });
+/** @nocollapse */ SlickAutoCompleteModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickAutoCompleteModule, providers: [SlickFunctionLockService], imports: [[CommonModule, FormsModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickAutoCompleteModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, FormsModule],
+                    declarations: [SlickAutoCompleteComponent, SlickAutoCompleteListItemTemplateDirective],
+                    exports: [SlickAutoCompleteComponent, SlickAutoCompleteListItemTemplateDirective],
+                    providers: [SlickFunctionLockService]
+                }]
+        }] });
+export { SlickAutoCompleteComponent };
+export { SlickAutoCompleteListItemTemplateDirective };
+//# sourceMappingURL=data:application/json;base64,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