@natec/mef-dev-ui-kit 15.0.0 → 16.0.1

package/esm2022/lib/pg-components/select/select.component.mjs

@@ -0,0 +1,782 @@
+/**
+ * complex but work well
+ * TODO: rebuild latter
+ */
+import { DOWN_ARROW, ENTER, TAB } from "@angular/cdk/keycodes";
+import { CdkConnectedOverlay } from "@angular/cdk/overlay";
+import { forwardRef, Component, EventEmitter, HostListener, Input, Output, ViewChild, ViewEncapsulation } from "@angular/core";
+import { NG_VALUE_ACCESSOR } from "@angular/forms";
+import { OptionPipe } from "./option.pipe";
+import { toBoolean } from '../util/convert';
+import { animate, state, style, transition, trigger } from "@angular/animations";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+import * as i3 from "@angular/cdk/overlay";
+/**
+  * Example of usage:
+  * <example-url>https://mef.dev/ui_kit_demo/view/select</example-url>
+  */
+export class MefDevSelectComponent {
+    _elementRef;
+    _renderer;
+    cDRef;
+    _allowClear = false;
+    _disabled = false;
+    _isTags = false;
+    _isMultiple = false;
+    _keepUnListOptions = false;
+    _showSearch = false;
+    _el;
+    _isOpen = false;
+    _prefixCls = "pg-select";
+    _classList = [];
+    _dropDownClassMap;
+    _dropDownPrefixCls = `${this._prefixCls}-dropdown`;
+    _selectionClassMap;
+    _selectionPrefixCls = `${this._prefixCls}-selection`;
+    _size;
+    _value;
+    _placeholder = "placeholder";
+    _notFoundContent = "No Content";
+    _searchText = "";
+    _triggerWidth = 0;
+    _selectedOption;
+    _operatingMultipleOption;
+    _selectedOptions = new Set();
+    _options = [];
+    _cacheOptions = [];
+    _filterOptions = [];
+    _tagsOptions = [];
+    _activeFilterOption;
+    _isMultiInit = false;
+    _dropDownPosition = "bottom";
+    _composing = false;
+    _mode;
+    // ngModel Access
+    onChange = () => null;
+    onTouched = () => null;
+    searchInputElementRef;
+    trigger;
+    dropdownUl;
+    SearchChange = new EventEmitter();
+    change = new EventEmitter();
+    OpenChange = new EventEmitter();
+    ScrollToBottom = new EventEmitter();
+    Filter = true;
+    MaxMultiple = Infinity;
+    FirstDefault = false;
+    _cdkOverlay;
+    set AllowClear(value) {
+        this._allowClear = toBoolean(value);
+    }
+    get AllowClear() {
+        return this._allowClear;
+    }
+    set KeepUnListOptions(value) {
+        this._keepUnListOptions = toBoolean(value);
+    }
+    get KeepUnListOptions() {
+        return this._keepUnListOptions;
+    }
+    set Mode(value) {
+        this._mode = value;
+        if (this._mode === "multiple") {
+            this.Multiple = true;
+        }
+        else if (this._mode === "tags") {
+            this.Tags = true;
+        }
+        else if (this._mode === "combobox") {
+            this.ShowSearch = true;
+        }
+    }
+    set Multiple(value) {
+        this._isMultiple = toBoolean(value);
+        if (this._isMultiple) {
+            this.ShowSearch = true;
+        }
+    }
+    get Multiple() {
+        return this._isMultiple;
+    }
+    set PlaceHolder(value) {
+        this._placeholder = value;
+    }
+    get PlaceHolder() {
+        return this._placeholder;
+    }
+    set NotFoundContent(value) {
+        this._notFoundContent = value;
+    }
+    get NotFoundContent() {
+        return this._notFoundContent;
+    }
+    set Size(value) {
+        // @ts-ignore
+        this._size = { large: "lg", small: "sm" }[value];
+        this.setClassMap();
+    }
+    get Size() {
+        return this._size;
+    }
+    set ShowSearch(value) {
+        this._showSearch = toBoolean(value);
+    }
+    get ShowSearch() {
+        return this._showSearch;
+    }
+    set Tags(value) {
+        const isTags = toBoolean(value);
+        this._isTags = isTags;
+        this.Multiple = isTags;
+    }
+    get Tags() {
+        return this._isTags;
+    }
+    set Disabled(value) {
+        this._disabled = toBoolean(value);
+        this.closeDropDown();
+        this.setClassMap();
+    }
+    get Disabled() {
+        return this._disabled;
+    }
+    set Open(value) {
+        const isOpen = toBoolean(value);
+        if (this._isOpen === isOpen) {
+            return;
+        }
+        if (isOpen) {
+            this.scrollToActive();
+            this._setTriggerWidth();
+        }
+        this._isOpen = isOpen;
+        this.OpenChange.emit(this._isOpen);
+        this.setClassMap();
+        if (this._isOpen) {
+            setTimeout(() => {
+                this.checkDropDownScroll();
+            });
+        }
+    }
+    get Open() {
+        return this._isOpen;
+    }
+    /** new -option insert or new tags insert */
+    // @ts-ignore
+    addOption = option => {
+        this._options.push(option);
+        if (!this._isTags) {
+            if (option.Value) {
+                this.updateSelectedOption(this._value);
+            }
+            else {
+                this.forceUpdateSelectedOption(this._value);
+            }
+        }
+    };
+    /** -option remove or tags remove */
+    removeOption(option) {
+        this._options.splice(this._options.indexOf(option), 1);
+        if (!this._isTags) {
+            this.forceUpdateSelectedOption(this._value);
+        }
+    }
+    /** dropdown position changed */
+    onPositionChange(position) {
+        this._dropDownPosition = position.connectionPair.originY;
+    }
+    compositionStart() {
+        this._composing = true;
+    }
+    compositionEnd() {
+        this._composing = false;
+    }
+    /** clear single selected option */
+    clearSelect($event) {
+        if ($event) {
+            $event.preventDefault();
+            $event.stopPropagation();
+        } // @ts-ignore
+        this._selectedOption = null; // @ts-ignore
+        this.Value = null; // @ts-ignore
+        this.onChange(null);
+    }
+    /** click dropdown option by user */
+    clickOption(option, $event) {
+        if (!option) {
+            return;
+        }
+        this.chooseOption(option, true, $event);
+        this.clearSearchText();
+        if (!this._isMultiple) {
+            this.Open = false;
+        }
+    }
+    /** choose option */
+    chooseOption(option, isUserClick = false, $event) {
+        if ($event) {
+            $event.preventDefault();
+            $event.stopPropagation();
+        }
+        this._activeFilterOption = option;
+        if (option && !option.Disabled) {
+            if (!this.Multiple) {
+                this._selectedOption = option;
+                this._value = option.Value;
+                if (isUserClick) {
+                    this.change.next(this._value);
+                    this.onChange(option.Value);
+                }
+            }
+            else {
+                if (isUserClick) {
+                    this.isInSet(this._selectedOptions, option)
+                        ? this.unSelectMultipleOption(option)
+                        : this.selectMultipleOption(option);
+                }
+            }
+        }
+    }
+    updateWidth(element, text) {
+        if (text) {
+            /** wait for scroll width change */ // @ts-ignore
+            setTimeout(_ => {
+                this._renderer.setStyle(element, "width", `${element.scrollWidth}px`);
+            });
+        }
+        else {
+            this._renderer.removeStyle(element, "width");
+        }
+    }
+    /** determine if option in set */
+    isInSet(set, option) {
+        return Array.from(set).find((data) => data.Value === option.Value);
+    }
+    /** cancel select multiple option */ // @ts-ignore
+    unSelectMultipleOption = (option, $event, emitChange = true) => {
+        this._operatingMultipleOption = option;
+        this._selectedOptions.delete(option);
+        if (emitChange) {
+            this.emitMultipleOptions();
+        }
+        // 对Tag进行特殊处理
+        if (this._isTags &&
+            this._options.indexOf(option) !== -1 &&
+            this._tagsOptions.indexOf(option) !== -1) {
+            this.removeOption(option);
+            this._tagsOptions.splice(this._tagsOptions.indexOf(option), 1);
+        }
+        if ($event) {
+            $event.preventDefault();
+            $event.stopPropagation();
+        }
+    };
+    /** select multiple option */
+    selectMultipleOption(option, $event) {
+        /** if tags do push to tag option */
+        if (this._isTags &&
+            this._options.indexOf(option) === -1 &&
+            this._tagsOptions.indexOf(option) === -1) {
+            this.addOption(option);
+            this._tagsOptions.push(option);
+        }
+        this._operatingMultipleOption = option;
+        if (this._selectedOptions.size < this.MaxMultiple) {
+            this._selectedOptions.add(option);
+        }
+        this.emitMultipleOptions();
+        if ($event) {
+            $event.preventDefault();
+            $event.stopPropagation();
+        }
+    }
+    /** emit multiple options */
+    emitMultipleOptions() {
+        if (this._isMultiInit) {
+            return;
+        }
+        const arrayOptions = Array.from(this._selectedOptions);
+        this._value = arrayOptions.map(item => item.Value);
+        this.onChange(this._value);
+    }
+    /** update selected option when add remove option etc */
+    updateSelectedOption(currentModelValue, triggerByNgModel = false) {
+        if (currentModelValue == null) {
+            return;
+        }
+        if (this.Multiple) {
+            const selectedOptions = this._options.filter(item => {
+                return item != null && currentModelValue.indexOf(item.Value) !== -1;
+            });
+            if ((this.KeepUnListOptions || this.Tags) && !triggerByNgModel) {
+                const _selectedOptions = Array.from(this._selectedOptions);
+                selectedOptions.forEach(option => {
+                    const _exist = _selectedOptions.some(item => item._value == option._value);
+                    if (!_exist) {
+                        this._selectedOptions.add(option);
+                    }
+                });
+            }
+            else {
+                this._selectedOptions = new Set();
+                selectedOptions.forEach(option => {
+                    this._selectedOptions.add(option);
+                });
+            }
+        }
+        else {
+            const selectedOption = this._options.filter(item => {
+                return item != null && item.Value == currentModelValue;
+            });
+            this.chooseOption(selectedOption[0]);
+        }
+    }
+    forceUpdateSelectedOption(value) {
+        /** trigger dirty check */ // @ts-ignore
+        setTimeout(_ => {
+            this.updateSelectedOption(value);
+        });
+    }
+    get Value() {
+        return this._value;
+    }
+    set Value(value) {
+        this._updateValue(value);
+    }
+    clearAllSelectedOption(emitChange = true) {
+        this._selectedOptions.forEach(item => {
+            this.unSelectMultipleOption(item, null, emitChange);
+        });
+    }
+    handleKeyEnterEvent(event) {
+        /** when composing end */
+        if (!this._composing && this._isOpen) {
+            event.preventDefault();
+            event.stopPropagation();
+            this.updateFilterOption(false);
+            this.clickOption(this._activeFilterOption);
+        }
+    }
+    handleKeyBackspaceEvent(event) {
+        if (!this._searchText && !this._composing && this._isMultiple) {
+            event.preventDefault();
+            const lastOption = Array.from(this._selectedOptions).pop();
+            this.unSelectMultipleOption(lastOption);
+        }
+    }
+    handleKeyDownEvent($event) {
+        if (this._isOpen) {
+            $event.preventDefault();
+            $event.stopPropagation();
+            this._activeFilterOption = this.nextOption(this._activeFilterOption, this._filterOptions.filter(w => !w.Disabled));
+            this.scrollToActive();
+        }
+    }
+    handleKeyUpEvent($event) {
+        if (this._isOpen) {
+            $event.preventDefault();
+            $event.stopPropagation();
+            this._activeFilterOption = this.preOption(this._activeFilterOption, this._filterOptions.filter(w => !w.Disabled));
+            this.scrollToActive();
+        }
+    }
+    preOption(option, options) {
+        return options[options.indexOf(option) - 1] || options[options.length - 1];
+    }
+    nextOption(option, options) {
+        return options[options.indexOf(option) + 1] || options[0];
+    }
+    clearSearchText() {
+        this._searchText = "";
+        this.updateFilterOption();
+    }
+    updateFilterOption(updateActiveFilter = true) {
+        if (this.Filter) {
+            this._filterOptions = new OptionPipe().transform(this._options, {
+                searchText: this._searchText,
+                tags: this._isTags,
+                notFoundContent: this._isTags
+                    ? this._searchText
+                    : this._notFoundContent,
+                disabled: !this._isTags,
+                value: this._isTags ? this._searchText : "disabled"
+            });
+        }
+        else {
+            this._filterOptions = this._options;
+        }
+        /** TODO: cause pre & next key selection not work */
+        if (updateActiveFilter && !this._selectedOption) {
+            this._activeFilterOption = this._filterOptions[0];
+        }
+    }
+    onSearchChange(searchValue) {
+        this.SearchChange.emit(searchValue);
+    }
+    onClick(e) {
+        e.preventDefault();
+        if (!this._disabled) {
+            this.Open = !this.Open;
+            if (this.ShowSearch) {
+                /** wait for search display */ // @ts-ignore
+                setTimeout(_ => {
+                    this.searchInputElementRef.nativeElement.focus();
+                });
+            }
+        }
+    }
+    onKeyDown(e) {
+        const keyCode = e.keyCode;
+        if (keyCode === TAB && this.Open) {
+            this.Open = false;
+            return;
+        }
+        if ((keyCode !== DOWN_ARROW && keyCode !== ENTER) || this.Open) {
+            return;
+        }
+        e.preventDefault();
+        if (!this._disabled) {
+            this.Open = true;
+            if (this.ShowSearch) {
+                /** wait for search display */ // @ts-ignore
+                setTimeout(_ => {
+                    this.searchInputElementRef.nativeElement.focus();
+                });
+            }
+        }
+    }
+    closeDropDown() {
+        if (!this.Open) {
+            return;
+        }
+        this.onTouched();
+        if (this.Multiple) {
+            this._renderer.removeStyle(this.searchInputElementRef.nativeElement, "width");
+        }
+        this.clearSearchText();
+        this.Open = false;
+    }
+    setClassMap() {
+        this._classList.forEach(_className => {
+            this._renderer.removeClass(this._el, _className);
+        }); // @ts-ignore
+        this._classList = [
+            this._prefixCls,
+            this._mode === "combobox" && `${this._prefixCls}-combobox`,
+            !this._disabled && `${this._prefixCls}-enabled`,
+            this._disabled && `${this._prefixCls}-disabled`,
+            this._isOpen && `${this._prefixCls}-open`,
+            this._showSearch && `${this._prefixCls}-show-search`,
+            this._size && `${this._prefixCls}-${this._size}`
+        ].filter(item => {
+            return !!item;
+        });
+        this._classList.forEach(_className => {
+            this._renderer.addClass(this._el, _className);
+        });
+        this._selectionClassMap = {
+            [this._selectionPrefixCls]: true,
+            [`${this._selectionPrefixCls}--single`]: !this.Multiple,
+            [`${this._selectionPrefixCls}--multiple`]: this.Multiple
+        };
+    }
+    setDropDownClassMap() {
+        this._dropDownClassMap = {
+            [this._dropDownPrefixCls]: true,
+            ["component-select"]: this._mode === "combobox",
+            [`${this._dropDownPrefixCls}--single`]: !this.Multiple,
+            [`${this._dropDownPrefixCls}--multiple`]: this.Multiple,
+            [`${this._dropDownPrefixCls}-placement-bottomLeft`]: this._dropDownPosition === "bottom",
+            [`${this._dropDownPrefixCls}-placement-topLeft`]: this._dropDownPosition === "top"
+        };
+    }
+    scrollToActive() {
+        /** wait for dropdown display */ // @ts-ignore
+        setTimeout(_ => {
+            if (this._activeFilterOption && this._activeFilterOption.Value) {
+                const index = this._filterOptions.findIndex(option => option.Value === this._activeFilterOption.Value);
+                try {
+                    const scrollPane = this.dropdownUl.nativeElement.children[index];
+                    // TODO: scrollIntoViewIfNeeded is not a standard API, why doing so?
+                    /* tslint:disable-next-line:no-any */
+                    scrollPane.scrollIntoViewIfNeeded(false);
+                }
+                catch (e) { }
+            }
+        });
+    }
+    flushComponentState() {
+        this.updateFilterOption();
+        if (!this.Multiple) {
+            this.updateSelectedOption(this._value);
+        }
+        else {
+            if (this._value) {
+                this.updateSelectedOption(this._value);
+            }
+        }
+    }
+    _setTriggerWidth() {
+        this._triggerWidth = this._getTriggerRect().width;
+        /** should remove after after https://github.com/angular/material2/pull/8765 merged **/
+        if (this._cdkOverlay && this._cdkOverlay.overlayRef) {
+            this._cdkOverlay.overlayRef.updateSize({
+                width: this._triggerWidth
+            });
+        }
+    }
+    _getTriggerRect() {
+        return this.trigger.nativeElement.getBoundingClientRect();
+    }
+    writeValue(value) {
+        this._updateValue(value, false);
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.Disabled = isDisabled;
+    }
+    dropDownScroll(ul) {
+        if (ul && ul.scrollHeight - ul.scrollTop === ul.clientHeight) {
+            this.ScrollToBottom.emit(true);
+        }
+    }
+    checkDropDownScroll() {
+        if (this.dropdownUl &&
+            this.dropdownUl.nativeElement.scrollHeight ===
+                this.dropdownUl.nativeElement.clientHeight) {
+            this.ScrollToBottom.emit(true);
+        }
+    }
+    constructor(_elementRef, _renderer, cDRef) {
+        this._elementRef = _elementRef;
+        this._renderer = _renderer;
+        this.cDRef = cDRef;
+        this._el = this._elementRef.nativeElement;
+    }
+    ngAfterContentInit() {
+        if (this._value != null) {
+            this.flushComponentState();
+        }
+    }
+    ngOnInit() {
+        this.updateFilterOption();
+        this.setClassMap();
+        this.setDropDownClassMap();
+    }
+    ngAfterContentChecked() {
+        if (this._cacheOptions !== this._options) {
+            /** update filter option after every content check cycle */
+            this.updateFilterOption();
+            this._cacheOptions = this._options;
+        }
+        else {
+            this.updateFilterOption(false);
+        }
+        if (this.FirstDefault) {
+            if (!this._value && this._options) {
+                if (this._options[0] !== undefined && this._options[0].Value) {
+                    this.chooseOption(this._options[0], false);
+                    setTimeout(() => {
+                        this.onChange(this._options[0].Value);
+                    });
+                }
+            }
+        }
+    }
+    _updateValue(value, emitChange = true) {
+        if (this._value === value) {
+            return;
+        }
+        if (value == null && this.Multiple) {
+            this._value = [];
+        }
+        else {
+            this._value = value;
+        }
+        if (!this.Multiple) {
+            if (value == null) { // @ts-ignore
+                this._selectedOption = null;
+            }
+            else {
+                this.updateSelectedOption(value);
+            }
+        }
+        else {
+            if (value) {
+                if (value.length === 0) {
+                    this.clearAllSelectedOption(emitChange);
+                }
+                else {
+                    this.updateSelectedOption(value, true);
+                }
+            }
+            else if (value == null) {
+                this.clearAllSelectedOption(emitChange);
+            }
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.0", ngImport: i0, type: MefDevSelectComponent, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.0", type: MefDevSelectComponent, selector: "mefdev-select", inputs: { Filter: "Filter", MaxMultiple: "MaxMultiple", FirstDefault: "FirstDefault", AllowClear: "AllowClear", KeepUnListOptions: "KeepUnListOptions", Mode: "Mode", Multiple: "Multiple", PlaceHolder: "PlaceHolder", NotFoundContent: "NotFoundContent", Size: "Size", ShowSearch: "ShowSearch", Tags: "Tags", Disabled: "Disabled", Open: "Open" }, outputs: { SearchChange: "SearchChange", change: "change", OpenChange: "OpenChange", ScrollToBottom: "ScrollToBottom" }, host: { listeners: { "click": "onClick($event)", "keydown": "onKeyDown($event)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => MefDevSelectComponent),
+                multi: true
+            }
+        ], viewQueries: [{ propertyName: "searchInputElementRef", first: true, predicate: ["searchInput"], descendants: true }, { propertyName: "trigger", first: true, predicate: ["trigger"], descendants: true }, { propertyName: "dropdownUl", first: true, predicate: ["dropdownUl"], descendants: true }, { propertyName: "_cdkOverlay", first: true, predicate: CdkConnectedOverlay, descendants: true }], ngImport: i0, template: "<div tabindex=\"0\" #trigger cdkOverlayOrigin #origin=\"cdkOverlayOrigin\" [ngClass]=\"_selectionClassMap\"\r\n  (keydown.Enter)=\"handleKeyEnterEvent($event)\" (keydown.Backspace)=\"handleKeyBackspaceEvent($event)\"\r\n  (keydown.ArrowUp)=\"handleKeyUpEvent($event)\" (keydown.ArrowDown)=\"handleKeyDownEvent($event)\">\r\n  <div class=\"pg-select-selection__rendered\" *ngIf=\"!ShowSearch\">\r\n    <div class=\"pg-select-selection__placeholder\">\r\n      <ng-template [ngIf]=\"!_selectedOption\">\r\n        {{ PlaceHolder }}\r\n      </ng-template>\r\n    </div>\r\n    <div class=\"pg-select-selection-selected-value\">\r\n      {{ _selectedOption?.Label }}\r\n    </div>\r\n  </div>\r\n  <div class=\"pg-select-selection__rendered\" *ngIf=\"ShowSearch\">\r\n    <div [hidden]=\"_searchText||(!Open&&_selectedOption)||_selectedOptions.size\"\r\n      class=\"pg-select-selection__placeholder\">\r\n      <ng-template [ngIf]=\"(!_composing)&&_selectedOption\">\r\n        {{ _selectedOption.Label }}\r\n      </ng-template>\r\n      <ng-template [ngIf]=\"(!_composing)&&(!_selectedOption)\">\r\n        {{ PlaceHolder }}\r\n      </ng-template>\r\n    </div>\r\n    <ul *ngIf=\"Multiple\">\r\n      <li *ngFor=\"let option of _selectedOptions\" [@tagAnimation] [attr.title]=\"option?.Label || option?.Value\"\r\n        class=\"pg-select-selection__choice\" style=\"-webkit-user-select: none;\">\r\n        <span class=\"pg-select-selection__choice__remove\" (click)=\"unSelectMultipleOption(option,$event)\"></span>\r\n        <div class=\"pg-select-selection__choice__content\">{{ option?.Label }}</div>\r\n      </li>\r\n      <li class=\"pg-select-search pg-select-search--inline\">\r\n        <div class=\"pg-select-search__field__wrap\">\r\n          <input class=\"pg-select-search__field\" (compositionstart)=\"compositionStart()\"\r\n            (compositionend)=\"compositionEnd();updateWidth(searchInput,_searchText);\" [(ngModel)]=\"_searchText\"\r\n            (ngModelChange)=\"updateFilterOption();onSearchChange($event);\"\r\n            (keydown)=\"updateWidth(searchInput,_searchText)\" (input)=\"updateWidth(searchInput,_searchText)\"\r\n            (blur)=\"onTouched()\" #searchInput>\r\n          <span class=\"pg-select-search__field__mirror\"></span></div>\r\n      </li>\r\n    </ul>\r\n    <div *ngIf=\"!Multiple\" class=\"pg-select-selection-selected-value\" [hidden]=\"!(_selectedOption?.Label)||Open\">\r\n      {{ _selectedOption?.Label }}\r\n    </div>\r\n    <div *ngIf=\"!Multiple\" [hidden]=\"!Open\" class=\"pg-select-search pg-select-search--inline\">\r\n      <div class=\"pg-select-search__field__wrap\">\r\n        <input class=\"pg-select-search__field\" (blur)=\"onTouched()\" (compositionstart)=\"compositionStart()\"\r\n          (compositionend)=\"compositionEnd()\" [(ngModel)]=\"_searchText\"\r\n          (ngModelChange)=\"updateFilterOption();onSearchChange($event);\" #searchInput>\r\n        <span class=\"pg-select-search__field__mirror\"></span>\r\n      </div>\r\n    </div>\r\n  </div>\r\n  <span (click)=\"onTouched();clearSelect($event)\" class=\"pg-select-selection__clear\" style=\"-webkit-user-select: none;\"\r\n    *ngIf=\"_selectedOption?.Label&&AllowClear&&!Multiple\">\r\n  </span>\r\n  <span class=\"pg-select-arrow\"><b></b></span>\r\n</div>\r\n<ng-template cdkConnectedOverlay cdkConnectedOverlayHasBackdrop [cdkConnectedOverlayOrigin]=\"origin\"\r\n  (backdropClick)=\"closeDropDown()\" (detach)=\"closeDropDown();\" (positionChange)=\"onPositionChange($event)\"\r\n  [cdkConnectedOverlayWidth]=\"_triggerWidth\" [cdkConnectedOverlayOpen]=\"_isOpen\">\r\n  <div [ngClass]=\"_dropDownClassMap\" [@dropDownAnimation]=\"_dropDownPosition\">\r\n    <div style=\"overflow: auto;\">\r\n      <ul class=\"pg-select-dropdown-menu pg-select-dropdown-menu-vertical pg-select-dropdown-menu-root\" #dropdownUl\r\n        (scroll)=\"dropDownScroll(dropdownUl)\">\r\n        <li *ngFor=\"let option of _filterOptions\" [class.pg-select-dropdown-menu-item-disabled]=\"option.Disabled\"\r\n          [class.pg-select-dropdown-menu-item-active]=\"option.Value == _activeFilterOption?.Value\"\r\n          [class.pg-select-dropdown-menu-item-selected]=\"(option.Value==(_selectedOption?.Value))||(isInSet(_selectedOptions,option))\"\r\n          class=\"pg-select-dropdown-menu-item\" (click)=\"clickOption(option,$event)\">\r\n          <ng-template *ngIf=\"option.OptionTemplate\" [ngTemplateOutlet]=\"option.OptionTemplate\">\r\n          </ng-template>\r\n          <ng-template [ngIf]=\"!option.OptionTemplate\">\r\n            {{ option.Label }}\r\n          </ng-template>\r\n        </li>\r\n      </ul>\r\n    </div>\r\n  </div>\r\n</ng-template>", dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i2.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: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: i3.CdkConnectedOverlay, selector: "[cdk-connected-overlay], [connected-overlay], [cdkConnectedOverlay]", inputs: ["cdkConnectedOverlayOrigin", "cdkConnectedOverlayPositions", "cdkConnectedOverlayPositionStrategy", "cdkConnectedOverlayOffsetX", "cdkConnectedOverlayOffsetY", "cdkConnectedOverlayWidth", "cdkConnectedOverlayHeight", "cdkConnectedOverlayMinWidth", "cdkConnectedOverlayMinHeight", "cdkConnectedOverlayBackdropClass", "cdkConnectedOverlayPanelClass", "cdkConnectedOverlayViewportMargin", "cdkConnectedOverlayScrollStrategy", "cdkConnectedOverlayOpen", "cdkConnectedOverlayDisableClose", "cdkConnectedOverlayTransformOriginOn", "cdkConnectedOverlayHasBackdrop", "cdkConnectedOverlayLockPosition", "cdkConnectedOverlayFlexibleDimensions", "cdkConnectedOverlayGrowAfterOpen", "cdkConnectedOverlayPush"], outputs: ["backdropClick", "positionChange", "attach", "detach", "overlayKeydown", "overlayOutsideClick"], exportAs: ["cdkConnectedOverlay"] }, { kind: "directive", type: i3.CdkOverlayOrigin, selector: "[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]", exportAs: ["cdkOverlayOrigin"] }], animations: [trigger('dropDownAnimation', [
+                state('bottom', style({
+                    opacity: 1,
+                    transform: 'scaleY(1)',
+                    transformOrigin: '0% 0%'
+                })),
+                transition('void => bottom', [
+                    style({
+                        opacity: 0,
+                        transform: 'scaleY(0)',
+                        transformOrigin: '0% 0%'
+                    }),
+                    animate('150ms cubic-bezier(0.25, 0.8, 0.25, 1)')
+                ]),
+                state('top', style({
+                    opacity: 1,
+                    transform: 'scaleY(1)',
+                    transformOrigin: '0% 100%'
+                })),
+                transition('void => top', [
+                    style({
+                        opacity: 0,
+                        transform: 'scaleY(0)',
+                        transformOrigin: '0% 100%'
+                    }),
+                    animate('150ms cubic-bezier(0.25, 0.8, 0.25, 1)')
+                ]),
+                transition('* => void', [
+                    animate('250ms 100ms linear', style({ opacity: 0 }))
+                ])
+            ]),
+            trigger('tagAnimation', [
+                state('*', style({ opacity: 1, transform: 'scale(1)' })),
+                transition('void => *', [
+                    style({ opacity: 0, transform: 'scale(0)' }),
+                    animate('150ms linear')
+                ]),
+                state('void', style({ opacity: 0, transform: 'scale(0)' })),
+                transition('* => void', [
+                    style({ opacity: 1, transform: 'scale(1)' }),
+                    animate('150ms linear')
+                ])
+            ])], encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.0", ngImport: i0, type: MefDevSelectComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "mefdev-select", encapsulation: ViewEncapsulation.None, providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => MefDevSelectComponent),
+                            multi: true
+                        }
+                    ], animations: [trigger('dropDownAnimation', [
+                            state('bottom', style({
+                                opacity: 1,
+                                transform: 'scaleY(1)',
+                                transformOrigin: '0% 0%'
+                            })),
+                            transition('void => bottom', [
+                                style({
+                                    opacity: 0,
+                                    transform: 'scaleY(0)',
+                                    transformOrigin: '0% 0%'
+                                }),
+                                animate('150ms cubic-bezier(0.25, 0.8, 0.25, 1)')
+                            ]),
+                            state('top', style({
+                                opacity: 1,
+                                transform: 'scaleY(1)',
+                                transformOrigin: '0% 100%'
+                            })),
+                            transition('void => top', [
+                                style({
+                                    opacity: 0,
+                                    transform: 'scaleY(0)',
+                                    transformOrigin: '0% 100%'
+                                }),
+                                animate('150ms cubic-bezier(0.25, 0.8, 0.25, 1)')
+                            ]),
+                            transition('* => void', [
+                                animate('250ms 100ms linear', style({ opacity: 0 }))
+                            ])
+                        ]),
+                        trigger('tagAnimation', [
+                            state('*', style({ opacity: 1, transform: 'scale(1)' })),
+                            transition('void => *', [
+                                style({ opacity: 0, transform: 'scale(0)' }),
+                                animate('150ms linear')
+                            ]),
+                            state('void', style({ opacity: 0, transform: 'scale(0)' })),
+                            transition('* => void', [
+                                style({ opacity: 1, transform: 'scale(1)' }),
+                                animate('150ms linear')
+                            ])
+                        ])], template: "<div tabindex=\"0\" #trigger cdkOverlayOrigin #origin=\"cdkOverlayOrigin\" [ngClass]=\"_selectionClassMap\"\r\n  (keydown.Enter)=\"handleKeyEnterEvent($event)\" (keydown.Backspace)=\"handleKeyBackspaceEvent($event)\"\r\n  (keydown.ArrowUp)=\"handleKeyUpEvent($event)\" (keydown.ArrowDown)=\"handleKeyDownEvent($event)\">\r\n  <div class=\"pg-select-selection__rendered\" *ngIf=\"!ShowSearch\">\r\n    <div class=\"pg-select-selection__placeholder\">\r\n      <ng-template [ngIf]=\"!_selectedOption\">\r\n        {{ PlaceHolder }}\r\n      </ng-template>\r\n    </div>\r\n    <div class=\"pg-select-selection-selected-value\">\r\n      {{ _selectedOption?.Label }}\r\n    </div>\r\n  </div>\r\n  <div class=\"pg-select-selection__rendered\" *ngIf=\"ShowSearch\">\r\n    <div [hidden]=\"_searchText||(!Open&&_selectedOption)||_selectedOptions.size\"\r\n      class=\"pg-select-selection__placeholder\">\r\n      <ng-template [ngIf]=\"(!_composing)&&_selectedOption\">\r\n        {{ _selectedOption.Label }}\r\n      </ng-template>\r\n      <ng-template [ngIf]=\"(!_composing)&&(!_selectedOption)\">\r\n        {{ PlaceHolder }}\r\n      </ng-template>\r\n    </div>\r\n    <ul *ngIf=\"Multiple\">\r\n      <li *ngFor=\"let option of _selectedOptions\" [@tagAnimation] [attr.title]=\"option?.Label || option?.Value\"\r\n        class=\"pg-select-selection__choice\" style=\"-webkit-user-select: none;\">\r\n        <span class=\"pg-select-selection__choice__remove\" (click)=\"unSelectMultipleOption(option,$event)\"></span>\r\n        <div class=\"pg-select-selection__choice__content\">{{ option?.Label }}</div>\r\n      </li>\r\n      <li class=\"pg-select-search pg-select-search--inline\">\r\n        <div class=\"pg-select-search__field__wrap\">\r\n          <input class=\"pg-select-search__field\" (compositionstart)=\"compositionStart()\"\r\n            (compositionend)=\"compositionEnd();updateWidth(searchInput,_searchText);\" [(ngModel)]=\"_searchText\"\r\n            (ngModelChange)=\"updateFilterOption();onSearchChange($event);\"\r\n            (keydown)=\"updateWidth(searchInput,_searchText)\" (input)=\"updateWidth(searchInput,_searchText)\"\r\n            (blur)=\"onTouched()\" #searchInput>\r\n          <span class=\"pg-select-search__field__mirror\"></span></div>\r\n      </li>\r\n    </ul>\r\n    <div *ngIf=\"!Multiple\" class=\"pg-select-selection-selected-value\" [hidden]=\"!(_selectedOption?.Label)||Open\">\r\n      {{ _selectedOption?.Label }}\r\n    </div>\r\n    <div *ngIf=\"!Multiple\" [hidden]=\"!Open\" class=\"pg-select-search pg-select-search--inline\">\r\n      <div class=\"pg-select-search__field__wrap\">\r\n        <input class=\"pg-select-search__field\" (blur)=\"onTouched()\" (compositionstart)=\"compositionStart()\"\r\n          (compositionend)=\"compositionEnd()\" [(ngModel)]=\"_searchText\"\r\n          (ngModelChange)=\"updateFilterOption();onSearchChange($event);\" #searchInput>\r\n        <span class=\"pg-select-search__field__mirror\"></span>\r\n      </div>\r\n    </div>\r\n  </div>\r\n  <span (click)=\"onTouched();clearSelect($event)\" class=\"pg-select-selection__clear\" style=\"-webkit-user-select: none;\"\r\n    *ngIf=\"_selectedOption?.Label&&AllowClear&&!Multiple\">\r\n  </span>\r\n  <span class=\"pg-select-arrow\"><b></b></span>\r\n</div>\r\n<ng-template cdkConnectedOverlay cdkConnectedOverlayHasBackdrop [cdkConnectedOverlayOrigin]=\"origin\"\r\n  (backdropClick)=\"closeDropDown()\" (detach)=\"closeDropDown();\" (positionChange)=\"onPositionChange($event)\"\r\n  [cdkConnectedOverlayWidth]=\"_triggerWidth\" [cdkConnectedOverlayOpen]=\"_isOpen\">\r\n  <div [ngClass]=\"_dropDownClassMap\" [@dropDownAnimation]=\"_dropDownPosition\">\r\n    <div style=\"overflow: auto;\">\r\n      <ul class=\"pg-select-dropdown-menu pg-select-dropdown-menu-vertical pg-select-dropdown-menu-root\" #dropdownUl\r\n        (scroll)=\"dropDownScroll(dropdownUl)\">\r\n        <li *ngFor=\"let option of _filterOptions\" [class.pg-select-dropdown-menu-item-disabled]=\"option.Disabled\"\r\n          [class.pg-select-dropdown-menu-item-active]=\"option.Value == _activeFilterOption?.Value\"\r\n          [class.pg-select-dropdown-menu-item-selected]=\"(option.Value==(_selectedOption?.Value))||(isInSet(_selectedOptions,option))\"\r\n          class=\"pg-select-dropdown-menu-item\" (click)=\"clickOption(option,$event)\">\r\n          <ng-template *ngIf=\"option.OptionTemplate\" [ngTemplateOutlet]=\"option.OptionTemplate\">\r\n          </ng-template>\r\n          <ng-template [ngIf]=\"!option.OptionTemplate\">\r\n            {{ option.Label }}\r\n          </ng-template>\r\n        </li>\r\n      </ul>\r\n    </div>\r\n  </div>\r\n</ng-template>" }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { searchInputElementRef: [{
+                type: ViewChild,
+                args: ["searchInput"]
+            }], trigger: [{
+                type: ViewChild,
+                args: ["trigger"]
+            }], dropdownUl: [{
+                type: ViewChild,
+                args: ["dropdownUl"]
+            }], SearchChange: [{
+                type: Output
+            }], change: [{
+                type: Output
+            }], OpenChange: [{
+                type: Output
+            }], ScrollToBottom: [{
+                type: Output
+            }], Filter: [{
+                type: Input
+            }], MaxMultiple: [{
+                type: Input
+            }], FirstDefault: [{
+                type: Input
+            }], _cdkOverlay: [{
+                type: ViewChild,
+                args: [CdkConnectedOverlay]
+            }], AllowClear: [{
+                type: Input
+            }], KeepUnListOptions: [{
+                type: Input
+            }], Mode: [{
+                type: Input
+            }], Multiple: [{
+                type: Input
+            }], PlaceHolder: [{
+                type: Input
+            }], NotFoundContent: [{
+                type: Input
+            }], Size: [{
+                type: Input
+            }], ShowSearch: [{
+                type: Input
+            }], Tags: [{
+                type: Input
+            }], Disabled: [{
+                type: Input
+            }], Open: [{
+                type: Input
+            }], onClick: [{
+                type: HostListener,
+                args: ["click", ["$event"]]
+            }], onKeyDown: [{
+                type: HostListener,
+                args: ["keydown", ["$event"]]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select.component.js","sourceRoot":"","sources":["../../../../../../projects/ui-kit-lib/src/lib/pg-components/select/select.component.ts","../../../../../../projects/ui-kit-lib/src/lib/pg-components/select/select.component.html"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * complex but work well\r\n * TODO: rebuild latter\r\n */\r\nimport { DOWN_ARROW, ENTER, TAB } from \"@angular/cdk/keycodes\";\r\nimport {\r\n  CdkConnectedOverlay,\r\n  ConnectedOverlayPositionChange\r\n} from \"@angular/cdk/overlay\";\r\nimport {\r\n  forwardRef,\r\n  AfterContentChecked,\r\n  AfterContentInit,\r\n  Component,\r\n  ElementRef,\r\n  EventEmitter,\r\n  HostListener,\r\n  Input,\r\n  OnInit,\r\n  Output,\r\n  Renderer2,\r\n  ViewChild,\r\n  ViewEncapsulation,\r\n  ChangeDetectorRef\r\n} from \"@angular/core\";\r\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from \"@angular/forms\";\r\nimport { MefDevOptionComponent } from \"./option.component\";\r\nimport { OptionPipe } from \"./option.pipe\";\r\nimport { toBoolean } from '../util/convert';\r\nimport { animate, state, style, transition, trigger } from \"@angular/animations\";\r\n\r\n\r\n/**\r\n  * Example of usage:\r\n  * <example-url>https://mef.dev/ui_kit_demo/view/select</example-url>\r\n  */\r\n@Component({\r\n  selector: \"mefdev-select\",\r\n  encapsulation: ViewEncapsulation.None,\r\n  templateUrl: \"./select.component.html\",\r\n\r\n  providers: [\r\n    {\r\n      provide: NG_VALUE_ACCESSOR,\r\n      useExisting: forwardRef(() => MefDevSelectComponent),\r\n      multi: true\r\n    }\r\n  ],\r\n  animations: [trigger('dropDownAnimation', [\r\n    state('bottom', style({\r\n      opacity        : 1,\r\n      transform      : 'scaleY(1)',\r\n      transformOrigin: '0% 0%'\r\n    })),\r\n    transition('void => bottom', [\r\n      style({\r\n        opacity        : 0,\r\n        transform      : 'scaleY(0)',\r\n        transformOrigin: '0% 0%'\r\n      }),\r\n      animate('150ms cubic-bezier(0.25, 0.8, 0.25, 1)')\r\n    ]),\r\n    state('top', style({\r\n      opacity        : 1,\r\n      transform      : 'scaleY(1)',\r\n      transformOrigin: '0% 100%'\r\n    })),\r\n    transition('void => top', [\r\n      style({\r\n        opacity        : 0,\r\n        transform      : 'scaleY(0)',\r\n        transformOrigin: '0% 100%'\r\n      }),\r\n      animate('150ms cubic-bezier(0.25, 0.8, 0.25, 1)')\r\n    ]),\r\n    transition('* => void', [\r\n      animate('250ms 100ms linear', style({ opacity: 0 }))\r\n    ])\r\n  ]),\r\n\r\n  trigger('tagAnimation', [\r\n    state('*', style({ opacity: 1, transform: 'scale(1)' })),\r\n    transition('void => *', [\r\n      style({ opacity: 0, transform: 'scale(0)' }),\r\n      animate('150ms linear')\r\n    ]),\r\n    state('void', style({ opacity: 0, transform: 'scale(0)' })),\r\n    transition('* => void', [\r\n      style({ opacity: 1, transform: 'scale(1)' }),\r\n      animate('150ms linear')\r\n    ])])]\r\n})\r\nexport class MefDevSelectComponent\r\n  implements\r\n    OnInit,\r\n    AfterContentInit,\r\n    AfterContentChecked,\r\n    ControlValueAccessor {\r\n  private _allowClear = false;\r\n  private _disabled = false;\r\n  private _isTags = false;\r\n  private _isMultiple = false;\r\n  private _keepUnListOptions = false;\r\n  private _showSearch = false;\r\n  _el: HTMLElement;\r\n  _isOpen = false;\r\n  _prefixCls = \"pg-select\";\r\n  _classList: string[] = [];\r\n  _dropDownClassMap: any;\r\n  _dropDownPrefixCls = `${this._prefixCls}-dropdown`;\r\n  _selectionClassMap: any;\r\n  _selectionPrefixCls = `${this._prefixCls}-selection`;\r\n  _size: string;\r\n  _value: string[] | string;\r\n  _placeholder = \"placeholder\";\r\n  _notFoundContent = \"No Content\";\r\n  _searchText = \"\";\r\n  _triggerWidth = 0;\r\n  _selectedOption: MefDevOptionComponent;\r\n  _operatingMultipleOption: MefDevOptionComponent;\r\n  _selectedOptions: Set<MefDevOptionComponent> = new Set();\r\n  _options: MefDevOptionComponent[] = [];\r\n  _cacheOptions: MefDevOptionComponent[] = [];\r\n  _filterOptions: MefDevOptionComponent[] = [];\r\n  _tagsOptions: MefDevOptionComponent[] = [];\r\n  _activeFilterOption: MefDevOptionComponent;\r\n  _isMultiInit = false;\r\n  _dropDownPosition: \"top\" | \"center\" | \"bottom\" = \"bottom\";\r\n  _composing = false;\r\n  _mode: any;\r\n  // ngModel Access\r\n  onChange: (value: string | string[]) => void = () => null;\r\n  onTouched: () => void = () => null;\r\n  @ViewChild(\"searchInput\") searchInputElementRef: any;\r\n  @ViewChild(\"trigger\") trigger: ElementRef;\r\n  @ViewChild(\"dropdownUl\") dropdownUl: ElementRef;\r\n  @Output() SearchChange: EventEmitter<string> = new EventEmitter();\r\n  @Output() change: EventEmitter<string> = new EventEmitter();\r\n  @Output() OpenChange: EventEmitter<boolean> = new EventEmitter();\r\n  @Output() ScrollToBottom: EventEmitter<boolean> = new EventEmitter();\r\n  @Input() Filter = true;\r\n  @Input() MaxMultiple = Infinity;\r\n  @Input() FirstDefault: boolean = false;\r\n  @ViewChild(CdkConnectedOverlay) _cdkOverlay: CdkConnectedOverlay;\r\n\r\n  @Input()\r\n  set AllowClear(value: boolean) {\r\n    this._allowClear = toBoolean(value);\r\n  }\r\n\r\n  get AllowClear(): boolean {\r\n    return this._allowClear;\r\n  }\r\n\r\n  @Input()\r\n  set KeepUnListOptions(value: boolean) {\r\n    this._keepUnListOptions = toBoolean(value);\r\n  }\r\n\r\n  get KeepUnListOptions(): boolean {\r\n    return this._keepUnListOptions;\r\n  }\r\n\r\n  @Input()\r\n  set Mode(value: string) {\r\n    this._mode = value;\r\n    if (this._mode === \"multiple\") {\r\n      this.Multiple = true;\r\n    } else if (this._mode === \"tags\") {\r\n      this.Tags = true;\r\n    } else if (this._mode === \"combobox\") {\r\n      this.ShowSearch = true;\r\n    }\r\n  }\r\n\r\n  @Input()\r\n  set Multiple(value: boolean) {\r\n    this._isMultiple = toBoolean(value);\r\n    if (this._isMultiple) {\r\n      this.ShowSearch = true;\r\n    }\r\n  }\r\n\r\n  get Multiple(): boolean {\r\n    return this._isMultiple;\r\n  }\r\n\r\n  @Input()\r\n  set PlaceHolder(value: string) {\r\n    this._placeholder = value;\r\n  }\r\n\r\n  get PlaceHolder(): string {\r\n    return this._placeholder;\r\n  }\r\n\r\n  @Input()\r\n  set NotFoundContent(value: string) {\r\n    this._notFoundContent = value;\r\n  }\r\n\r\n  get NotFoundContent(): string {\r\n    return this._notFoundContent;\r\n  }\r\n\r\n  @Input()\r\n  set Size(value: string) {\r\n     // @ts-ignore\r\n    this._size = { large: \"lg\", small: \"sm\" }[value];\r\n    this.setClassMap();\r\n  }\r\n\r\n  get Size(): string {\r\n    return this._size;\r\n  }\r\n\r\n  @Input()\r\n  set ShowSearch(value: boolean) {\r\n    this._showSearch = toBoolean(value);\r\n  }\r\n\r\n  get ShowSearch(): boolean {\r\n    return this._showSearch;\r\n  }\r\n\r\n  @Input()\r\n  set Tags(value: boolean) {\r\n    const isTags = toBoolean(value);\r\n    this._isTags = isTags;\r\n    this.Multiple = isTags;\r\n  }\r\n\r\n  get Tags(): boolean {\r\n    return this._isTags;\r\n  }\r\n\r\n  @Input()\r\n  set Disabled(value: boolean) {\r\n    this._disabled = toBoolean(value);\r\n    this.closeDropDown();\r\n    this.setClassMap();\r\n  }\r\n\r\n  get Disabled(): boolean {\r\n    return this._disabled;\r\n  }\r\n\r\n  @Input()\r\n  set Open(value: boolean) {\r\n    const isOpen = toBoolean(value);\r\n    if (this._isOpen === isOpen) {\r\n      return;\r\n    }\r\n    if (isOpen) {\r\n      this.scrollToActive();\r\n      this._setTriggerWidth();\r\n    }\r\n    this._isOpen = isOpen;\r\n    this.OpenChange.emit(this._isOpen);\r\n    this.setClassMap();\r\n    if (this._isOpen) {\r\n      setTimeout(() => {\r\n        this.checkDropDownScroll();\r\n      });\r\n    }\r\n  }\r\n\r\n  get Open(): boolean {\r\n    return this._isOpen;\r\n  }\r\n\r\n  /** new -option insert or new tags insert */\r\n   // @ts-ignore\r\n  addOption = option => {\r\n    this._options.push(option);\r\n    if (!this._isTags) {\r\n      if (option.Value) {\r\n        this.updateSelectedOption(this._value);\r\n      } else {\r\n        this.forceUpdateSelectedOption(this._value);\r\n      }\r\n    }\r\n  };\r\n\r\n  /** -option remove or tags remove */\r\n  removeOption(option: MefDevOptionComponent): void {\r\n    this._options.splice(this._options.indexOf(option), 1);\r\n    if (!this._isTags) {\r\n      this.forceUpdateSelectedOption(this._value);\r\n    }\r\n  }\r\n\r\n  /** dropdown position changed */\r\n  onPositionChange(position: ConnectedOverlayPositionChange): void {\r\n    this._dropDownPosition = position.connectionPair.originY;\r\n  }\r\n\r\n  compositionStart(): void {\r\n    this._composing = true;\r\n  }\r\n\r\n  compositionEnd(): void {\r\n    this._composing = false;\r\n  }\r\n\r\n  /** clear single selected option */\r\n  clearSelect($event?: MouseEvent): void {\r\n    if ($event) {\r\n      $event.preventDefault();\r\n      $event.stopPropagation();\r\n    } // @ts-ignore\r\n    this._selectedOption = null; // @ts-ignore\r\n    this.Value = null; // @ts-ignore\r\n    this.onChange(null);\r\n  }\r\n\r\n  /** click dropdown option by user */\r\n  clickOption(option: MefDevOptionComponent, $event?: MouseEvent): void {\r\n    if (!option) {\r\n      return;\r\n    }\r\n    this.chooseOption(option, true, $event);\r\n    this.clearSearchText();\r\n    if (!this._isMultiple) {\r\n      this.Open = false;\r\n    }\r\n  }\r\n\r\n  /** choose option */\r\n  chooseOption(\r\n    option: MefDevOptionComponent,\r\n    isUserClick: boolean = false,\r\n    $event?: MouseEvent\r\n  ): void {\r\n    if ($event) {\r\n      $event.preventDefault();\r\n      $event.stopPropagation();\r\n    }\r\n    this._activeFilterOption = option;\r\n    if (option && !option.Disabled) {\r\n      if (!this.Multiple) {\r\n        this._selectedOption = option;\r\n        this._value = option.Value;\r\n        if (isUserClick) {\r\n          this.change.next(this._value);\r\n          this.onChange(option.Value);\r\n        }\r\n      } else {\r\n        if (isUserClick) {\r\n          this.isInSet(this._selectedOptions, option)\r\n            ? this.unSelectMultipleOption(option)\r\n            : this.selectMultipleOption(option);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  updateWidth(element: HTMLInputElement, text: string): void {\r\n    if (text) {\r\n      /** wait for scroll width change */ // @ts-ignore\r\n      setTimeout(_ => {\r\n        this._renderer.setStyle(element, \"width\", `${element.scrollWidth}px`);\r\n      });\r\n    } else {\r\n      this._renderer.removeStyle(element, \"width\");\r\n    }\r\n  }\r\n\r\n  /** determine if option in set */\r\n  isInSet(\r\n    set: Set<MefDevOptionComponent>,\r\n    option: MefDevOptionComponent\r\n  ): MefDevOptionComponent { // @ts-ignore\r\n    return (Array.from(set) as MefDevOptionComponent[]).find(\r\n      (data: MefDevOptionComponent) => data.Value === option.Value\r\n    );\r\n  }\r\n\r\n  /** cancel select multiple option */ // @ts-ignore\r\n  unSelectMultipleOption = (option, $event?, emitChange = true) => {\r\n    this._operatingMultipleOption = option;\r\n    this._selectedOptions.delete(option);\r\n    if (emitChange) {\r\n      this.emitMultipleOptions();\r\n    }\r\n\r\n    // 对Tag进行特殊处理\r\n    if (\r\n      this._isTags &&\r\n      this._options.indexOf(option) !== -1 &&\r\n      this._tagsOptions.indexOf(option) !== -1\r\n    ) {\r\n      this.removeOption(option);\r\n      this._tagsOptions.splice(this._tagsOptions.indexOf(option), 1);\r\n    }\r\n    if ($event) {\r\n      $event.preventDefault();\r\n      $event.stopPropagation();\r\n    }\r\n  };\r\n\r\n  /** select multiple option */\r\n  selectMultipleOption(option: MefDevOptionComponent, $event?: MouseEvent): void {\r\n    /** if tags do push to tag option */\r\n    if (\r\n      this._isTags &&\r\n      this._options.indexOf(option) === -1 &&\r\n      this._tagsOptions.indexOf(option) === -1\r\n    ) {\r\n      this.addOption(option);\r\n      this._tagsOptions.push(option);\r\n    }\r\n    this._operatingMultipleOption = option;\r\n    if (this._selectedOptions.size < this.MaxMultiple) {\r\n      this._selectedOptions.add(option);\r\n    }\r\n    this.emitMultipleOptions();\r\n\r\n    if ($event) {\r\n      $event.preventDefault();\r\n      $event.stopPropagation();\r\n    }\r\n  }\r\n\r\n  /** emit multiple options */\r\n  emitMultipleOptions(): void {\r\n    if (this._isMultiInit) {\r\n      return;\r\n    }\r\n    const arrayOptions = Array.from(this._selectedOptions);\r\n    this._value = arrayOptions.map(item => item.Value);\r\n    this.onChange(this._value);\r\n  }\r\n\r\n  /** update selected option when add remove option etc */\r\n  updateSelectedOption(\r\n    currentModelValue: string | string[],\r\n    triggerByNgModel: boolean = false\r\n  ): void {\r\n    if (currentModelValue == null) {\r\n      return;\r\n    }\r\n    if (this.Multiple) {\r\n      const selectedOptions = this._options.filter(item => {\r\n        return item != null && currentModelValue.indexOf(item.Value) !== -1;\r\n      });\r\n      if ((this.KeepUnListOptions || this.Tags) && !triggerByNgModel) {\r\n        const _selectedOptions = Array.from(this._selectedOptions);\r\n        selectedOptions.forEach(option => {\r\n          const _exist = _selectedOptions.some(\r\n            item => item._value == option._value\r\n          );\r\n          if (!_exist) {\r\n            this._selectedOptions.add(option);\r\n          }\r\n        });\r\n      } else {\r\n        this._selectedOptions = new Set();\r\n        selectedOptions.forEach(option => {\r\n          this._selectedOptions.add(option);\r\n        });\r\n      }\r\n    } else {\r\n      const selectedOption = this._options.filter(item => {\r\n        return item != null && item.Value == currentModelValue;\r\n      });\r\n      this.chooseOption(selectedOption[0]);\r\n    }\r\n  }\r\n\r\n  forceUpdateSelectedOption(value: string | string[]): void {\r\n    /** trigger dirty check */ // @ts-ignore\r\n    setTimeout(_ => {\r\n      this.updateSelectedOption(value);\r\n    });\r\n  }\r\n\r\n  get Value(): string | string[] {\r\n    return this._value;\r\n  }\r\n\r\n  set Value(value: string | string[]) {\r\n    this._updateValue(value);\r\n  }\r\n\r\n  clearAllSelectedOption(emitChange: boolean = true): void {\r\n    this._selectedOptions.forEach(item => {\r\n      this.unSelectMultipleOption(item, null, emitChange);\r\n    });\r\n  }\r\n\r\n  handleKeyEnterEvent(event: KeyboardEvent): void {\r\n    /** when composing end */\r\n    if (!this._composing && this._isOpen) {\r\n      event.preventDefault();\r\n      event.stopPropagation();\r\n      this.updateFilterOption(false);\r\n      this.clickOption(this._activeFilterOption);\r\n    }\r\n  }\r\n\r\n  handleKeyBackspaceEvent(event: KeyboardEvent): void {\r\n    if (!this._searchText && !this._composing && this._isMultiple) {\r\n      event.preventDefault();\r\n      const lastOption = Array.from(this._selectedOptions).pop();\r\n      this.unSelectMultipleOption(lastOption);\r\n    }\r\n  }\r\n\r\n  handleKeyDownEvent($event: MouseEvent): void {\r\n    if (this._isOpen) {\r\n      $event.preventDefault();\r\n      $event.stopPropagation();\r\n      this._activeFilterOption = this.nextOption(\r\n        this._activeFilterOption,\r\n        this._filterOptions.filter(w => !w.Disabled)\r\n      );\r\n      this.scrollToActive();\r\n    }\r\n  }\r\n\r\n  handleKeyUpEvent($event: MouseEvent): void {\r\n    if (this._isOpen) {\r\n      $event.preventDefault();\r\n      $event.stopPropagation();\r\n      this._activeFilterOption = this.preOption(\r\n        this._activeFilterOption,\r\n        this._filterOptions.filter(w => !w.Disabled)\r\n      );\r\n      this.scrollToActive();\r\n    }\r\n  }\r\n\r\n  preOption(\r\n    option: MefDevOptionComponent,\r\n    options: MefDevOptionComponent[]\r\n  ): MefDevOptionComponent {\r\n    return options[options.indexOf(option) - 1] || options[options.length - 1];\r\n  }\r\n\r\n  nextOption(\r\n    option: MefDevOptionComponent,\r\n    options: MefDevOptionComponent[]\r\n  ): MefDevOptionComponent {\r\n    return options[options.indexOf(option) + 1] || options[0];\r\n  }\r\n\r\n  clearSearchText(): void {\r\n    this._searchText = \"\";\r\n    this.updateFilterOption();\r\n  }\r\n\r\n  updateFilterOption(updateActiveFilter: boolean = true): void {\r\n    if (this.Filter) {\r\n      this._filterOptions = new OptionPipe().transform(this._options, {\r\n        searchText: this._searchText,\r\n        tags: this._isTags,\r\n        notFoundContent: this._isTags\r\n          ? this._searchText\r\n          : this._notFoundContent,\r\n        disabled: !this._isTags,\r\n        value: this._isTags ? this._searchText : \"disabled\"\r\n      });\r\n    } else {\r\n      this._filterOptions = this._options;\r\n    }\r\n\r\n    /** TODO: cause pre & next key selection not work */\r\n    if (updateActiveFilter && !this._selectedOption) {\r\n      this._activeFilterOption = this._filterOptions[0];\r\n    }\r\n  }\r\n\r\n  onSearchChange(searchValue: string): void {\r\n    this.SearchChange.emit(searchValue);\r\n  }\r\n\r\n  @HostListener(\"click\", [\"$event\"])\r\n  onClick(e: MouseEvent): void {\r\n    e.preventDefault();\r\n    if (!this._disabled) {\r\n      this.Open = !this.Open;\r\n      if (this.ShowSearch) {\r\n        /** wait for search display */ // @ts-ignore\r\n        setTimeout(_ => {\r\n          this.searchInputElementRef.nativeElement.focus();\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  @HostListener(\"keydown\", [\"$event\"])\r\n  onKeyDown(e: KeyboardEvent): void {\r\n    const keyCode = e.keyCode;\r\n    if (keyCode === TAB && this.Open) {\r\n      this.Open = false;\r\n      return;\r\n    }\r\n    if ((keyCode !== DOWN_ARROW && keyCode !== ENTER) || this.Open) {\r\n      return;\r\n    }\r\n    e.preventDefault();\r\n    if (!this._disabled) {\r\n      this.Open = true;\r\n      if (this.ShowSearch) {\r\n        /** wait for search display */ // @ts-ignore\r\n        setTimeout(_ => {\r\n          this.searchInputElementRef.nativeElement.focus();\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  closeDropDown(): void {\r\n    if (!this.Open) {\r\n      return;\r\n    }\r\n    this.onTouched();\r\n    if (this.Multiple) {\r\n      this._renderer.removeStyle(\r\n        this.searchInputElementRef.nativeElement,\r\n        \"width\"\r\n      );\r\n    }\r\n    this.clearSearchText();\r\n    this.Open = false;\r\n  }\r\n\r\n  setClassMap(): void {\r\n    this._classList.forEach(_className => {\r\n      this._renderer.removeClass(this._el, _className);\r\n    }); // @ts-ignore\r\n    this._classList = [\r\n      this._prefixCls,\r\n      this._mode === \"combobox\" && `${this._prefixCls}-combobox`,\r\n      !this._disabled && `${this._prefixCls}-enabled`,\r\n      this._disabled && `${this._prefixCls}-disabled`,\r\n      this._isOpen && `${this._prefixCls}-open`,\r\n      this._showSearch && `${this._prefixCls}-show-search`,\r\n      this._size && `${this._prefixCls}-${this._size}`\r\n    ].filter(item => {\r\n      return !!item;\r\n    });\r\n    this._classList.forEach(_className => {\r\n      this._renderer.addClass(this._el, _className);\r\n    });\r\n    this._selectionClassMap = {\r\n      [this._selectionPrefixCls]: true,\r\n      [`${this._selectionPrefixCls}--single`]: !this.Multiple,\r\n      [`${this._selectionPrefixCls}--multiple`]: this.Multiple\r\n    };\r\n  }\r\n\r\n  setDropDownClassMap(): void {\r\n    this._dropDownClassMap = {\r\n      [this._dropDownPrefixCls]: true,\r\n      [\"component-select\"]: this._mode === \"combobox\",\r\n      [`${this._dropDownPrefixCls}--single`]: !this.Multiple,\r\n      [`${this._dropDownPrefixCls}--multiple`]: this.Multiple,\r\n      [`${this._dropDownPrefixCls}-placement-bottomLeft`]:\r\n        this._dropDownPosition === \"bottom\",\r\n      [`${this._dropDownPrefixCls}-placement-topLeft`]:\r\n        this._dropDownPosition === \"top\"\r\n    };\r\n  }\r\n\r\n  scrollToActive(): void {\r\n    /** wait for dropdown display */ // @ts-ignore\r\n    setTimeout(_ => {\r\n      if (this._activeFilterOption && this._activeFilterOption.Value) {\r\n        const index = this._filterOptions.findIndex(\r\n          option => option.Value === this._activeFilterOption.Value\r\n        );\r\n        try {\r\n          const scrollPane = this.dropdownUl.nativeElement.children[\r\n            index\r\n          ] as HTMLLIElement;\r\n          // TODO: scrollIntoViewIfNeeded is not a standard API, why doing so?\r\n          /* tslint:disable-next-line:no-any */\r\n          (scrollPane as any).scrollIntoViewIfNeeded(false);\r\n        } catch (e) {}\r\n      }\r\n    });\r\n  }\r\n\r\n  flushComponentState(): void {\r\n    this.updateFilterOption();\r\n    if (!this.Multiple) {\r\n      this.updateSelectedOption(this._value);\r\n    } else {\r\n      if (this._value) {\r\n        this.updateSelectedOption(this._value);\r\n      }\r\n    }\r\n  }\r\n\r\n  _setTriggerWidth(): void {\r\n    this._triggerWidth = this._getTriggerRect().width;\r\n    /** should remove after after https://github.com/angular/material2/pull/8765 merged **/\r\n    if (this._cdkOverlay && this._cdkOverlay.overlayRef) {\r\n      this._cdkOverlay.overlayRef.updateSize({\r\n        width: this._triggerWidth\r\n      });\r\n    }\r\n  }\r\n\r\n  _getTriggerRect(): ClientRect {\r\n    return this.trigger.nativeElement.getBoundingClientRect();\r\n  }\r\n\r\n  writeValue(value: string | string[]): void {\r\n    this._updateValue(value, false);\r\n  }\r\n\r\n  registerOnChange(fn: (value: string | string[]) => void): void {\r\n    this.onChange = fn;\r\n  }\r\n\r\n  registerOnTouched(fn: () => void): void {\r\n    this.onTouched = fn;\r\n  }\r\n\r\n  setDisabledState(isDisabled: boolean): void {\r\n    this.Disabled = isDisabled;\r\n  }\r\n\r\n  dropDownScroll(ul: HTMLUListElement): void {\r\n    if (ul && ul.scrollHeight - ul.scrollTop === ul.clientHeight) {\r\n      this.ScrollToBottom.emit(true);\r\n    }\r\n  }\r\n\r\n  checkDropDownScroll(): void {\r\n    if (\r\n      this.dropdownUl &&\r\n      this.dropdownUl.nativeElement.scrollHeight ===\r\n        this.dropdownUl.nativeElement.clientHeight\r\n    ) {\r\n      this.ScrollToBottom.emit(true);\r\n    }\r\n  }\r\n\r\n  constructor(\r\n    private _elementRef: ElementRef,\r\n    private _renderer: Renderer2,\r\n    private cDRef: ChangeDetectorRef\r\n  ) {\r\n    this._el = this._elementRef.nativeElement;\r\n  }\r\n\r\n  ngAfterContentInit(): void {\r\n    if (this._value != null) {\r\n      this.flushComponentState();\r\n    }\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this.updateFilterOption();\r\n    this.setClassMap();\r\n    this.setDropDownClassMap();\r\n  }\r\n\r\n  ngAfterContentChecked(): void {\r\n    if (this._cacheOptions !== this._options) {\r\n      /** update filter option after every content check cycle */\r\n      this.updateFilterOption();\r\n      this._cacheOptions = this._options;\r\n    } else {\r\n      this.updateFilterOption(false);\r\n    }\r\n\r\n    if (this.FirstDefault) {\r\n      if (!this._value && this._options) {\r\n        if (this._options[0] !== undefined && this._options[0].Value) {\r\n          this.chooseOption(this._options[0], false);\r\n          setTimeout(() => {\r\n            this.onChange(this._options[0].Value);\r\n          });\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  private _updateValue(\r\n    value: string[] | string,\r\n    emitChange: boolean = true\r\n  ): void {\r\n    if (this._value === value) {\r\n      return;\r\n    }\r\n    if (value == null && this.Multiple) {\r\n      this._value = [];\r\n    } else {\r\n      this._value = value;\r\n    }\r\n    if (!this.Multiple) {\r\n      if (value == null) { // @ts-ignore\r\n        this._selectedOption = null;\r\n      } else {\r\n        this.updateSelectedOption(value);\r\n      }\r\n    } else {\r\n      if (value) {\r\n        if (value.length === 0) {\r\n          this.clearAllSelectedOption(emitChange);\r\n        } else {\r\n          this.updateSelectedOption(value, true);\r\n        }\r\n      } else if (value == null) {\r\n        this.clearAllSelectedOption(emitChange);\r\n      }\r\n    }\r\n  }\r\n}\r\n","<div tabindex=\"0\" #trigger cdkOverlayOrigin #origin=\"cdkOverlayOrigin\" [ngClass]=\"_selectionClassMap\"\r\n  (keydown.Enter)=\"handleKeyEnterEvent($event)\" (keydown.Backspace)=\"handleKeyBackspaceEvent($event)\"\r\n  (keydown.ArrowUp)=\"handleKeyUpEvent($event)\" (keydown.ArrowDown)=\"handleKeyDownEvent($event)\">\r\n  <div class=\"pg-select-selection__rendered\" *ngIf=\"!ShowSearch\">\r\n    <div class=\"pg-select-selection__placeholder\">\r\n      <ng-template [ngIf]=\"!_selectedOption\">\r\n        {{ PlaceHolder }}\r\n      </ng-template>\r\n    </div>\r\n    <div class=\"pg-select-selection-selected-value\">\r\n      {{ _selectedOption?.Label }}\r\n    </div>\r\n  </div>\r\n  <div class=\"pg-select-selection__rendered\" *ngIf=\"ShowSearch\">\r\n    <div [hidden]=\"_searchText||(!Open&&_selectedOption)||_selectedOptions.size\"\r\n      class=\"pg-select-selection__placeholder\">\r\n      <ng-template [ngIf]=\"(!_composing)&&_selectedOption\">\r\n        {{ _selectedOption.Label }}\r\n      </ng-template>\r\n      <ng-template [ngIf]=\"(!_composing)&&(!_selectedOption)\">\r\n        {{ PlaceHolder }}\r\n      </ng-template>\r\n    </div>\r\n    <ul *ngIf=\"Multiple\">\r\n      <li *ngFor=\"let option of _selectedOptions\" [@tagAnimation] [attr.title]=\"option?.Label || option?.Value\"\r\n        class=\"pg-select-selection__choice\" style=\"-webkit-user-select: none;\">\r\n        <span class=\"pg-select-selection__choice__remove\" (click)=\"unSelectMultipleOption(option,$event)\"></span>\r\n        <div class=\"pg-select-selection__choice__content\">{{ option?.Label }}</div>\r\n      </li>\r\n      <li class=\"pg-select-search pg-select-search--inline\">\r\n        <div class=\"pg-select-search__field__wrap\">\r\n          <input class=\"pg-select-search__field\" (compositionstart)=\"compositionStart()\"\r\n            (compositionend)=\"compositionEnd();updateWidth(searchInput,_searchText);\" [(ngModel)]=\"_searchText\"\r\n            (ngModelChange)=\"updateFilterOption();onSearchChange($event);\"\r\n            (keydown)=\"updateWidth(searchInput,_searchText)\" (input)=\"updateWidth(searchInput,_searchText)\"\r\n            (blur)=\"onTouched()\" #searchInput>\r\n          <span class=\"pg-select-search__field__mirror\"></span></div>\r\n      </li>\r\n    </ul>\r\n    <div *ngIf=\"!Multiple\" class=\"pg-select-selection-selected-value\" [hidden]=\"!(_selectedOption?.Label)||Open\">\r\n      {{ _selectedOption?.Label }}\r\n    </div>\r\n    <div *ngIf=\"!Multiple\" [hidden]=\"!Open\" class=\"pg-select-search pg-select-search--inline\">\r\n      <div class=\"pg-select-search__field__wrap\">\r\n        <input class=\"pg-select-search__field\" (blur)=\"onTouched()\" (compositionstart)=\"compositionStart()\"\r\n          (compositionend)=\"compositionEnd()\" [(ngModel)]=\"_searchText\"\r\n          (ngModelChange)=\"updateFilterOption();onSearchChange($event);\" #searchInput>\r\n        <span class=\"pg-select-search__field__mirror\"></span>\r\n      </div>\r\n    </div>\r\n  </div>\r\n  <span (click)=\"onTouched();clearSelect($event)\" class=\"pg-select-selection__clear\" style=\"-webkit-user-select: none;\"\r\n    *ngIf=\"_selectedOption?.Label&&AllowClear&&!Multiple\">\r\n  </span>\r\n  <span class=\"pg-select-arrow\"><b></b></span>\r\n</div>\r\n<ng-template cdkConnectedOverlay cdkConnectedOverlayHasBackdrop [cdkConnectedOverlayOrigin]=\"origin\"\r\n  (backdropClick)=\"closeDropDown()\" (detach)=\"closeDropDown();\" (positionChange)=\"onPositionChange($event)\"\r\n  [cdkConnectedOverlayWidth]=\"_triggerWidth\" [cdkConnectedOverlayOpen]=\"_isOpen\">\r\n  <div [ngClass]=\"_dropDownClassMap\" [@dropDownAnimation]=\"_dropDownPosition\">\r\n    <div style=\"overflow: auto;\">\r\n      <ul class=\"pg-select-dropdown-menu pg-select-dropdown-menu-vertical pg-select-dropdown-menu-root\" #dropdownUl\r\n        (scroll)=\"dropDownScroll(dropdownUl)\">\r\n        <li *ngFor=\"let option of _filterOptions\" [class.pg-select-dropdown-menu-item-disabled]=\"option.Disabled\"\r\n          [class.pg-select-dropdown-menu-item-active]=\"option.Value == _activeFilterOption?.Value\"\r\n          [class.pg-select-dropdown-menu-item-selected]=\"(option.Value==(_selectedOption?.Value))||(isInSet(_selectedOptions,option))\"\r\n          class=\"pg-select-dropdown-menu-item\" (click)=\"clickOption(option,$event)\">\r\n          <ng-template *ngIf=\"option.OptionTemplate\" [ngTemplateOutlet]=\"option.OptionTemplate\">\r\n          </ng-template>\r\n          <ng-template [ngIf]=\"!option.OptionTemplate\">\r\n            {{ option.Label }}\r\n          </ng-template>\r\n        </li>\r\n      </ul>\r\n    </div>\r\n  </div>\r\n</ng-template>"]}