angular-multiselect3 10.0.0

package/esm2022/lib/multiselect.component.mjs

@@ -0,0 +1,1038 @@
+import { Component, HostListener, NgModule, ViewEncapsulation, ContentChild, ViewChild, forwardRef, Input, Output, EventEmitter, } from '@angular/core';
+import { FormsModule, NG_VALUE_ACCESSOR, NG_VALIDATORS, } from '@angular/forms';
+import { CommonModule } from '@angular/common';
+import { MyException } from './multiselect.model';
+import { ClickOutsideDirective, ScrollDirective } from './clickOutside';
+import { ListFilterPipe } from './list-filter';
+import { Item, Badge, Search, TemplateRenderer, CIcon } from './menu-item';
+import { DataService } from './multiselect.service';
+import { Subject } from 'rxjs';
+import { VirtualScrollerModule, VirtualScrollerComponent, } from './virtual-scroll/virtual-scroll';
+import { debounceTime, distinctUntilChanged, tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./list-filter";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "./virtual-scroll/virtual-scroll";
+export const DROPDOWN_CONTROL_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => AngularMultiSelect),
+    multi: true,
+};
+export const DROPDOWN_CONTROL_VALIDATION = {
+    provide: NG_VALIDATORS,
+    useExisting: forwardRef(() => AngularMultiSelect),
+    multi: true,
+};
+const noop = () => { };
+export class AngularMultiSelect {
+    _elementRef;
+    cdr;
+    filterPipe;
+    data;
+    settings;
+    loading;
+    onSelect = new EventEmitter();
+    onDeSelect = new EventEmitter();
+    onSelectAll = new EventEmitter();
+    onDeSelectAll = new EventEmitter();
+    onOpen = new EventEmitter();
+    onClose = new EventEmitter();
+    onScrollToEnd = new EventEmitter();
+    onFilterSelectAll = new EventEmitter();
+    onFilterDeSelectAll = new EventEmitter();
+    onAddFilterNewItem = new EventEmitter();
+    onGroupSelect = new EventEmitter();
+    onGroupDeSelect = new EventEmitter();
+    itemTempl;
+    badgeTempl;
+    searchTempl;
+    searchInput;
+    selectedListElem;
+    dropdownListElem;
+    cuppaDropdown;
+    onEscapeDown(event) {
+        if (this.settings.escapeToClose) {
+            this.closeDropdown();
+        }
+    }
+    onScroll(event) {
+        if (this.isActive && this.settings.tagToBody) {
+            this.closeDropdown();
+            /*             const elem = this.cuppaDropdown.nativeElement;
+                              if(this.settings.autoPosition){
+                                  this.dropDownTop = elem.getBoundingClientRect().y + elem.clientHeight + 1;
+                              }
+                              this.dropDownLeft = elem.getBoundingClientRect().x; */
+        }
+    }
+    virtualdata = [];
+    searchTerm$ = new Subject();
+    selectedItems;
+    isActive = false;
+    isSelectAll = false;
+    isFilterSelectAll = false;
+    isInfiniteFilterSelectAll = false;
+    groupedData;
+    filter;
+    chunkArray;
+    scrollTop;
+    chunkIndex = [];
+    cachedItems = [];
+    groupCachedItems = [];
+    totalRows;
+    itemHeight = 41.6;
+    screenItemsLen;
+    cachedItemsLen;
+    totalHeight;
+    scroller;
+    maxBuffer;
+    lastScrolled;
+    lastRepaintY;
+    selectedListHeight;
+    filterLength = 0;
+    infiniteFilterLength = 0;
+    viewPortItems;
+    item;
+    dropdownListYOffset = 0;
+    subscription;
+    dropDownWidth = 0;
+    dropDownTop = '';
+    dropDownBottom = 'unset';
+    dropDownLeft = 0;
+    id = Math.random().toString(36).substring(2);
+    defaultSettings = {
+        singleSelection: false,
+        text: 'Select',
+        enableCheckAll: true,
+        selectAllText: 'Select All',
+        unSelectAllText: 'UnSelect All',
+        filterSelectAllText: 'Select all filtered results',
+        filterUnSelectAllText: 'UnSelect all filtered results',
+        enableSearchFilter: false,
+        searchBy: [],
+        maxHeight: 300,
+        badgeShowLimit: 999999999999,
+        classes: '',
+        disabled: false,
+        searchPlaceholderText: 'Search',
+        showCheckbox: true,
+        noDataLabel: 'No Data Available',
+        searchAutofocus: true,
+        lazyLoading: false,
+        labelKey: 'itemName',
+        primaryKey: 'id',
+        position: 'bottom',
+        autoPosition: true,
+        enableFilterSelectAll: true,
+        selectGroup: false,
+        addNewItemOnFilter: false,
+        addNewButtonText: 'Add',
+        escapeToClose: true,
+        clearAll: true,
+        tagToBody: true,
+    };
+    randomSize = true;
+    parseError;
+    filteredList = [];
+    virtualScroollInit = false;
+    virtualScroller;
+    isDisabledItemPresent = false;
+    constructor(_elementRef, cdr, filterPipe) {
+        this._elementRef = _elementRef;
+        this.cdr = cdr;
+        this.filterPipe = filterPipe;
+        this.searchTerm$
+            .asObservable()
+            .pipe(debounceTime(1000), distinctUntilChanged(), tap((term) => term))
+            .subscribe((val) => {
+            this.filterInfiniteList(val);
+        });
+    }
+    ngOnInit() {
+        this.settings = Object.assign(this.defaultSettings, this.settings);
+        this.cachedItems = this.cloneArray(this.data);
+        if (this.settings.position == 'top') {
+            setTimeout(() => {
+                this.selectedListHeight = { val: 0 };
+                this.selectedListHeight.val =
+                    this.selectedListElem.nativeElement.clientHeight;
+            });
+        }
+        setTimeout(() => {
+            this.calculateDropdownDirection();
+        });
+        this.virtualScroollInit = false;
+    }
+    onKeyUp(evt) {
+        this.searchTerm$.next(evt.target.value);
+    }
+    ngOnChanges(changes) {
+        if (changes.data && !changes.data.firstChange) {
+            if (this.settings.groupBy) {
+                this.groupedData = this.transformData(this.data, this.settings.groupBy);
+                if (this.data.length == 0) {
+                    this.selectedItems = [];
+                }
+                this.groupCachedItems = this.cloneArray(this.groupedData);
+            }
+            this.cachedItems = this.cloneArray(this.data);
+        }
+        if (changes.settings && !changes.settings.firstChange) {
+            this.settings = Object.assign(this.defaultSettings, this.settings);
+        }
+        if (changes.loading) {
+        }
+        if (this.settings.lazyLoading && this.virtualScroollInit && changes.data) {
+            this.virtualdata = changes.data.currentValue;
+        }
+    }
+    ngDoCheck() {
+        if (this.selectedItems) {
+            if (this.selectedItems.length == 0 ||
+                this.data.length == 0 ||
+                this.selectedItems.length < this.data.length) {
+                this.isSelectAll = false;
+            }
+        }
+    }
+    ngAfterViewInit() {
+        if (this.settings.lazyLoading) {
+            // this._elementRef.nativeElement.getElementsByClassName("lazyContainer")[0].addEventListener('scroll', this.onScroll.bind(this));
+        }
+    }
+    ngAfterViewChecked() {
+        if (this.selectedListElem.nativeElement.clientHeight &&
+            this.settings.position == 'top' &&
+            this.selectedListHeight) {
+            this.selectedListHeight.val =
+                this.selectedListElem.nativeElement.clientHeight;
+            this.cdr.detectChanges();
+        }
+        //this.calculateDropdownDirection();
+    }
+    onItemClick(item, index, evt) {
+        if (item.disabled) {
+            return;
+        }
+        if (this.settings.disabled) {
+            return;
+        }
+        let found = this.isSelected(item);
+        let limit = this.selectedItems.length < this.settings.limitSelection ? true : false;
+        if (!found) {
+            if (this.settings.limitSelection) {
+                if (limit) {
+                    this.addSelected(item);
+                    this.onSelect.emit(item);
+                }
+            }
+            else {
+                this.addSelected(item);
+                this.onSelect.emit(item);
+            }
+        }
+        else {
+            this.removeSelected(item);
+            this.onDeSelect.emit(item);
+        }
+        if (this.isSelectAll || this.data.length > this.selectedItems.length) {
+            this.isSelectAll = false;
+        }
+        if (this.data.length == this.selectedItems.length) {
+            this.isSelectAll = true;
+        }
+        if (this.settings.groupBy) {
+            this.updateGroupInfo(item);
+        }
+    }
+    validate(c) {
+        return null;
+    }
+    onTouchedCallback = noop;
+    onChangeCallback = noop;
+    writeValue(value) {
+        if (value !== undefined && value !== null && value !== '') {
+            if (this.settings.singleSelection) {
+                if (this.settings.groupBy) {
+                    this.groupedData = this.transformData(this.data, this.settings.groupBy);
+                    this.groupCachedItems = this.cloneArray(this.groupedData);
+                    this.selectedItems = [value[0]];
+                }
+                else {
+                    try {
+                        if (value.length > 1) {
+                            this.selectedItems = [value[0]];
+                            throw new MyException(404, {
+                                msg: 'Single Selection Mode, Selected Items cannot have more than one item.',
+                            });
+                        }
+                        else {
+                            this.selectedItems = value;
+                        }
+                    }
+                    catch (e) {
+                        console.error(e.body.msg);
+                    }
+                }
+            }
+            else {
+                if (this.settings.limitSelection) {
+                    this.selectedItems = value.slice(0, this.settings.limitSelection);
+                }
+                else {
+                    this.selectedItems = value;
+                }
+                if (this.selectedItems != null &&
+                    this.selectedItems.length === this.data.length &&
+                    this.data.length > 0) {
+                    this.isSelectAll = true;
+                }
+                if (this.settings.groupBy) {
+                    this.groupedData = this.transformData(this.data, this.settings.groupBy);
+                    this.groupCachedItems = this.cloneArray(this.groupedData);
+                }
+            }
+        }
+        else {
+            this.selectedItems = [];
+        }
+    }
+    //From ControlValueAccessor interface
+    registerOnChange(fn) {
+        this.onChangeCallback = fn;
+    }
+    //From ControlValueAccessor interface
+    registerOnTouched(fn) {
+        this.onTouchedCallback = fn;
+    }
+    trackByFn(index, item) {
+        return item[this.settings.primaryKey];
+    }
+    isSelected(clickedItem) {
+        if (clickedItem.disabled) {
+            return false;
+        }
+        let found = false;
+        this.selectedItems &&
+            this.selectedItems.forEach((item) => {
+                if (clickedItem[this.settings.primaryKey] ===
+                    item[this.settings.primaryKey]) {
+                    found = true;
+                }
+            });
+        return found;
+    }
+    addSelected(item) {
+        if (item.disabled) {
+            return;
+        }
+        if (this.settings.singleSelection) {
+            this.selectedItems = [];
+            this.selectedItems.push(item);
+            this.closeDropdown();
+        }
+        else
+            this.selectedItems = [...this.selectedItems, item];
+        this.onChangeCallback(this.selectedItems);
+        this.onTouchedCallback(this.selectedItems);
+    }
+    removeSelected(clickedItem) {
+        this.selectedItems &&
+            this.selectedItems.forEach((item) => {
+                if (clickedItem[this.settings.primaryKey] ===
+                    item[this.settings.primaryKey]) {
+                    this.selectedItems.splice(this.selectedItems.indexOf(item), 1);
+                }
+            });
+        this.onChangeCallback(this.selectedItems);
+        this.onTouchedCallback(this.selectedItems);
+    }
+    toggleDropdown(evt) {
+        if (this.settings.disabled) {
+            return;
+        }
+        this.isActive = !this.isActive;
+        if (this.isActive) {
+            this.openDropdown();
+        }
+        else {
+            this.closeDropdown();
+        }
+        if (this.settings.lazyLoading) {
+            this.virtualdata = this.data;
+            this.virtualScroollInit = true;
+        }
+        evt.preventDefault();
+    }
+    openDropdown() {
+        if (this.settings.disabled) {
+            return;
+        }
+        this.isActive = true;
+        this.calculateDropdownDirection();
+        if (this.settings.searchAutofocus &&
+            this.searchInput &&
+            this.settings.enableSearchFilter &&
+            !this.searchTempl) {
+            setTimeout(() => {
+                this.searchInput.nativeElement.focus();
+            }, 0);
+        }
+        this.onOpen.emit(true);
+    }
+    closeDropdown() {
+        if (this.searchInput && this.settings.lazyLoading) {
+            this.searchInput.nativeElement.value = '';
+        }
+        if (this.searchInput) {
+            this.searchInput.nativeElement.value = '';
+        }
+        this.filter = '';
+        this.isActive = false;
+        this.searchTerm$.next('');
+        this.onClose.emit(false);
+    }
+    closeDropdownOnClickOut() {
+        if (this.isActive) {
+            if (this.searchInput && this.settings.lazyLoading) {
+                this.searchInput.nativeElement.value = '';
+            }
+            if (this.searchInput) {
+                this.searchInput.nativeElement.value = '';
+            }
+            this.filter = '';
+            this.isActive = false;
+            this.clearSearch();
+            this.searchTerm$.next('');
+            this.onClose.emit(false);
+        }
+    }
+    toggleSelectAll(event) {
+        if (!this.isSelectAll) {
+            this.selectedItems = [];
+            if (this.settings.groupBy) {
+                this.groupedData.forEach((obj) => {
+                    obj.selected = !obj.disabled;
+                });
+                this.groupCachedItems.forEach((obj) => {
+                    obj.selected = !obj.disabled;
+                });
+            }
+            // this.selectedItems = this.data.slice();
+            this.selectedItems = this.data.filter((individualData) => !individualData.disabled);
+            this.isSelectAll = true;
+            this.onChangeCallback(this.selectedItems);
+            this.onTouchedCallback(this.selectedItems);
+            this.onSelectAll.emit(this.selectedItems);
+        }
+        else {
+            if (this.settings.groupBy) {
+                this.groupedData.forEach((obj) => {
+                    obj.selected = false;
+                });
+                this.groupCachedItems.forEach((obj) => {
+                    obj.selected = false;
+                });
+            }
+            this.selectedItems = [];
+            this.isSelectAll = false;
+            this.onChangeCallback(this.selectedItems);
+            this.onTouchedCallback(this.selectedItems);
+            this.onDeSelectAll.emit(this.selectedItems);
+        }
+        setTimeout(() => {
+            this.calculateDropdownDirection();
+        });
+        event.stopPropagation();
+    }
+    filterGroupedList() {
+        if (this.filter == '' || this.filter == null) {
+            this.clearSearch();
+            return;
+        }
+        this.groupedData = this.cloneArray(this.groupCachedItems);
+        this.groupedData = this.groupedData.filter((obj) => {
+            let arr = [];
+            if (obj[this.settings.labelKey]
+                .toLowerCase()
+                .indexOf(this.filter.toLowerCase()) > -1) {
+                arr = obj.list;
+            }
+            else {
+                arr = obj.list.filter((t) => {
+                    return (t[this.settings.labelKey]
+                        .toLowerCase()
+                        .indexOf(this.filter.toLowerCase()) > -1);
+                });
+            }
+            obj.list = arr;
+            if (obj[this.settings.labelKey]
+                .toLowerCase()
+                .indexOf(this.filter.toLowerCase()) > -1) {
+                return arr;
+            }
+            else {
+                return arr.some((cat) => {
+                    return (cat[this.settings.labelKey]
+                        .toLowerCase()
+                        .indexOf(this.filter.toLowerCase()) > -1);
+                });
+            }
+        });
+    }
+    toggleFilterSelectAll() {
+        if (!this.isFilterSelectAll) {
+            let added = [];
+            if (this.settings.groupBy) {
+                this.groupedData.forEach((item) => {
+                    item.sele;
+                    if (item.list) {
+                        item.list.forEach((el) => {
+                            if (!this.isSelected(el)) {
+                                this.addSelected(el);
+                                added.push(el);
+                            }
+                        });
+                    }
+                    this.updateGroupInfo(item);
+                });
+                this.filteredList.forEach((el) => {
+                    if (!this.isSelected(el) && !el.hasOwnProperty('grpTitle')) {
+                        this.addSelected(el);
+                        added.push(el);
+                    }
+                });
+            }
+            else {
+                this.filteredList.forEach((item) => {
+                    if (!this.isSelected(item)) {
+                        this.addSelected(item);
+                        added.push(item);
+                    }
+                });
+            }
+            this.isFilterSelectAll = true;
+            this.onFilterSelectAll.emit(added);
+        }
+        else {
+            let removed = [];
+            if (this.settings.groupBy) {
+                this.groupedData.forEach((item) => {
+                    if (item.list) {
+                        item.list.forEach((el) => {
+                            if (this.isSelected(el)) {
+                                this.removeSelected(el);
+                                removed.push(el);
+                            }
+                        });
+                    }
+                    this.updateGroupInfo(item);
+                });
+                this.filteredList.forEach((el) => {
+                    if (this.isSelected(el)) {
+                        this.removeSelected(el);
+                        removed.push(el);
+                    }
+                });
+            }
+            else {
+                this.filteredList.forEach((item) => {
+                    if (this.isSelected(item)) {
+                        this.removeSelected(item);
+                        removed.push(item);
+                    }
+                });
+            }
+            this.isFilterSelectAll = false;
+            this.onFilterDeSelectAll.emit(removed);
+        }
+    }
+    toggleInfiniteFilterSelectAll() {
+        if (!this.isInfiniteFilterSelectAll) {
+            this.virtualdata.forEach((item) => {
+                if (!this.isSelected(item)) {
+                    this.addSelected(item);
+                }
+            });
+            this.isInfiniteFilterSelectAll = true;
+        }
+        else {
+            this.virtualdata.forEach((item) => {
+                if (this.isSelected(item)) {
+                    this.removeSelected(item);
+                }
+            });
+            this.isInfiniteFilterSelectAll = false;
+        }
+    }
+    clearSearch() {
+        if (this.settings.groupBy) {
+            this.groupedData = [];
+            this.groupedData = this.cloneArray(this.groupCachedItems);
+        }
+        this.filter = '';
+        this.isFilterSelectAll = false;
+        this.searchTerm$.next('');
+        this.data = this.cachedItems;
+    }
+    onFilterChange(data) {
+        if ((this.filter && this.filter == '') || data.length == 0) {
+            this.isFilterSelectAll = false;
+            this.data = this.cachedItems.slice();
+        }
+        let cnt = 0;
+        data.forEach((item) => {
+            if (!item.hasOwnProperty('grpTitle') && this.isSelected(item)) {
+                cnt++;
+            }
+        });
+        if (cnt > 0 && this.filterLength == cnt) {
+            this.isFilterSelectAll = true;
+        }
+        else if (cnt > 0 && this.filterLength != cnt) {
+            this.isFilterSelectAll = false;
+        }
+        this.data = data;
+    }
+    cloneArray(arr) {
+        let i, copy;
+        if (Array.isArray(arr)) {
+            return JSON.parse(JSON.stringify(arr));
+        }
+        else if (typeof arr === 'object') {
+            throw 'Cannot clone array containing an object!';
+        }
+        else {
+            return arr;
+        }
+    }
+    updateGroupInfo(item) {
+        if (item.disabled) {
+            return;
+        }
+        let key = this.settings.groupBy;
+        this.groupedData.forEach((obj) => {
+            let cnt = 0;
+            if (obj.grpTitle && item[key] == obj[key]) {
+                if (obj.list) {
+                    obj.list.forEach((el) => {
+                        if (this.isSelected(el)) {
+                            cnt++;
+                        }
+                    });
+                }
+            }
+            if (obj.list && cnt === obj.list.length && item[key] == obj[key]) {
+                obj.selected = true;
+            }
+            else if (obj.list && cnt != obj.list.length && item[key] == obj[key]) {
+                obj.selected = false;
+            }
+        });
+        this.groupCachedItems.forEach((obj) => {
+            let cnt = 0;
+            if (obj.grpTitle && item[key] == obj[key]) {
+                if (obj.list) {
+                    obj.list.forEach((el) => {
+                        if (this.isSelected(el)) {
+                            cnt++;
+                        }
+                    });
+                }
+            }
+            if (obj.list && cnt === obj.list.length && item[key] == obj[key]) {
+                obj.selected = true;
+            }
+            else if (obj.list && cnt != obj.list.length && item[key] == obj[key]) {
+                obj.selected = false;
+            }
+        });
+    }
+    transformData(arr, field) {
+        const groupedObj = arr.reduce((prev, cur) => {
+            if (!prev[cur[field]]) {
+                prev[cur[field]] = [cur];
+            }
+            else {
+                prev[cur[field]].push(cur);
+            }
+            return prev;
+        }, {});
+        const tempArr = [];
+        Object.keys(groupedObj).map((x) => {
+            let obj = {};
+            let disabledChildrens = [];
+            obj['grpTitle'] = true;
+            obj[this.settings.labelKey] = x;
+            obj[this.settings.groupBy] = x;
+            obj['selected'] = false;
+            obj['list'] = [];
+            let cnt = 0;
+            groupedObj[x].forEach((item) => {
+                item['list'] = [];
+                if (item.disabled) {
+                    this.isDisabledItemPresent = true;
+                    disabledChildrens.push(item);
+                }
+                obj.list.push(item);
+                if (this.isSelected(item)) {
+                    cnt++;
+                }
+            });
+            if (cnt == obj.list.length) {
+                obj.selected = true;
+            }
+            else {
+                obj.selected = false;
+            }
+            // Check if current group item's all childrens are disabled or not
+            obj['disabled'] = disabledChildrens.length === groupedObj[x].length;
+            tempArr.push(obj);
+            // obj.list.forEach((item: any) => {
+            //     tempArr.push(item);
+            // });
+        });
+        return tempArr;
+    }
+    filterInfiniteList(evt) {
+        let filteredElems = [];
+        if (this.settings.groupBy) {
+            this.groupedData = this.groupCachedItems.slice();
+        }
+        else {
+            this.data = this.cachedItems.slice();
+            this.virtualdata = this.cachedItems.slice();
+        }
+        if ((evt != null || evt != '') && !this.settings.groupBy) {
+            if (this.settings.searchBy.length > 0) {
+                for (let t = 0; t < this.settings.searchBy.length; t++) {
+                    this.virtualdata.filter((el) => {
+                        if (el[this.settings.searchBy[t].toString()]
+                            .toString()
+                            .toLowerCase()
+                            .indexOf(evt.toString().toLowerCase()) >= 0) {
+                            filteredElems.push(el);
+                        }
+                    });
+                }
+            }
+            else {
+                this.virtualdata.filter(function (el) {
+                    for (let prop in el) {
+                        if (el[prop]
+                            .toString()
+                            .toLowerCase()
+                            .indexOf(evt.toString().toLowerCase()) >= 0) {
+                            filteredElems.push(el);
+                            break;
+                        }
+                    }
+                });
+            }
+            this.virtualdata = [];
+            this.virtualdata = filteredElems;
+            this.infiniteFilterLength = this.virtualdata.length;
+        }
+        if (evt.toString() != '' && this.settings.groupBy) {
+            this.groupedData.filter(function (el) {
+                if (el.hasOwnProperty('grpTitle')) {
+                    filteredElems.push(el);
+                }
+                else {
+                    for (let prop in el) {
+                        if (el[prop]
+                            .toString()
+                            .toLowerCase()
+                            .indexOf(evt.toString().toLowerCase()) >= 0) {
+                            filteredElems.push(el);
+                            break;
+                        }
+                    }
+                }
+            });
+            this.groupedData = [];
+            this.groupedData = filteredElems;
+            this.infiniteFilterLength = this.groupedData.length;
+        }
+        else if (evt.toString() == '' && this.cachedItems.length > 0) {
+            this.virtualdata = [];
+            this.virtualdata = this.cachedItems;
+            this.infiniteFilterLength = 0;
+        }
+        if (this.virtualScroller) {
+            this.virtualScroller.refresh();
+        }
+    }
+    resetInfiniteSearch() {
+        this.filter = '';
+        this.isInfiniteFilterSelectAll = false;
+        this.virtualdata = [];
+        this.virtualdata = this.cachedItems;
+        this.groupedData = this.groupCachedItems;
+        this.searchTerm$.next('');
+        this.infiniteFilterLength = 0;
+    }
+    onScrollEnd(e) {
+        if (e.endIndex === this.data.length - 1 || e.startIndex === 0) {
+        }
+        this.onScrollToEnd.emit(e);
+    }
+    ngOnDestroy() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+    }
+    selectGroup(item) {
+        if (item.disabled) {
+            return;
+        }
+        if (item.selected) {
+            item.selected = false;
+            item.list.forEach((obj) => {
+                this.removeSelected(obj);
+            });
+            this.onGroupDeSelect.emit(item);
+            this.updateGroupInfo(item);
+        }
+        else {
+            item.selected = true;
+            item.list.forEach((obj) => {
+                if (!this.isSelected(obj)) {
+                    this.addSelected(obj);
+                }
+            });
+            this.onGroupSelect.emit(item);
+            this.updateGroupInfo(item);
+        }
+    }
+    addFilterNewItem() {
+        this.onAddFilterNewItem.emit(this.filter);
+        this.filterPipe.transform(this.data, this.filter, this.settings.searchBy);
+    }
+    calculateDropdownDirection() {
+        let shouldOpenTowardsTop = this.settings.position == 'top';
+        const elem = this.cuppaDropdown.nativeElement;
+        const dropdownWidth = elem.clientWidth;
+        this.dropDownWidth = dropdownWidth;
+        this.dropDownLeft = this.settings.tagToBody
+            ? elem.getBoundingClientRect().x
+            : 'unset';
+        if (this.settings.position == 'top' && !this.settings.autoPosition) {
+            this.openTowardsTop(true);
+        }
+        else if (this.settings.position == 'bottom' &&
+            !this.settings.autoPosition) {
+            this.openTowardsTop(false);
+        }
+        if (this.settings.autoPosition) {
+            const dropdownHeight = this.defaultSettings.maxHeight;
+            const viewportHeight = document.documentElement.clientHeight;
+            const selectedListBounds = this.selectedListElem.nativeElement.getBoundingClientRect();
+            const spaceOnTop = selectedListBounds.top;
+            const spaceOnBottom = viewportHeight - selectedListBounds.top;
+            if (spaceOnBottom < spaceOnTop && dropdownHeight < spaceOnTop) {
+                this.openTowardsTop(true);
+            }
+            else {
+                this.openTowardsTop(false);
+            }
+            // Keep preference if there is not enough space on either the top or bottom
+            /* 			if (spaceOnTop || spaceOnBottom) {
+                                  if (shouldOpenTowardsTop) {
+                                      shouldOpenTowardsTop = spaceOnTop;
+                                  } else {
+                                      shouldOpenTowardsTop = !spaceOnBottom;
+                                  }
+                              } */
+        }
+    }
+    openTowardsTop(value) {
+        const elem = this.cuppaDropdown.nativeElement;
+        if (value && this.selectedListElem.nativeElement.clientHeight) {
+            this.dropdownListYOffset =
+                15 - this.selectedListElem.nativeElement.clientHeight;
+            if (this.settings.tagToBody) {
+                this.dropDownTop =
+                    elem.getBoundingClientRect().y -
+                        this.selectedListElem.nativeElement.clientHeight * 2 -
+                        15 -
+                        this.defaultSettings.maxHeight +
+                        'px';
+            }
+            else {
+                this.dropDownBottom =
+                    this.selectedListElem.nativeElement.clientHeight + 15 + 'px';
+            }
+            this.settings.position = 'top';
+        }
+        else {
+            if (this.settings.tagToBody) {
+                this.dropDownTop =
+                    elem.getBoundingClientRect().y + elem.clientHeight + 1 + 'px';
+            }
+            else {
+                this.dropDownTop = 'unset';
+                this.dropDownBottom = 'unset';
+            }
+            this.dropdownListYOffset = 0;
+            this.settings.position = 'bottom';
+        }
+    }
+    clearSelection(e) {
+        if (this.settings.groupBy) {
+            this.groupCachedItems.forEach((obj) => {
+                obj.selected = false;
+            });
+        }
+        this.clearSearch();
+        this.selectedItems = [];
+        this.isSelectAll = false;
+        this.onChangeCallback(this.selectedItems);
+        this.onTouchedCallback(this.selectedItems);
+        this.onDeSelectAll.emit(this.selectedItems);
+    }
+    filteritems(evt) {
+        this.filteredList = this.filterPipe.transform(this.cachedItems, evt.target.value, this.settings.searchBy);
+        if (this.filteredList) {
+            let len = 0;
+            this.filteredList.forEach((obj, i) => {
+                if (obj.disabled) {
+                    this.isDisabledItemPresent = true;
+                }
+                if (!obj.hasOwnProperty('grpTitle')) {
+                    len++;
+                }
+            });
+            this.filterLength = len;
+        }
+        this.onFilterChange(this.filteredList);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AngularMultiSelect, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i1.ListFilterPipe }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: AngularMultiSelect, selector: "angular2-multiselect", inputs: { data: "data", settings: "settings", loading: "loading" }, outputs: { onSelect: "onSelect", onDeSelect: "onDeSelect", onSelectAll: "onSelectAll", onDeSelectAll: "onDeSelectAll", onOpen: "onOpen", onClose: "onClose", onScrollToEnd: "onScrollToEnd", onFilterSelectAll: "onFilterSelectAll", onFilterDeSelectAll: "onFilterDeSelectAll", onAddFilterNewItem: "onAddFilterNewItem", onGroupSelect: "onGroupSelect", onGroupDeSelect: "onGroupDeSelect" }, host: { listeners: { "document:keyup.escape": "onEscapeDown($event)", "window:scroll": "onScroll($event)" }, properties: { "class": "defaultSettings.classes" } }, providers: [DROPDOWN_CONTROL_VALUE_ACCESSOR, DROPDOWN_CONTROL_VALIDATION], queries: [{ propertyName: "itemTempl", first: true, predicate: Item, descendants: true }, { propertyName: "badgeTempl", first: true, predicate: Badge, descendants: true }, { propertyName: "searchTempl", first: true, predicate: Search, descendants: true }], viewQueries: [{ propertyName: "searchInput", first: true, predicate: ["searchInput"], descendants: true }, { propertyName: "selectedListElem", first: true, predicate: ["selectedList"], descendants: true }, { propertyName: "dropdownListElem", first: true, predicate: ["dropdownList"], descendants: true }, { propertyName: "cuppaDropdown", first: true, predicate: ["cuppaDropdown"], descendants: true }, { propertyName: "virtualScroller", first: true, predicate: VirtualScrollerComponent, descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div class=\"cuppa-dropdown\" (clickOutside)=\"closeDropdownOnClickOut()\" [enabled]=\"isActive\" #cuppaDropdown>\n  <div class=\"selected-list\" #selectedList>\n    <div class=\"c-btn\" (click)=\"toggleDropdown($event)\" [ngClass]=\"{'disabled': settings.disabled}\" [attr.tabindex]=\"0\">\n\n      <span *ngIf=\"selectedItems?.length == 0\">{{ settings.text }}</span>\n      <span *ngIf=\"settings.singleSelection && !badgeTempl\">\n                <span *ngFor=\"let item of selectedItems;trackBy: trackByFn.bind(this);let k = index\">\n                    {{ item[settings.labelKey] }}\n                </span>\n            </span>\n      <span class=\"c-list\" *ngIf=\"selectedItems?.length > 0 && settings.singleSelection && badgeTempl \">\n                <div class=\"c-token\" *ngFor=\"let item of selectedItems;trackBy: trackByFn.bind(this);let k = index\">\n                    <span *ngIf=\"!badgeTempl\" class=\"c-label\">{{ item[settings.labelKey] }}</span>\n\n                    <span *ngIf=\"badgeTempl\" class=\"c-label\">\n                        <c-templateRenderer [data]=\"badgeTempl\" [item]=\"item\"></c-templateRenderer>\n                    </span>\n                    <span class=\"c-remove\" (click)=\"onItemClick(item,k,$event);$event.stopPropagation()\">\n                        <c-icon name=\"remove\"/>\n                    </span>\n                </div>\n            </span>\n      <div class=\"c-list\" *ngIf=\"selectedItems?.length > 0 && !settings.singleSelection\">\n        <div class=\"c-token\" *ngFor=\"let item of selectedItems;trackBy: trackByFn.bind(this);let k = index\"\n             [hidden]=\"k > settings.badgeShowLimit-1\">\n\n          @if (badgeTempl) {\n            <span class=\"c-label\"><c-templateRenderer [data]=\"badgeTempl\" [item]=\"item\"></c-templateRenderer></span>\n          } @else {\n            <span class=\"c-label\">{{ item[settings.labelKey] }}</span>\n\n          }\n\n          <span class=\"c-remove\" (click)=\"onItemClick(item,k,$event);$event.stopPropagation()\">\n                        <c-icon [name]=\"'remove'\"></c-icon>\n                    </span>\n        </div>\n      </div>\n      <span class=\"countplaceholder\"\n            *ngIf=\"selectedItems?.length > settings.badgeShowLimit\">+{{ selectedItems?.length - settings.badgeShowLimit }}</span>\n      <span class=\"c-remove clear-all\" *ngIf=\"settings.clearAll && selectedItems?.length > 0 && !settings.disabled\"\n            (click)=\"clearSelection($event);$event.stopPropagation()\">\n                <c-icon [name]=\"'remove'\"></c-icon>\n            </span>\n      @if (isActive) {\n        <span class=\"c-angle-up\"><c-icon [name]=\"'angle-up'\"></c-icon></span>\n      } @else {\n        <span class=\"c-angle-down\"><c-icon [name]=\"'angle-down'\"></c-icon></span>\n      }\n    </div>\n  </div>\n  <div #dropdownList class=\"dropdown-list animated fadeIn\"\n       [ngClass]=\"{'tagToBody': settings.tagToBody}\"\n       [style.width.px]=\"dropDownWidth\"\n       [style.top]=\"dropDownTop\"\n       [style.bottom]=\"dropDownBottom\"\n       [style.left.px]=\"dropDownLeft\"\n       [hidden]=\"!isActive\">\n    <div [ngClass]=\"{'arrow-up': settings.position == 'bottom', 'arrow-down': settings.position == 'top'}\"\n         class=\"arrow-2\"></div>\n    <div [ngClass]=\"{'arrow-up': settings.position == 'bottom', 'arrow-down': settings.position == 'top'}\"></div>\n    <div class=\"list-area\" [ngClass]=\"{'single-select-mode': settings.singleSelection }\">\n      <div class=\"pure-checkbox select-all\"\n           *ngIf=\"settings.enableCheckAll && !settings.singleSelection && !settings.limitSelection && data?.length > 0 && !isDisabledItemPresent\"\n      >\n        <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelectAll\"\n               [disabled]=\"settings.limitSelection == selectedItems?.length\"\n               [id]=\"id\" (change)=\"toggleSelectAll($event)\"/>\n        <label [for]=\"id\">\n          <span [hidden]=\"isSelectAll\">{{ settings.selectAllText }}</span>\n          <span [hidden]=\"!isSelectAll\">{{ settings.unSelectAllText }}</span>\n        </label>\n      </div>\n      <img class=\"loading-icon\" *ngIf=\"loading\" src=\"assets/img/loading.gif\"/>\n      <div class=\"list-filter\" *ngIf=\"settings.enableSearchFilter\">\n                <span class=\"c-search\" id=\"searchIcon\">\n                    <c-icon [name]=\"'search'\"></c-icon>\n                </span>\n        <span *ngIf=\"!settings.lazyLoading\" [hidden]=\"filter == undefined || filter?.length == 0\" class=\"c-clear\"\n              (click)=\"clearSearch()\">\n                    <c-icon [name]=\"'clear'\"></c-icon>\n                </span>\n        <span *ngIf=\"settings.lazyLoading\" [hidden]=\"filter == undefined || filter?.length == 0\" class=\"c-clear\"\n              (click)=\"resetInfiniteSearch()\">\n                    <c-icon [name]=\"'clear'\"></c-icon>\n                </span>\n\n        <input class=\"c-input\" *ngIf=\"settings.groupBy && !settings.lazyLoading && !searchTempl\" #searchInput\n               type=\"text\" [placeholder]=\"settings.searchPlaceholderText\"\n               [(ngModel)]=\"filter\" (keyup)=\"filterGroupedList()\" aria-labelledby=\"searchIcon\">\n        <input class=\"c-input\" *ngIf=\"!settings.groupBy && !settings.lazyLoading && !searchTempl\" #searchInput\n               type=\"text\" [placeholder]=\"settings.searchPlaceholderText\"\n               [(ngModel)]=\"filter\" (keyup)=\"filteritems($event)\" aria-labelledby=\"searchIcon\">\n        <input class=\"c-input\" *ngIf=\"settings.lazyLoading && !searchTempl\" #searchInput type=\"text\"\n               [placeholder]=\"settings.searchPlaceholderText\"\n               [(ngModel)]=\"filter\" (keyup)=\"onKeyUp($event)\" aria-labelledby=\"searchIcon\">\n        <!--            <input class=\"c-input\" *ngIf=\"!settings.lazyLoading && !searchTempl && settings.groupBy\" #searchInput type=\"text\" [placeholder]=\"settings.searchPlaceholderText\"\n        [(ngModel)]=\"filter\" (keyup)=\"filterGroupList($event)\">-->\n        <c-templateRenderer *ngIf=\"searchTempl\" [data]=\"searchTempl\" [item]=\"item\"></c-templateRenderer>\n      </div>\n      <div class=\"filter-select-all\"\n           *ngIf=\"!settings.lazyLoading && settings.enableFilterSelectAll && !isDisabledItemPresent\">\n        <div class=\"pure-checkbox select-all\"\n             *ngIf=\"!settings.groupBy && filter?.length > 0 && filterLength > 0  && !settings.singleSelection\"\n             (click)=\"toggleFilterSelectAll()\">\n          <input type=\"checkbox\" [checked]=\"isFilterSelectAll\"\n                 [disabled]=\"settings.limitSelection == selectedItems?.length\" aria-labelledby=\"optionName\"\n                 aria-label=\"option\"/>\n          <label>\n            <span [hidden]=\"isFilterSelectAll\">{{ settings.filterSelectAllText }}</span>\n            <span [hidden]=\"!isFilterSelectAll\">{{ settings.filterUnSelectAllText }}</span>\n          </label>\n        </div>\n        <div class=\"pure-checkbox select-all\"\n             *ngIf=\"settings.groupBy && filter?.length > 0 && groupedData?.length > 0  && !settings.singleSelection\"\n             (click)=\"toggleFilterSelectAll()\">\n          <input type=\"checkbox\" [checked]=\"isFilterSelectAll && filter?.length > 0\"\n                 [disabled]=\"settings.limitSelection == selectedItems?.length\"\n                 aria-labelledby=\"option\"/>\n          <label>\n            <span [hidden]=\"isFilterSelectAll\">{{ settings.filterSelectAllText }}</span>\n            <span [hidden]=\"!isFilterSelectAll\">{{ settings.filterUnSelectAllText }}</span>\n          </label>\n        </div>\n      </div>\n      <div class=\"filter-select-all\"\n           *ngIf=\"settings.lazyLoading && settings.enableFilterSelectAll && !isDisabledItemPresent && !settings.singleSelection\">\n        <div class=\"pure-checkbox select-all\" *ngIf=\"filter?.length > 0 && infiniteFilterLength > 0\"\n             (click)=\"toggleInfiniteFilterSelectAll()\">\n          <input type=\"checkbox\" [checked]=\"isInfiniteFilterSelectAll\"\n                 [disabled]=\"settings.limitSelection == selectedItems?.length\"\n                 aria-labelledby=\"option\"/>\n          <label>\n            <span [hidden]=\"isInfiniteFilterSelectAll\">{{ settings.filterSelectAllText }}</span>\n            <span [hidden]=\"!isInfiniteFilterSelectAll\">{{ settings.filterUnSelectAllText }}</span>\n          </label>\n        </div>\n      </div>\n      <div class=\"filter-select-all\" *ngIf=\"filter?.length\">\n        <div class=\"btn-container\" *ngIf=\"settings.addNewItemOnFilter\">\n          <button class=\"c-btn btn-iceblue\" (click)=\"addFilterNewItem()\">{{ settings.addNewButtonText }}</button>\n        </div>\n      </div>\n\n      <div *ngIf=\"!settings.groupBy && !settings.lazyLoading && itemTempl == undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <ul class=\"lazyContainer\">\n          <li *ngFor=\"let item of data; let i = index;\" (click)=\"onItemClick(item,i,$event)\"\n              class=\"pure-checkbox\" [ngClass]=\"{'selected-item': isSelected(item) == true }\">\n            <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(item)\"\n                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n                   aria-labelledby=\"option\"/>\n            <label>{{ item[settings.labelKey] }}</label>\n          </li>\n        </ul>\n      </div>\n      <!-- lazy loading -->\n      <div *ngIf=\"!settings.groupBy && settings.lazyLoading && itemTempl == undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <ul virtualScroller #scroll [enableUnequalChildrenSizes]=\"randomSize\" [items]=\"virtualdata\"\n            (vsStart)=\"onScrollEnd($event)\"\n            (vsEnd)=\"onScrollEnd($event)\" [ngStyle]=\"{'height': settings.maxHeight+'px'}\" class=\"lazyContainer\">\n          <li *ngFor=\"let item of scroll.viewPortItems; let i = index;\" (click)=\"onItemClick(item,i,$event)\"\n              class=\"pure-checkbox\"\n              [ngClass]=\"{'selected-item': isSelected(item) == true }\">\n            <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(item)\"\n                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n            />\n            <label>{{ item[settings.labelKey] }}</label>\n          </li>\n        </ul>\n      </div>\n      <!-- custom template -->\n      <div *ngIf=\"!settings.groupBy && !settings.lazyLoading && itemTempl != undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <ul class=\"lazyContainer\">\n          <li *ngFor=\"let item of data; let i = index;\" (click)=\"onItemClick(item,i,$event)\"\n              class=\"pure-checkbox\" [ngClass]=\"{'selected-item': isSelected(item) == true }\">\n            <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(item)\"\n                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n            />\n            <label></label>\n            <c-templateRenderer [data]=\"itemTempl\" [item]=\"item\"></c-templateRenderer>\n          </li>\n        </ul>\n      </div>\n      <!-- lazy loading and custom template -->\n      <div *ngIf=\"!settings.groupBy && settings.lazyLoading && itemTempl != undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <ul virtualScroller #scroll2 [enableUnequalChildrenSizes]=\"randomSize\" [items]=\"virtualdata\"\n            (vsStart)=\"onScrollEnd($event)\"\n            (vsEnd)=\"onScrollEnd($event)\" class=\"lazyContainer\" [ngStyle]=\"{'height': settings.maxHeight+'px'}\">\n          <li *ngFor=\"let item of scroll2.viewPortItems; let i = index;\" (click)=\"onItemClick(item,i,$event)\"\n              class=\"pure-checkbox\"\n              [ngClass]=\"{'selected-item': isSelected(item) == true }\">\n            <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(item)\"\n                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n            />\n            <label></label>\n            <c-templateRenderer [data]=\"itemTempl\" [item]=\"item\"></c-templateRenderer>\n          </li>\n        </ul>\n      </div>\n      <!-- lazy loading, group By and custom template -->\n      <div *ngIf=\"settings.groupBy && settings.lazyLoading && itemTempl != undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <ul virtualScroller #scroll3 [enableUnequalChildrenSizes]=\"randomSize\" [items]=\"virtualdata\"\n            (vsStart)=\"onScrollEnd($event)\"\n            (vsEnd)=\"onScrollEnd($event)\" [ngStyle]=\"{'height': settings.maxHeight+'px'}\" class=\"lazyContainer\">\n                    <span *ngFor=\"let item of scroll3.viewPortItems; let i = index;\">\n                        <li (click)=\"onItemClick(item,i,$event)\" *ngIf=\"!item.grpTitle\"\n                            [ngClass]=\"{'grp-title': item.grpTitle,'grp-item': !item.grpTitle && !settings.singleSelection}\"\n                            class=\"pure-checkbox\">\n                            <input *ngIf=\"settings.showCheckbox && !settings.singleSelection\" type=\"checkbox\"\n                                   [checked]=\"isSelected(item)\"\n                                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n                            />\n                            <label></label>\n                            <c-templateRenderer [data]=\"itemTempl\" [item]=\"item\"></c-templateRenderer>\n                        </li>\n                        <li *ngIf=\"item.grpTitle\"\n                            [ngClass]=\"{'grp-title': item.grpTitle,'grp-item': !item.grpTitle && !settings.singleSelection}\"\n                            class=\"pure-checkbox\">\n                            <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(item)\"\n                                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n                            />\n                            <label></label>\n                            <c-templateRenderer [data]=\"itemTempl\" [item]=\"item\"></c-templateRenderer>\n                        </li>\n                    </span>\n        </ul>\n      </div>\n      <!-- group By and custom template -->\n      <div *ngIf=\"settings.groupBy && !settings.lazyLoading && itemTempl != undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <ul class=\"lazyContainer\">\n                    <span *ngFor=\"let item of groupedData; let i = index;\">\n                        <li (click)=\"selectGroup(item)\"\n                            [ngClass]=\"{'grp-title': item.grpTitle,'grp-item': !item.grpTitle && !settings.singleSelection}\"\n                            class=\"pure-checkbox\">\n                            <input *ngIf=\"settings.showCheckbox && !settings.singleSelection\" type=\"checkbox\"\n                                   [checked]=\"item.selected\"\n                                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n                            />\n                            <label>{{ item[settings.labelKey] }}</label>\n                            <ul class=\"lazyContainer\">\n                                <span *ngFor=\"let val of item.list ; let j = index;\">\n                                    <li (click)=\"onItemClick(val,j,$event); $event.stopPropagation()\"\n                                        [ngClass]=\"{'grp-title': val.grpTitle,'grp-item': !val.grpTitle && !settings.singleSelection}\"\n                                        class=\"pure-checkbox\">\n                                        <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(val)\"\n                                               [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(val)) || val.disabled\"\n                                        />\n                                        <label></label>\n                                        <c-templateRenderer [data]=\"itemTempl\" [item]=\"val\"></c-templateRenderer>\n                                    </li>\n                                </span>\n                            </ul>\n\n                        </li>\n                    </span>\n        </ul>\n      </div>\n      <!-- lazy loading, group By -->\n      <div *ngIf=\"settings.groupBy && settings.lazyLoading && itemTempl == undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <virtual-scroller [items]=\"groupedData\" (vsUpdate)=\"viewPortItems = $event\" (vsEnd)=\"onScrollEnd($event)\"\n                          [ngStyle]=\"{'height': settings.maxHeight+'px'}\">\n          <ul virtualScroller #scroll4 [enableUnequalChildrenSizes]=\"randomSize\" [items]=\"virtualdata\"\n              (vsStart)=\"onScrollEnd($event)\"\n              (vsEnd)=\"onScrollEnd($event)\" [ngStyle]=\"{'height': settings.maxHeight+'px'}\" class=\"lazyContainer\">\n                        <span *ngFor=\"let item of scroll4.viewPortItems; let i = index;\">\n                            <li *ngIf=\"item.grpTitle\"\n                                [ngClass]=\"{'grp-title': item.grpTitle,'grp-item': !item.grpTitle && !settings.singleSelection, 'selected-item': isSelected(item) == true }\"\n                                class=\"pure-checkbox\">\n                                <input *ngIf=\"settings.showCheckbox && !item.grpTitle && !settings.singleSelection\"\n                                       type=\"checkbox\" [checked]=\"isSelected(item)\"\n                                       [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n                                />\n                                <label>{{ item[settings.labelKey] }}</label>\n                            </li>\n                            <li (click)=\"onItemClick(item,i,$event)\" *ngIf=\"!item.grpTitle\"\n                                [ngClass]=\"{'grp-title': item.grpTitle,'grp-item': !item.grpTitle && !settings.singleSelection, 'selected-item': isSelected(item) == true }\"\n                                class=\"pure-checkbox\">\n                                <input *ngIf=\"settings.showCheckbox && !item.grpTitle\" type=\"checkbox\"\n                                       [checked]=\"isSelected(item)\"\n                                       [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n                                />\n                                <label>{{ item[settings.labelKey] }}</label>\n                            </li>\n                        </span>\n          </ul>\n        </virtual-scroller>\n      </div>\n      <!-- group By -->\n      <div *ngIf=\"settings.groupBy && !settings.lazyLoading && itemTempl == undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <ul class=\"lazyContainer\">\n                    <span *ngFor=\"let item of groupedData ; let i = index;\">\n                        <li (click)=\"selectGroup(item)\"\n                            [ngClass]=\"{'grp-title': item.grpTitle,'grp-item': !item.grpTitle && !settings.singleSelection}\"\n                            class=\"pure-checkbox\">\n                            <input *ngIf=\"settings.showCheckbox && !settings.singleSelection\" type=\"checkbox\"\n                                   [checked]=\"item.selected\"\n                                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n                            />\n                            <label>{{ item[settings.labelKey] }}</label>\n                            <ul class=\"lazyContainer\">\n                                <span *ngFor=\"let val of item.list ; let j = index;\">\n                                    <li (click)=\"onItemClick(val,j,$event); $event.stopPropagation()\"\n                                        [ngClass]=\"{'selected-item': isSelected(val) == true,'grp-title': val.grpTitle,'grp-item': !val.grpTitle && !settings.singleSelection}\"\n                                        class=\"pure-checkbox\">\n                                        <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(val)\"\n                                               [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(val)) || val.disabled\"\n                                        />\n                                        <label>{{ val[settings.labelKey] }}</label>\n                                    </li>\n                                </span>\n                            </ul>\n                        </li>\n                    </span>\n        </ul>\n      </div>\n      <h5 class=\"list-message\" *ngIf=\"data?.length == 0\">{{ settings.noDataLabel }}</h5>\n    </div>\n  </div>\n</div>\n", styles: ["virtual-scroll{display:block;width:100%}.cuppa-dropdown{position:relative}.c-btn{display:inline-block;border-width:1px;line-height:1.25;border-radius:3px;font-size:.85rem;padding:5px 10px;cursor:pointer;align-items:center;min-height:38px}.c-btn.disabled{background:#ccc}.selected-list .c-list{float:left;padding:0;margin:0;width:calc(100% - 20px)}.selected-list .c-list .c-token{list-style:none;padding:4px 22px 4px 8px;border-radius:2px;margin-right:4px;margin-top:2px;float:left;position:relative}.selected-list .c-list .c-token .c-label{display:block;float:left}.selected-list .c-list .c-token .c-remove{position:absolute;right:8px;top:50%;transform:translateY(-50%);width:8px}.selected-list .c-list .c-token .c-remove svg{fill:#fff}.selected-list .fa-angle-down,.selected-list .fa-angle-up{font-size:15pt;position:absolute;right:10px;top:50%;transform:translateY(-50%)}.selected-list .c-angle-down,.selected-list .c-angle-up{width:12px;height:12px;position:absolute;right:10px;top:50%;transform:translateY(-50%);pointer-events:none}.selected-list .c-angle-down svg,.selected-list .c-angle-up svg{fill:#333}.selected-list .countplaceholder{position:absolute;right:45px;top:50%;transform:translateY(-50%)}.selected-list .c-btn{width:100%;padding:5px 10px;cursor:pointer;display:flex;position:relative}.selected-list .c-btn .c-icon{position:absolute;right:5px;top:50%;transform:translateY(-50%)}.dropdown-list.tagToBody{position:fixed}.dropdown-list{position:absolute;padding-top:14px;width:100%;z-index:99999}.dropdown-list ul{padding:0;list-style:none;overflow:auto;margin:0}.dropdown-list ul li{padding:10px;cursor:pointer;text-align:left}.dropdown-list ul li:first-child{padding-top:10px}.dropdown-list ul li:last-child{padding-bottom:10px}.dropdown-list ::-webkit-scrollbar{width:8px}.dropdown-list ::-webkit-scrollbar-thumb{background:#ccc;border-radius:5px}.dropdown-list ::-webkit-scrollbar-track{background:#f2f2f2}.arrow-up,.arrow-down{width:0;height:0;border-left:13px solid transparent;border-right:13px solid transparent;border-bottom:15px solid #fff;margin-left:15px;position:absolute;top:0}.arrow-down{bottom:-14px;top:unset;transform:rotate(180deg)}.arrow-2{border-bottom:15px solid #ccc;top:-1px}.arrow-down.arrow-2{top:unset;bottom:-16px}.list-area{border:1px solid #ccc;border-radius:3px;background:#fff;margin:0}.select-all{padding:10px;border-bottom:1px solid #ccc;text-align:left}.list-filter{border-bottom:1px solid #ccc;position:relative;padding-left:35px;height:35px}.list-filter input{border:0px;width:100%;height:100%;padding:0}.list-filter input:focus{outline:none}.list-filter .c-search{position:absolute;top:4px;left:10px;width:15px;height:15px}.list-filter .c-search svg{fill:#888}.list-filter .c-clear{position:absolute;top:4px;right:10px;width:15px;height:15px}.list-filter .c-clear svg{fill:#888}.pure-checkbox input[type=checkbox]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px}.pure-checkbox input[type=checkbox]:focus+label:before,.pure-checkbox input[type=checkbox]:hover+label:before{background-color:none}.pure-checkbox input[type=checkbox]:active+label:before{transition-duration:0s}.pure-checkbox input[type=checkbox]:disabled+label{color:#ccc}.pure-checkbox input[type=checkbox]+label{position:relative;padding-left:2em;vertical-align:middle;-webkit-user-select:none;user-select:none;cursor:pointer;margin:0;font-weight:300}.pure-checkbox input[type=checkbox]+label:before{box-sizing:content-box;content:\"\";position:absolute;top:50%;left:0;width:15px;height:15px;margin-top:-9px;text-align:center;transition:all .4s ease;border-radius:3px}.pure-checkbox input[type=checkbox]+label:after{box-sizing:content-box;content:\"\";position:absolute;top:50%;left:0;width:15px;height:15px;margin-top:-9px;transform:scale(0);transform-origin:50%;transition:transform .2s ease-out}.pure-checkbox input[type=checkbox]:disabled+label:before{border-color:#ccc}.pure-checkbox input[type=checkbox]:disabled:focus+label:before .pure-checkbox input[type=checkbox]:disabled:hover+label:before{background-color:inherit}.pure-checkbox input[type=checkbox]:disabled:checked+label:before{background-color:#ccc}.pure-checkbox input[type=checkbox]+label:after{background-color:transparent;top:50%;left:3px;width:9px;height:4px;margin-top:-5px;border-style:solid;border-width:0 0 2px 2px;border-image:none;transform:rotate(-45deg) scale(0)}.pure-checkbox input[type=checkbox]:checked+label:after{content:\"\";transform:rotate(-45deg) scale(1);transition:transform .2s ease-out}.pure-checkbox input[type=radio]:checked+label:before{background-color:#fff}.pure-checkbox input[type=radio]:checked+label:after{transform:scale(1)}.pure-checkbox input[type=radio]+label:before{border-radius:50%}.pure-checkbox input[type=checkbox]:checked+label:after{transform:rotate(-45deg) scale(1)}.list-message{text-align:center;margin:0;padding:15px 0;font-size:initial}.list-grp{padding:0 15px!important}.list-grp h4{text-transform:capitalize;margin:15px 0 0;font-size:14px;font-weight:700}.list-grp>li{padding-left:15px!important}.grp-item{padding-left:30px!important}.grp-title{padding-bottom:0!important}.grp-title label{margin-bottom:0!important;font-weight:800;text-transform:capitalize}.grp-title:hover{background:none!important}.loading-icon{width:20px;position:absolute;right:10px;top:23px;z-index:1}.nodata-label{width:100%;text-align:center;padding:10px 0 0}.btn-container{text-align:center;padding:5px}.clear-all{width:8px;position:absolute;top:50%;right:30px;transform:translateY(-50%)}\n"], dependencies: [{ kind: "directive", type: i0.forwardRef(() => i2.NgClass), selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i0.forwardRef(() => i2.NgForOf), selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i0.forwardRef(() => i2.NgIf), selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i0.forwardRef(() => i2.NgStyle), selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "directive", type: i0.forwardRef(() => i3.DefaultValueAccessor), selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i0.forwardRef(() => i3.NgControlStatus), selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i0.forwardRef(() => i3.NgModel), selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i0.forwardRef(() => i4.VirtualScrollerComponent), selector: "virtual-scroller,[virtualScroller]", inputs: ["executeRefreshOutsideAngularZone", "enableUnequalChildrenSizes", "useMarginInsteadOfTranslate", "modifyOverflowStyleOfParentScroll", "stripedTable", "scrollbarWidth", "scrollbarHeight", "childWidth", "childHeight", "ssrChildWidth", "ssrChildHeight", "ssrViewportWidth", "ssrViewportHeight", "bufferAmount", "scrollAnimationTime", "resizeBypassRefreshThreshold", "scrollThrottlingTime", "scrollDebounceTime", "checkResizeInterval", "items", "compareItems", "horizontal", "parentScroll"], outputs: ["vsUpdate", "vsChange", "vsStart", "vsEnd"], exportAs: ["virtualScroller"] }, { kind: "directive", type: i0.forwardRef(() => ClickOutsideDirective), selector: "[clickOutside]", inputs: ["enabled"], outputs: ["clickOutside"] }, { kind: "component", type: i0.forwardRef(() => TemplateRenderer), selector: "c-templateRenderer", inputs: ["data", "item"] }, { kind: "component", type: i0.forwardRef(() => CIcon), selector: "c-icon", inputs: ["name"] }], encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AngularMultiSelect, decorators: [{
+            type: Component,
+            args: [{ selector: 'angular2-multiselect', host: { '[class]': 'defaultSettings.classes' }, providers: [DROPDOWN_CONTROL_VALUE_ACCESSOR, DROPDOWN_CONTROL_VALIDATION], encapsulation: ViewEncapsulation.None, template: "<div class=\"cuppa-dropdown\" (clickOutside)=\"closeDropdownOnClickOut()\" [enabled]=\"isActive\" #cuppaDropdown>\n  <div class=\"selected-list\" #selectedList>\n    <div class=\"c-btn\" (click)=\"toggleDropdown($event)\" [ngClass]=\"{'disabled': settings.disabled}\" [attr.tabindex]=\"0\">\n\n      <span *ngIf=\"selectedItems?.length == 0\">{{ settings.text }}</span>\n      <span *ngIf=\"settings.singleSelection && !badgeTempl\">\n                <span *ngFor=\"let item of selectedItems;trackBy: trackByFn.bind(this);let k = index\">\n                    {{ item[settings.labelKey] }}\n                </span>\n            </span>\n      <span class=\"c-list\" *ngIf=\"selectedItems?.length > 0 && settings.singleSelection && badgeTempl \">\n                <div class=\"c-token\" *ngFor=\"let item of selectedItems;trackBy: trackByFn.bind(this);let k = index\">\n                    <span *ngIf=\"!badgeTempl\" class=\"c-label\">{{ item[settings.labelKey] }}</span>\n\n                    <span *ngIf=\"badgeTempl\" class=\"c-label\">\n                        <c-templateRenderer [data]=\"badgeTempl\" [item]=\"item\"></c-templateRenderer>\n                    </span>\n                    <span class=\"c-remove\" (click)=\"onItemClick(item,k,$event);$event.stopPropagation()\">\n                        <c-icon name=\"remove\"/>\n                    </span>\n                </div>\n            </span>\n      <div class=\"c-list\" *ngIf=\"selectedItems?.length > 0 && !settings.singleSelection\">\n        <div class=\"c-token\" *ngFor=\"let item of selectedItems;trackBy: trackByFn.bind(this);let k = index\"\n             [hidden]=\"k > settings.badgeShowLimit-1\">\n\n          @if (badgeTempl) {\n            <span class=\"c-label\"><c-templateRenderer [data]=\"badgeTempl\" [item]=\"item\"></c-templateRenderer></span>\n          } @else {\n            <span class=\"c-label\">{{ item[settings.labelKey] }}</span>\n\n          }\n\n          <span class=\"c-remove\" (click)=\"onItemClick(item,k,$event);$event.stopPropagation()\">\n                        <c-icon [name]=\"'remove'\"></c-icon>\n                    </span>\n        </div>\n      </div>\n      <span class=\"countplaceholder\"\n            *ngIf=\"selectedItems?.length > settings.badgeShowLimit\">+{{ selectedItems?.length - settings.badgeShowLimit }}</span>\n      <span class=\"c-remove clear-all\" *ngIf=\"settings.clearAll && selectedItems?.length > 0 && !settings.disabled\"\n            (click)=\"clearSelection($event);$event.stopPropagation()\">\n                <c-icon [name]=\"'remove'\"></c-icon>\n            </span>\n      @if (isActive) {\n        <span class=\"c-angle-up\"><c-icon [name]=\"'angle-up'\"></c-icon></span>\n      } @else {\n        <span class=\"c-angle-down\"><c-icon [name]=\"'angle-down'\"></c-icon></span>\n      }\n    </div>\n  </div>\n  <div #dropdownList class=\"dropdown-list animated fadeIn\"\n       [ngClass]=\"{'tagToBody': settings.tagToBody}\"\n       [style.width.px]=\"dropDownWidth\"\n       [style.top]=\"dropDownTop\"\n       [style.bottom]=\"dropDownBottom\"\n       [style.left.px]=\"dropDownLeft\"\n       [hidden]=\"!isActive\">\n    <div [ngClass]=\"{'arrow-up': settings.position == 'bottom', 'arrow-down': settings.position == 'top'}\"\n         class=\"arrow-2\"></div>\n    <div [ngClass]=\"{'arrow-up': settings.position == 'bottom', 'arrow-down': settings.position == 'top'}\"></div>\n    <div class=\"list-area\" [ngClass]=\"{'single-select-mode': settings.singleSelection }\">\n      <div class=\"pure-checkbox select-all\"\n           *ngIf=\"settings.enableCheckAll && !settings.singleSelection && !settings.limitSelection && data?.length > 0 && !isDisabledItemPresent\"\n      >\n        <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelectAll\"\n               [disabled]=\"settings.limitSelection == selectedItems?.length\"\n               [id]=\"id\" (change)=\"toggleSelectAll($event)\"/>\n        <label [for]=\"id\">\n          <span [hidden]=\"isSelectAll\">{{ settings.selectAllText }}</span>\n          <span [hidden]=\"!isSelectAll\">{{ settings.unSelectAllText }}</span>\n        </label>\n      </div>\n      <img class=\"loading-icon\" *ngIf=\"loading\" src=\"assets/img/loading.gif\"/>\n      <div class=\"list-filter\" *ngIf=\"settings.enableSearchFilter\">\n                <span class=\"c-search\" id=\"searchIcon\">\n                    <c-icon [name]=\"'search'\"></c-icon>\n                </span>\n        <span *ngIf=\"!settings.lazyLoading\" [hidden]=\"filter == undefined || filter?.length == 0\" class=\"c-clear\"\n              (click)=\"clearSearch()\">\n                    <c-icon [name]=\"'clear'\"></c-icon>\n                </span>\n        <span *ngIf=\"settings.lazyLoading\" [hidden]=\"filter == undefined || filter?.length == 0\" class=\"c-clear\"\n              (click)=\"resetInfiniteSearch()\">\n                    <c-icon [name]=\"'clear'\"></c-icon>\n                </span>\n\n        <input class=\"c-input\" *ngIf=\"settings.groupBy && !settings.lazyLoading && !searchTempl\" #searchInput\n               type=\"text\" [placeholder]=\"settings.searchPlaceholderText\"\n               [(ngModel)]=\"filter\" (keyup)=\"filterGroupedList()\" aria-labelledby=\"searchIcon\">\n        <input class=\"c-input\" *ngIf=\"!settings.groupBy && !settings.lazyLoading && !searchTempl\" #searchInput\n               type=\"text\" [placeholder]=\"settings.searchPlaceholderText\"\n               [(ngModel)]=\"filter\" (keyup)=\"filteritems($event)\" aria-labelledby=\"searchIcon\">\n        <input class=\"c-input\" *ngIf=\"settings.lazyLoading && !searchTempl\" #searchInput type=\"text\"\n               [placeholder]=\"settings.searchPlaceholderText\"\n               [(ngModel)]=\"filter\" (keyup)=\"onKeyUp($event)\" aria-labelledby=\"searchIcon\">\n        <!--            <input class=\"c-input\" *ngIf=\"!settings.lazyLoading && !searchTempl && settings.groupBy\" #searchInput type=\"text\" [placeholder]=\"settings.searchPlaceholderText\"\n        [(ngModel)]=\"filter\" (keyup)=\"filterGroupList($event)\">-->\n        <c-templateRenderer *ngIf=\"searchTempl\" [data]=\"searchTempl\" [item]=\"item\"></c-templateRenderer>\n      </div>\n      <div class=\"filter-select-all\"\n           *ngIf=\"!settings.lazyLoading && settings.enableFilterSelectAll && !isDisabledItemPresent\">\n        <div class=\"pure-checkbox select-all\"\n             *ngIf=\"!settings.groupBy && filter?.length > 0 && filterLength > 0  && !settings.singleSelection\"\n             (click)=\"toggleFilterSelectAll()\">\n          <input type=\"checkbox\" [checked]=\"isFilterSelectAll\"\n                 [disabled]=\"settings.limitSelection == selectedItems?.length\" aria-labelledby=\"optionName\"\n                 aria-label=\"option\"/>\n          <label>\n            <span [hidden]=\"isFilterSelectAll\">{{ settings.filterSelectAllText }}</span>\n            <span [hidden]=\"!isFilterSelectAll\">{{ settings.filterUnSelectAllText }}</span>\n          </label>\n        </div>\n        <div class=\"pure-checkbox select-all\"\n             *ngIf=\"settings.groupBy && filter?.length > 0 && groupedData?.length > 0  && !settings.singleSelection\"\n             (click)=\"toggleFilterSelectAll()\">\n          <input type=\"checkbox\" [checked]=\"isFilterSelectAll && filter?.length > 0\"\n                 [disabled]=\"settings.limitSelection == selectedItems?.length\"\n                 aria-labelledby=\"option\"/>\n          <label>\n            <span [hidden]=\"isFilterSelectAll\">{{ settings.filterSelectAllText }}</span>\n            <span [hidden]=\"!isFilterSelectAll\">{{ settings.filterUnSelectAllText }}</span>\n          </label>\n        </div>\n      </div>\n      <div class=\"filter-select-all\"\n           *ngIf=\"settings.lazyLoading && settings.enableFilterSelectAll && !isDisabledItemPresent && !settings.singleSelection\">\n        <div class=\"pure-checkbox select-all\" *ngIf=\"filter?.length > 0 && infiniteFilterLength > 0\"\n             (click)=\"toggleInfiniteFilterSelectAll()\">\n          <input type=\"checkbox\" [checked]=\"isInfiniteFilterSelectAll\"\n                 [disabled]=\"settings.limitSelection == selectedItems?.length\"\n                 aria-labelledby=\"option\"/>\n          <label>\n            <span [hidden]=\"isInfiniteFilterSelectAll\">{{ settings.filterSelectAllText }}</span>\n            <span [hidden]=\"!isInfiniteFilterSelectAll\">{{ settings.filterUnSelectAllText }}</span>\n          </label>\n        </div>\n      </div>\n      <div class=\"filter-select-all\" *ngIf=\"filter?.length\">\n        <div class=\"btn-container\" *ngIf=\"settings.addNewItemOnFilter\">\n          <button class=\"c-btn btn-iceblue\" (click)=\"addFilterNewItem()\">{{ settings.addNewButtonText }}</button>\n        </div>\n      </div>\n\n      <div *ngIf=\"!settings.groupBy && !settings.lazyLoading && itemTempl == undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <ul class=\"lazyContainer\">\n          <li *ngFor=\"let item of data; let i = index;\" (click)=\"onItemClick(item,i,$event)\"\n              class=\"pure-checkbox\" [ngClass]=\"{'selected-item': isSelected(item) == true }\">\n            <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(item)\"\n                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n                   aria-labelledby=\"option\"/>\n            <label>{{ item[settings.labelKey] }}</label>\n          </li>\n        </ul>\n      </div>\n      <!-- lazy loading -->\n      <div *ngIf=\"!settings.groupBy && settings.lazyLoading && itemTempl == undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <ul virtualScroller #scroll [enableUnequalChildrenSizes]=\"randomSize\" [items]=\"virtualdata\"\n            (vsStart)=\"onScrollEnd($event)\"\n            (vsEnd)=\"onScrollEnd($event)\" [ngStyle]=\"{'height': settings.maxHeight+'px'}\" class=\"lazyContainer\">\n          <li *ngFor=\"let item of scroll.viewPortItems; let i = index;\" (click)=\"onItemClick(item,i,$event)\"\n              class=\"pure-checkbox\"\n              [ngClass]=\"{'selected-item': isSelected(item) == true }\">\n            <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(item)\"\n                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n            />\n            <label>{{ item[settings.labelKey] }}</label>\n          </li>\n        </ul>\n      </div>\n      <!-- custom template -->\n      <div *ngIf=\"!settings.groupBy && !settings.lazyLoading && itemTempl != undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <ul class=\"lazyContainer\">\n          <li *ngFor=\"let item of data; let i = index;\" (click)=\"onItemClick(item,i,$event)\"\n              class=\"pure-checkbox\" [ngClass]=\"{'selected-item': isSelected(item) == true }\">\n            <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(item)\"\n                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n            />\n            <label></label>\n            <c-templateRenderer [data]=\"itemTempl\" [item]=\"item\"></c-templateRenderer>\n          </li>\n        </ul>\n      </div>\n      <!-- lazy loading and custom template -->\n      <div *ngIf=\"!settings.groupBy && settings.lazyLoading && itemTempl != undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <ul virtualScroller #scroll2 [enableUnequalChildrenSizes]=\"randomSize\" [items]=\"virtualdata\"\n            (vsStart)=\"onScrollEnd($event)\"\n            (vsEnd)=\"onScrollEnd($event)\" class=\"lazyContainer\" [ngStyle]=\"{'height': settings.maxHeight+'px'}\">\n          <li *ngFor=\"let item of scroll2.viewPortItems; let i = index;\" (click)=\"onItemClick(item,i,$event)\"\n              class=\"pure-checkbox\"\n              [ngClass]=\"{'selected-item': isSelected(item) == true }\">\n            <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(item)\"\n                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n            />\n            <label></label>\n            <c-templateRenderer [data]=\"itemTempl\" [item]=\"item\"></c-templateRenderer>\n          </li>\n        </ul>\n      </div>\n      <!-- lazy loading, group By and custom template -->\n      <div *ngIf=\"settings.groupBy && settings.lazyLoading && itemTempl != undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <ul virtualScroller #scroll3 [enableUnequalChildrenSizes]=\"randomSize\" [items]=\"virtualdata\"\n            (vsStart)=\"onScrollEnd($event)\"\n            (vsEnd)=\"onScrollEnd($event)\" [ngStyle]=\"{'height': settings.maxHeight+'px'}\" class=\"lazyContainer\">\n                    <span *ngFor=\"let item of scroll3.viewPortItems; let i = index;\">\n                        <li (click)=\"onItemClick(item,i,$event)\" *ngIf=\"!item.grpTitle\"\n                            [ngClass]=\"{'grp-title': item.grpTitle,'grp-item': !item.grpTitle && !settings.singleSelection}\"\n                            class=\"pure-checkbox\">\n                            <input *ngIf=\"settings.showCheckbox && !settings.singleSelection\" type=\"checkbox\"\n                                   [checked]=\"isSelected(item)\"\n                                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n                            />\n                            <label></label>\n                            <c-templateRenderer [data]=\"itemTempl\" [item]=\"item\"></c-templateRenderer>\n                        </li>\n                        <li *ngIf=\"item.grpTitle\"\n                            [ngClass]=\"{'grp-title': item.grpTitle,'grp-item': !item.grpTitle && !settings.singleSelection}\"\n                            class=\"pure-checkbox\">\n                            <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(item)\"\n                                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n                            />\n                            <label></label>\n                            <c-templateRenderer [data]=\"itemTempl\" [item]=\"item\"></c-templateRenderer>\n                        </li>\n                    </span>\n        </ul>\n      </div>\n      <!-- group By and custom template -->\n      <div *ngIf=\"settings.groupBy && !settings.lazyLoading && itemTempl != undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <ul class=\"lazyContainer\">\n                    <span *ngFor=\"let item of groupedData; let i = index;\">\n                        <li (click)=\"selectGroup(item)\"\n                            [ngClass]=\"{'grp-title': item.grpTitle,'grp-item': !item.grpTitle && !settings.singleSelection}\"\n                            class=\"pure-checkbox\">\n                            <input *ngIf=\"settings.showCheckbox && !settings.singleSelection\" type=\"checkbox\"\n                                   [checked]=\"item.selected\"\n                                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n                            />\n                            <label>{{ item[settings.labelKey] }}</label>\n                            <ul class=\"lazyContainer\">\n                                <span *ngFor=\"let val of item.list ; let j = index;\">\n                                    <li (click)=\"onItemClick(val,j,$event); $event.stopPropagation()\"\n                                        [ngClass]=\"{'grp-title': val.grpTitle,'grp-item': !val.grpTitle && !settings.singleSelection}\"\n                                        class=\"pure-checkbox\">\n                                        <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(val)\"\n                                               [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(val)) || val.disabled\"\n                                        />\n                                        <label></label>\n                                        <c-templateRenderer [data]=\"itemTempl\" [item]=\"val\"></c-templateRenderer>\n                                    </li>\n                                </span>\n                            </ul>\n\n                        </li>\n                    </span>\n        </ul>\n      </div>\n      <!-- lazy loading, group By -->\n      <div *ngIf=\"settings.groupBy && settings.lazyLoading && itemTempl == undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <virtual-scroller [items]=\"groupedData\" (vsUpdate)=\"viewPortItems = $event\" (vsEnd)=\"onScrollEnd($event)\"\n                          [ngStyle]=\"{'height': settings.maxHeight+'px'}\">\n          <ul virtualScroller #scroll4 [enableUnequalChildrenSizes]=\"randomSize\" [items]=\"virtualdata\"\n              (vsStart)=\"onScrollEnd($event)\"\n              (vsEnd)=\"onScrollEnd($event)\" [ngStyle]=\"{'height': settings.maxHeight+'px'}\" class=\"lazyContainer\">\n                        <span *ngFor=\"let item of scroll4.viewPortItems; let i = index;\">\n                            <li *ngIf=\"item.grpTitle\"\n                                [ngClass]=\"{'grp-title': item.grpTitle,'grp-item': !item.grpTitle && !settings.singleSelection, 'selected-item': isSelected(item) == true }\"\n                                class=\"pure-checkbox\">\n                                <input *ngIf=\"settings.showCheckbox && !item.grpTitle && !settings.singleSelection\"\n                                       type=\"checkbox\" [checked]=\"isSelected(item)\"\n                                       [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n                                />\n                                <label>{{ item[settings.labelKey] }}</label>\n                            </li>\n                            <li (click)=\"onItemClick(item,i,$event)\" *ngIf=\"!item.grpTitle\"\n                                [ngClass]=\"{'grp-title': item.grpTitle,'grp-item': !item.grpTitle && !settings.singleSelection, 'selected-item': isSelected(item) == true }\"\n                                class=\"pure-checkbox\">\n                                <input *ngIf=\"settings.showCheckbox && !item.grpTitle\" type=\"checkbox\"\n                                       [checked]=\"isSelected(item)\"\n                                       [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n                                />\n                                <label>{{ item[settings.labelKey] }}</label>\n                            </li>\n                        </span>\n          </ul>\n        </virtual-scroller>\n      </div>\n      <!-- group By -->\n      <div *ngIf=\"settings.groupBy && !settings.lazyLoading && itemTempl == undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <ul class=\"lazyContainer\">\n                    <span *ngFor=\"let item of groupedData ; let i = index;\">\n                        <li (click)=\"selectGroup(item)\"\n                            [ngClass]=\"{'grp-title': item.grpTitle,'grp-item': !item.grpTitle && !settings.singleSelection}\"\n                            class=\"pure-checkbox\">\n                            <input *ngIf=\"settings.showCheckbox && !settings.singleSelection\" type=\"checkbox\"\n                                   [checked]=\"item.selected\"\n                                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n                            />\n                            <label>{{ item[settings.labelKey] }}</label>\n                            <ul class=\"lazyContainer\">\n                                <span *ngFor=\"let val of item.list ; let j = index;\">\n                                    <li (click)=\"onItemClick(val,j,$event); $event.stopPropagation()\"\n                                        [ngClass]=\"{'selected-item': isSelected(val) == true,'grp-title': val.grpTitle,'grp-item': !val.grpTitle && !settings.singleSelection}\"\n                                        class=\"pure-checkbox\">\n                                        <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(val)\"\n                                               [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(val)) || val.disabled\"\n                                        />\n                                        <label>{{ val[settings.labelKey] }}</label>\n                                    </li>\n                                </span>\n                            </ul>\n                        </li>\n                    </span>\n        </ul>\n      </div>\n      <h5 class=\"list-message\" *ngIf=\"data?.length == 0\">{{ settings.noDataLabel }}</h5>\n    </div>\n  </div>\n</div>\n", styles: ["virtual-scroll{display:block;width:100%}.cuppa-dropdown{position:relative}.c-btn{display:inline-block;border-width:1px;line-height:1.25;border-radius:3px;font-size:.85rem;padding:5px 10px;cursor:pointer;align-items:center;min-height:38px}.c-btn.disabled{background:#ccc}.selected-list .c-list{float:left;padding:0;margin:0;width:calc(100% - 20px)}.selected-list .c-list .c-token{list-style:none;padding:4px 22px 4px 8px;border-radius:2px;margin-right:4px;margin-top:2px;float:left;position:relative}.selected-list .c-list .c-token .c-label{display:block;float:left}.selected-list .c-list .c-token .c-remove{position:absolute;right:8px;top:50%;transform:translateY(-50%);width:8px}.selected-list .c-list .c-token .c-remove svg{fill:#fff}.selected-list .fa-angle-down,.selected-list .fa-angle-up{font-size:15pt;position:absolute;right:10px;top:50%;transform:translateY(-50%)}.selected-list .c-angle-down,.selected-list .c-angle-up{width:12px;height:12px;position:absolute;right:10px;top:50%;transform:translateY(-50%);pointer-events:none}.selected-list .c-angle-down svg,.selected-list .c-angle-up svg{fill:#333}.selected-list .countplaceholder{position:absolute;right:45px;top:50%;transform:translateY(-50%)}.selected-list .c-btn{width:100%;padding:5px 10px;cursor:pointer;display:flex;position:relative}.selected-list .c-btn .c-icon{position:absolute;right:5px;top:50%;transform:translateY(-50%)}.dropdown-list.tagToBody{position:fixed}.dropdown-list{position:absolute;padding-top:14px;width:100%;z-index:99999}.dropdown-list ul{padding:0;list-style:none;overflow:auto;margin:0}.dropdown-list ul li{padding:10px;cursor:pointer;text-align:left}.dropdown-list ul li:first-child{padding-top:10px}.dropdown-list ul li:last-child{padding-bottom:10px}.dropdown-list ::-webkit-scrollbar{width:8px}.dropdown-list ::-webkit-scrollbar-thumb{background:#ccc;border-radius:5px}.dropdown-list ::-webkit-scrollbar-track{background:#f2f2f2}.arrow-up,.arrow-down{width:0;height:0;border-left:13px solid transparent;border-right:13px solid transparent;border-bottom:15px solid #fff;margin-left:15px;position:absolute;top:0}.arrow-down{bottom:-14px;top:unset;transform:rotate(180deg)}.arrow-2{border-bottom:15px solid #ccc;top:-1px}.arrow-down.arrow-2{top:unset;bottom:-16px}.list-area{border:1px solid #ccc;border-radius:3px;background:#fff;margin:0}.select-all{padding:10px;border-bottom:1px solid #ccc;text-align:left}.list-filter{border-bottom:1px solid #ccc;position:relative;padding-left:35px;height:35px}.list-filter input{border:0px;width:100%;height:100%;padding:0}.list-filter input:focus{outline:none}.list-filter .c-search{position:absolute;top:4px;left:10px;width:15px;height:15px}.list-filter .c-search svg{fill:#888}.list-filter .c-clear{position:absolute;top:4px;right:10px;width:15px;height:15px}.list-filter .c-clear svg{fill:#888}.pure-checkbox input[type=checkbox]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px}.pure-checkbox input[type=checkbox]:focus+label:before,.pure-checkbox input[type=checkbox]:hover+label:before{background-color:none}.pure-checkbox input[type=checkbox]:active+label:before{transition-duration:0s}.pure-checkbox input[type=checkbox]:disabled+label{color:#ccc}.pure-checkbox input[type=checkbox]+label{position:relative;padding-left:2em;vertical-align:middle;-webkit-user-select:none;user-select:none;cursor:pointer;margin:0;font-weight:300}.pure-checkbox input[type=checkbox]+label:before{box-sizing:content-box;content:\"\";position:absolute;top:50%;left:0;width:15px;height:15px;margin-top:-9px;text-align:center;transition:all .4s ease;border-radius:3px}.pure-checkbox input[type=checkbox]+label:after{box-sizing:content-box;content:\"\";position:absolute;top:50%;left:0;width:15px;height:15px;margin-top:-9px;transform:scale(0);transform-origin:50%;transition:transform .2s ease-out}.pure-checkbox input[type=checkbox]:disabled+label:before{border-color:#ccc}.pure-checkbox input[type=checkbox]:disabled:focus+label:before .pure-checkbox input[type=checkbox]:disabled:hover+label:before{background-color:inherit}.pure-checkbox input[type=checkbox]:disabled:checked+label:before{background-color:#ccc}.pure-checkbox input[type=checkbox]+label:after{background-color:transparent;top:50%;left:3px;width:9px;height:4px;margin-top:-5px;border-style:solid;border-width:0 0 2px 2px;border-image:none;transform:rotate(-45deg) scale(0)}.pure-checkbox input[type=checkbox]:checked+label:after{content:\"\";transform:rotate(-45deg) scale(1);transition:transform .2s ease-out}.pure-checkbox input[type=radio]:checked+label:before{background-color:#fff}.pure-checkbox input[type=radio]:checked+label:after{transform:scale(1)}.pure-checkbox input[type=radio]+label:before{border-radius:50%}.pure-checkbox input[type=checkbox]:checked+label:after{transform:rotate(-45deg) scale(1)}.list-message{text-align:center;margin:0;padding:15px 0;font-size:initial}.list-grp{padding:0 15px!important}.list-grp h4{text-transform:capitalize;margin:15px 0 0;font-size:14px;font-weight:700}.list-grp>li{padding-left:15px!important}.grp-item{padding-left:30px!important}.grp-title{padding-bottom:0!important}.grp-title label{margin-bottom:0!important;font-weight:800;text-transform:capitalize}.grp-title:hover{background:none!important}.loading-icon{width:20px;position:absolute;right:10px;top:23px;z-index:1}.nodata-label{width:100%;text-align:center;padding:10px 0 0}.btn-container{text-align:center;padding:5px}.clear-all{width:8px;position:absolute;top:50%;right:30px;transform:translateY(-50%)}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i1.ListFilterPipe }], propDecorators: { data: [{
+                type: Input
+            }], settings: [{
+                type: Input
+            }], loading: [{
+                type: Input
+            }], onSelect: [{
+                type: Output,
+                args: ['onSelect']
+            }], onDeSelect: [{
+                type: Output,
+                args: ['onDeSelect']
+            }], onSelectAll: [{
+                type: Output,
+                args: ['onSelectAll']
+            }], onDeSelectAll: [{
+                type: Output,
+                args: ['onDeSelectAll']
+            }], onOpen: [{
+                type: Output,
+                args: ['onOpen']
+            }], onClose: [{
+                type: Output,
+                args: ['onClose']
+            }], onScrollToEnd: [{
+                type: Output,
+                args: ['onScrollToEnd']
+            }], onFilterSelectAll: [{
+                type: Output,
+                args: ['onFilterSelectAll']
+            }], onFilterDeSelectAll: [{
+                type: Output,
+                args: ['onFilterDeSelectAll']
+            }], onAddFilterNewItem: [{
+                type: Output,
+                args: ['onAddFilterNewItem']
+            }], onGroupSelect: [{
+                type: Output,
+                args: ['onGroupSelect']
+            }], onGroupDeSelect: [{
+                type: Output,
+                args: ['onGroupDeSelect']
+            }], itemTempl: [{
+                type: ContentChild,
+                args: [Item, { static: false }]
+            }], badgeTempl: [{
+                type: ContentChild,
+                args: [Badge, { static: false }]
+            }], searchTempl: [{
+                type: ContentChild,
+                args: [Search, { static: false }]
+            }], searchInput: [{
+                type: ViewChild,
+                args: ['searchInput', { static: false }]
+            }], selectedListElem: [{
+                type: ViewChild,
+                args: ['selectedList', { static: false }]
+            }], dropdownListElem: [{
+                type: ViewChild,
+                args: ['dropdownList', { static: false }]
+            }], cuppaDropdown: [{
+                type: ViewChild,
+                args: ['cuppaDropdown', { static: false }]
+            }], onEscapeDown: [{
+                type: HostListener,
+                args: ['document:keyup.escape', ['$event']]
+            }], onScroll: [{
+                type: HostListener,
+                args: ['window:scroll', ['$event']]
+            }], virtualScroller: [{
+                type: ViewChild,
+                args: [VirtualScrollerComponent, { static: false }]
+            }] } });
+export class AngularMultiSelectModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AngularMultiSelectModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: AngularMultiSelectModule, declarations: [AngularMultiSelect, ClickOutsideDirective,
+            ScrollDirective,
+            ListFilterPipe,
+            Item,
+            TemplateRenderer,
+            Badge,
+            Search,
+            CIcon], imports: [CommonModule, FormsModule, VirtualScrollerModule], exports: [AngularMultiSelect, ClickOutsideDirective,
+            ScrollDirective,
+            ListFilterPipe,
+            Item,
+            TemplateRenderer,
+            Badge,
+            Search,
+            CIcon] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AngularMultiSelectModule, providers: [DataService, ListFilterPipe], imports: [CommonModule, FormsModule, VirtualScrollerModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AngularMultiSelectModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, FormsModule, VirtualScrollerModule],
+                    declarations: [
+                        AngularMultiSelect,
+                        ClickOutsideDirective,
+                        ScrollDirective,
+                        ListFilterPipe,
+                        Item,
+                        TemplateRenderer,
+                        Badge,
+                        Search,
+                        CIcon,
+                    ],
+                    exports: [
+                        AngularMultiSelect,
+                        ClickOutsideDirective,
+                        ScrollDirective,
+                        ListFilterPipe,
+                        Item,
+                        TemplateRenderer,
+                        Badge,
+                        Search,
+                        CIcon,
+                    ],
+                    providers: [DataService, ListFilterPipe],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"multiselect.component.js","sourceRoot":"","sources":["../../../projects/angular2-multiselect-dropdown-lib/src/lib/multiselect.component.ts","../../../projects/angular2-multiselect-dropdown-lib/src/lib/multiselect.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  OnInit,\n  HostListener,\n  OnDestroy,\n  NgModule,\n  SimpleChanges,\n  OnChanges,\n  ChangeDetectorRef,\n  AfterViewChecked,\n  ViewEncapsulation,\n  ContentChild,\n  ViewChild,\n  forwardRef,\n  Input,\n  Output,\n  EventEmitter,\n  ElementRef,\n} from '@angular/core';\nimport {\n  FormsModule,\n  NG_VALUE_ACCESSOR,\n  ControlValueAccessor,\n  NG_VALIDATORS,\n  Validator,\n  UntypedFormControl,\n} from '@angular/forms';\nimport { CommonModule } from '@angular/common';\nimport { MyException } from './multiselect.model';\nimport { DropdownSettings } from './multiselect.interface';\nimport { ClickOutsideDirective, ScrollDirective } from './clickOutside';\nimport { ListFilterPipe } from './list-filter';\nimport { Item, Badge, Search, TemplateRenderer, CIcon } from './menu-item';\nimport { DataService } from './multiselect.service';\nimport { Subscription, Subject } from 'rxjs';\nimport {\n  VirtualScrollerModule,\n  VirtualScrollerComponent,\n} from './virtual-scroll/virtual-scroll';\nimport { debounceTime, distinctUntilChanged, tap } from 'rxjs/operators';\n\nexport const DROPDOWN_CONTROL_VALUE_ACCESSOR: any = {\n  provide: NG_VALUE_ACCESSOR,\n  useExisting: forwardRef(() => AngularMultiSelect),\n  multi: true,\n};\nexport const DROPDOWN_CONTROL_VALIDATION: any = {\n  provide: NG_VALIDATORS,\n  useExisting: forwardRef(() => AngularMultiSelect),\n  multi: true,\n};\nconst noop = () => {};\n\n@Component({\n  selector: 'angular2-multiselect',\n  templateUrl: './multiselect.component.html',\n  host: { '[class]': 'defaultSettings.classes' },\n  styleUrls: ['./multiselect.component.scss'],\n  providers: [DROPDOWN_CONTROL_VALUE_ACCESSOR, DROPDOWN_CONTROL_VALIDATION],\n  encapsulation: ViewEncapsulation.None,\n})\nexport class AngularMultiSelect\n  implements\n    OnInit,\n    ControlValueAccessor,\n    OnChanges,\n    Validator,\n    AfterViewChecked,\n    OnDestroy\n{\n  @Input()\n  data: Array<any>;\n\n  @Input()\n  settings: DropdownSettings;\n\n  @Input()\n  loading: boolean;\n\n  @Output('onSelect')\n  onSelect: EventEmitter<any> = new EventEmitter<any>();\n\n  @Output('onDeSelect')\n  onDeSelect: EventEmitter<any> = new EventEmitter<any>();\n\n  @Output('onSelectAll')\n  onSelectAll: EventEmitter<Array<any>> = new EventEmitter<Array<any>>();\n\n  @Output('onDeSelectAll')\n  onDeSelectAll: EventEmitter<Array<any>> = new EventEmitter<Array<any>>();\n\n  @Output('onOpen')\n  onOpen: EventEmitter<any> = new EventEmitter<any>();\n\n  @Output('onClose')\n  onClose: EventEmitter<any> = new EventEmitter<any>();\n\n  @Output('onScrollToEnd')\n  onScrollToEnd: EventEmitter<any> = new EventEmitter<any>();\n\n  @Output('onFilterSelectAll')\n  onFilterSelectAll: EventEmitter<Array<any>> = new EventEmitter<Array<any>>();\n\n  @Output('onFilterDeSelectAll')\n  onFilterDeSelectAll: EventEmitter<Array<any>> = new EventEmitter<\n    Array<any>\n  >();\n\n  @Output('onAddFilterNewItem')\n  onAddFilterNewItem: EventEmitter<any> = new EventEmitter<any>();\n\n  @Output('onGroupSelect')\n  onGroupSelect: EventEmitter<any> = new EventEmitter<any>();\n\n  @Output('onGroupDeSelect')\n  onGroupDeSelect: EventEmitter<any> = new EventEmitter<any>();\n\n  @ContentChild(Item, { static: false }) itemTempl: Item;\n  @ContentChild(Badge, { static: false }) badgeTempl: Badge;\n  @ContentChild(Search, { static: false }) searchTempl: Search;\n\n  @ViewChild('searchInput', { static: false }) searchInput: ElementRef;\n  @ViewChild('selectedList', { static: false }) selectedListElem: ElementRef;\n  @ViewChild('dropdownList', { static: false }) dropdownListElem: ElementRef;\n  @ViewChild('cuppaDropdown', { static: false }) cuppaDropdown: ElementRef;\n\n  @HostListener('document:keyup.escape', ['$event'])\n  onEscapeDown(event: KeyboardEvent) {\n    if (this.settings.escapeToClose) {\n      this.closeDropdown();\n    }\n  }\n\n  @HostListener('window:scroll', ['$event'])\n  onScroll(event: any) {\n    if (this.isActive && this.settings.tagToBody) {\n      this.closeDropdown();\n      /*             const elem = this.cuppaDropdown.nativeElement;\n                        if(this.settings.autoPosition){\n                            this.dropDownTop = elem.getBoundingClientRect().y + elem.clientHeight + 1;\n                        }\n                        this.dropDownLeft = elem.getBoundingClientRect().x; */\n    }\n  }\n\n  virtualdata: any = [];\n  searchTerm$ = new Subject<string>();\n\n  public selectedItems: Array<any>;\n  public isActive: boolean = false;\n  public isSelectAll: boolean = false;\n  public isFilterSelectAll: boolean = false;\n  public isInfiniteFilterSelectAll: boolean = false;\n  public groupedData: Array<any>;\n  filter: any;\n  public chunkArray: any[];\n  public scrollTop: any;\n  public chunkIndex: any[] = [];\n  public cachedItems: any[] = [];\n  public groupCachedItems: any[] = [];\n  public totalRows: any;\n  public itemHeight: any = 41.6;\n  public screenItemsLen: any;\n  public cachedItemsLen: any;\n  public totalHeight: any;\n  public scroller: any;\n  public maxBuffer: any;\n  public lastScrolled: any;\n  public lastRepaintY: any;\n  public selectedListHeight: any;\n  public filterLength: any = 0;\n  public infiniteFilterLength: any = 0;\n  public viewPortItems: any;\n  public item: any;\n  public dropdownListYOffset: number = 0;\n  subscription: Subscription;\n  public dropDownWidth: number = 0;\n  public dropDownTop: any = '';\n  public dropDownBottom: any = 'unset';\n  public dropDownLeft: number = 0;\n  public id: any = Math.random().toString(36).substring(2);\n  defaultSettings: DropdownSettings = {\n    singleSelection: false,\n    text: 'Select',\n    enableCheckAll: true,\n    selectAllText: 'Select All',\n    unSelectAllText: 'UnSelect All',\n    filterSelectAllText: 'Select all filtered results',\n    filterUnSelectAllText: 'UnSelect all filtered results',\n    enableSearchFilter: false,\n    searchBy: [],\n    maxHeight: 300,\n    badgeShowLimit: 999999999999,\n    classes: '',\n    disabled: false,\n    searchPlaceholderText: 'Search',\n    showCheckbox: true,\n    noDataLabel: 'No Data Available',\n    searchAutofocus: true,\n    lazyLoading: false,\n    labelKey: 'itemName',\n    primaryKey: 'id',\n    position: 'bottom',\n    autoPosition: true,\n    enableFilterSelectAll: true,\n    selectGroup: false,\n    addNewItemOnFilter: false,\n    addNewButtonText: 'Add',\n    escapeToClose: true,\n    clearAll: true,\n    tagToBody: true,\n  };\n  randomSize: boolean = true;\n  public parseError: boolean;\n  public filteredList: any = [];\n  virtualScroollInit: boolean = false;\n  @ViewChild(VirtualScrollerComponent, { static: false })\n  private virtualScroller: VirtualScrollerComponent;\n  public isDisabledItemPresent = false;\n\n  constructor(\n    public _elementRef: ElementRef,\n    private cdr: ChangeDetectorRef,\n    private filterPipe: ListFilterPipe,\n  ) {\n    this.searchTerm$\n      .asObservable()\n      .pipe(\n        debounceTime(1000),\n        distinctUntilChanged(),\n        tap((term) => term),\n      )\n      .subscribe((val) => {\n        this.filterInfiniteList(val);\n      });\n  }\n  ngOnInit() {\n    this.settings = Object.assign(this.defaultSettings, this.settings);\n\n    this.cachedItems = this.cloneArray(this.data);\n    if (this.settings.position == 'top') {\n      setTimeout(() => {\n        this.selectedListHeight = { val: 0 };\n        this.selectedListHeight.val =\n          this.selectedListElem.nativeElement.clientHeight;\n      });\n    }\n    setTimeout(() => {\n      this.calculateDropdownDirection();\n    });\n    this.virtualScroollInit = false;\n  }\n  onKeyUp(evt: any) {\n    this.searchTerm$.next((<HTMLInputElement>evt.target).value);\n  }\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes.data && !changes.data.firstChange) {\n      if (this.settings.groupBy) {\n        this.groupedData = this.transformData(this.data, this.settings.groupBy);\n        if (this.data.length == 0) {\n          this.selectedItems = [];\n        }\n        this.groupCachedItems = this.cloneArray(this.groupedData);\n      }\n      this.cachedItems = this.cloneArray(this.data);\n    }\n    if (changes.settings && !changes.settings.firstChange) {\n      this.settings = Object.assign(this.defaultSettings, this.settings);\n    }\n    if (changes.loading) {\n    }\n    if (this.settings.lazyLoading && this.virtualScroollInit && changes.data) {\n      this.virtualdata = changes.data.currentValue;\n    }\n  }\n  ngDoCheck() {\n    if (this.selectedItems) {\n      if (\n        this.selectedItems.length == 0 ||\n        this.data.length == 0 ||\n        this.selectedItems.length < this.data.length\n      ) {\n        this.isSelectAll = false;\n      }\n    }\n  }\n  ngAfterViewInit() {\n    if (this.settings.lazyLoading) {\n      // this._elementRef.nativeElement.getElementsByClassName(\"lazyContainer\")[0].addEventListener('scroll', this.onScroll.bind(this));\n    }\n  }\n  ngAfterViewChecked() {\n    if (\n      this.selectedListElem.nativeElement.clientHeight &&\n      this.settings.position == 'top' &&\n      this.selectedListHeight\n    ) {\n      this.selectedListHeight.val =\n        this.selectedListElem.nativeElement.clientHeight;\n      this.cdr.detectChanges();\n    }\n    //this.calculateDropdownDirection();\n  }\n  onItemClick(item: any, index: number, evt: Event) {\n    if (item.disabled) {\n      return;\n    }\n\n    if (this.settings.disabled) {\n      return;\n    }\n\n    let found = this.isSelected(item);\n    let limit =\n      this.selectedItems.length < this.settings.limitSelection ? true : false;\n\n    if (!found) {\n      if (this.settings.limitSelection) {\n        if (limit) {\n          this.addSelected(item);\n          this.onSelect.emit(item);\n        }\n      } else {\n        this.addSelected(item);\n        this.onSelect.emit(item);\n      }\n    } else {\n      this.removeSelected(item);\n      this.onDeSelect.emit(item);\n    }\n    if (this.isSelectAll || this.data.length > this.selectedItems.length) {\n      this.isSelectAll = false;\n    }\n\n    if (this.data.length == this.selectedItems.length) {\n      this.isSelectAll = true;\n    }\n    if (this.settings.groupBy) {\n      this.updateGroupInfo(item);\n    }\n  }\n  public validate(c: UntypedFormControl): any {\n    return null;\n  }\n  private onTouchedCallback: (_: any) => void = noop;\n  private onChangeCallback: (_: any) => void = noop;\n\n  writeValue(value: any) {\n    if (value !== undefined && value !== null && value !== '') {\n      if (this.settings.singleSelection) {\n        if (this.settings.groupBy) {\n          this.groupedData = this.transformData(\n            this.data,\n            this.settings.groupBy,\n          );\n          this.groupCachedItems = this.cloneArray(this.groupedData);\n          this.selectedItems = [value[0]];\n        } else {\n          try {\n            if (value.length > 1) {\n              this.selectedItems = [value[0]];\n              throw new MyException(404, {\n                msg: 'Single Selection Mode, Selected Items cannot have more than one item.',\n              });\n            } else {\n              this.selectedItems = value;\n            }\n          } catch (e) {\n            console.error(e.body.msg);\n          }\n        }\n      } else {\n        if (this.settings.limitSelection) {\n          this.selectedItems = value.slice(0, this.settings.limitSelection);\n        } else {\n          this.selectedItems = value;\n        }\n        if (\n          this.selectedItems != null &&\n          this.selectedItems.length === this.data.length &&\n          this.data.length > 0\n        ) {\n          this.isSelectAll = true;\n        }\n        if (this.settings.groupBy) {\n          this.groupedData = this.transformData(\n            this.data,\n            this.settings.groupBy,\n          );\n          this.groupCachedItems = this.cloneArray(this.groupedData);\n        }\n      }\n    } else {\n      this.selectedItems = [];\n    }\n  }\n\n  //From ControlValueAccessor interface\n  registerOnChange(fn: any) {\n    this.onChangeCallback = fn;\n  }\n\n  //From ControlValueAccessor interface\n  registerOnTouched(fn: any) {\n    this.onTouchedCallback = fn;\n  }\n  trackByFn(index: number, item: any) {\n    return item[this.settings.primaryKey];\n  }\n  isSelected(clickedItem: any) {\n    if (clickedItem.disabled) {\n      return false;\n    }\n    let found = false;\n    this.selectedItems &&\n      this.selectedItems.forEach((item) => {\n        if (\n          clickedItem[this.settings.primaryKey] ===\n          item[this.settings.primaryKey]\n        ) {\n          found = true;\n        }\n      });\n    return found;\n  }\n  addSelected(item: any) {\n    if (item.disabled) {\n      return;\n    }\n    if (this.settings.singleSelection) {\n      this.selectedItems = [];\n      this.selectedItems.push(item);\n      this.closeDropdown();\n    } else this.selectedItems = [...this.selectedItems, item];\n    this.onChangeCallback(this.selectedItems);\n    this.onTouchedCallback(this.selectedItems);\n  }\n  removeSelected(clickedItem: any) {\n    this.selectedItems &&\n      this.selectedItems.forEach((item) => {\n        if (\n          clickedItem[this.settings.primaryKey] ===\n          item[this.settings.primaryKey]\n        ) {\n          this.selectedItems.splice(this.selectedItems.indexOf(item), 1);\n        }\n      });\n    this.onChangeCallback(this.selectedItems);\n    this.onTouchedCallback(this.selectedItems);\n  }\n  toggleDropdown(evt: any) {\n    if (this.settings.disabled) {\n      return;\n    }\n    this.isActive = !this.isActive;\n    if (this.isActive) {\n      this.openDropdown();\n    } else {\n      this.closeDropdown();\n    }\n    if (this.settings.lazyLoading) {\n      this.virtualdata = this.data;\n      this.virtualScroollInit = true;\n    }\n    evt.preventDefault();\n  }\n  public openDropdown() {\n    if (this.settings.disabled) {\n      return;\n    }\n    this.isActive = true;\n    this.calculateDropdownDirection();\n    if (\n      this.settings.searchAutofocus &&\n      this.searchInput &&\n      this.settings.enableSearchFilter &&\n      !this.searchTempl\n    ) {\n      setTimeout(() => {\n        this.searchInput.nativeElement.focus();\n      }, 0);\n    }\n    this.onOpen.emit(true);\n  }\n  public closeDropdown() {\n    if (this.searchInput && this.settings.lazyLoading) {\n      this.searchInput.nativeElement.value = '';\n    }\n    if (this.searchInput) {\n      this.searchInput.nativeElement.value = '';\n    }\n    this.filter = '';\n    this.isActive = false;\n    this.searchTerm$.next('');\n    this.onClose.emit(false);\n  }\n  public closeDropdownOnClickOut() {\n    if (this.isActive) {\n      if (this.searchInput && this.settings.lazyLoading) {\n        this.searchInput.nativeElement.value = '';\n      }\n      if (this.searchInput) {\n        this.searchInput.nativeElement.value = '';\n      }\n      this.filter = '';\n      this.isActive = false;\n      this.clearSearch();\n      this.searchTerm$.next('');\n      this.onClose.emit(false);\n    }\n  }\n  toggleSelectAll(event) {\n    if (!this.isSelectAll) {\n      this.selectedItems = [];\n      if (this.settings.groupBy) {\n        this.groupedData.forEach((obj) => {\n          obj.selected = !obj.disabled;\n        });\n        this.groupCachedItems.forEach((obj) => {\n          obj.selected = !obj.disabled;\n        });\n      }\n      // this.selectedItems = this.data.slice();\n      this.selectedItems = this.data.filter(\n        (individualData) => !individualData.disabled,\n      );\n      this.isSelectAll = true;\n      this.onChangeCallback(this.selectedItems);\n      this.onTouchedCallback(this.selectedItems);\n\n      this.onSelectAll.emit(this.selectedItems);\n    } else {\n      if (this.settings.groupBy) {\n        this.groupedData.forEach((obj) => {\n          obj.selected = false;\n        });\n        this.groupCachedItems.forEach((obj) => {\n          obj.selected = false;\n        });\n      }\n      this.selectedItems = [];\n      this.isSelectAll = false;\n      this.onChangeCallback(this.selectedItems);\n      this.onTouchedCallback(this.selectedItems);\n\n      this.onDeSelectAll.emit(this.selectedItems);\n    }\n    setTimeout(() => {\n      this.calculateDropdownDirection();\n    });\n    event.stopPropagation();\n  }\n  filterGroupedList() {\n    if (this.filter == '' || this.filter == null) {\n      this.clearSearch();\n      return;\n    }\n    this.groupedData = this.cloneArray(this.groupCachedItems);\n    this.groupedData = this.groupedData.filter((obj) => {\n      let arr = [];\n      if (\n        obj[this.settings.labelKey]\n          .toLowerCase()\n          .indexOf(this.filter.toLowerCase()) > -1\n      ) {\n        arr = obj.list;\n      } else {\n        arr = obj.list.filter((t) => {\n          return (\n            t[this.settings.labelKey]\n              .toLowerCase()\n              .indexOf(this.filter.toLowerCase()) > -1\n          );\n        });\n      }\n\n      obj.list = arr;\n      if (\n        obj[this.settings.labelKey]\n          .toLowerCase()\n          .indexOf(this.filter.toLowerCase()) > -1\n      ) {\n        return arr;\n      } else {\n        return arr.some((cat) => {\n          return (\n            cat[this.settings.labelKey]\n              .toLowerCase()\n              .indexOf(this.filter.toLowerCase()) > -1\n          );\n        });\n      }\n    });\n  }\n  toggleFilterSelectAll() {\n    if (!this.isFilterSelectAll) {\n      let added = [];\n      if (this.settings.groupBy) {\n        this.groupedData.forEach((item: any) => {\n          item.sele;\n          if (item.list) {\n            item.list.forEach((el: any) => {\n              if (!this.isSelected(el)) {\n                this.addSelected(el);\n                added.push(el);\n              }\n            });\n          }\n          this.updateGroupInfo(item);\n        });\n\n        this.filteredList.forEach((el: any) => {\n          if (!this.isSelected(el) && !el.hasOwnProperty('grpTitle')) {\n            this.addSelected(el);\n            added.push(el);\n          }\n        });\n      } else {\n        this.filteredList.forEach((item: any) => {\n          if (!this.isSelected(item)) {\n            this.addSelected(item);\n            added.push(item);\n          }\n        });\n      }\n\n      this.isFilterSelectAll = true;\n      this.onFilterSelectAll.emit(added);\n    } else {\n      let removed = [];\n      if (this.settings.groupBy) {\n        this.groupedData.forEach((item: any) => {\n          if (item.list) {\n            item.list.forEach((el: any) => {\n              if (this.isSelected(el)) {\n                this.removeSelected(el);\n                removed.push(el);\n              }\n            });\n          }\n          this.updateGroupInfo(item);\n        });\n        this.filteredList.forEach((el: any) => {\n          if (this.isSelected(el)) {\n            this.removeSelected(el);\n            removed.push(el);\n          }\n        });\n      } else {\n        this.filteredList.forEach((item: any) => {\n          if (this.isSelected(item)) {\n            this.removeSelected(item);\n            removed.push(item);\n          }\n        });\n      }\n      this.isFilterSelectAll = false;\n      this.onFilterDeSelectAll.emit(removed);\n    }\n  }\n  toggleInfiniteFilterSelectAll() {\n    if (!this.isInfiniteFilterSelectAll) {\n      this.virtualdata.forEach((item: any) => {\n        if (!this.isSelected(item)) {\n          this.addSelected(item);\n        }\n      });\n      this.isInfiniteFilterSelectAll = true;\n    } else {\n      this.virtualdata.forEach((item: any) => {\n        if (this.isSelected(item)) {\n          this.removeSelected(item);\n        }\n      });\n      this.isInfiniteFilterSelectAll = false;\n    }\n  }\n  clearSearch() {\n    if (this.settings.groupBy) {\n      this.groupedData = [];\n      this.groupedData = this.cloneArray(this.groupCachedItems);\n    }\n    this.filter = '';\n    this.isFilterSelectAll = false;\n    this.searchTerm$.next('');\n    this.data = this.cachedItems;\n  }\n  onFilterChange(data: any) {\n    if ((this.filter && this.filter == '') || data.length == 0) {\n      this.isFilterSelectAll = false;\n      this.data = this.cachedItems.slice();\n    }\n    let cnt = 0;\n    data.forEach((item: any) => {\n      if (!item.hasOwnProperty('grpTitle') && this.isSelected(item)) {\n        cnt++;\n      }\n    });\n\n    if (cnt > 0 && this.filterLength == cnt) {\n      this.isFilterSelectAll = true;\n    } else if (cnt > 0 && this.filterLength != cnt) {\n      this.isFilterSelectAll = false;\n    }\n    this.data = data;\n  }\n  cloneArray(arr: any) {\n    let i, copy;\n\n    if (Array.isArray(arr)) {\n      return JSON.parse(JSON.stringify(arr));\n    } else if (typeof arr === 'object') {\n      throw 'Cannot clone array containing an object!';\n    } else {\n      return arr;\n    }\n  }\n  updateGroupInfo(item: any) {\n    if (item.disabled) {\n      return;\n    }\n    let key = this.settings.groupBy;\n    this.groupedData.forEach((obj: any) => {\n      let cnt = 0;\n      if (obj.grpTitle && item[key] == obj[key]) {\n        if (obj.list) {\n          obj.list.forEach((el: any) => {\n            if (this.isSelected(el)) {\n              cnt++;\n            }\n          });\n        }\n      }\n      if (obj.list && cnt === obj.list.length && item[key] == obj[key]) {\n        obj.selected = true;\n      } else if (obj.list && cnt != obj.list.length && item[key] == obj[key]) {\n        obj.selected = false;\n      }\n    });\n    this.groupCachedItems.forEach((obj: any) => {\n      let cnt = 0;\n      if (obj.grpTitle && item[key] == obj[key]) {\n        if (obj.list) {\n          obj.list.forEach((el: any) => {\n            if (this.isSelected(el)) {\n              cnt++;\n            }\n          });\n        }\n      }\n      if (obj.list && cnt === obj.list.length && item[key] == obj[key]) {\n        obj.selected = true;\n      } else if (obj.list && cnt != obj.list.length && item[key] == obj[key]) {\n        obj.selected = false;\n      }\n    });\n  }\n  transformData(arr: Array<any>, field: any): Array<any> {\n    const groupedObj: any = arr.reduce((prev: any, cur: any) => {\n      if (!prev[cur[field]]) {\n        prev[cur[field]] = [cur];\n      } else {\n        prev[cur[field]].push(cur);\n      }\n      return prev;\n    }, {});\n    const tempArr: any = [];\n    Object.keys(groupedObj).map((x: any) => {\n      let obj: any = {};\n      let disabledChildrens = [];\n      obj['grpTitle'] = true;\n      obj[this.settings.labelKey] = x;\n      obj[this.settings.groupBy] = x;\n      obj['selected'] = false;\n      obj['list'] = [];\n      let cnt = 0;\n      groupedObj[x].forEach((item: any) => {\n        item['list'] = [];\n        if (item.disabled) {\n          this.isDisabledItemPresent = true;\n          disabledChildrens.push(item);\n        }\n        obj.list.push(item);\n        if (this.isSelected(item)) {\n          cnt++;\n        }\n      });\n      if (cnt == obj.list.length) {\n        obj.selected = true;\n      } else {\n        obj.selected = false;\n      }\n\n      // Check if current group item's all childrens are disabled or not\n      obj['disabled'] = disabledChildrens.length === groupedObj[x].length;\n      tempArr.push(obj);\n      // obj.list.forEach((item: any) => {\n      //     tempArr.push(item);\n      // });\n    });\n    return tempArr;\n  }\n  public filterInfiniteList(evt: any) {\n    let filteredElems: Array<any> = [];\n    if (this.settings.groupBy) {\n      this.groupedData = this.groupCachedItems.slice();\n    } else {\n      this.data = this.cachedItems.slice();\n      this.virtualdata = this.cachedItems.slice();\n    }\n\n    if ((evt != null || evt != '') && !this.settings.groupBy) {\n      if (this.settings.searchBy.length > 0) {\n        for (let t = 0; t < this.settings.searchBy.length; t++) {\n          this.virtualdata.filter((el: any) => {\n            if (\n              el[this.settings.searchBy[t].toString()]\n                .toString()\n                .toLowerCase()\n                .indexOf(evt.toString().toLowerCase()) >= 0\n            ) {\n              filteredElems.push(el);\n            }\n          });\n        }\n      } else {\n        this.virtualdata.filter(function (el: any) {\n          for (let prop in el) {\n            if (\n              el[prop]\n                .toString()\n                .toLowerCase()\n                .indexOf(evt.toString().toLowerCase()) >= 0\n            ) {\n              filteredElems.push(el);\n              break;\n            }\n          }\n        });\n      }\n      this.virtualdata = [];\n      this.virtualdata = filteredElems;\n      this.infiniteFilterLength = this.virtualdata.length;\n    }\n    if (evt.toString() != '' && this.settings.groupBy) {\n      this.groupedData.filter(function (el: any) {\n        if (el.hasOwnProperty('grpTitle')) {\n          filteredElems.push(el);\n        } else {\n          for (let prop in el) {\n            if (\n              el[prop]\n                .toString()\n                .toLowerCase()\n                .indexOf(evt.toString().toLowerCase()) >= 0\n            ) {\n              filteredElems.push(el);\n              break;\n            }\n          }\n        }\n      });\n      this.groupedData = [];\n      this.groupedData = filteredElems;\n      this.infiniteFilterLength = this.groupedData.length;\n    } else if (evt.toString() == '' && this.cachedItems.length > 0) {\n      this.virtualdata = [];\n      this.virtualdata = this.cachedItems;\n      this.infiniteFilterLength = 0;\n    }\n    if (this.virtualScroller) {\n      this.virtualScroller.refresh();\n    }\n  }\n  resetInfiniteSearch() {\n    this.filter = '';\n    this.isInfiniteFilterSelectAll = false;\n    this.virtualdata = [];\n    this.virtualdata = this.cachedItems;\n    this.groupedData = this.groupCachedItems;\n    this.searchTerm$.next('');\n    this.infiniteFilterLength = 0;\n  }\n  onScrollEnd(e: any) {\n    if (e.endIndex === this.data.length - 1 || e.startIndex === 0) {\n    }\n    this.onScrollToEnd.emit(e);\n  }\n  ngOnDestroy() {\n    if (this.subscription) {\n      this.subscription.unsubscribe();\n    }\n  }\n  selectGroup(item: any) {\n    if (item.disabled) {\n      return;\n    }\n    if (item.selected) {\n      item.selected = false;\n      item.list.forEach((obj: any) => {\n        this.removeSelected(obj);\n      });\n\n      this.onGroupDeSelect.emit(item);\n      this.updateGroupInfo(item);\n    } else {\n      item.selected = true;\n      item.list.forEach((obj: any) => {\n        if (!this.isSelected(obj)) {\n          this.addSelected(obj);\n        }\n      });\n      this.onGroupSelect.emit(item);\n      this.updateGroupInfo(item);\n    }\n  }\n  addFilterNewItem() {\n    this.onAddFilterNewItem.emit(this.filter);\n    this.filterPipe.transform(this.data, this.filter, this.settings.searchBy);\n  }\n  calculateDropdownDirection() {\n    let shouldOpenTowardsTop = this.settings.position == 'top';\n    const elem = this.cuppaDropdown.nativeElement;\n    const dropdownWidth = elem.clientWidth;\n    this.dropDownWidth = dropdownWidth;\n    this.dropDownLeft = this.settings.tagToBody\n      ? elem.getBoundingClientRect().x\n      : 'unset';\n    if (this.settings.position == 'top' && !this.settings.autoPosition) {\n      this.openTowardsTop(true);\n    } else if (\n      this.settings.position == 'bottom' &&\n      !this.settings.autoPosition\n    ) {\n      this.openTowardsTop(false);\n    }\n    if (this.settings.autoPosition) {\n      const dropdownHeight = this.defaultSettings.maxHeight;\n      const viewportHeight = document.documentElement.clientHeight;\n      const selectedListBounds =\n        this.selectedListElem.nativeElement.getBoundingClientRect();\n\n      const spaceOnTop: number = selectedListBounds.top;\n      const spaceOnBottom: number = viewportHeight - selectedListBounds.top;\n      if (spaceOnBottom < spaceOnTop && dropdownHeight < spaceOnTop) {\n        this.openTowardsTop(true);\n      } else {\n        this.openTowardsTop(false);\n      }\n      // Keep preference if there is not enough space on either the top or bottom\n      /* \t\t\tif (spaceOnTop || spaceOnBottom) {\n                            if (shouldOpenTowardsTop) {\n                                shouldOpenTowardsTop = spaceOnTop;\n                            } else {\n                                shouldOpenTowardsTop = !spaceOnBottom;\n                            }\n                        } */\n    }\n  }\n  openTowardsTop(value: boolean) {\n    const elem = this.cuppaDropdown.nativeElement;\n    if (value && this.selectedListElem.nativeElement.clientHeight) {\n      this.dropdownListYOffset =\n        15 - this.selectedListElem.nativeElement.clientHeight;\n      if (this.settings.tagToBody) {\n        this.dropDownTop =\n          elem.getBoundingClientRect().y -\n          this.selectedListElem.nativeElement.clientHeight * 2 -\n          15 -\n          this.defaultSettings.maxHeight +\n          'px';\n      } else {\n        this.dropDownBottom =\n          this.selectedListElem.nativeElement.clientHeight + 15 + 'px';\n      }\n      this.settings.position = 'top';\n    } else {\n      if (this.settings.tagToBody) {\n        this.dropDownTop =\n          elem.getBoundingClientRect().y + elem.clientHeight + 1 + 'px';\n      } else {\n        this.dropDownTop = 'unset';\n        this.dropDownBottom = 'unset';\n      }\n      this.dropdownListYOffset = 0;\n      this.settings.position = 'bottom';\n    }\n  }\n  clearSelection(e?: any) {\n    if (this.settings.groupBy) {\n      this.groupCachedItems.forEach((obj) => {\n        obj.selected = false;\n      });\n    }\n    this.clearSearch();\n    this.selectedItems = [];\n    this.isSelectAll = false;\n    this.onChangeCallback(this.selectedItems);\n    this.onTouchedCallback(this.selectedItems);\n    this.onDeSelectAll.emit(this.selectedItems);\n  }\n  filteritems(evt: any) {\n    this.filteredList = this.filterPipe.transform(\n      this.cachedItems,\n      evt.target.value,\n      this.settings.searchBy,\n    );\n    if (this.filteredList) {\n      let len = 0;\n      this.filteredList.forEach((obj: any, i: any) => {\n        if (obj.disabled) {\n          this.isDisabledItemPresent = true;\n        }\n        if (!obj.hasOwnProperty('grpTitle')) {\n          len++;\n        }\n      });\n      this.filterLength = len;\n    }\n    this.onFilterChange(this.filteredList);\n  }\n}\n\n@NgModule({\n  imports: [CommonModule, FormsModule, VirtualScrollerModule],\n  declarations: [\n    AngularMultiSelect,\n    ClickOutsideDirective,\n    ScrollDirective,\n    ListFilterPipe,\n    Item,\n    TemplateRenderer,\n    Badge,\n    Search,\n    CIcon,\n  ],\n  exports: [\n    AngularMultiSelect,\n    ClickOutsideDirective,\n    ScrollDirective,\n    ListFilterPipe,\n    Item,\n    TemplateRenderer,\n    Badge,\n    Search,\n    CIcon,\n  ],\n  providers: [DataService, ListFilterPipe],\n})\nexport class AngularMultiSelectModule {}\n","<div class=\"cuppa-dropdown\" (clickOutside)=\"closeDropdownOnClickOut()\" [enabled]=\"isActive\" #cuppaDropdown>\n  <div class=\"selected-list\" #selectedList>\n    <div class=\"c-btn\" (click)=\"toggleDropdown($event)\" [ngClass]=\"{'disabled': settings.disabled}\" [attr.tabindex]=\"0\">\n\n      <span *ngIf=\"selectedItems?.length == 0\">{{ settings.text }}</span>\n      <span *ngIf=\"settings.singleSelection && !badgeTempl\">\n                <span *ngFor=\"let item of selectedItems;trackBy: trackByFn.bind(this);let k = index\">\n                    {{ item[settings.labelKey] }}\n                </span>\n            </span>\n      <span class=\"c-list\" *ngIf=\"selectedItems?.length > 0 && settings.singleSelection && badgeTempl \">\n                <div class=\"c-token\" *ngFor=\"let item of selectedItems;trackBy: trackByFn.bind(this);let k = index\">\n                    <span *ngIf=\"!badgeTempl\" class=\"c-label\">{{ item[settings.labelKey] }}</span>\n\n                    <span *ngIf=\"badgeTempl\" class=\"c-label\">\n                        <c-templateRenderer [data]=\"badgeTempl\" [item]=\"item\"></c-templateRenderer>\n                    </span>\n                    <span class=\"c-remove\" (click)=\"onItemClick(item,k,$event);$event.stopPropagation()\">\n                        <c-icon name=\"remove\"/>\n                    </span>\n                </div>\n            </span>\n      <div class=\"c-list\" *ngIf=\"selectedItems?.length > 0 && !settings.singleSelection\">\n        <div class=\"c-token\" *ngFor=\"let item of selectedItems;trackBy: trackByFn.bind(this);let k = index\"\n             [hidden]=\"k > settings.badgeShowLimit-1\">\n\n          @if (badgeTempl) {\n            <span class=\"c-label\"><c-templateRenderer [data]=\"badgeTempl\" [item]=\"item\"></c-templateRenderer></span>\n          } @else {\n            <span class=\"c-label\">{{ item[settings.labelKey] }}</span>\n\n          }\n\n          <span class=\"c-remove\" (click)=\"onItemClick(item,k,$event);$event.stopPropagation()\">\n                        <c-icon [name]=\"'remove'\"></c-icon>\n                    </span>\n        </div>\n      </div>\n      <span class=\"countplaceholder\"\n            *ngIf=\"selectedItems?.length > settings.badgeShowLimit\">+{{ selectedItems?.length - settings.badgeShowLimit }}</span>\n      <span class=\"c-remove clear-all\" *ngIf=\"settings.clearAll && selectedItems?.length > 0 && !settings.disabled\"\n            (click)=\"clearSelection($event);$event.stopPropagation()\">\n                <c-icon [name]=\"'remove'\"></c-icon>\n            </span>\n      @if (isActive) {\n        <span class=\"c-angle-up\"><c-icon [name]=\"'angle-up'\"></c-icon></span>\n      } @else {\n        <span class=\"c-angle-down\"><c-icon [name]=\"'angle-down'\"></c-icon></span>\n      }\n    </div>\n  </div>\n  <div #dropdownList class=\"dropdown-list animated fadeIn\"\n       [ngClass]=\"{'tagToBody': settings.tagToBody}\"\n       [style.width.px]=\"dropDownWidth\"\n       [style.top]=\"dropDownTop\"\n       [style.bottom]=\"dropDownBottom\"\n       [style.left.px]=\"dropDownLeft\"\n       [hidden]=\"!isActive\">\n    <div [ngClass]=\"{'arrow-up': settings.position == 'bottom', 'arrow-down': settings.position == 'top'}\"\n         class=\"arrow-2\"></div>\n    <div [ngClass]=\"{'arrow-up': settings.position == 'bottom', 'arrow-down': settings.position == 'top'}\"></div>\n    <div class=\"list-area\" [ngClass]=\"{'single-select-mode': settings.singleSelection }\">\n      <div class=\"pure-checkbox select-all\"\n           *ngIf=\"settings.enableCheckAll && !settings.singleSelection && !settings.limitSelection && data?.length > 0 && !isDisabledItemPresent\"\n      >\n        <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelectAll\"\n               [disabled]=\"settings.limitSelection == selectedItems?.length\"\n               [id]=\"id\" (change)=\"toggleSelectAll($event)\"/>\n        <label [for]=\"id\">\n          <span [hidden]=\"isSelectAll\">{{ settings.selectAllText }}</span>\n          <span [hidden]=\"!isSelectAll\">{{ settings.unSelectAllText }}</span>\n        </label>\n      </div>\n      <img class=\"loading-icon\" *ngIf=\"loading\" src=\"assets/img/loading.gif\"/>\n      <div class=\"list-filter\" *ngIf=\"settings.enableSearchFilter\">\n                <span class=\"c-search\" id=\"searchIcon\">\n                    <c-icon [name]=\"'search'\"></c-icon>\n                </span>\n        <span *ngIf=\"!settings.lazyLoading\" [hidden]=\"filter == undefined || filter?.length == 0\" class=\"c-clear\"\n              (click)=\"clearSearch()\">\n                    <c-icon [name]=\"'clear'\"></c-icon>\n                </span>\n        <span *ngIf=\"settings.lazyLoading\" [hidden]=\"filter == undefined || filter?.length == 0\" class=\"c-clear\"\n              (click)=\"resetInfiniteSearch()\">\n                    <c-icon [name]=\"'clear'\"></c-icon>\n                </span>\n\n        <input class=\"c-input\" *ngIf=\"settings.groupBy && !settings.lazyLoading && !searchTempl\" #searchInput\n               type=\"text\" [placeholder]=\"settings.searchPlaceholderText\"\n               [(ngModel)]=\"filter\" (keyup)=\"filterGroupedList()\" aria-labelledby=\"searchIcon\">\n        <input class=\"c-input\" *ngIf=\"!settings.groupBy && !settings.lazyLoading && !searchTempl\" #searchInput\n               type=\"text\" [placeholder]=\"settings.searchPlaceholderText\"\n               [(ngModel)]=\"filter\" (keyup)=\"filteritems($event)\" aria-labelledby=\"searchIcon\">\n        <input class=\"c-input\" *ngIf=\"settings.lazyLoading && !searchTempl\" #searchInput type=\"text\"\n               [placeholder]=\"settings.searchPlaceholderText\"\n               [(ngModel)]=\"filter\" (keyup)=\"onKeyUp($event)\" aria-labelledby=\"searchIcon\">\n        <!--            <input class=\"c-input\" *ngIf=\"!settings.lazyLoading && !searchTempl && settings.groupBy\" #searchInput type=\"text\" [placeholder]=\"settings.searchPlaceholderText\"\n        [(ngModel)]=\"filter\" (keyup)=\"filterGroupList($event)\">-->\n        <c-templateRenderer *ngIf=\"searchTempl\" [data]=\"searchTempl\" [item]=\"item\"></c-templateRenderer>\n      </div>\n      <div class=\"filter-select-all\"\n           *ngIf=\"!settings.lazyLoading && settings.enableFilterSelectAll && !isDisabledItemPresent\">\n        <div class=\"pure-checkbox select-all\"\n             *ngIf=\"!settings.groupBy && filter?.length > 0 && filterLength > 0  && !settings.singleSelection\"\n             (click)=\"toggleFilterSelectAll()\">\n          <input type=\"checkbox\" [checked]=\"isFilterSelectAll\"\n                 [disabled]=\"settings.limitSelection == selectedItems?.length\" aria-labelledby=\"optionName\"\n                 aria-label=\"option\"/>\n          <label>\n            <span [hidden]=\"isFilterSelectAll\">{{ settings.filterSelectAllText }}</span>\n            <span [hidden]=\"!isFilterSelectAll\">{{ settings.filterUnSelectAllText }}</span>\n          </label>\n        </div>\n        <div class=\"pure-checkbox select-all\"\n             *ngIf=\"settings.groupBy && filter?.length > 0 && groupedData?.length > 0  && !settings.singleSelection\"\n             (click)=\"toggleFilterSelectAll()\">\n          <input type=\"checkbox\" [checked]=\"isFilterSelectAll && filter?.length > 0\"\n                 [disabled]=\"settings.limitSelection == selectedItems?.length\"\n                 aria-labelledby=\"option\"/>\n          <label>\n            <span [hidden]=\"isFilterSelectAll\">{{ settings.filterSelectAllText }}</span>\n            <span [hidden]=\"!isFilterSelectAll\">{{ settings.filterUnSelectAllText }}</span>\n          </label>\n        </div>\n      </div>\n      <div class=\"filter-select-all\"\n           *ngIf=\"settings.lazyLoading && settings.enableFilterSelectAll && !isDisabledItemPresent && !settings.singleSelection\">\n        <div class=\"pure-checkbox select-all\" *ngIf=\"filter?.length > 0 && infiniteFilterLength > 0\"\n             (click)=\"toggleInfiniteFilterSelectAll()\">\n          <input type=\"checkbox\" [checked]=\"isInfiniteFilterSelectAll\"\n                 [disabled]=\"settings.limitSelection == selectedItems?.length\"\n                 aria-labelledby=\"option\"/>\n          <label>\n            <span [hidden]=\"isInfiniteFilterSelectAll\">{{ settings.filterSelectAllText }}</span>\n            <span [hidden]=\"!isInfiniteFilterSelectAll\">{{ settings.filterUnSelectAllText }}</span>\n          </label>\n        </div>\n      </div>\n      <div class=\"filter-select-all\" *ngIf=\"filter?.length\">\n        <div class=\"btn-container\" *ngIf=\"settings.addNewItemOnFilter\">\n          <button class=\"c-btn btn-iceblue\" (click)=\"addFilterNewItem()\">{{ settings.addNewButtonText }}</button>\n        </div>\n      </div>\n\n      <div *ngIf=\"!settings.groupBy && !settings.lazyLoading && itemTempl == undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <ul class=\"lazyContainer\">\n          <li *ngFor=\"let item of data; let i = index;\" (click)=\"onItemClick(item,i,$event)\"\n              class=\"pure-checkbox\" [ngClass]=\"{'selected-item': isSelected(item) == true }\">\n            <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(item)\"\n                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n                   aria-labelledby=\"option\"/>\n            <label>{{ item[settings.labelKey] }}</label>\n          </li>\n        </ul>\n      </div>\n      <!-- lazy loading -->\n      <div *ngIf=\"!settings.groupBy && settings.lazyLoading && itemTempl == undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <ul virtualScroller #scroll [enableUnequalChildrenSizes]=\"randomSize\" [items]=\"virtualdata\"\n            (vsStart)=\"onScrollEnd($event)\"\n            (vsEnd)=\"onScrollEnd($event)\" [ngStyle]=\"{'height': settings.maxHeight+'px'}\" class=\"lazyContainer\">\n          <li *ngFor=\"let item of scroll.viewPortItems; let i = index;\" (click)=\"onItemClick(item,i,$event)\"\n              class=\"pure-checkbox\"\n              [ngClass]=\"{'selected-item': isSelected(item) == true }\">\n            <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(item)\"\n                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n            />\n            <label>{{ item[settings.labelKey] }}</label>\n          </li>\n        </ul>\n      </div>\n      <!-- custom template -->\n      <div *ngIf=\"!settings.groupBy && !settings.lazyLoading && itemTempl != undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <ul class=\"lazyContainer\">\n          <li *ngFor=\"let item of data; let i = index;\" (click)=\"onItemClick(item,i,$event)\"\n              class=\"pure-checkbox\" [ngClass]=\"{'selected-item': isSelected(item) == true }\">\n            <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(item)\"\n                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n            />\n            <label></label>\n            <c-templateRenderer [data]=\"itemTempl\" [item]=\"item\"></c-templateRenderer>\n          </li>\n        </ul>\n      </div>\n      <!-- lazy loading and custom template -->\n      <div *ngIf=\"!settings.groupBy && settings.lazyLoading && itemTempl != undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <ul virtualScroller #scroll2 [enableUnequalChildrenSizes]=\"randomSize\" [items]=\"virtualdata\"\n            (vsStart)=\"onScrollEnd($event)\"\n            (vsEnd)=\"onScrollEnd($event)\" class=\"lazyContainer\" [ngStyle]=\"{'height': settings.maxHeight+'px'}\">\n          <li *ngFor=\"let item of scroll2.viewPortItems; let i = index;\" (click)=\"onItemClick(item,i,$event)\"\n              class=\"pure-checkbox\"\n              [ngClass]=\"{'selected-item': isSelected(item) == true }\">\n            <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(item)\"\n                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n            />\n            <label></label>\n            <c-templateRenderer [data]=\"itemTempl\" [item]=\"item\"></c-templateRenderer>\n          </li>\n        </ul>\n      </div>\n      <!-- lazy loading, group By and custom template -->\n      <div *ngIf=\"settings.groupBy && settings.lazyLoading && itemTempl != undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <ul virtualScroller #scroll3 [enableUnequalChildrenSizes]=\"randomSize\" [items]=\"virtualdata\"\n            (vsStart)=\"onScrollEnd($event)\"\n            (vsEnd)=\"onScrollEnd($event)\" [ngStyle]=\"{'height': settings.maxHeight+'px'}\" class=\"lazyContainer\">\n                    <span *ngFor=\"let item of scroll3.viewPortItems; let i = index;\">\n                        <li (click)=\"onItemClick(item,i,$event)\" *ngIf=\"!item.grpTitle\"\n                            [ngClass]=\"{'grp-title': item.grpTitle,'grp-item': !item.grpTitle && !settings.singleSelection}\"\n                            class=\"pure-checkbox\">\n                            <input *ngIf=\"settings.showCheckbox && !settings.singleSelection\" type=\"checkbox\"\n                                   [checked]=\"isSelected(item)\"\n                                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n                            />\n                            <label></label>\n                            <c-templateRenderer [data]=\"itemTempl\" [item]=\"item\"></c-templateRenderer>\n                        </li>\n                        <li *ngIf=\"item.grpTitle\"\n                            [ngClass]=\"{'grp-title': item.grpTitle,'grp-item': !item.grpTitle && !settings.singleSelection}\"\n                            class=\"pure-checkbox\">\n                            <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(item)\"\n                                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n                            />\n                            <label></label>\n                            <c-templateRenderer [data]=\"itemTempl\" [item]=\"item\"></c-templateRenderer>\n                        </li>\n                    </span>\n        </ul>\n      </div>\n      <!-- group By and custom template -->\n      <div *ngIf=\"settings.groupBy && !settings.lazyLoading && itemTempl != undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <ul class=\"lazyContainer\">\n                    <span *ngFor=\"let item of groupedData; let i = index;\">\n                        <li (click)=\"selectGroup(item)\"\n                            [ngClass]=\"{'grp-title': item.grpTitle,'grp-item': !item.grpTitle && !settings.singleSelection}\"\n                            class=\"pure-checkbox\">\n                            <input *ngIf=\"settings.showCheckbox && !settings.singleSelection\" type=\"checkbox\"\n                                   [checked]=\"item.selected\"\n                                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n                            />\n                            <label>{{ item[settings.labelKey] }}</label>\n                            <ul class=\"lazyContainer\">\n                                <span *ngFor=\"let val of item.list ; let j = index;\">\n                                    <li (click)=\"onItemClick(val,j,$event); $event.stopPropagation()\"\n                                        [ngClass]=\"{'grp-title': val.grpTitle,'grp-item': !val.grpTitle && !settings.singleSelection}\"\n                                        class=\"pure-checkbox\">\n                                        <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(val)\"\n                                               [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(val)) || val.disabled\"\n                                        />\n                                        <label></label>\n                                        <c-templateRenderer [data]=\"itemTempl\" [item]=\"val\"></c-templateRenderer>\n                                    </li>\n                                </span>\n                            </ul>\n\n                        </li>\n                    </span>\n        </ul>\n      </div>\n      <!-- lazy loading, group By -->\n      <div *ngIf=\"settings.groupBy && settings.lazyLoading && itemTempl == undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <virtual-scroller [items]=\"groupedData\" (vsUpdate)=\"viewPortItems = $event\" (vsEnd)=\"onScrollEnd($event)\"\n                          [ngStyle]=\"{'height': settings.maxHeight+'px'}\">\n          <ul virtualScroller #scroll4 [enableUnequalChildrenSizes]=\"randomSize\" [items]=\"virtualdata\"\n              (vsStart)=\"onScrollEnd($event)\"\n              (vsEnd)=\"onScrollEnd($event)\" [ngStyle]=\"{'height': settings.maxHeight+'px'}\" class=\"lazyContainer\">\n                        <span *ngFor=\"let item of scroll4.viewPortItems; let i = index;\">\n                            <li *ngIf=\"item.grpTitle\"\n                                [ngClass]=\"{'grp-title': item.grpTitle,'grp-item': !item.grpTitle && !settings.singleSelection, 'selected-item': isSelected(item) == true }\"\n                                class=\"pure-checkbox\">\n                                <input *ngIf=\"settings.showCheckbox && !item.grpTitle && !settings.singleSelection\"\n                                       type=\"checkbox\" [checked]=\"isSelected(item)\"\n                                       [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n                                />\n                                <label>{{ item[settings.labelKey] }}</label>\n                            </li>\n                            <li (click)=\"onItemClick(item,i,$event)\" *ngIf=\"!item.grpTitle\"\n                                [ngClass]=\"{'grp-title': item.grpTitle,'grp-item': !item.grpTitle && !settings.singleSelection, 'selected-item': isSelected(item) == true }\"\n                                class=\"pure-checkbox\">\n                                <input *ngIf=\"settings.showCheckbox && !item.grpTitle\" type=\"checkbox\"\n                                       [checked]=\"isSelected(item)\"\n                                       [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n                                />\n                                <label>{{ item[settings.labelKey] }}</label>\n                            </li>\n                        </span>\n          </ul>\n        </virtual-scroller>\n      </div>\n      <!-- group By -->\n      <div *ngIf=\"settings.groupBy && !settings.lazyLoading && itemTempl == undefined\"\n           [style.maxHeight]=\"settings.maxHeight+'px'\"\n           style=\"overflow: auto;\">\n        <ul class=\"lazyContainer\">\n                    <span *ngFor=\"let item of groupedData ; let i = index;\">\n                        <li (click)=\"selectGroup(item)\"\n                            [ngClass]=\"{'grp-title': item.grpTitle,'grp-item': !item.grpTitle && !settings.singleSelection}\"\n                            class=\"pure-checkbox\">\n                            <input *ngIf=\"settings.showCheckbox && !settings.singleSelection\" type=\"checkbox\"\n                                   [checked]=\"item.selected\"\n                                   [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(item)) || item.disabled\"\n                            />\n                            <label>{{ item[settings.labelKey] }}</label>\n                            <ul class=\"lazyContainer\">\n                                <span *ngFor=\"let val of item.list ; let j = index;\">\n                                    <li (click)=\"onItemClick(val,j,$event); $event.stopPropagation()\"\n                                        [ngClass]=\"{'selected-item': isSelected(val) == true,'grp-title': val.grpTitle,'grp-item': !val.grpTitle && !settings.singleSelection}\"\n                                        class=\"pure-checkbox\">\n                                        <input *ngIf=\"settings.showCheckbox\" type=\"checkbox\" [checked]=\"isSelected(val)\"\n                                               [disabled]=\"(settings.limitSelection == selectedItems?.length && !isSelected(val)) || val.disabled\"\n                                        />\n                                        <label>{{ val[settings.labelKey] }}</label>\n                                    </li>\n                                </span>\n                            </ul>\n                        </li>\n                    </span>\n        </ul>\n      </div>\n      <h5 class=\"list-message\" *ngIf=\"data?.length == 0\">{{ settings.noDataLabel }}</h5>\n    </div>\n  </div>\n</div>\n"]}