ngx-dropdown-list 1.1.0 → 1.2.0

package/README.md

@@ -2,7 +2,7 @@
 
 [![npm](https://img.shields.io/npm/v/ngx-dropdown-list.svg?style=flat-square)](https://www.npmjs.com/package/ngx-dropdown-list) [![npm downloads](https://img.shields.io/npm/dm/ngx-dropdown-list.svg)](https://www.npmjs.com/package/ngx-dropdown-list) [![Travis](https://img.shields.io/travis/ckyycc/ngx-dropdown-list.svg?style=flat-square)](https://travis-ci.org/ckyycc/ngx-dropdown-list) [![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square)](https://github.com/ckyycc/ngx-dropdown-list/blob/master/LICENSE)
 
-An Angular 7 module for selecting data from drop-down list which supports multi-selection and filter.
+An Angular 13 module for selecting data from drop-down list which supports multi-selection and filter.
 
 ## Installation
 ```bash
@@ -91,7 +91,7 @@ timezones = [
 
 Todo
 ----
-* ~~Support Angular 7~~
+* ~~Support Angular 13~~
 * ...
 
 ## License

package/esm2020/ngx-dropdown-list.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmd4LWRyb3Bkb3duLWxpc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9uZ3gtZHJvcGRvd24tbGlzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpY19hcGknO1xuIl19

package/esm2020/public_api.mjs

@@ -0,0 +1,2 @@
+export * from './src/ngx-dropdown-list/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywrQkFBK0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc3JjL25neC1kcm9wZG93bi1saXN0L2luZGV4JztcclxuIl19

package/esm2020/src/ngx-dropdown-list/anchor/anchor.component.mjs

@@ -0,0 +1,149 @@
+import { Component, ElementRef, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { stopPropagationAndDefault, isNumber } from '../utils/util';
+import { DecimalPipe } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class AnchorComponent {
+    constructor(_decimalPipe) {
+        this._decimalPipe = _decimalPipe;
+        /**
+         * bind to [checkbox] for checking whether the clearance flag should be shown or not.
+         */
+        this.checkbox = false;
+        /**
+         * bind to [allowClear] for enabling the clearance (clearance is not avaiable when checkbox is enabled)
+         */
+        this.allowClear = true;
+        /**
+         * bind to [openStatus], it's the visibility status of dropdown, for showing the arrow on anchor
+         */
+        this.openStatus = false;
+        /**
+         * bind to [disabled] for disabling the anchor
+         */
+        this.disabled = false;
+        /**
+         * will be triggered when clicking the anchor
+         */
+        this.anchorClick = new EventEmitter();
+        /**
+         * will be triggered when clicking the clearance
+         */
+        this.clearanceClick = new EventEmitter();
+    }
+    /**
+     * flag for showing the clearance flag
+     */
+    get showClearanceFlag() {
+        return !this.checkbox && this.selectedText && this.allowClear;
+    }
+    /**
+     * the text displays on anchor
+     */
+    get anchorDisplayText() {
+        let anchorDisplayText = this.selectedText ? (this.formatNumber ? (isNumber(this.selectedText) ?
+            this._decimalPipe.transform(this.selectedText, '1.0-2') : this.selectedText) :
+            this.selectedText) + (this.suffixText ? this.suffixText : '') : this.placeHolder;
+        let charLength = 1;
+        if (this.showClearanceFlag && this.anchorLength > 0) {
+            charLength = Math.floor((this.anchorLength - 50) / 7);
+        }
+        else {
+            charLength = Math.floor((this.anchorLength - 50) / 7);
+        }
+        if (anchorDisplayText.length > charLength) {
+            anchorDisplayText = anchorDisplayText.slice(0, charLength - 2) + '...';
+        }
+        return anchorDisplayText;
+    }
+    /**
+     * anchor CSS class
+     */
+    get anchorClass() {
+        let anchorClassStatusPart;
+        let anchorClassFontColor;
+        if (this.disabled) {
+            anchorClassStatusPart = 'selection-anchor-disabled';
+            anchorClassFontColor = 'place-holder';
+        }
+        else {
+            if (this.openStatus) {
+                anchorClassStatusPart = 'selection-anchor-open';
+            }
+            else {
+                anchorClassStatusPart = 'selection-anchor-close';
+            }
+            if (this.selectedText != null) {
+                anchorClassFontColor = 'selected-item';
+            }
+            else {
+                anchorClassFontColor = 'place-holder';
+            }
+        }
+        return `${anchorClassStatusPart} ${anchorClassFontColor}`;
+    }
+    /**
+     * triggered when clicking the anchor
+     */
+    onAnchorClick(event) {
+        this.anchorClick.emit(event);
+    }
+    /**
+     * triggered with (blur) of anchor
+     */
+    onAnchorBlur(event) {
+        stopPropagationAndDefault(event);
+    }
+    /**
+     * triggered when clicking the clearance
+     */
+    onClearanceClick(event) {
+        this.clearanceClick.emit(event);
+    }
+    /**
+     * triggered when resizing, get the clientWidth of anchor
+     */
+    onResize() {
+        this.anchorLength = this.anchorRef ? this.anchorRef.nativeElement ? this.anchorRef.nativeElement.clientWidth : 0 : 0;
+    }
+}
+AnchorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AnchorComponent, deps: [{ token: i1.DecimalPipe }], target: i0.ɵɵFactoryTarget.Component });
+AnchorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: AnchorComponent, selector: "anchor", inputs: { placeHolder: "placeHolder", checkbox: "checkbox", suffixText: "suffixText", allowClear: "allowClear", formatNumber: "formatNumber", selectedText: "selectedText", openStatus: "openStatus", disabled: "disabled" }, outputs: { anchorClick: "anchorClick", clearanceClick: "clearanceClick" }, providers: [DecimalPipe], viewQueries: [{ propertyName: "anchorRef", first: true, predicate: ["anchor"], descendants: true, read: ElementRef }], ngImport: i0, template: `
+    <span #anchor tabindex="2" [ngClass]="anchorClass" (window:resize)="onResize()"
+          (mousedown)="onAnchorClick($event)" (blur)="onAnchorBlur($event)"> {{anchorDisplayText}}
+      <span #selectionClearance class="selection-clearance" (mousedown)="onClearanceClick($event)" *ngIf="showClearanceFlag">&times;</span>
+    </span>
+  `, isInline: true, styles: ["@charset \"UTF-8\";*,*:before,*:after{font-size:inherit;font-weight:inherit;font-family:inherit;box-sizing:inherit;background:inherit}.vertical-center,.selection-anchor-close:after,.selection-anchor-open:after,.selection-anchor-disabled:after{position:absolute;top:50%;transform:translateY(-50%)}.hover-box,.selection-anchor-close:hover{outline:0;box-shadow:0 0 6px #23adff;border-radius:4px}.anchor-box,.selection-anchor-disabled,.selection-anchor,.selection-anchor-close,.selection-anchor-open{height:100%;border-radius:4px;width:100%;position:relative;display:inline-block;padding:8px 12px 5px;border:1px solid;outline:0;box-shadow:inset 0 1px 1px #00000013;box-sizing:border-box;white-space:nowrap}.selection-anchor,.selection-anchor-close,.selection-anchor-open{cursor:pointer}.selection-anchor .selection-clearance,.selection-anchor-close .selection-clearance,.selection-anchor-open .selection-clearance{position:absolute;right:35px;font-weight:700}.selection-anchor .selection-clearance:hover,.selection-anchor-close .selection-clearance:hover,.selection-anchor-open .selection-clearance:hover{color:#000}.selection-anchor:focus,.selection-anchor-close:focus,.selection-anchor-open:focus{box-shadow:inset 0 1px 1px #00000013,0 0 8px #66afe999;transition:border-color ease-in-out .15s,box-shadow ease-in-out .15s;border-color:#66afe9}.selection-anchor-disabled{border-color:#ccc;cursor:default;pointer-events:none;background:#f8f8f8;filter:opacity(50%)}.selection-anchor-disabled:after{font-size:9px;content:\"\\25bc\";right:10px;padding-bottom:3px}.selection-anchor-open{border-bottom:none;border-bottom-right-radius:0;border-bottom-left-radius:0;border-color:#66afe9}.selection-anchor-open:after{font-size:9px;content:\"\\25b2\";right:10px;padding-bottom:3px}.selection-anchor-close{border-color:#ccc}.selection-anchor-close:after{font-size:9px;content:\"\\25bc\";right:10px;padding-bottom:3px}.place-holder{color:#999}.selected-item{color:#495057}\n"], directives: [{ type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AnchorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'anchor', template: `
+    <span #anchor tabindex="2" [ngClass]="anchorClass" (window:resize)="onResize()"
+          (mousedown)="onAnchorClick($event)" (blur)="onAnchorBlur($event)"> {{anchorDisplayText}}
+      <span #selectionClearance class="selection-clearance" (mousedown)="onClearanceClick($event)" *ngIf="showClearanceFlag">&times;</span>
+    </span>
+  `, providers: [DecimalPipe], styles: ["@charset \"UTF-8\";*,*:before,*:after{font-size:inherit;font-weight:inherit;font-family:inherit;box-sizing:inherit;background:inherit}.vertical-center,.selection-anchor-close:after,.selection-anchor-open:after,.selection-anchor-disabled:after{position:absolute;top:50%;transform:translateY(-50%)}.hover-box,.selection-anchor-close:hover{outline:0;box-shadow:0 0 6px #23adff;border-radius:4px}.anchor-box,.selection-anchor-disabled,.selection-anchor,.selection-anchor-close,.selection-anchor-open{height:100%;border-radius:4px;width:100%;position:relative;display:inline-block;padding:8px 12px 5px;border:1px solid;outline:0;box-shadow:inset 0 1px 1px #00000013;box-sizing:border-box;white-space:nowrap}.selection-anchor,.selection-anchor-close,.selection-anchor-open{cursor:pointer}.selection-anchor .selection-clearance,.selection-anchor-close .selection-clearance,.selection-anchor-open .selection-clearance{position:absolute;right:35px;font-weight:700}.selection-anchor .selection-clearance:hover,.selection-anchor-close .selection-clearance:hover,.selection-anchor-open .selection-clearance:hover{color:#000}.selection-anchor:focus,.selection-anchor-close:focus,.selection-anchor-open:focus{box-shadow:inset 0 1px 1px #00000013,0 0 8px #66afe999;transition:border-color ease-in-out .15s,box-shadow ease-in-out .15s;border-color:#66afe9}.selection-anchor-disabled{border-color:#ccc;cursor:default;pointer-events:none;background:#f8f8f8;filter:opacity(50%)}.selection-anchor-disabled:after{font-size:9px;content:\"\\25bc\";right:10px;padding-bottom:3px}.selection-anchor-open{border-bottom:none;border-bottom-right-radius:0;border-bottom-left-radius:0;border-color:#66afe9}.selection-anchor-open:after{font-size:9px;content:\"\\25b2\";right:10px;padding-bottom:3px}.selection-anchor-close{border-color:#ccc}.selection-anchor-close:after{font-size:9px;content:\"\\25bc\";right:10px;padding-bottom:3px}.place-holder{color:#999}.selected-item{color:#495057}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.DecimalPipe }]; }, propDecorators: { anchorRef: [{
+                type: ViewChild,
+                args: ['anchor', { read: ElementRef }]
+            }], placeHolder: [{
+                type: Input
+            }], checkbox: [{
+                type: Input
+            }], suffixText: [{
+                type: Input
+            }], allowClear: [{
+                type: Input
+            }], formatNumber: [{
+                type: Input
+            }], selectedText: [{
+                type: Input
+            }], openStatus: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], anchorClick: [{
+                type: Output
+            }], clearanceClick: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"anchor.component.js","sourceRoot":"","sources":["../../../../../src/ngx-dropdown-list/anchor/anchor.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, ElementRef, EventEmitter, Input, Output, ViewChild} from '@angular/core';\r\nimport {stopPropagationAndDefault, isNumber} from '../utils/util';\r\nimport {DecimalPipe} from '@angular/common';\r\n\r\n@Component({\r\n  selector: 'anchor',\r\n  template: `\r\n    <span #anchor tabindex=\"2\" [ngClass]=\"anchorClass\" (window:resize)=\"onResize()\"\r\n          (mousedown)=\"onAnchorClick($event)\" (blur)=\"onAnchorBlur($event)\"> {{anchorDisplayText}}\r\n      <span #selectionClearance class=\"selection-clearance\" (mousedown)=\"onClearanceClick($event)\" *ngIf=\"showClearanceFlag\">&times;</span>\r\n    </span>\r\n  `,\r\n  styleUrls: ['./anchor.component.scss'],\r\n  providers: [DecimalPipe]\r\n})\r\n\r\nexport class AnchorComponent {\r\n  /**\r\n   * Child element reference of anchor\r\n   */\r\n  @ViewChild('anchor', { read: ElementRef }) anchorRef: ElementRef;\r\n\r\n  /**\r\n   * bind to [placeHolder] for displaying the place holder string of the anchor.\r\n   */\r\n  @Input() placeHolder: string;\r\n  /**\r\n   * bind to [checkbox] for checking whether the clearance flag should be shown or not.\r\n   */\r\n  @Input() checkbox = false;\r\n  /**\r\n   * bind to [suffixText] for displaying the suffix of the selected text of anchor\r\n   */\r\n  @Input() suffixText: string;\r\n  /**\r\n   * bind to [allowClear] for enabling the clearance (clearance is not avaiable when checkbox is enabled)\r\n   */\r\n  @Input() allowClear = true;\r\n  /**\r\n   * bind to [formatNumber] for show formatted number text\r\n   */\r\n  @Input() formatNumber: boolean;\r\n  /**\r\n   * bind to [selectedText] for displaying the selected text on anchor\r\n   */\r\n  @Input() selectedText: any;\r\n  /**\r\n   * bind to [openStatus], it's the visibility status of dropdown, for showing the arrow on anchor\r\n   */\r\n  @Input() openStatus = false;\r\n  /**\r\n   * bind to [disabled] for disabling the anchor\r\n   */\r\n  @Input() disabled = false;\r\n  /**\r\n   * will be triggered when clicking the anchor\r\n   */\r\n  @Output() anchorClick = new EventEmitter<any>();\r\n  /**\r\n   * will be triggered when clicking the clearance\r\n   */\r\n  @Output() clearanceClick = new EventEmitter<any>();\r\n\r\n  /**\r\n   * length of anchor element, used for calculate the string length of the anchor displayed text.\r\n   */\r\n  anchorLength: number;\r\n\r\n  constructor(private _decimalPipe: DecimalPipe) {}\r\n\r\n  /**\r\n   * flag for showing the clearance flag\r\n   */\r\n  get showClearanceFlag(): boolean {\r\n    return !this.checkbox && this.selectedText && this.allowClear;\r\n  }\r\n\r\n  /**\r\n   * the text displays on anchor\r\n   */\r\n  get anchorDisplayText(): string {\r\n    let anchorDisplayText =  this.selectedText ? (this.formatNumber ? (isNumber(this.selectedText) ?\r\n      this._decimalPipe.transform(this.selectedText, '1.0-2') : this.selectedText) :\r\n      this.selectedText) + (this.suffixText ? this.suffixText : '') : this.placeHolder;\r\n\r\n    let charLength = 1;\r\n    if (this.showClearanceFlag && this.anchorLength > 0) {\r\n      charLength = Math.floor((this.anchorLength - 50) / 7);\r\n    } else {\r\n      charLength = Math.floor((this.anchorLength - 50) / 7);\r\n    }\r\n\r\n    if (anchorDisplayText.length > charLength) {\r\n      anchorDisplayText = anchorDisplayText.slice(0, charLength - 2) + '...';\r\n    }\r\n    return anchorDisplayText;\r\n  }\r\n\r\n  /**\r\n   * anchor CSS class\r\n   */\r\n  get anchorClass(): string {\r\n    let anchorClassStatusPart;\r\n    let anchorClassFontColor;\r\n    if (this.disabled) {\r\n      anchorClassStatusPart = 'selection-anchor-disabled';\r\n      anchorClassFontColor = 'place-holder';\r\n    } else {\r\n      if (this.openStatus) {\r\n        anchorClassStatusPart = 'selection-anchor-open';\r\n      } else {\r\n        anchorClassStatusPart = 'selection-anchor-close';\r\n      }\r\n      if (this.selectedText != null) {\r\n        anchorClassFontColor = 'selected-item';\r\n      } else {\r\n        anchorClassFontColor = 'place-holder';\r\n      }\r\n    }\r\n    return `${anchorClassStatusPart} ${anchorClassFontColor}`;\r\n  }\r\n\r\n  /**\r\n   * triggered when clicking the anchor\r\n   */\r\n  onAnchorClick(event: Event): void {\r\n    this.anchorClick.emit(event);\r\n  }\r\n\r\n  /**\r\n   * triggered with (blur) of anchor\r\n   */\r\n  onAnchorBlur(event: Event): void {\r\n    stopPropagationAndDefault(event);\r\n  }\r\n\r\n  /**\r\n   * triggered when clicking the clearance\r\n   */\r\n  onClearanceClick(event: Event): void {\r\n    this.clearanceClick.emit(event);\r\n  }\r\n\r\n  /**\r\n   * triggered when resizing, get the clientWidth of anchor\r\n   */\r\n  onResize() {\r\n    this.anchorLength = this.anchorRef ? this.anchorRef.nativeElement ? this.anchorRef.nativeElement.clientWidth : 0 : 0;\r\n  }\r\n}\r\n"]}

package/esm2020/src/ngx-dropdown-list/dropdown/dropdown.component.mjs

@@ -0,0 +1,252 @@
+import { Component, ElementRef, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { clearAllSelection, getFirstSelectedItem, hasGroup, stopPropagationAndDefault } from '../utils/util';
+import * as i0 from "@angular/core";
+import * as i1 from "../filter/input-filter.component";
+import * as i2 from "../group-item/group-item.component";
+import * as i3 from "../item/item.component";
+import * as i4 from "@angular/common";
+export class DropdownComponent {
+    constructor() {
+        /**
+         * bind to [checkbox], the flag for multi-select (checkbox) mode.
+         */
+        this.checkbox = false;
+        /**
+         * bind to [filterBox] for displaying the filter input text box
+         */
+        this.filterBox = false;
+        /**
+         * bind to [allowClear] for enabling the clearance (clearance is not avaiable when checkbox is enabled)
+         */
+        this.allowClear = true;
+        /**
+         * bind to [formatNumber] for show formatted number text
+         */
+        this.formatNumber = false;
+        /**
+         * for 2-way binding of [selectedValue]
+         */
+        this.selectedValueChange = new EventEmitter(true);
+        /**
+         * [selectionChange] event that will be triggered when changing of the selection
+         */
+        this.selectionChange = new EventEmitter(true);
+        /**
+         * [dropdownBlur] event that will be triggered with (blur) of dropdown
+         */
+        this.dropdownBlur = new EventEmitter();
+        /**
+         * [itemClick] event that will be triggered when clicking the option of dropdown
+         */
+        this.itemClick = new EventEmitter();
+        /**
+         * flag of clicking dropdown. It's to prevent (blur) of dropdown from happening in checkbox mode.
+         */
+        this._clickedItems = false;
+    }
+    ngOnChanges(changes) {
+        if (changes.items) {
+            this._checkSelectionChange(changes.items.previousValue, changes.items.currentValue);
+        }
+    }
+    /**
+     * triggered when clicking the dropdown
+     */
+    onItemsClick(event) {
+        if (event.offsetX > (event.target.clientWidth + event.target.clientLeft)) {
+            stopPropagationAndDefault(event);
+            return;
+        }
+        // should ignore clicking on filter
+        if (this.checkbox && event.target.type !== 'text') {
+            this._clickedItems = true;
+        }
+    }
+    /**
+     * triggered when clicking the item
+     */
+    onItemClick(currentItem) {
+        if (!this.checkbox) {
+            this.selectedValue = this._getItemValue(currentItem); // currentItem.value != null ? currentItem.value : currentItem.text;
+            clearAllSelection(this.items);
+            // set the selection of current one
+            currentItem.selected = true;
+            this.itemClick.emit(currentItem);
+            this._onSelectionChange(this.selectedValue);
+        }
+    }
+    /**
+     * triggers with (blur) event of filter input box
+     */
+    onFilterTextBlur(event) {
+        this.dropdownBlur.emit(event);
+    }
+    /**
+     * triggers with (blur) event of dropdown
+     */
+    onItemsBlur(event) {
+        if (this.checkbox) {
+            if (this._clickedItems) {
+                // in checkbox mode, this blur event will be ignored when clicking the dropdown (check the checkbox)
+                event.target.focus();
+                this._clickedItems = false;
+                return;
+            }
+        }
+        this.dropdownBlur.emit(event);
+    }
+    /**
+     * toggle the selection when checking status changed (in checkbox mode)
+     */
+    toggleSelection(item) {
+        item.selected = !item.selected;
+        this.selectionChange.emit(this._getItemValue(item)); // item.value != null ? item.value : item.text);
+    }
+    /**
+     * items values list after applying the filter
+     */
+    get itemsValues() {
+        let filter;
+        if (this.filterValue) {
+            filter = this.filterValue.toUpperCase();
+        }
+        if (filter == null) {
+            return this.items;
+        }
+        if (!this.items || this.items.length === 0) {
+            return [];
+        }
+        if (hasGroup(this.items)) {
+            const items = [];
+            this.items.forEach(groupItem => {
+                if (groupItem.group != null && groupItem.group.toString().toUpperCase().includes(filter)) {
+                    // if groupItem contains the filters, the groupItem needs to be displayed as well
+                    items.push(groupItem);
+                }
+                else {
+                    const filteredItems = groupItem.items.filter(item => item.text != null && item.text.toString().toUpperCase().includes(filter));
+                    if (filteredItems && filteredItems.length > 0) {
+                        items.push({ group: groupItem.group, items: filteredItems });
+                    }
+                }
+            });
+            return items;
+        }
+        else {
+            return this.items.filter(item => (item.text != null && item.text.toString().toUpperCase().includes(filter)));
+        }
+    }
+    /**
+     * options CSS class
+     */
+    get optionsClass() {
+        if (this.filterBox && !this.checkbox) {
+            return 'options with-filter';
+        }
+        else {
+            return 'options no-filter';
+        }
+    }
+    /**
+     * get item value. Return text if value is not available
+     */
+    _getItemValue(item) {
+        return item ? item.value != null ? item.value : item.text : undefined;
+    }
+    /**
+     * selection changed, emits events: (selectedValueChange) and (selectionChange);
+     */
+    _onSelectionChange(value) {
+        this.selectedValueChange.emit(value);
+        this.selectionChange.emit(value);
+    }
+    /**
+     * check whether the selection is changed. Emits relative events when if changed.
+     */
+    _checkSelectionChange(previousValue, currentValue) {
+        const curSelectedItem = getFirstSelectedItem(currentValue);
+        const lastSelectedItem = getFirstSelectedItem(previousValue);
+        const curSelectedItemId = curSelectedItem ? curSelectedItem.id : undefined;
+        const lastSelectedItemId = lastSelectedItem ? lastSelectedItem.id : undefined;
+        if (curSelectedItemId !== lastSelectedItemId && !this.checkbox) {
+            this._onSelectionChange(this._getItemValue(curSelectedItem));
+        }
+    }
+}
+DropdownComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: DropdownComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+DropdownComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: DropdownComponent, selector: "dropdown", inputs: { placeHolder: "placeHolder", items: "items", checkbox: "checkbox", selectedValue: "selectedValue", filterBox: "filterBox", suffixText: "suffixText", disabled: "disabled", allowClear: "allowClear", formatNumber: "formatNumber" }, outputs: { selectedValueChange: "selectedValueChange", selectionChange: "selectionChange", dropdownBlur: "dropdownBlur", itemClick: "itemClick" }, viewQueries: [{ propertyName: "dropdownRef", first: true, predicate: ["dropdown"], descendants: true, read: ElementRef }, { propertyName: "filterInputRef", first: true, predicate: ["filterInput"], descendants: true, read: ElementRef }], usesOnChanges: true, ngImport: i0, template: `
+    <span #dropdown class="dropdown" tabindex="3" (mousedown)="onItemsClick($event)" (blur)="onItemsBlur($event)" *ngIf="!disabled" >
+      <input-filter #filterInput tabindex="4" *ngIf="filterBox && !checkbox" [(filterValue)]="filterValue" (inputFilterBlur)="onFilterTextBlur($event)"></input-filter>
+      <span #selectionOptions [ngClass]="optionsClass">
+        <ng-container *ngFor="let item of itemsValues" >
+          <ng-container *ngIf="item && item.group">
+            <group-item [item]="item"></group-item>
+            <item *ngFor="let subItem of item.items" (itemClick)="onItemClick(subItem)" (checkStatusChange)="toggleSelection(subItem)"
+                  [item]="subItem" [checkbox]="checkbox" [formatNumber]="formatNumber" [suffixText]="suffixText">
+            </item>
+          </ng-container>
+          <ng-container *ngIf="item && !item.group">
+            <item (itemClick)="onItemClick(item)" (checkStatusChange)="toggleSelection(item)"
+                  [item]="item" [checkbox]="checkbox" [formatNumber]="formatNumber" [suffixText]="suffixText">
+            </item>
+          </ng-container>
+        </ng-container>
+      </span>
+    </span>
+  `, isInline: true, styles: ["*,*:before,*:after{font-size:inherit;font-weight:inherit;font-family:inherit;box-sizing:inherit;background:inherit}.dropdown{width:100%;padding:0;display:none;margin:0;border:1px solid #66afe9;border-top:none;border-bottom:none;border-top-right-radius:0;border-top-left-radius:0;box-sizing:border-box;position:relative;z-index:999}.dropdown:focus{outline:0}.dropdown .options{width:calc(100% + 2px);left:0;box-sizing:border-box;background:white;position:absolute;max-height:228px;overflow-y:auto;overflow-x:hidden;border:1px solid #66afe9;border-top:none;border-bottom-right-radius:4px;border-bottom-left-radius:4px;margin-left:-1px;margin-right:-1px}.dropdown .with-filter{top:32px}.dropdown .no-filter{top:0}\n"], components: [{ type: i1.InputFilterComponent, selector: "input-filter", inputs: ["filterValue"], outputs: ["inputFilterBlur", "filterValueChange"] }, { type: i2.GroupItemComponent, selector: "group-item", inputs: ["item"] }, { type: i3.ItemComponent, selector: "item", inputs: ["checkbox", "item", "formatNumber", "suffixText"], outputs: ["itemClick", "checkStatusChange"] }], directives: [{ type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i4.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: DropdownComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'dropdown', template: `
+    <span #dropdown class="dropdown" tabindex="3" (mousedown)="onItemsClick($event)" (blur)="onItemsBlur($event)" *ngIf="!disabled" >
+      <input-filter #filterInput tabindex="4" *ngIf="filterBox && !checkbox" [(filterValue)]="filterValue" (inputFilterBlur)="onFilterTextBlur($event)"></input-filter>
+      <span #selectionOptions [ngClass]="optionsClass">
+        <ng-container *ngFor="let item of itemsValues" >
+          <ng-container *ngIf="item && item.group">
+            <group-item [item]="item"></group-item>
+            <item *ngFor="let subItem of item.items" (itemClick)="onItemClick(subItem)" (checkStatusChange)="toggleSelection(subItem)"
+                  [item]="subItem" [checkbox]="checkbox" [formatNumber]="formatNumber" [suffixText]="suffixText">
+            </item>
+          </ng-container>
+          <ng-container *ngIf="item && !item.group">
+            <item (itemClick)="onItemClick(item)" (checkStatusChange)="toggleSelection(item)"
+                  [item]="item" [checkbox]="checkbox" [formatNumber]="formatNumber" [suffixText]="suffixText">
+            </item>
+          </ng-container>
+        </ng-container>
+      </span>
+    </span>
+  `, styles: ["*,*:before,*:after{font-size:inherit;font-weight:inherit;font-family:inherit;box-sizing:inherit;background:inherit}.dropdown{width:100%;padding:0;display:none;margin:0;border:1px solid #66afe9;border-top:none;border-bottom:none;border-top-right-radius:0;border-top-left-radius:0;box-sizing:border-box;position:relative;z-index:999}.dropdown:focus{outline:0}.dropdown .options{width:calc(100% + 2px);left:0;box-sizing:border-box;background:white;position:absolute;max-height:228px;overflow-y:auto;overflow-x:hidden;border:1px solid #66afe9;border-top:none;border-bottom-right-radius:4px;border-bottom-left-radius:4px;margin-left:-1px;margin-right:-1px}.dropdown .with-filter{top:32px}.dropdown .no-filter{top:0}\n"] }]
+        }], propDecorators: { dropdownRef: [{
+                type: ViewChild,
+                args: ['dropdown', { read: ElementRef }]
+            }], filterInputRef: [{
+                type: ViewChild,
+                args: ['filterInput', { read: ElementRef }]
+            }], placeHolder: [{
+                type: Input
+            }], items: [{
+                type: Input
+            }], checkbox: [{
+                type: Input
+            }], selectedValue: [{
+                type: Input
+            }], filterBox: [{
+                type: Input
+            }], suffixText: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], allowClear: [{
+                type: Input
+            }], formatNumber: [{
+                type: Input
+            }], selectedValueChange: [{
+                type: Output
+            }], selectionChange: [{
+                type: Output
+            }], dropdownBlur: [{
+                type: Output
+            }], itemClick: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dropdown.component.js","sourceRoot":"","sources":["../../../../../src/ngx-dropdown-list/dropdown/dropdown.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, ElementRef, EventEmitter, Input, OnChanges, Output, SimpleChanges, ViewChild} from '@angular/core';\r\nimport {clearAllSelection, getFirstSelectedItem, hasGroup, stopPropagationAndDefault} from '../utils/util';\r\n\r\n@Component({\r\n  selector: 'dropdown',\r\n  template: `\r\n    <span #dropdown class=\"dropdown\" tabindex=\"3\" (mousedown)=\"onItemsClick($event)\" (blur)=\"onItemsBlur($event)\" *ngIf=\"!disabled\" >\r\n      <input-filter #filterInput tabindex=\"4\" *ngIf=\"filterBox && !checkbox\" [(filterValue)]=\"filterValue\" (inputFilterBlur)=\"onFilterTextBlur($event)\"></input-filter>\r\n      <span #selectionOptions [ngClass]=\"optionsClass\">\r\n        <ng-container *ngFor=\"let item of itemsValues\" >\r\n          <ng-container *ngIf=\"item && item.group\">\r\n            <group-item [item]=\"item\"></group-item>\r\n            <item *ngFor=\"let subItem of item.items\" (itemClick)=\"onItemClick(subItem)\" (checkStatusChange)=\"toggleSelection(subItem)\"\r\n                  [item]=\"subItem\" [checkbox]=\"checkbox\" [formatNumber]=\"formatNumber\" [suffixText]=\"suffixText\">\r\n            </item>\r\n          </ng-container>\r\n          <ng-container *ngIf=\"item && !item.group\">\r\n            <item (itemClick)=\"onItemClick(item)\" (checkStatusChange)=\"toggleSelection(item)\"\r\n                  [item]=\"item\" [checkbox]=\"checkbox\" [formatNumber]=\"formatNumber\" [suffixText]=\"suffixText\">\r\n            </item>\r\n          </ng-container>\r\n        </ng-container>\r\n      </span>\r\n    </span>\r\n  `,\r\n  styleUrls: ['./dropdown.component.scss']\r\n})\r\n\r\nexport class DropdownComponent implements OnChanges {\r\n  /**\r\n   * Child element reference of dropdown\r\n   */\r\n  @ViewChild('dropdown', { read: ElementRef }) dropdownRef: ElementRef;\r\n  /**\r\n   * Child element reference of filter input text\r\n   */\r\n  @ViewChild('filterInput', { read: ElementRef }) filterInputRef: ElementRef;\r\n  /**\r\n   * bind to [placeHolder] for displaying the place holder string of the anchor.\r\n   */\r\n  @Input() placeHolder: string;\r\n  /**\r\n   * bind to [items] for the options/groups in the dropdown\r\n   */\r\n  @Input() items: any[];\r\n  /**\r\n   * bind to [checkbox], the flag for multi-select (checkbox) mode.\r\n   */\r\n  @Input() checkbox = false;\r\n  /**\r\n   * bind to [selectedValue] for the value of the selected option from dropdown\r\n   */\r\n  @Input() selectedValue: any;\r\n  /**\r\n   * bind to [filterBox] for displaying the filter input text box\r\n   */\r\n  @Input() filterBox = false;\r\n  /**\r\n   * bind to [suffixText] for displaying the suffix of the selected text of anchor\r\n   */\r\n  @Input() suffixText: string;\r\n  /**\r\n   * bind to [disabled] for disabling the dropdown\r\n   */\r\n  @Input() disabled: boolean;\r\n  /**\r\n   * bind to [allowClear] for enabling the clearance (clearance is not avaiable when checkbox is enabled)\r\n   */\r\n  @Input() allowClear = true;\r\n  /**\r\n   * bind to [formatNumber] for show formatted number text\r\n   */\r\n  @Input() formatNumber = false;\r\n  /**\r\n   * for 2-way binding of [selectedValue]\r\n   */\r\n  @Output() selectedValueChange = new EventEmitter<string>(true);\r\n  /**\r\n   * [selectionChange] event that will be triggered when changing of the selection\r\n   */\r\n  @Output() selectionChange = new EventEmitter<any>(true);\r\n  /**\r\n   * [dropdownBlur] event that will be triggered with (blur) of dropdown\r\n   */\r\n  @Output() dropdownBlur = new EventEmitter<any>();\r\n  /**\r\n   * [itemClick] event that will be triggered when clicking the option of dropdown\r\n   */\r\n  @Output() itemClick = new EventEmitter<any>();\r\n  /**\r\n   * filter value\r\n   */\r\n  filterValue: string;\r\n  /**\r\n   * flag of clicking dropdown. It's to prevent (blur) of dropdown from happening in checkbox mode.\r\n   */\r\n  private _clickedItems = false;\r\n\r\n  ngOnChanges(changes: SimpleChanges) {\r\n    if (changes.items) {\r\n      this._checkSelectionChange(changes.items.previousValue, changes.items.currentValue);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * triggered when clicking the dropdown\r\n   */\r\n  onItemsClick(event: any): void {\r\n    if (event.offsetX > (event.target.clientWidth + event.target.clientLeft)) {\r\n      stopPropagationAndDefault(event);\r\n      return;\r\n    }\r\n    // should ignore clicking on filter\r\n    if (this.checkbox && event.target.type !== 'text') {\r\n      this._clickedItems = true;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * triggered when clicking the item\r\n   */\r\n  onItemClick(currentItem): void {\r\n    if (!this.checkbox) {\r\n      this.selectedValue = this._getItemValue(currentItem); // currentItem.value != null ? currentItem.value : currentItem.text;\r\n      clearAllSelection(this.items);\r\n      // set the selection of current one\r\n      currentItem.selected = true;\r\n      this.itemClick.emit(currentItem);\r\n      this._onSelectionChange(this.selectedValue);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * triggers with (blur) event of filter input box\r\n   */\r\n  onFilterTextBlur(event): void {\r\n    this.dropdownBlur.emit(event);\r\n  }\r\n\r\n  /**\r\n   * triggers with (blur) event of dropdown\r\n   */\r\n  onItemsBlur(event): void {\r\n    if (this.checkbox) {\r\n      if (this._clickedItems) {\r\n        // in checkbox mode, this blur event will be ignored when clicking the dropdown (check the checkbox)\r\n        event.target.focus();\r\n        this._clickedItems = false;\r\n        return;\r\n      }\r\n    }\r\n    this.dropdownBlur.emit(event);\r\n  }\r\n\r\n  /**\r\n   * toggle the selection when checking status changed (in checkbox mode)\r\n   */\r\n  toggleSelection(item: {id: string, value?: any, text: any, selected?: boolean}): void {\r\n    item.selected = !item.selected;\r\n    this.selectionChange.emit(this._getItemValue(item)); // item.value != null ? item.value : item.text);\r\n  }\r\n\r\n  /**\r\n   * items values list after applying the filter\r\n   */\r\n  get itemsValues(): any[] {\r\n    let filter;\r\n    if (this.filterValue) {\r\n      filter = this.filterValue.toUpperCase();\r\n    }\r\n\r\n    if (filter == null) {\r\n      return this.items;\r\n    }\r\n    if (!this.items || this.items.length === 0) {\r\n      return [];\r\n    }\r\n    if (hasGroup(this.items)) {\r\n      const items = [];\r\n      this.items.forEach(groupItem => {\r\n        if (groupItem.group != null && groupItem.group.toString().toUpperCase().includes(filter)) {\r\n          // if groupItem contains the filters, the groupItem needs to be displayed as well\r\n          items.push(groupItem);\r\n        } else {\r\n          const filteredItems = groupItem.items.filter(item => item.text != null && item.text.toString().toUpperCase().includes(filter));\r\n          if (filteredItems && filteredItems.length > 0) {\r\n            items.push({group: groupItem.group, items: filteredItems});\r\n          }\r\n        }\r\n      });\r\n      return items;\r\n    } else {\r\n      return this.items.filter(item => (item.text != null && item.text.toString().toUpperCase().includes(filter)));\r\n    }\r\n  }\r\n  /**\r\n   * options CSS class\r\n   */\r\n  get optionsClass(): string {\r\n    if (this.filterBox && !this.checkbox) {\r\n      return 'options with-filter';\r\n    } else {\r\n      return 'options no-filter';\r\n    }\r\n  }\r\n\r\n  /**\r\n   * get item value. Return text if value is not available\r\n   */\r\n  private _getItemValue(item): any {\r\n    return item ? item.value != null ? item.value : item.text : undefined;\r\n  }\r\n\r\n  /**\r\n   * selection changed, emits events: (selectedValueChange) and (selectionChange);\r\n   */\r\n  private _onSelectionChange(value) {\r\n    this.selectedValueChange.emit(value);\r\n    this.selectionChange.emit(value);\r\n  }\r\n\r\n  /**\r\n   * check whether the selection is changed. Emits relative events when if changed.\r\n   */\r\n  private _checkSelectionChange(previousValue, currentValue) {\r\n    const curSelectedItem = getFirstSelectedItem(currentValue);\r\n    const lastSelectedItem = getFirstSelectedItem(previousValue);\r\n    const curSelectedItemId = curSelectedItem ? curSelectedItem.id : undefined;\r\n    const lastSelectedItemId = lastSelectedItem ? lastSelectedItem.id : undefined;\r\n    if (curSelectedItemId !== lastSelectedItemId && !this.checkbox) {\r\n      this._onSelectionChange(this._getItemValue(curSelectedItem));\r\n    }\r\n  }\r\n}\r\n"]}