@coreui/angular-pro 4.2.34 → 4.2.37

package/esm2020/lib/multi-select/multi-select/multi-select.component.mjs

@@ -1,15 +1,16 @@
-var _MultiSelectComponent_destroy$;
-import { __classPrivateFieldGet } from "tslib";
-import { Component, ContentChildren, ElementRef, EventEmitter, forwardRef, HostBinding, HostListener, Input, Output, ViewChild } from '@angular/core';
-import { FocusKeyManager } from '@angular/cdk/a11y';
-import { coerceBooleanProperty } from '@angular/cdk/coercion';
+var _MultiSelectComponent_destroy$, _MultiSelectComponent_optionsReady$, _MultiSelectComponent_options, _MultiSelectComponent_value;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
+import { Component, ContentChildren, ElementRef, EventEmitter, forwardRef, HostBinding, HostListener, Input, Output, ViewChild, ViewChildren } from '@angular/core';
 import { NG_VALUE_ACCESSOR } from '@angular/forms';
-import { Subject } from 'rxjs';
+import { FocusKeyManager } from '@angular/cdk/a11y';
+import { coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { combineLatestWith, debounceTime, delay, distinctUntilChanged, filter, map, take, takeUntil, tap } from 'rxjs/operators';
 import { DropdownComponent, DropdownToggleDirective } from '../../dropdown';
 import { MultiSelectService } from '../multi-select.service';
 import { MultiSelectOptionComponent } from '../multi-select-option/multi-select-option.component';
 import { MultiSelectNativeSelectComponent } from '../multi-select-native-select/multi-select-native-select.component';
-import { takeUntil } from 'rxjs/operators';
+import { TemplateIdDirective } from '../../shared';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/cdk/a11y";
 import * as i2 from "../multi-select.service";
@@ -17,7 +18,10 @@ import * as i3 from "@angular/common";
 import * as i4 from "@angular/forms";
 import * as i5 from "../../dropdown/dropdown/dropdown.component";
 import * as i6 from "../../dropdown/dropdown-menu/dropdown-menu.directive";
-import * as i7 from "../multi-select-tag/multi-select-tag.component";
+import * as i7 from "@angular/cdk/scrolling";
+import * as i8 from "../multi-select-option/multi-select-option.component";
+import * as i9 from "../multi-select-tag/multi-select-tag.component";
+import * as i10 from "./multi-select-search.directive";
 // @ts-ignore
 export const observeReferenceModifier = {
     name: 'observeReferenceModifier', enabled: true, phase: 'main', fn({ state }) { },
@@ -49,31 +53,125 @@ export class MultiSelectComponent {
         this.multiSelectService = multiSelectService;
         this.iterableDiffers = iterableDiffers;
         _MultiSelectComponent_destroy$.set(this, new Subject());
+        _MultiSelectComponent_optionsReady$.set(this, new Subject());
+        this.optionsArray$ = new BehaviorSubject([]);
+        _MultiSelectComponent_options.set(this, new Map());
+        this.optionsSelected$ = new BehaviorSubject([]);
+        this.optionsSelected = new Map();
+        this.value$ = new BehaviorSubject([]);
         this.onChange = (value) => { };
         this.onTouched = () => { };
+        /**
+         * Enables selection cleaner element
+         * @type boolean
+         * @default true
+         */
         this.cleaner = true;
         this._disabled = false;
         this._multiple = false;
-        this.nativeName = '';
+        /**
+         * Hidden native select form
+         * @type string
+         * @default ''
+         */
+        this.nativeFormId = '';
+        /**
+         * Hidden native select id
+         * @type string
+         * @default ''
+         */
         this.nativeId = '';
-        this.options = [];
+        /**
+         * Hidden native select name
+         * @type string
+         * @default ''
+         */
+        this.nativeName = '';
+        /**
+         * Sets maxHeight of options list in px
+         * @type (string | number)
+         * @default 'auto'
+         */
         this.optionsMaxHeight = 'auto';
-        this.optionsStyle = 'checkbox';
+        /**
+         * Specifies a short hint that is visible in the search input
+         * @type string
+         * @default 'Select...'
+         */
         this.placeholder = 'Select...';
+        /**
+         * Enables search input element
+         * @type boolean | SearchFn | 'external'
+         * @default true
+         */
         this.search = true;
+        /**
+         * Sets the label for no results when filtering
+         * @type string
+         * @default 'no items'
+         */
         this.searchNoResultsLabel = 'no items';
         this._searchValue = '';
+        /**
+         * Emits searchValue string for external filtering
+         * @type string
+         */
         this.searchValueChange = new EventEmitter();
+        /**
+         * Enables select all button
+         * @type boolean
+         * @default true
+         */
         this.selectAll = true;
+        /**
+         * Sets the select all button label
+         * @type string
+         * @default 'Select all options'
+         */
         this.selectAllLabel = 'Select all options';
+        /**
+         * Selection type
+         * @type 'counter' | 'tags' | 'text'
+         * @default 'tags'
+         */
         this.selectionType = 'tags';
+        /**
+         * Counter selection label value
+         * @type string
+         * @default 'item(s) selected'
+         */
         this.selectionTypeCounterText = 'item(s) selected';
+        /**
+         * Counter selection label plural map for I18nPluralPipe
+         * @type IPluralMap
+         * @default { '=1': 'item selected', 'other': 'items selected' }
+         */
         this.selectionTypeCounterTextPluralMap = { '=1': 'item selected', 'other': 'items selected' };
-        this._value = [''];
+        _MultiSelectComponent_value.set(this, []);
+        /**
+         * Emits valueChange
+         * @type string | string[]
+         */
         this.valueChange = new EventEmitter();
         this._virtualScroller = false;
-        this._visibleItems = 10;
+        this._visibleItems = 8;
+        /**
+         * The size of the option item in the list (in pixels).
+         * @type number
+         * @default 40
+         */
+        this.itemSize = 40;
+        /**
+         * Min width of the options list (in pixels).
+         * @type number
+         * @default 196
+         */
+        this.itemMinWidth = 196;
         this._visible = false;
+        /**
+         * Emits visibleChange
+         * @type boolean
+         */
         this.visibleChange = new EventEmitter();
         /**
          * Optional popper Options object
@@ -82,20 +180,24 @@ export class MultiSelectComponent {
         this.popperjsOptions = {
             strategy: 'fixed', modifiers: [observeReferenceModifier, {
                     name: 'offset', options: {
-                        offset: () => this.selectionType === 'tags' && this.selectedOptions.length ? [-2, 8] : [-12, 12]
+                        offset: () => this.selectionType === 'tags' && this.optionsSelected.size ? [-2, 8] : [-12, 12]
                     }
                 }]
         };
         this.isDropdownVisible = false;
-        this._selectedOptions = [];
-        this._tabIndex = '-1';
+        this.templates = {};
+        this._tabIndex = -1;
         this.visibleOptions = 0;
         this._subtreeFocused = this.focusOrigin(null);
-        this.differ = this.iterableDiffers.find(this._value).create();
+        this.activeOption = null;
+        this.differ = this.iterableDiffers.find(__classPrivateFieldGet(this, _MultiSelectComponent_value, "f")).create();
     }
     writeValue(value) {
-        if (value !== null) {
-            this.value = Array.isArray(value) ? [...value] : [value ?? ''];
+        if (value?.length > 0) {
+            this.value = Array.isArray(value) ? [...value] : [value];
+        }
+        else {
+            this.value = Array(0);
         }
     }
     registerOnChange(fn) {
@@ -107,6 +209,11 @@ export class MultiSelectComponent {
     setDisabledState(isDisabled) {
         this.disabled = isDisabled;
     }
+    /**
+     * Disables multi-select component
+     * @type boolean
+     * @default false
+     */
     set disabled(value) {
         if (this._disabled !== value) {
             this._disabled = coerceBooleanProperty(value);
@@ -116,16 +223,47 @@ export class MultiSelectComponent {
     get disabled() {
         return this._disabled;
     }
+    /**
+     * Specifies that multiple options can be selected at once
+     * @type boolean
+     * @default false
+     */
     set multiple(value) {
         this._multiple = coerceBooleanProperty(value);
     }
     get multiple() {
         return this._multiple;
     }
+    /**
+     * List of option elements
+     * @type IOption[]
+     * @default []
+     */
+    set options(options) {
+        if (Array.isArray(options)) {
+            this.makeOptions(options);
+        }
+    }
+    get options() {
+        return [...__classPrivateFieldGet(this, _MultiSelectComponent_options, "f").values()];
+    }
+    /**
+     * Sets option style
+     * @type 'checkbox' | 'text'
+     * @default 'checkbox'
+     */
+    set optionsStyle(value) {
+        this.multiSelectService.optionsStyle = value ?? 'checkbox';
+    }
+    /**
+     * Sets initial search string
+     * @type string
+     * @default ''
+     */
     set searchValue(value) {
         if (this._searchValue !== value.trimStart()) {
             this._searchValue = value.trimStart();
-            this.visible = !!this.searchValue.length || this.visible;
+            this.visible = !!this.searchValue.length ? true : this.visible;
             this.filterOptions(this.searchValue);
             this.inputElementSize();
             this.searchValueChange.emit(this._searchValue);
@@ -139,27 +277,25 @@ export class MultiSelectComponent {
      * @type string | string[]
      */
     set value(value) {
-        const newValue = Array.isArray(value) ? [...value] : [value ?? ''];
+        const newValue = Array.isArray(value) ? [...value] : [value ?? undefined];
         if (this.differ) {
             const changes = this.differ.diff(newValue);
             if (changes) {
-                this._value = [...newValue];
-                this.onChange([...newValue]);
-                this.selectOptions();
-                // not required here:
-                // this.selectedOptionsUpdate();
-                this.valueChange.emit(this.value);
+                __classPrivateFieldSet(this, _MultiSelectComponent_value, [...newValue], "f");
+                this.value$.next([...newValue]);
+                this.onChange(this.value);
+                // this.valueChange.emit(this.value);
             }
         }
     }
     get value() {
-        return this.multiple ? [...this._value] : this._value[0]?.toString() ?? '';
+        const value = this.multiSelectService.selectionModel?.selected ?? [...__classPrivateFieldGet(this, _MultiSelectComponent_value, "f")];
+        return this.multiple ? [...value] : value?.toString() ?? undefined;
     }
     /**
-     * Enable virtual scroller for the options list.
+     * Enable virtual scroller for options list.
      * @type boolean
      * @default false
-     * todo: virtual scroller implementation
      */
     set virtualScroller(value) {
         this._virtualScroller = coerceBooleanProperty(value);
@@ -170,11 +306,11 @@ export class MultiSelectComponent {
     /**
      * Amount of visible options, if set - overwrites optionsMaxHeight
      * @type number
-     * @default 10
+     * @default 8
      */
     set visibleItems(value) {
-        this._visibleItems = value || 1;
-        this.optionsMaxHeight = ((42 * value) + 16).toString();
+        this._visibleItems = coerceNumberProperty(value || 8);
+        this.optionsMaxHeight = ((this.itemSize * this._visibleItems) + 16).toString();
     }
     get visibleItems() {
         return this._visibleItems;
@@ -189,21 +325,16 @@ export class MultiSelectComponent {
         if (visible !== this._visible) {
             this._visible = visible;
             this.multiSelectService.toggleVisible(visible);
-            if (visible) {
-                this.listKeyManager?.setFirstItemActive();
+            if (!visible) {
+                // this.searchValue = '';
             }
         }
     }
     get visible() {
         return this._visible;
     }
-    set selectedOptions(value) {
-        this._selectedOptions = value;
-        this.value = this.selectedOptions.map(item => item.value);
-        this.inputElementSize();
-    }
     get selectedOptions() {
-        return this._selectedOptions;
+        return [...this.optionsSelected.values()];
     }
     get selectedOptionsText() {
         return this.selectedOptions.map(option => option.label).join(', ');
@@ -223,7 +354,7 @@ export class MultiSelectComponent {
     get multiselectClasses() {
         return {
             'form-multi-select': true,
-            'form-multi-select-selection-tags': this.selectionType === 'tags' && this.selectedOptions.length > 0,
+            'form-multi-select-selection-tags': this.selectionType === 'tags' && this.optionsSelected.size > 0,
             [`form-multi-select-${this.size}`]: !!this.size,
             'form-multi-select-with-cleaner': this.cleaner,
             show: this.visible,
@@ -240,7 +371,7 @@ export class MultiSelectComponent {
     }
     set tabIndex(value) {
         setTimeout(() => {
-            this._tabIndex = this.disabled || this.search ? '-1' : value === null ? null : '0';
+            this._tabIndex = this.disabled || this.search ? -1 : value === null ? null : 0;
         });
     }
     onKeyUp($event) {
@@ -248,28 +379,81 @@ export class MultiSelectComponent {
             return;
         }
         this.onTouched();
+        const targetTagName = $event.target.tagName;
         if ($event.key === 'Escape') {
             this.visible = false;
             this.searchValue = '';
             this.setFocus('keyboard', 'onKeyUp');
             return;
         }
-        if (['Enter', ' ', 'ArrowDown'].includes($event.key) && [this.inputElement?.nativeElement, this.elementRef.nativeElement].includes($event.target)) {
+        if (['Enter', 'Space', 'ArrowDown'].includes($event.code) && [this.inputElement?.nativeElement, this.elementRef.nativeElement].includes($event.target)) {
+            $event.stopPropagation();
             this.visible = true;
             if (!this.search) {
                 this.setFocus('keyboard', 'onKeyUp');
             }
             return;
         }
-        if ($event.key === 'Tab' && $event.target === this.elementRef.nativeElement) {
-            this.visible = true;
-            if (!this.search) {
-                this.setFocus('keyboard', 'onKeyUp');
+        if (['Tab'].includes($event.key)) {
+            if ($event.target === this.elementRef.nativeElement) {
+                this.visible = true;
+                if (!this.search) {
+                    this.setFocus('keyboard', 'onKeyUp');
+                }
+                this.tabTarget = targetTagName;
+                return;
+            }
+            if (this.visible && this.subtreeFocused) {
+                if (targetTagName === 'C-MULTI-SELECT-OPTION') {
+                    if (this.tabTarget === 'C-MULTI-SELECT-OPTION') {
+                        if ($event.shiftKey && this.listKeyManager.activeItem?.value === this.options.filter(option => option.visible && !option.disabled).slice(0)[0].value) {
+                            this.setFocus('keyboard', 'onKeyUp');
+                            this.tabTarget = targetTagName;
+                            return;
+                        }
+                        if (!$event.shiftKey && this.listKeyManager.activeItem?.value === this.options.filter(option => option.visible && !option.disabled).slice(-1)[0].value) {
+                            this.setFocus('keyboard', 'onKeyUp');
+                            this.tabTarget = targetTagName;
+                            this.updateActiveItem(0);
+                            return;
+                        }
+                    }
+                    if (!this.listKeyManager.activeItem || this.tabTarget !== targetTagName) {
+                        if (this.activeOption) {
+                            this.listKeyManager.setActiveItem(this.activeOption);
+                        }
+                        else {
+                            this.setFirstItemActive();
+                        }
+                    }
+                    else {
+                        $event.shiftKey ? this.listKeyManager.setPreviousItemActive() : this.listKeyManager.setNextItemActive();
+                    }
+                }
+                this.tabTarget = targetTagName;
+                return;
             }
-            return;
         }
     }
     onKeyDown($event) {
+        const targetTagName = $event.target.tagName;
+        if ($event.key === 'Enter' && targetTagName === 'INPUT') {
+            $event.preventDefault();
+        }
+        if ($event.key === 'Tab') {
+            this.tabTarget = targetTagName;
+            return;
+        }
+        if ($event.key === 'ArrowDown' && targetTagName !== 'C-MULTI-SELECT-OPTION') {
+            $event.preventDefault();
+            return;
+        }
+        if ($event.key === 'Escape') {
+            this.visible = false;
+            this.searchValue = '';
+            this.setFocus('keyboard', 'onKeyUp');
+            return;
+        }
         if (this.disabled) {
             return;
         }
@@ -277,44 +461,132 @@ export class MultiSelectComponent {
         if ($event.target === this.inputElement.nativeElement) {
             return;
         }
-        this.listKeyManager?.onKeydown($event);
+        if ($event.key !== 'Tab') {
+            this.listKeyManager?.onKeydown($event);
+        }
     }
     onClick($event) {
         if (this.disabled) {
             return;
         }
-        if (!this.visible) {
-            this.visible = true;
-            this.setFocus('mouse', 'onClick');
+        if ([this.dropdown.nativeElement].includes($event.target)) {
+            this.visible = !this.visible;
         }
-        else if ([this.dropdown.nativeElement].includes($event.target)) {
-            this.visible = false;
-            this.setFocus('mouse', 'onClick');
+        else {
+            this.visible = true;
         }
         this.onTouched();
+        this.setFocus('mouse', 'onClick');
     }
     get subtreeFocused() {
         return this._subtreeFocused;
     }
-    set subtreeFocused(value) {
-        this._subtreeFocused = this.disabled ? false : value;
-        this.visible = value === false ? false : this.visible;
+    set subtreeFocused(focused) {
+        this._subtreeFocused = this.disabled ? false : focused;
+        if (!focused) {
+            this.searchValue = '';
+        }
+        if (!this.virtualScroller) {
+            this.visible = focused === false ? false : this.visible;
+        }
     }
     focusOrigin(origin) {
         if (this.disabled) {
             return false;
         }
-        const focused = !!origin;
-        this.searchValue = focused ? this.searchValue : '';
-        return focused;
+        return !!origin;
     }
     ngOnInit() {
-        this.tabIndex = '0';
+        this.multiSelectService.setSelectionModel(this.multiple);
+        this.multiSelectService.selectionModel.changed
+            .pipe(takeUntil(__classPrivateFieldGet(this, _MultiSelectComponent_destroy$, "f")), filter(() => !this.multiple), delay(0), tap(change => {
+            if (change.added.length) {
+                // close dropdown for single select (!multiple)
+                this.visible = false;
+                this.searchValue = '';
+            }
+        }))
+            .subscribe();
+        this.multiSelectService.selectionModel.changed
+            .pipe(takeUntil(__classPrivateFieldGet(this, _MultiSelectComponent_destroy$, "f")), 
+        // delay(0),
+        combineLatestWith(__classPrivateFieldGet(this, _MultiSelectComponent_optionsReady$, "f")), tap(([change, ready]) => {
+            const { added, removed } = { ...change };
+            // added.forEach(key => {
+            //   const value = this.#options.get(key);
+            //   if (value) {
+            //     this.optionsSelected.set(key, value);
+            //   }
+            // });
+            removed.forEach(value => {
+                this.optionsSelected.delete(value);
+            });
+            this.multiSelectService.selectionModel.selected.forEach(key => {
+                const value = __classPrivateFieldGet(this, _MultiSelectComponent_options, "f").get(key);
+                if (value) {
+                    this.optionsSelected.set(key, value);
+                }
+            });
+            this.optionsSelected$.next(Array.from(this.optionsSelected.values()));
+            this.value = [...this.multiSelectService.selectionModel.selected];
+            this.inputElementSize();
+            this.updateNativeSelect();
+        }))
+            .subscribe();
+        // set initial values
+        this.multiSelectService.selectionModel.select(...__classPrivateFieldGet(this, _MultiSelectComponent_value, "f"));
+        this.value$
+            .pipe(takeUntil(__classPrivateFieldGet(this, _MultiSelectComponent_destroy$, "f")))
+            .subscribe(value => {
+            if (!value.length) {
+                this.clearAllOptions();
+                return;
+            }
+            value.forEach(value => {
+                this.multiSelectService.selectionModel.select(value);
+            });
+        });
+        this.value$
+            .pipe(takeUntil(__classPrivateFieldGet(this, _MultiSelectComponent_destroy$, "f")), debounceTime(100), tap(value => {
+            this.valueChange.emit(this.value);
+        }))
+            .subscribe();
+        this.optionsArray$
+            .pipe(takeUntil(__classPrivateFieldGet(this, _MultiSelectComponent_destroy$, "f")), tap(options => {
+            this.visibleOptions = options.filter((item) => item.visible).length;
+            this.activeOption = null;
+            if (this.virtualScroller) {
+                this.multiSelectOptionsContent?.forEach(option => {
+                    option.active = false;
+                });
+                this.scrollViewport?.setRenderedRange({ start: 0, end: this.visibleItems });
+                this.scrollViewport?.scrollToIndex(0);
+            }
+            else {
+                this.multiSelectOptionsContent?.forEach(option => {
+                    const found = options.find(item => item.value === option.value);
+                    option.visible = found?.visible ?? false;
+                    option.active = false;
+                });
+                const firstFocusable = this.firstFocusableItem;
+                if (firstFocusable) {
+                    this.updateActiveItem(firstFocusable);
+                }
+            }
+            if (!this.activeOption) {
+                setTimeout(() => {
+                    this.updateActiveItem(0);
+                });
+            }
+            this.multiSelectOptionsContent?.notifyOnChanges();
+            // console.log('=> optionsArray$', options.length);
+        }))
+            .subscribe();
+        this.tabIndex = 0;
     }
     ngOnDestroy() {
         __classPrivateFieldGet(this, _MultiSelectComponent_destroy$, "f").next(true);
         __classPrivateFieldGet(this, _MultiSelectComponent_destroy$, "f").complete();
-        this.multiselectSubscribe(false);
         this.setFocusMonitor(false);
     }
     ngOnChanges(changes) {
@@ -323,174 +595,190 @@ export class MultiSelectComponent {
             if (valueChanges.currentValue.length === 0) {
                 this.clearAllOptions();
             }
-            else {
-                this.selectOptions();
-            }
-            this.selectedOptionsUpdate();
+            this.inputElementSize();
         }
     }
-    ngAfterContentInit() {
-        this.visibleOptions = this.multiSelectOptions.length;
-        this.multiSelectOptions.changes
-            .pipe(takeUntil(__classPrivateFieldGet(this, _MultiSelectComponent_destroy$, "f")))
-            .subscribe(next => {
-            this.visibleOptions = this.multiSelectOptions?.filter((item) => item.visible).length;
-            this.selectOptions();
+    makeOptions(options) {
+        if (this.search === 'external' && this.searchValue.length) {
+            __classPrivateFieldGet(this, _MultiSelectComponent_options, "f").forEach((value, key) => {
+                value.visible = false;
+            });
+        }
+        options.forEach(option => {
+            const key = option.value;
+            const value = {
+                value: option.value ?? option.label,
+                label: option.label ?? option.value,
+                disabled: option.disabled === true,
+                visible: this.search === 'external' ? true : option.visible !== false,
+                text: option.text ?? option.label ?? option.value,
+                selected: option.selected
+                // selected: this.multiSelectService.selectionModel.isSelected(option.value),
+                // id: option.id
+            };
+            __classPrivateFieldGet(this, _MultiSelectComponent_options, "f").set(key, { ...value });
         });
+        this.filterOptions(this.searchValue);
+        __classPrivateFieldGet(this, _MultiSelectComponent_optionsReady$, "f").next(true);
+        // console.log('makeOptions', this.#options.size);
+        this.multiSelectOptionsContent?.notifyOnChanges();
     }
     ngAfterViewInit() {
-        this.selectOptions();
+        this.setVirtualScroller();
+        this.multiSelectOptionsContent?.changes
+            .pipe(takeUntil(__classPrivateFieldGet(this, _MultiSelectComponent_destroy$, "f")), delay(0), distinctUntilChanged((previous, current) => {
+            const prev = previous.toArray().map(option => option.value);
+            const curr = current.toArray().map(option => option.value);
+            return JSON.stringify(prev) === JSON.stringify(curr);
+        }))
+            .subscribe(next => {
+            this.visibleOptions = this.multiSelectOptionsContent?.filter((option) => option.visible).length;
+            if (this.visibleOptions) {
+                this.makeOptions(this.multiSelectOptionsContent.toArray());
+            }
+        });
+        this.visibleOptions = this.multiSelectOptionsContent?.length;
+        if (this.visibleOptions) {
+            this.multiSelectOptionsContent.notifyOnChanges();
+        }
         this.multiselectSubscribe();
-        this.listKeyManager = new FocusKeyManager(this.multiSelectOptions).withHomeAndEnd().withTypeAhead();
-        this.listKeyManager.skipPredicate(item => (item.disabled || !item.visible));
-        this.listKeyManager.setFirstItemActive();
         this.setFocusMonitor(!this.disabled);
-        // not required here:
-        // this.selectedOptionsUpdate();
+        this.setListKeyManager();
+        this.inputElementSize();
+        this.multiSelectOptionsContent.notifyOnChanges();
         setTimeout(() => {
             this.createNativeSelect();
         });
+        this.multiSelectService.multiSelectFocus$
+            .pipe(takeUntil(__classPrivateFieldGet(this, _MultiSelectComponent_destroy$, "f")))
+            .subscribe((option) => {
+            if (this.activeOption?.value !== option.value) {
+                this.listKeyManager.setActiveItem(option);
+            }
+        });
     }
     multiselectSubscribe(subscribe = true) {
-        if (subscribe) {
-            this.multiselectVisibleSubscription = this.multiSelectService.multiSelectVisible$.subscribe((visible) => {
-                if (this.isDropdownVisible !== visible) {
-                    this.isDropdownVisible = visible;
-                    this.visibleChange.emit(visible);
-                    if (!visible) {
-                        this.setFocus('program', 'multiSelectVisible$');
-                    }
+        this.multiSelectService.multiSelectVisible$
+            .pipe(takeUntil(__classPrivateFieldGet(this, _MultiSelectComponent_destroy$, "f")), debounceTime(100), distinctUntilChanged())
+            .subscribe((visible) => {
+            if (this.isDropdownVisible !== visible) {
+                this.isDropdownVisible = visible;
+                this.visibleChange.emit(visible);
+                if (!visible) {
                 }
-            });
-            this.multiselectStateSubscription = this.multiSelectService.multiSelectState$.subscribe((option) => {
-                if (option.selected === true && !this.multiple) {
-                    const selectedOptions = this.multiSelectOptions.toArray().filter((item) => item.selected);
-                    selectedOptions.reverse().forEach((item) => {
-                        if (item !== option) {
-                            item.selected = false;
-                        }
-                    });
-                    // close dropdown for single select (!multiple)
-                    this.visible = false;
-                    this.searchValue = '';
+                else {
+                    if (this.virtualScroller) {
+                        this.scrollViewport?.setRenderedRange({ start: 0, end: this.visibleItems });
+                        this.scrollViewport?.scrollToIndex(0);
+                    }
                 }
-                // todo?
-                // if (!!option) {
-                this.selectedOptionsUpdate();
-                // }
-            });
-        }
-        else {
-            this.multiselectVisibleSubscription?.unsubscribe();
-            this.multiselectStateSubscription?.unsubscribe();
-        }
-    }
-    selectOptions() {
-        this.multiSelectOptions?.forEach((option, index) => {
-            option.optionsStyle = this.optionsStyle;
-            option.selected = option.value !== undefined ? this._value.includes(option.value) : !!option.selected;
+                this.multiSelectOptionsContent.notifyOnChanges();
+            }
+            this.updateActiveItem(0);
         });
     }
     clearAllOptions($event) {
-        this.selectedOptions.forEach((option) => {
-            if (!option._disabled) {
-                option.selected = false;
-            }
+        setTimeout(() => {
+            const enabledOptions = Array.from(this.optionsSelected.values()).filter(option => !option.disabled).map(option => option.value);
+            this.multiSelectService.selectionModel.deselect(...enabledOptions);
         });
-        this.selectedOptionsUpdate();
+        this.searchValue = '';
         if ($event) {
-            this.searchValue = '';
             this.setFocus('program', 'clearAllOptions');
         }
     }
     selectAllOptions() {
-        this.multiSelectOptions.forEach((option, index) => {
-            if (!option.disabled && option.visible) {
-                option.selected = true;
-            }
-        });
-        this.selectedOptionsUpdate();
+        const enabledOptions = Array.from(__classPrivateFieldGet(this, _MultiSelectComponent_options, "f").values()).filter(option => option.visible && !option.disabled).map(option => option.value);
+        this.multiSelectService.selectionModel.select(...enabledOptions);
+        this.inputElementSize();
     }
-    handleTagRemove($event) {
+    handleTagRemove(value) {
+        this.multiSelectService.selectionModel.deselect(value);
         this.setFocus('program', 'handleTagRemove');
     }
     setFocus(origin = 'program', methodName) {
         if (this.disabled) {
             return;
         }
-        const element = this.inputElement ?? this.elementRef;
+        const element = (this.inputElement.nativeElement ?? this.elementRef.nativeElement);
         const preventScroll = origin === 'program';
         this.focusMonitor?.focusVia(element, origin, { preventScroll: preventScroll });
-        // console.log('setFocus', origin, methodName, 'preventScroll:', preventScroll );
+        // console.log('setFocus', origin, methodName, 'preventScroll:', preventScroll, element.tagName);
     }
     filterOptions(value) {
         const searchString = value.toLowerCase() ?? '';
-        this.multiSelectOptions?.forEach((item, index) => {
-            if (this.search === 'external' || !searchString) {
+        __classPrivateFieldGet(this, _MultiSelectComponent_options, "f").forEach((item, index) => {
+            if (searchString === '') {
                 item.visible = true;
+                return;
             }
-            else {
-                item.visible = item.label?.toLowerCase().includes(searchString) ?? true;
+            if (typeof this.search === 'function') {
+                item.visible = this.search(item, searchString);
+                return;
+            }
+            if (this.search === 'external' || !searchString) {
+                // item.visible = true;
+                return;
             }
+            item.visible = item.label?.toLowerCase().includes(searchString) ?? true;
         });
-        this.visibleOptions = this.multiSelectOptions?.filter((item) => item.visible).length;
+        this.optionsArray$.next(Array.from(__classPrivateFieldGet(this, _MultiSelectComponent_options, "f").values()).filter((item) => item.visible));
     }
     createNativeSelect() {
+        if (!this.nativeId) {
+            return;
+        }
         this.viewContainerRef.clear();
         this.nativeSelectRef = this.viewContainerRef.createComponent(MultiSelectNativeSelectComponent);
         this.updateNativeSelect();
     }
     updateNativeSelect() {
-        if (!this.nativeSelectRef) {
+        if (!this.nativeSelectRef || !this.nativeId) {
             return;
         }
-        const options = this.selectedOptions.map(item => {
-            const { selected, value, label } = item;
+        const options = Array.from(this.optionsSelected).map(item => {
+            const { selected, value, label } = item[1];
             return { selected, value, label };
         });
         this.nativeSelectRef.instance.multiple = this.multiple;
+        this.nativeSelectRef.instance.form = this.nativeFormId;
+        this.nativeSelectRef.instance.id = this.nativeId;
         this.nativeSelectRef.instance.name = this.nativeName;
-        this.nativeSelectRef.instance.form = this.nativeId;
         this.nativeSelectRef.instance.options = [...options];
         this.nativeSelectRef.instance.disabled = this.disabled;
         this.nativeSelectRef.instance.changeDetectorRef.markForCheck();
     }
     inputElementSize() {
-        if (this.inputElement) {
-            if (this.selectedOptions.length > 0 || this.selectionType === 'counter') {
-                this.renderer.setAttribute(this.inputElement.nativeElement, 'size', (this.searchValue.length + 2).toString());
-            }
-            else {
-                this.renderer.removeAttribute(this.inputElement.nativeElement, 'size');
+        setTimeout(() => {
+            if (this.inputElement) {
+                if ((this.optionsSelected.size > 0 || this.selectionType === 'counter') && !this.inputElement.nativeElement?.disabled) {
+                    this.renderer.setAttribute(this.inputElement.nativeElement, 'size', (this.searchValue.length + 2).toString());
+                }
+                else {
+                    this.renderer.removeAttribute(this.inputElement.nativeElement, 'size');
+                }
             }
-        }
+        });
     }
     handleSearchKeyDown($event) {
-        if (this.searchValue.length || this.selectedOptions.length === 0) {
+        if (this.searchValue.length || this.optionsSelected.size === 0) {
             return;
         }
         if (['Backspace', 'Delete'].includes($event.key)) {
             $event.stopPropagation();
             const last = this.selectedOptions.filter(option => !option.disabled).pop();
-            this.selectOption(last, false);
+            if (last) {
+                this.multiSelectService.selectionModel.deselect(last.value);
+            }
         }
     }
-    selectOption(option, selected) {
-        option.selected = selected;
-        this.selectedOptionsUpdate();
-    }
-    selectedOptionsUpdate() {
-        setTimeout(() => {
-            this.selectedOptions = this.multiSelectOptions?.filter((option) => !!option.selected);
-            this.inputElementSize();
-            this.updateNativeSelect();
-            this.changeDetectorRef.markForCheck();
-        });
-    }
     setFocusMonitor(monitor) {
         if (monitor && !this.disabled) {
-            this.focusMonitorSubscription = this.focusMonitor?.monitor(this.elementRef, true).subscribe((origin) => {
-                // console.log('focusMonitorSubscription', this.elementRef, origin);
+            this.focusMonitorSubscription = this.focusMonitor?.monitor(this.elementRef, true)
+                .pipe(
+            // to avoid focus lost on speed scrolling with virtualScroll
+            debounceTime(100))
+                .subscribe((origin) => {
                 this.ngZone.run(() => {
                     this.subtreeFocused = this.focusOrigin(origin);
                     this.changeDetectorRef?.markForCheck();
@@ -502,33 +790,168 @@ export class MultiSelectComponent {
             this.focusMonitorSubscription?.unsubscribe();
         }
     }
+    handleScrolledIndexChange(scrolledIndex, scrollViewport) {
+        if (!this.scrollViewport) {
+            this.scrollViewport = scrollViewport;
+        }
+        const availableOptions = this.options.filter(option => option.visible);
+        const firstVisibleOption = availableOptions[scrolledIndex];
+        const activeOptionIndex = availableOptions.findIndex(option => option.value === this.activeOption?.value);
+        const optionsArray = this.multiSelectOptionsContent.toArray();
+        if (scrolledIndex > activeOptionIndex) {
+            const firstVisibleItem = optionsArray.find(option => option.value === firstVisibleOption?.value);
+            if (firstVisibleItem && scrolledIndex) {
+                this.listKeyManager.setActiveItem(firstVisibleItem);
+            }
+            return;
+        }
+        if (scrolledIndex + this.visibleItems - 2 <= activeOptionIndex) {
+            const lastVisibleItem = optionsArray.findIndex(option => option.value === firstVisibleOption.value);
+            if (lastVisibleItem > -1) {
+                this.listKeyManager.setActiveItem(lastVisibleItem + this.visibleItems - 2);
+            }
+            return;
+        }
+    }
+    trackByFn(index, option) {
+        return option.value;
+    }
+    handleSearchValueChange(searchValue) {
+        this.searchValue = searchValue;
+        if (!searchValue) {
+            this.scrollViewport?.scrollToIndex(0);
+            this.multiSelectOptionsContent.notifyOnChanges();
+        }
+    }
+    setVirtualScroller() {
+        if (!this.virtualScroller) {
+            return;
+        }
+        // multiSelectOptionTemplate for virtualScroller
+        this.contentTemplates.forEach((child) => {
+            this.templates[child.id] = child.templateRef;
+        });
+        // if no template found, get defaultMultiSelectOptionTemplate from view
+        if (!this.templates['multiSelectOptionTemplate']) {
+            this.multiSelectOptionsContent = this.multiSelectOptionsView;
+        }
+        // multiSelectOptionsContent gets out of order on changes
+        // do sort() and reset()
+        const indexOfOption = (option) => {
+            return [...option.elementRef.nativeElement.parentElement.children]?.indexOf(option.elementRef.nativeElement);
+        };
+        const optionsChange$ = this.multiSelectOptionsContent.changes;
+        const sortedOptions$ = optionsChange$.pipe(takeUntil(__classPrivateFieldGet(this, _MultiSelectComponent_destroy$, "f")), map(options => options.toArray()), filter(options => options.length > 0), map(options => options.sort((a, b) => indexOfOption(a) - indexOfOption(b))));
+        sortedOptions$
+            .pipe(takeUntil(__classPrivateFieldGet(this, _MultiSelectComponent_destroy$, "f")))
+            .subscribe(sortedOptions => {
+            return this.multiSelectOptionsContent.reset(sortedOptions);
+        });
+        this.scrollViewportView.changes
+            .pipe(takeUntil(__classPrivateFieldGet(this, _MultiSelectComponent_destroy$, "f")), take(1), map(changes => changes.toArray()[0]), tap((scrollViewport) => {
+            if (!this.scrollViewport) {
+                this.scrollViewport = scrollViewport;
+                const cdkVirtualScrollContentWrapper = this.scrollViewport.getElementRef().nativeElement?.firstElementChild;
+                if (cdkVirtualScrollContentWrapper) {
+                    const style = getComputedStyle(cdkVirtualScrollContentWrapper, null);
+                    const padding = parseInt(style.getPropertyValue('padding-left') ?? '12px') * 3;
+                    const observer = new MutationObserver((mutationRecords) => {
+                        mutationRecords.forEach(child => {
+                            child.addedNodes.forEach(node => {
+                                if (node.nodeName === 'C-MULTI-SELECT-OPTION') {
+                                    const width = node.offsetWidth;
+                                    if (width > this.itemMinWidth) {
+                                        this.itemMinWidth = width + padding;
+                                    }
+                                }
+                            });
+                        });
+                    });
+                    observer.observe(cdkVirtualScrollContentWrapper, { childList: true });
+                    __classPrivateFieldGet(this, _MultiSelectComponent_destroy$, "f").subscribe(() => {
+                        observer.disconnect();
+                    });
+                }
+            }
+        }))
+            .subscribe();
+    }
+    setListKeyManager() {
+        // run once on multiSelectOptionsContent first set
+        this.multiSelectOptionsContent.changes
+            .pipe(takeUntil(__classPrivateFieldGet(this, _MultiSelectComponent_destroy$, "f")), take(1))
+            .subscribe(change => {
+            this.listKeyManager = new FocusKeyManager(this.multiSelectOptionsContent)
+                .withHomeAndEnd()
+                .skipPredicate((option) => (option.disabled || !option.visible));
+            if (!this._virtualScroller) {
+                this.listKeyManager.withTypeAhead(300);
+            }
+            this.listKeyManager.change
+                .pipe(takeUntil(__classPrivateFieldGet(this, _MultiSelectComponent_destroy$, "f")))
+                .subscribe(change => {
+                if (change < 0) {
+                    this.activeOption ? this.listKeyManager.setActiveItem(this.activeOption) : this.setFirstItemActive();
+                }
+                if (this.listKeyManager.activeItem) {
+                    this.listKeyManager.activeItem.active = true;
+                }
+                this.activeOption = this.listKeyManager.activeItem;
+                this.multiSelectOptionsContent.notifyOnChanges();
+            });
+            if (!this.listKeyManager.activeItem) {
+                this.setFirstItemActive();
+            }
+        });
+    }
+    get firstFocusableItem() {
+        return this.multiSelectOptionsContent?.find(option => option.visible && !option.disabled);
+    }
+    setFirstItemActive() {
+        const firstFocusableItem = this.firstFocusableItem;
+        firstFocusableItem ? this.listKeyManager?.setActiveItem(firstFocusableItem) : this.listKeyManager?.setFirstItemActive();
+        this.activeOption = this.listKeyManager?.activeItem ?? null;
+    }
+    updateActiveItem(item) {
+        const firstFocusableItem = this.firstFocusableItem ?? item;
+        firstFocusableItem ? this.listKeyManager?.updateActiveItem(firstFocusableItem) : this.listKeyManager?.updateActiveItem(0);
+        if (this.listKeyManager?.activeItem) {
+            this.multiSelectOptionsContent?.forEach(option => {
+                option.active = false;
+            });
+            this.listKeyManager.activeItem.active = true;
+        }
+        this.activeOption = this.listKeyManager?.activeItem ?? null;
+    }
 }
-_MultiSelectComponent_destroy$ = new WeakMap();
-MultiSelectComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: MultiSelectComponent, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }, { token: i0.ViewContainerRef }, { token: i1.FocusMonitor }, { token: i2.MultiSelectService }, { token: i0.IterableDiffers }], target: i0.ɵɵFactoryTarget.Component });
-MultiSelectComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: MultiSelectComponent, selector: "c-multi-select", inputs: { cleaner: "cleaner", disabled: "disabled", multiple: "multiple", nativeName: "nativeName", nativeId: "nativeId", options: "options", optionsMaxHeight: "optionsMaxHeight", optionsStyle: "optionsStyle", placeholder: "placeholder", search: "search", searchNoResultsLabel: "searchNoResultsLabel", searchValue: "searchValue", selectAll: "selectAll", selectAllLabel: "selectAllLabel", selectionType: "selectionType", selectionTypeCounterText: "selectionTypeCounterText", selectionTypeCounterTextPluralMap: "selectionTypeCounterTextPluralMap", size: "size", value: "value", valid: "valid", virtualScroller: "virtualScroller", visibleItems: "visibleItems", visible: "visible", popperjsOptions: ["popperOptions", "popperjsOptions"] }, outputs: { searchValueChange: "searchValueChange", valueChange: "valueChange", visibleChange: "visibleChange" }, host: { listeners: { "keyup": "onKeyUp($event)", "keydown": "onKeyDown($event)", "click": "onClick($event)" }, properties: { "class": "this.hostClasses", "attr.aria-multiselectable": "this.ariaMultiSelectable", "attr.tabindex": "this.tabIndex" } }, providers: [
+_MultiSelectComponent_destroy$ = new WeakMap(), _MultiSelectComponent_optionsReady$ = new WeakMap(), _MultiSelectComponent_options = new WeakMap(), _MultiSelectComponent_value = new WeakMap();
+MultiSelectComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MultiSelectComponent, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }, { token: i0.ViewContainerRef }, { token: i1.FocusMonitor }, { token: i2.MultiSelectService }, { token: i0.IterableDiffers }], target: i0.ɵɵFactoryTarget.Component });
+MultiSelectComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: MultiSelectComponent, selector: "c-multi-select", inputs: { cleaner: "cleaner", disabled: "disabled", multiple: "multiple", nativeFormId: "nativeFormId", nativeId: "nativeId", nativeName: "nativeName", options: "options", optionsMaxHeight: "optionsMaxHeight", optionsStyle: "optionsStyle", placeholder: "placeholder", search: "search", searchNoResultsLabel: "searchNoResultsLabel", searchValue: "searchValue", selectAll: "selectAll", selectAllLabel: "selectAllLabel", selectionType: "selectionType", selectionTypeCounterText: "selectionTypeCounterText", selectionTypeCounterTextPluralMap: "selectionTypeCounterTextPluralMap", size: "size", value: "value", valid: "valid", virtualScroller: "virtualScroller", visibleItems: "visibleItems", itemSize: "itemSize", itemMinWidth: "itemMinWidth", visible: "visible", popperjsOptions: ["popperOptions", "popperjsOptions"] }, outputs: { searchValueChange: "searchValueChange", valueChange: "valueChange", visibleChange: "visibleChange" }, host: { listeners: { "keyup": "onKeyUp($event)", "keydown": "onKeyDown($event)", "click": "onClick($event)" }, properties: { "class": "this.hostClasses", "attr.aria-multiselectable": "this.ariaMultiSelectable", "attr.tabindex": "this.tabIndex" } }, providers: [
         MultiSelectService,
         {
             provide: NG_VALUE_ACCESSOR, useExisting: forwardRef(() => MultiSelectComponent), multi: true
         }
-    ], queries: [{ propertyName: "multiSelectOptions", predicate: MultiSelectOptionComponent, descendants: true }], viewQueries: [{ propertyName: "inputElement", first: true, predicate: ["inputElement"], descendants: true }, { propertyName: "dropdownMenu", first: true, predicate: ["dropdownMenu"], descendants: true }, { propertyName: "dropdownToggle", first: true, predicate: DropdownToggleDirective, descendants: true }, { propertyName: "dropdown", first: true, predicate: DropdownComponent, descendants: true, read: ElementRef }], exportAs: ["cMultiSelect"], usesOnChanges: true, ngImport: i0, template: "<c-dropdown #dropdown=\"cDropdown\" [autoClose]=\"'outside'\" class=\"picker\" [ngClass]=\"multiselectClasses\"\n            [(visible)]=\"visible\" [popperOptions]=\"popperjsOptions\">\n  <div [caret]=\"false\" [disabled]=\"disabled\" cDropdownToggle #dropdownToggle=\"cDropdownToggle\">\n    <div class=\"form-multi-select-selection\">\n      <ng-template [ngIf]=\"selectionType === 'tags'\">\n        <c-multi-select-tag\n          *ngFor=\"let option of selectedOptions; index as i\"\n          (remove)=\"handleTagRemove($event)\"\n          [option]=\"option\"\n          tabindex=\"-1\"\n          class=\"form-multi-select-tag\"\n        ></c-multi-select-tag>\n      </ng-template>\n      <ng-template [ngIf]=\"selectionType === 'text' && !!selectedOptionsText\">\n        <span class=\"form-multi-select-search\">{{ selectedOptionsText }}</span>\n      </ng-template>\n      <ng-template [ngIf]=\"selectionType === 'counter'\">\n        <span *ngIf=\"counterTextType === 'string'; else pluralMap\">{{ counterText }}</span>\n        <ng-template #pluralMap>\n          <span>{{selectedOptions.length}} {{ selectedOptions.length | i18nPlural: selectionTypeCounterTextPluralMap ?? { other: counterText } }}</span>\n        </ng-template>\n      </ng-template>\n      <!--      <ng-template [ngIf]=\"!search && selectedOptions.length === 0 && selectionType !== 'counter'\">-->\n      <!--        <span class=\"form-multi-select-search\">{{ placeholder }}</span>-->\n      <!--      </ng-template>-->\n    </div>\n\n    <input\n      #inputElement\n      (keydown)=\"handleSearchKeyDown($event)\"\n      [(ngModel)]=\"searchValue\"\n      [disabled]=\"disabled || !search\"\n      [ngClass]=\"{ 'form-multi-select-search': true, disabled: (disabled || !search) }\"\n      [attr.placeholder]=\"selectedOptions.length === 0 && selectionType !== 'counter' ? placeholder : null\"\n      autocomplete=\"off\"\n      tabindex=\"{{ disabled ? '-1' : '0' }}\"\n      type=\"text\"\n    >\n\n    <button\n      (click)=\"clearAllOptions($event)\"\n      *ngIf=\"cleaner && selectedOptions.length > 0 && !disabled\"\n      [disabled]=\"disabled || !isDropdownVisible\"\n      aria-label=\"Clear all\"\n      class=\"form-multi-select-selection-cleaner\"\n    ></button>\n  </div>\n\n  <div *ngIf=\"!disabled\" class=\"\" cDropdownMenu #dropdownMenu=\"cDropdownMenu\" [visible]=\"dropdown.visible\">\n    <ng-template [ngIfElse]=\"optionsEmpty\" [ngIf]=\"visibleOptions > 0\">\n      <button (click)=\"selectAllOptions()\" *ngIf=\"selectAll && multiple\" class=\"form-multi-select-all\">\n        {{ selectAllLabel }}\n      </button>\n      <div #multiselectOptionsDiv\n           [ngStyle]=\"optionsMaxHeight !== 'auto' ? { 'maxHeight.px': optionsMaxHeight, overflowY: 'scroll' } : {}\"\n           class=\"form-multi-select-options\"\n      >\n        <ng-content></ng-content>\n      </div>\n    </ng-template>\n    <ng-template #optionsEmpty>\n      <div class=\"form-multi-select-options-empty\">{{ searchNoResultsLabel }}</div>\n    </ng-template>\n  </div>\n</c-dropdown>\n", styles: [":host{display:block}:host:focus-visible{outline:none}:host.cdk-focused:not(.disabled) .form-multi-select{color:var(--cui-form-multi-select-focus-color, rgba(44, 56, 74, .95));background-color:var(--cui-form-multi-select-focus-bg, #fff);border-color:var(--cui-form-multi-select-focus-border-color, #6557e4);box-shadow:0 0 0 .25rem #321fdb40}:host:not(.cdk-focused) .form-multi-select:not(.show) input.form-multi-select-search:not([placeholder]){width:.1rem;margin-inline-start:0}:host .form-multi-select-search[size]{display:inline}:host .form-multi-select-selection-tags .form-multi-select-search{height:1.5rem}:host-context(.dark-theme)::ng-deep .form-multi-select-optgroup-label{color:var(--cui-form-multi-select-disabled-color)}\n"], dependencies: [{ kind: "directive", type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "directive", type: i4.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: i4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i4.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i5.DropdownComponent, selector: "c-dropdown", inputs: ["alignment", "autoClose", "dark", "direction", "placement", "popper", "popperOptions", "variant", "visible"], outputs: ["visibleChange"], exportAs: ["cDropdown"] }, { kind: "directive", type: i5.DropdownToggleDirective, selector: "[cDropdownToggle]", inputs: ["dropdownComponent", "disabled", "caret", "split"], exportAs: ["cDropdownToggle"] }, { kind: "directive", type: i6.DropdownMenuDirective, selector: "[cDropdownMenu]", inputs: ["alignment", "visible", "dark"], exportAs: ["cDropdownMenu"] }, { kind: "component", type: i7.MultiSelectTagComponent, selector: "c-multi-select-tag", inputs: ["option"], outputs: ["remove"] }, { kind: "pipe", type: i3.I18nPluralPipe, name: "i18nPlural" }] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: MultiSelectComponent, decorators: [{
+    ], queries: [{ propertyName: "multiSelectOptionsContent", predicate: MultiSelectOptionComponent, descendants: true }, { propertyName: "contentTemplates", predicate: TemplateIdDirective, descendants: true }], viewQueries: [{ propertyName: "optionsElementRef", first: true, predicate: ["options"], descendants: true }, { propertyName: "inputElement", first: true, predicate: ["inputElement"], descendants: true }, { propertyName: "dropdownMenu", first: true, predicate: ["dropdownMenu"], descendants: true }, { propertyName: "dropdown", first: true, predicate: DropdownComponent, descendants: true, read: ElementRef }, { propertyName: "dropdownToggle", first: true, predicate: DropdownToggleDirective, descendants: true, read: ElementRef }, { propertyName: "multiSelectOptionsView", predicate: MultiSelectOptionComponent, descendants: true }, { propertyName: "scrollViewportView", predicate: ["scrollViewport"], descendants: true }], exportAs: ["cMultiSelect"], usesOnChanges: true, ngImport: i0, template: "<c-dropdown #dropdown=\"cDropdown\"\n            [(visible)]=\"visible\"\n            [autoClose]=\"'outside'\"\n            [ngClass]=\"multiselectClasses\"\n            [popperOptions]=\"popperjsOptions\"\n            class=\"picker\">\n  <div #dropdownToggle=\"cDropdownToggle\" [caret]=\"false\" [disabled]=\"disabled\" cDropdownToggle>\n    <div class=\"form-multi-select-selection\">\n      <ng-template [ngIf]=\"selectionType === 'tags'\">\n        <ng-container *ngIf=\"(optionsSelected$ | async) as optionTags\">\n          <c-multi-select-tag\n            (remove)=\"handleTagRemove($event)\"\n            *ngFor=\"let option of optionTags; index as i\"\n            [disabled]=\"option.disabled ?? false\"\n            [label]=\"option.label\"\n            [option]=\"option\"\n            [value]=\"option.value\"\n            class=\"form-multi-select-tag\"\n            tabindex=\"-1\">\n          </c-multi-select-tag>\n        </ng-container>\n      </ng-template>\n      <ng-template [ngIf]=\"selectionType === 'text' && !!selectedOptionsText\">\n        <span class=\"form-multi-select-search\">{{ selectedOptionsText }}</span>\n      </ng-template>\n      <ng-template [ngIf]=\"selectionType === 'counter'\">\n        <span *ngIf=\"counterTextType === 'string'; else pluralMap\">{{ counterText }}</span>\n        <ng-template #pluralMap>\n          <span>{{selectedOptions.length}} {{ selectedOptions.length | i18nPlural: selectionTypeCounterTextPluralMap ?? { other: counterText } }}</span>\n        </ng-template>\n      </ng-template>\n      <!--      <ng-template [ngIf]=\"!search && selectedOptions.length === 0 && selectionType !== 'counter'\">-->\n      <!--        <span class=\"form-multi-select-search\">{{ placeholder }}</span>-->\n      <!--      </ng-template>-->\n    </div>\n\n    <input\n      #inputElement\n      (keydown)=\"handleSearchKeyDown($event)\"\n      (valueChange)=\"handleSearchValueChange($event)\"\n      [attr.placeholder]=\"optionsSelected.size === 0 && selectionType !== 'counter' ? placeholder : null\"\n      [disabled]=\"disabled || !search\"\n      [ngClass]=\"{ 'form-multi-select-search': true, disabled: (disabled || !search) }\"\n      [ngModel]=\"searchValue\"\n      [value]=\"searchValue\"\n      autocomplete=\"off\"\n      cMultiSelectSearch\n      size=\"3\"\n      tabindex=\"{{ disabled ? -1 : 0 }}\"\n      type=\"text\"\n    >\n\n    <button\n      (click)=\"clearAllOptions($event)\"\n      *ngIf=\"cleaner && optionsSelected.size > 0 && !disabled\"\n      [disabled]=\"disabled || !isDropdownVisible\"\n      aria-label=\"Clear all\"\n      class=\"form-multi-select-selection-cleaner\"\n    ></button>\n  </div>\n  <div #dropdownMenu=\"cDropdownMenu\" *ngIf=\"!disabled\" [visible]=\"dropdown.visible\" cDropdownMenu>\n    <ng-template [ngIfElse]=\"optionsEmpty\" [ngIf]=\"visibleOptions > 0 && options.length > 0\">\n      <button (click)=\"selectAllOptions()\"\n              *ngIf=\"selectAll && multiple && !virtualScroller\"\n              class=\"form-multi-select-all\"\n      >\n        {{ selectAllLabel }}\n      </button>\n      <ng-container\n        *ngTemplateOutlet=\"virtualScroller ? multiselectVirtualScroller : multiselectOptionsDiv\"></ng-container>\n    </ng-template>\n    <ng-template #optionsEmpty>\n      <div class=\"form-multi-select-options-empty\">{{ searchNoResultsLabel }}</div>\n    </ng-template>\n  </div>\n</c-dropdown>\n\n<ng-template #multiselectVirtualScroller>\n  <cdk-virtual-scroll-viewport\n    #scrollViewport\n    (scrolledIndexChange)=\"handleScrolledIndexChange($event, scrollViewport)\"\n    *ngIf=\"optionsArray$ | async as optionsArray\"\n    [itemSize]=\"itemSize\"\n    [ngStyle]=\"optionsMaxHeight !== 'auto' ? { 'height.px': optionsMaxHeight, 'maxHeight.px': optionsMaxHeight, 'minWidth.px': itemMinWidth ?? 196, overflowX: 'hidden' } : { 'minWidth.px': itemMinWidth ?? 196, overflowX: 'hidden'}\"\n    maxBufferPx=\"{{itemSize * visibleItems}}\"\n    minBufferPx=\"{{itemSize * visibleItems}}\"\n  >\n    <ng-container\n      #cdkVirtualFor\n      *cdkVirtualFor=\"let option of optionsArray; trackBy: trackByFn; templateCacheSize: 0; even as even; odd as odd; index as index; count as count; first as first; last as last;\"\n      [ngTemplateOutletContext]=\"{$implicit: option, even, odd, index, count, first, last}\"\n      [ngTemplateOutlet]=\"templates['multiSelectOptionTemplate'] || defaultMultiSelectOptionTemplate\"\n    >\n    </ng-container>\n  </cdk-virtual-scroll-viewport>\n\n</ng-template>\n\n<ng-template #multiselectOptionsDiv>\n  <div\n    [ngStyle]=\"optionsMaxHeight !== 'auto' ? { 'maxHeight.px': optionsMaxHeight, overflowY: 'scroll' } : {}\"\n    class=\"form-multi-select-options\"\n  >\n    <ng-content></ng-content>\n  </div>\n</ng-template>\n\n<ng-template #defaultMultiSelectOptionTemplate let-option>\n  <c-multi-select-option\n    [disabled]=\"option.disabled\"\n    [label]=\"option.label\"\n    [selected]=\"option.selected\"\n    [text]=\"option.text\"\n    [value]=\"option.value\"\n    [visible]=\"option.visible\"\n  >\n    {{option.text}}\n  </c-multi-select-option>\n</ng-template>\n", styles: [":host{display:block}:host:focus-visible{outline:none}:host.cdk-focused:not(.disabled) .form-multi-select{color:var(--cui-form-multi-select-focus-color, rgba(44, 56, 74, .95));background-color:var(--cui-form-multi-select-focus-bg, #fff);border-color:var(--cui-form-multi-select-focus-border-color, #6557e4);box-shadow:0 0 0 .25rem #321fdb40}:host:not(.cdk-focused) .form-multi-select:not(.show) input.form-multi-select-search:not([placeholder]){width:.1rem;margin-inline-start:0}:host .form-multi-select-search[size]{display:inline-block}:host .form-multi-select-selection-tags .form-multi-select-search{height:1.5rem}:host ::ng-deep .cdk-virtual-scroll-content-wrapper{padding:var(--cui-form-multi-select-options-padding-y) var(--cui-form-multi-select-options-padding-x);font-size:1rem;color:var(--cui-form-multi-select-options-color)}:host .cdk-virtual-scroll-viewport{width:var(--cui-dropdown-min-width)}:host-context(.dark-theme)::ng-deep .form-multi-select-optgroup-label{color:var(--cui-form-multi-select-disabled-color)}\n"], dependencies: [{ kind: "directive", type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i3.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "directive", type: i4.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: i4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i4.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i5.DropdownComponent, selector: "c-dropdown", inputs: ["alignment", "autoClose", "dark", "direction", "placement", "popper", "popperOptions", "variant", "visible"], outputs: ["visibleChange"], exportAs: ["cDropdown"] }, { kind: "directive", type: i5.DropdownToggleDirective, selector: "[cDropdownToggle]", inputs: ["dropdownComponent", "disabled", "caret", "split"], exportAs: ["cDropdownToggle"] }, { kind: "directive", type: i6.DropdownMenuDirective, selector: "[cDropdownMenu]", inputs: ["alignment", "visible", "dark"], exportAs: ["cDropdownMenu"] }, { kind: "directive", type: i7.CdkFixedSizeVirtualScroll, selector: "cdk-virtual-scroll-viewport[itemSize]", inputs: ["itemSize", "minBufferPx", "maxBufferPx"] }, { kind: "directive", type: i7.CdkVirtualForOf, selector: "[cdkVirtualFor][cdkVirtualForOf]", inputs: ["cdkVirtualForOf", "cdkVirtualForTrackBy", "cdkVirtualForTemplate", "cdkVirtualForTemplateCacheSize"] }, { kind: "component", type: i7.CdkVirtualScrollViewport, selector: "cdk-virtual-scroll-viewport", inputs: ["orientation", "appendOnly"], outputs: ["scrolledIndexChange"] }, { kind: "component", type: i8.MultiSelectOptionComponent, selector: "c-multi-select-option", inputs: ["optionsStyle", "label", "text", "visible", "disabled", "selected", "value", "active", "role"], outputs: ["selectedChange", "focusChange"], exportAs: ["cMultiSelectOption"] }, { kind: "component", type: i9.MultiSelectTagComponent, selector: "c-multi-select-tag", inputs: ["option", "disabled", "label", "value"], outputs: ["remove"] }, { kind: "directive", type: i10.MultiSelectSearchDirective, selector: "[cMultiSelectSearch]", inputs: ["delay", "value"], outputs: ["valueChange"], exportAs: ["cMultiSelectSearch"] }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }, { kind: "pipe", type: i3.I18nPluralPipe, name: "i18nPlural" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MultiSelectComponent, decorators: [{
             type: Component,
             args: [{ selector: 'c-multi-select', exportAs: 'cMultiSelect', providers: [
                         MultiSelectService,
                         {
                             provide: NG_VALUE_ACCESSOR, useExisting: forwardRef(() => MultiSelectComponent), multi: true
                         }
-                    ], template: "<c-dropdown #dropdown=\"cDropdown\" [autoClose]=\"'outside'\" class=\"picker\" [ngClass]=\"multiselectClasses\"\n            [(visible)]=\"visible\" [popperOptions]=\"popperjsOptions\">\n  <div [caret]=\"false\" [disabled]=\"disabled\" cDropdownToggle #dropdownToggle=\"cDropdownToggle\">\n    <div class=\"form-multi-select-selection\">\n      <ng-template [ngIf]=\"selectionType === 'tags'\">\n        <c-multi-select-tag\n          *ngFor=\"let option of selectedOptions; index as i\"\n          (remove)=\"handleTagRemove($event)\"\n          [option]=\"option\"\n          tabindex=\"-1\"\n          class=\"form-multi-select-tag\"\n        ></c-multi-select-tag>\n      </ng-template>\n      <ng-template [ngIf]=\"selectionType === 'text' && !!selectedOptionsText\">\n        <span class=\"form-multi-select-search\">{{ selectedOptionsText }}</span>\n      </ng-template>\n      <ng-template [ngIf]=\"selectionType === 'counter'\">\n        <span *ngIf=\"counterTextType === 'string'; else pluralMap\">{{ counterText }}</span>\n        <ng-template #pluralMap>\n          <span>{{selectedOptions.length}} {{ selectedOptions.length | i18nPlural: selectionTypeCounterTextPluralMap ?? { other: counterText } }}</span>\n        </ng-template>\n      </ng-template>\n      <!--      <ng-template [ngIf]=\"!search && selectedOptions.length === 0 && selectionType !== 'counter'\">-->\n      <!--        <span class=\"form-multi-select-search\">{{ placeholder }}</span>-->\n      <!--      </ng-template>-->\n    </div>\n\n    <input\n      #inputElement\n      (keydown)=\"handleSearchKeyDown($event)\"\n      [(ngModel)]=\"searchValue\"\n      [disabled]=\"disabled || !search\"\n      [ngClass]=\"{ 'form-multi-select-search': true, disabled: (disabled || !search) }\"\n      [attr.placeholder]=\"selectedOptions.length === 0 && selectionType !== 'counter' ? placeholder : null\"\n      autocomplete=\"off\"\n      tabindex=\"{{ disabled ? '-1' : '0' }}\"\n      type=\"text\"\n    >\n\n    <button\n      (click)=\"clearAllOptions($event)\"\n      *ngIf=\"cleaner && selectedOptions.length > 0 && !disabled\"\n      [disabled]=\"disabled || !isDropdownVisible\"\n      aria-label=\"Clear all\"\n      class=\"form-multi-select-selection-cleaner\"\n    ></button>\n  </div>\n\n  <div *ngIf=\"!disabled\" class=\"\" cDropdownMenu #dropdownMenu=\"cDropdownMenu\" [visible]=\"dropdown.visible\">\n    <ng-template [ngIfElse]=\"optionsEmpty\" [ngIf]=\"visibleOptions > 0\">\n      <button (click)=\"selectAllOptions()\" *ngIf=\"selectAll && multiple\" class=\"form-multi-select-all\">\n        {{ selectAllLabel }}\n      </button>\n      <div #multiselectOptionsDiv\n           [ngStyle]=\"optionsMaxHeight !== 'auto' ? { 'maxHeight.px': optionsMaxHeight, overflowY: 'scroll' } : {}\"\n           class=\"form-multi-select-options\"\n      >\n        <ng-content></ng-content>\n      </div>\n    </ng-template>\n    <ng-template #optionsEmpty>\n      <div class=\"form-multi-select-options-empty\">{{ searchNoResultsLabel }}</div>\n    </ng-template>\n  </div>\n</c-dropdown>\n", styles: [":host{display:block}:host:focus-visible{outline:none}:host.cdk-focused:not(.disabled) .form-multi-select{color:var(--cui-form-multi-select-focus-color, rgba(44, 56, 74, .95));background-color:var(--cui-form-multi-select-focus-bg, #fff);border-color:var(--cui-form-multi-select-focus-border-color, #6557e4);box-shadow:0 0 0 .25rem #321fdb40}:host:not(.cdk-focused) .form-multi-select:not(.show) input.form-multi-select-search:not([placeholder]){width:.1rem;margin-inline-start:0}:host .form-multi-select-search[size]{display:inline}:host .form-multi-select-selection-tags .form-multi-select-search{height:1.5rem}:host-context(.dark-theme)::ng-deep .form-multi-select-optgroup-label{color:var(--cui-form-multi-select-disabled-color)}\n"] }]
+                    ], template: "<c-dropdown #dropdown=\"cDropdown\"\n            [(visible)]=\"visible\"\n            [autoClose]=\"'outside'\"\n            [ngClass]=\"multiselectClasses\"\n            [popperOptions]=\"popperjsOptions\"\n            class=\"picker\">\n  <div #dropdownToggle=\"cDropdownToggle\" [caret]=\"false\" [disabled]=\"disabled\" cDropdownToggle>\n    <div class=\"form-multi-select-selection\">\n      <ng-template [ngIf]=\"selectionType === 'tags'\">\n        <ng-container *ngIf=\"(optionsSelected$ | async) as optionTags\">\n          <c-multi-select-tag\n            (remove)=\"handleTagRemove($event)\"\n            *ngFor=\"let option of optionTags; index as i\"\n            [disabled]=\"option.disabled ?? false\"\n            [label]=\"option.label\"\n            [option]=\"option\"\n            [value]=\"option.value\"\n            class=\"form-multi-select-tag\"\n            tabindex=\"-1\">\n          </c-multi-select-tag>\n        </ng-container>\n      </ng-template>\n      <ng-template [ngIf]=\"selectionType === 'text' && !!selectedOptionsText\">\n        <span class=\"form-multi-select-search\">{{ selectedOptionsText }}</span>\n      </ng-template>\n      <ng-template [ngIf]=\"selectionType === 'counter'\">\n        <span *ngIf=\"counterTextType === 'string'; else pluralMap\">{{ counterText }}</span>\n        <ng-template #pluralMap>\n          <span>{{selectedOptions.length}} {{ selectedOptions.length | i18nPlural: selectionTypeCounterTextPluralMap ?? { other: counterText } }}</span>\n        </ng-template>\n      </ng-template>\n      <!--      <ng-template [ngIf]=\"!search && selectedOptions.length === 0 && selectionType !== 'counter'\">-->\n      <!--        <span class=\"form-multi-select-search\">{{ placeholder }}</span>-->\n      <!--      </ng-template>-->\n    </div>\n\n    <input\n      #inputElement\n      (keydown)=\"handleSearchKeyDown($event)\"\n      (valueChange)=\"handleSearchValueChange($event)\"\n      [attr.placeholder]=\"optionsSelected.size === 0 && selectionType !== 'counter' ? placeholder : null\"\n      [disabled]=\"disabled || !search\"\n      [ngClass]=\"{ 'form-multi-select-search': true, disabled: (disabled || !search) }\"\n      [ngModel]=\"searchValue\"\n      [value]=\"searchValue\"\n      autocomplete=\"off\"\n      cMultiSelectSearch\n      size=\"3\"\n      tabindex=\"{{ disabled ? -1 : 0 }}\"\n      type=\"text\"\n    >\n\n    <button\n      (click)=\"clearAllOptions($event)\"\n      *ngIf=\"cleaner && optionsSelected.size > 0 && !disabled\"\n      [disabled]=\"disabled || !isDropdownVisible\"\n      aria-label=\"Clear all\"\n      class=\"form-multi-select-selection-cleaner\"\n    ></button>\n  </div>\n  <div #dropdownMenu=\"cDropdownMenu\" *ngIf=\"!disabled\" [visible]=\"dropdown.visible\" cDropdownMenu>\n    <ng-template [ngIfElse]=\"optionsEmpty\" [ngIf]=\"visibleOptions > 0 && options.length > 0\">\n      <button (click)=\"selectAllOptions()\"\n              *ngIf=\"selectAll && multiple && !virtualScroller\"\n              class=\"form-multi-select-all\"\n      >\n        {{ selectAllLabel }}\n      </button>\n      <ng-container\n        *ngTemplateOutlet=\"virtualScroller ? multiselectVirtualScroller : multiselectOptionsDiv\"></ng-container>\n    </ng-template>\n    <ng-template #optionsEmpty>\n      <div class=\"form-multi-select-options-empty\">{{ searchNoResultsLabel }}</div>\n    </ng-template>\n  </div>\n</c-dropdown>\n\n<ng-template #multiselectVirtualScroller>\n  <cdk-virtual-scroll-viewport\n    #scrollViewport\n    (scrolledIndexChange)=\"handleScrolledIndexChange($event, scrollViewport)\"\n    *ngIf=\"optionsArray$ | async as optionsArray\"\n    [itemSize]=\"itemSize\"\n    [ngStyle]=\"optionsMaxHeight !== 'auto' ? { 'height.px': optionsMaxHeight, 'maxHeight.px': optionsMaxHeight, 'minWidth.px': itemMinWidth ?? 196, overflowX: 'hidden' } : { 'minWidth.px': itemMinWidth ?? 196, overflowX: 'hidden'}\"\n    maxBufferPx=\"{{itemSize * visibleItems}}\"\n    minBufferPx=\"{{itemSize * visibleItems}}\"\n  >\n    <ng-container\n      #cdkVirtualFor\n      *cdkVirtualFor=\"let option of optionsArray; trackBy: trackByFn; templateCacheSize: 0; even as even; odd as odd; index as index; count as count; first as first; last as last;\"\n      [ngTemplateOutletContext]=\"{$implicit: option, even, odd, index, count, first, last}\"\n      [ngTemplateOutlet]=\"templates['multiSelectOptionTemplate'] || defaultMultiSelectOptionTemplate\"\n    >\n    </ng-container>\n  </cdk-virtual-scroll-viewport>\n\n</ng-template>\n\n<ng-template #multiselectOptionsDiv>\n  <div\n    [ngStyle]=\"optionsMaxHeight !== 'auto' ? { 'maxHeight.px': optionsMaxHeight, overflowY: 'scroll' } : {}\"\n    class=\"form-multi-select-options\"\n  >\n    <ng-content></ng-content>\n  </div>\n</ng-template>\n\n<ng-template #defaultMultiSelectOptionTemplate let-option>\n  <c-multi-select-option\n    [disabled]=\"option.disabled\"\n    [label]=\"option.label\"\n    [selected]=\"option.selected\"\n    [text]=\"option.text\"\n    [value]=\"option.value\"\n    [visible]=\"option.visible\"\n  >\n    {{option.text}}\n  </c-multi-select-option>\n</ng-template>\n", styles: [":host{display:block}:host:focus-visible{outline:none}:host.cdk-focused:not(.disabled) .form-multi-select{color:var(--cui-form-multi-select-focus-color, rgba(44, 56, 74, .95));background-color:var(--cui-form-multi-select-focus-bg, #fff);border-color:var(--cui-form-multi-select-focus-border-color, #6557e4);box-shadow:0 0 0 .25rem #321fdb40}:host:not(.cdk-focused) .form-multi-select:not(.show) input.form-multi-select-search:not([placeholder]){width:.1rem;margin-inline-start:0}:host .form-multi-select-search[size]{display:inline-block}:host .form-multi-select-selection-tags .form-multi-select-search{height:1.5rem}:host ::ng-deep .cdk-virtual-scroll-content-wrapper{padding:var(--cui-form-multi-select-options-padding-y) var(--cui-form-multi-select-options-padding-x);font-size:1rem;color:var(--cui-form-multi-select-options-color)}:host .cdk-virtual-scroll-viewport{width:var(--cui-dropdown-min-width)}:host-context(.dark-theme)::ng-deep .form-multi-select-optgroup-label{color:var(--cui-form-multi-select-disabled-color)}\n"] }]
         }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }, { type: i0.ViewContainerRef }, { type: i1.FocusMonitor }, { type: i2.MultiSelectService }, { type: i0.IterableDiffers }]; }, propDecorators: { cleaner: [{
                 type: Input
             }], disabled: [{
                 type: Input
             }], multiple: [{
                 type: Input
-            }], nativeName: [{
+            }], nativeFormId: [{
                 type: Input
             }], nativeId: [{
                 type: Input
+            }], nativeName: [{
+                type: Input
             }], options: [{
                 type: Input
             }], optionsMaxHeight: [{
@@ -567,6 +990,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImpo
                 type: Input
             }], visibleItems: [{
                 type: Input
+            }], itemSize: [{
+                type: Input
+            }], itemMinWidth: [{
+                type: Input
             }], visible: [{
                 type: Input
             }], visibleChange: [{
@@ -574,21 +1001,33 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImpo
             }], popperjsOptions: [{
                 type: Input,
                 args: ['popperOptions']
-            }], multiSelectOptions: [{
+            }], multiSelectOptionsContent: [{
                 type: ContentChildren,
                 args: [MultiSelectOptionComponent, { descendants: true }]
+            }], multiSelectOptionsView: [{
+                type: ViewChildren,
+                args: [MultiSelectOptionComponent]
+            }], scrollViewportView: [{
+                type: ViewChildren,
+                args: ['scrollViewport']
+            }], optionsElementRef: [{
+                type: ViewChild,
+                args: ['options']
+            }], contentTemplates: [{
+                type: ContentChildren,
+                args: [TemplateIdDirective, { descendants: true }]
             }], inputElement: [{
                 type: ViewChild,
                 args: ['inputElement']
             }], dropdownMenu: [{
                 type: ViewChild,
                 args: ['dropdownMenu']
-            }], dropdownToggle: [{
-                type: ViewChild,
-                args: [DropdownToggleDirective]
             }], dropdown: [{
                 type: ViewChild,
                 args: [DropdownComponent, { read: ElementRef }]
+            }], dropdownToggle: [{
+                type: ViewChild,
+                args: [DropdownToggleDirective, { read: ElementRef }]
             }], hostClasses: [{
                 type: HostBinding,
                 args: ['class']
@@ -608,4 +1047,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImpo
                 type: HostListener,
                 args: ['click', ['$event']]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"multi-select.component.js","sourceRoot":"","sources":["../../../../../../projects/coreui-angular/src/lib/multi-select/multi-select/multi-select.component.ts","../../../../../../projects/coreui-angular/src/lib/multi-select/multi-select/multi-select.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterContentInit,\n  AfterViewInit,\n  ChangeDetectorRef,\n  Component,\n  ContentChildren,\n  ElementRef,\n  EventEmitter,\n  forwardRef,\n  HostBinding,\n  HostListener,\n  Input,\n  IterableDiffer,\n  IterableDiffers,\n  NgZone,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n  QueryList,\n  Renderer2,\n  SimpleChanges,\n  ViewChild,\n  ViewContainerRef\n} from '@angular/core';\nimport { FocusKeyManager, FocusMonitor, FocusOrigin } from '@angular/cdk/a11y';\nimport { BooleanInput, coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { Subject, Subscription } from 'rxjs';\nimport { Modifier, ModifierArguments, Options } from '@popperjs/core';\n\nimport { DropdownComponent, DropdownToggleDirective } from '../../dropdown';\nimport { IMultiSelect, IOption } from '../multi-select.type';\nimport { MultiSelectService } from '../multi-select.service';\nimport { MultiSelectOptionComponent } from '../multi-select-option/multi-select-option.component';\nimport { MultiSelectNativeSelectComponent } from '../multi-select-native-select/multi-select-native-select.component';\nimport { takeUntil } from 'rxjs/operators';\n\ninterface IPluralMap {\n  [k: string]: string;\n}\n\n// @ts-ignore\nexport const observeReferenceModifier: Modifier<string, any> = {\n  name: 'observeReferenceModifier', enabled: true, phase: 'main', fn({ state }) {},\n\n  effect: ({ state, instance }: ModifierArguments<Options>) => {\n    const RO_PROP = '__popperjsRO__';\n    const { reference } = state.elements;\n\n    // @ts-ignore\n    reference[RO_PROP] = new ResizeObserver((entries) => {\n      instance.update();\n    });\n\n    // @ts-ignore\n    reference[RO_PROP].observe(reference);\n    return () => {\n      // @ts-ignore\n      reference[RO_PROP].disconnect();\n      // @ts-ignore\n      delete reference[RO_PROP];\n    };\n  }\n};\n\n@Component({\n  selector: 'c-multi-select',\n  templateUrl: './multi-select.component.html',\n  styleUrls: ['./multi-select.component.scss'],\n  exportAs: 'cMultiSelect',\n  providers: [\n    MultiSelectService,\n    {\n      provide: NG_VALUE_ACCESSOR, useExisting: forwardRef(() => MultiSelectComponent), multi: true\n    }\n  ]\n})\nexport class MultiSelectComponent implements IMultiSelect, ControlValueAccessor, AfterContentInit, AfterViewInit, OnChanges, OnDestroy, OnInit {\n\n  constructor(\n    private elementRef: ElementRef,\n    private renderer: Renderer2,\n    private ngZone: NgZone,\n    private changeDetectorRef: ChangeDetectorRef,\n    private viewContainerRef: ViewContainerRef,\n    private focusMonitor: FocusMonitor,\n    private multiSelectService: MultiSelectService,\n    private iterableDiffers: IterableDiffers\n  ) {\n    this.differ = this.iterableDiffers.find(this._value).create();\n  }\n\n  private readonly differ!: IterableDiffer<any>;\n\n  static ngAcceptInputType_multiple: BooleanInput;\n  static ngAcceptInputType_disabled: BooleanInput;\n  static ngAcceptInputType_virtualScroller: BooleanInput;\n\n  readonly #destroy$ = new Subject<boolean>();\n\n  onChange = (value: any) => {};\n  onTouched = () => {};\n\n  writeValue(value: (string | string[])): void {\n    if (value !== null) {\n      this.value = Array.isArray(value) ? [...value] : [value ?? ''];\n    }\n  }\n\n  registerOnChange(fn: any): void {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn: any): void {\n    this.onTouched = fn;\n  }\n\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n  }\n\n  @Input() cleaner = true;\n\n  @Input() set disabled(value: boolean) {\n    if (this._disabled !== value) {\n      this._disabled = coerceBooleanProperty(value);\n      this.setFocusMonitor(!value);\n    }\n  }\n\n  get disabled(): boolean {\n    return this._disabled;\n  }\n\n  private _disabled = false;\n\n  @Input() set multiple(value: boolean) {\n    this._multiple = coerceBooleanProperty(value);\n  }\n\n  get multiple(): boolean {\n    return this._multiple;\n  }\n\n  private _multiple = false;\n\n  @Input() nativeName = '';\n  @Input() nativeId = '';\n  @Input() options: IOption[] = [];\n  @Input() optionsMaxHeight = 'auto';\n  @Input() optionsStyle: 'checkbox' | 'text' = 'checkbox';\n  @Input() placeholder = 'Select...';\n  @Input() search: boolean | 'external' = true;\n  @Input() searchNoResultsLabel = 'no items';\n\n  @Input()\n  set searchValue(value) {\n    if (this._searchValue !== value.trimStart()) {\n      this._searchValue = value.trimStart();\n      this.visible = !!this.searchValue.length || this.visible;\n      this.filterOptions(this.searchValue);\n      this.inputElementSize();\n      this.searchValueChange.emit(this._searchValue);\n    }\n  }\n\n  get searchValue() {\n    return this._searchValue;\n  }\n\n  private _searchValue: string = '';\n\n  @Output() readonly searchValueChange = new EventEmitter<string>();\n\n  @Input() selectAll = true;\n  @Input() selectAllLabel = 'Select all options';\n  @Input() selectionType: 'counter' | 'tags' | 'text' = 'tags';\n  @Input() selectionTypeCounterText: string = 'item(s) selected';\n  @Input() selectionTypeCounterTextPluralMap?: IPluralMap = { '=1': 'item selected', 'other': 'items selected' };\n\n  /**\n   * Size the component small or large.\n   * @type 'sm' | 'lg' | undefined\n   */\n  @Input() size?: 'sm' | 'lg';\n\n  /**\n   * Initial value of multi-select\n   * @type string | string[]\n   */\n  @Input() set value(value: string | string[]) {\n    const newValue = Array.isArray(value) ? [...value] : [value ?? ''];\n    if (this.differ) {\n      const changes = this.differ.diff(newValue);\n      if (changes) {\n        this._value = [...newValue];\n        this.onChange([...newValue]);\n        this.selectOptions();\n        // not required here:\n        // this.selectedOptionsUpdate();\n        this.valueChange.emit(this.value);\n      }\n    }\n  }\n\n  get value() {\n    return this.multiple ? [...this._value] : this._value[0]?.toString() ?? '';\n  }\n\n  private _value: string[] = [''];\n\n  @Output() readonly valueChange = new EventEmitter<string | string[]>();\n\n  /**\n   * Toggle visual validation feedback.\n   * @type boolean | undefined\n   * @default undefined\n   */\n  @Input() valid?: boolean;\n\n  /**\n   * Enable virtual scroller for the options list.\n   * @type boolean\n   * @default false\n   * todo: virtual scroller implementation\n   */\n  @Input()\n  set virtualScroller(value: boolean) {\n    this._virtualScroller = coerceBooleanProperty(value);\n  }\n\n  get virtualScroller() {\n    return this._virtualScroller;\n  }\n\n  private _virtualScroller = false;\n\n  /**\n   * Amount of visible options, if set - overwrites optionsMaxHeight\n   * @type number\n   * @default 10\n   */\n  @Input()\n  set visibleItems(value) {\n    this._visibleItems = value || 1;\n    this.optionsMaxHeight = ((42 * value) + 16).toString();\n  }\n\n  get visibleItems() {\n    return this._visibleItems;\n  }\n\n  private _visibleItems = 10;\n\n  /**\n   * Toggle the visibility of the dropdown select component.\n   * @type boolean\n   * @default false\n   */\n  @Input() set visible(value: boolean) {\n    const visible = coerceBooleanProperty(value);\n    if (visible !== this._visible) {\n      this._visible = visible;\n      this.multiSelectService.toggleVisible(visible);\n      if (visible) {\n        this.listKeyManager?.setFirstItemActive();\n      }\n    }\n  }\n\n  get visible() {\n    return this._visible;\n  }\n\n  private _visible = false;\n\n  @Output() readonly visibleChange = new EventEmitter<boolean>();\n\n  /**\n   * Optional popper Options object\n   * @type Partial<Options>\n   */\n  @Input('popperOptions') popperjsOptions: Partial<Options> = {\n    strategy: 'fixed', modifiers: [observeReferenceModifier, {\n      name: 'offset', options: {\n        offset: () => this.selectionType === 'tags' && this.selectedOptions.length ? [-2, 8] : [-12, 12]\n      }\n    }]\n  };\n\n  isDropdownVisible = false;\n\n  set selectedOptions(value) {\n    this._selectedOptions = value;\n    this.value = this.selectedOptions.map(item => item.value);\n    this.inputElementSize();\n  }\n\n  get selectedOptions() {\n    return this._selectedOptions;\n  }\n\n  private _selectedOptions: any[] = [];\n\n  get selectedOptionsText() {\n    return this.selectedOptions.map(option => option.label).join(', ');\n  }\n\n  get counterText() {\n    return `${this.selectedOptions.length} ${this.selectionTypeCounterText}`;\n  }\n\n  get counterTextType(): string {\n    return typeof this.selectionTypeCounterTextPluralMap ?? typeof this.selectionTypeCounterText;\n  };\n\n  private multiselectStateSubscription!: Subscription;\n  private multiselectVisibleSubscription!: Subscription;\n  private focusMonitorSubscription!: Subscription;\n\n  @ContentChildren(MultiSelectOptionComponent, { descendants: true }) multiSelectOptions!: QueryList<MultiSelectOptionComponent>;\n\n  private listKeyManager!: FocusKeyManager<MultiSelectOptionComponent>;\n\n  @ViewChild('inputElement') inputElement!: ElementRef;\n  @ViewChild('dropdownMenu') dropdownMenu!: ElementRef;\n  @ViewChild(DropdownToggleDirective) dropdownToggle!: ElementRef;\n  @ViewChild(DropdownComponent, { read: ElementRef }) dropdown!: ElementRef;\n\n  @HostBinding('class') get hostClasses() {\n    return {\n      disabled: this.disabled\n    };\n  }\n\n  get multiselectClasses() {\n    return {\n      'form-multi-select': true,\n      'form-multi-select-selection-tags': this.selectionType === 'tags' && this.selectedOptions.length > 0,\n      [`form-multi-select-${this.size}`]: !!this.size,\n      'form-multi-select-with-cleaner': this.cleaner,\n      show: this.visible,\n      disabled: this.disabled,\n      'is-valid': this.valid === true,\n      'is-invalid': this.valid === false\n    };\n  }\n\n  @HostBinding('attr.aria-multiselectable')\n  private get ariaMultiSelectable() {\n    return this.multiple;\n  }\n\n  @HostBinding('attr.tabindex')\n  private get tabIndex() {\n    return this._tabIndex;\n  }\n\n  private set tabIndex(value) {\n    setTimeout(() => {\n      this._tabIndex = this.disabled || this.search ? '-1' : value === null ? null : '0';\n    });\n  }\n\n  private _tabIndex: string | null = '-1';\n\n  @HostListener('keyup', ['$event']) onKeyUp($event: KeyboardEvent): void {\n    if (this.disabled) {\n      return;\n    }\n    this.onTouched();\n    if ($event.key === 'Escape') {\n      this.visible = false;\n      this.searchValue = '';\n      this.setFocus('keyboard', 'onKeyUp');\n      return;\n    }\n    if (['Enter', ' ', 'ArrowDown'].includes($event.key) && [this.inputElement?.nativeElement, this.elementRef.nativeElement].includes($event.target)) {\n      this.visible = true;\n      if (!this.search) {\n        this.setFocus('keyboard', 'onKeyUp');\n      }\n      return;\n    }\n    if ($event.key === 'Tab' && $event.target === this.elementRef.nativeElement) {\n      this.visible = true;\n      if (!this.search) {\n        this.setFocus('keyboard', 'onKeyUp');\n      }\n      return;\n    }\n  }\n\n  @HostListener('keydown', ['$event']) onKeyDown($event: KeyboardEvent) {\n    if (this.disabled) {\n      return;\n    }\n    // avoid setting focus to option while on input element\n    if ($event.target === this.inputElement.nativeElement) {\n      return;\n    }\n    this.listKeyManager?.onKeydown($event);\n  }\n\n  @HostListener('click', ['$event']) onClick($event: MouseEvent): void {\n    if (this.disabled) {\n      return;\n    }\n    if (!this.visible) {\n      this.visible = true;\n      this.setFocus('mouse', 'onClick');\n    } else if ([this.dropdown.nativeElement].includes($event.target)) {\n      this.visible = false;\n      this.setFocus('mouse', 'onClick');\n    }\n    this.onTouched();\n  }\n\n  public visibleOptions = 0;\n\n  get subtreeFocused() {\n    return this._subtreeFocused;\n  }\n\n  set subtreeFocused(value: boolean) {\n    this._subtreeFocused = this.disabled ? false : value;\n    this.visible = value === false ? false : this.visible;\n  }\n\n  private _subtreeFocused = this.focusOrigin(null);\n\n  private nativeSelectRef!: any;\n\n  focusOrigin(origin: FocusOrigin): boolean {\n    if (this.disabled) {\n      return false;\n    }\n    const focused = !!origin;\n    this.searchValue = focused ? this.searchValue : '';\n    return focused;\n  }\n\n  ngOnInit(): void {\n    this.tabIndex = '0';\n  }\n\n  ngOnDestroy(): void {\n    this.#destroy$.next(true);\n    this.#destroy$.complete();\n    this.multiselectSubscribe(false);\n    this.setFocusMonitor(false);\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['value']) {\n      const valueChanges = changes['value'];\n      if (valueChanges.currentValue.length === 0) {\n        this.clearAllOptions();\n      } else {\n        this.selectOptions();\n      }\n      this.selectedOptionsUpdate();\n    }\n  }\n\n  ngAfterContentInit(): void {\n\n    this.visibleOptions = this.multiSelectOptions.length;\n\n    this.multiSelectOptions.changes\n      .pipe(\n        takeUntil(this.#destroy$)\n      )\n      .subscribe(next => {\n        this.visibleOptions = this.multiSelectOptions?.filter((item) => item.visible).length;\n        this.selectOptions();\n      });\n  }\n\n  ngAfterViewInit(): void {\n\n    this.selectOptions();\n    this.multiselectSubscribe();\n\n    this.listKeyManager = new FocusKeyManager(this.multiSelectOptions).withHomeAndEnd().withTypeAhead();\n    this.listKeyManager.skipPredicate(item => (item.disabled || !item.visible));\n    this.listKeyManager.setFirstItemActive();\n\n    this.setFocusMonitor(!this.disabled);\n    // not required here:\n    // this.selectedOptionsUpdate();\n    setTimeout(() => {\n      this.createNativeSelect();\n    });\n  }\n\n  private multiselectSubscribe(subscribe: boolean = true) {\n    if (subscribe) {\n\n      this.multiselectVisibleSubscription = this.multiSelectService.multiSelectVisible$.subscribe((visible) => {\n        if (this.isDropdownVisible !== visible) {\n          this.isDropdownVisible = visible;\n          this.visibleChange.emit(visible);\n          if (!visible) {\n            this.setFocus('program', 'multiSelectVisible$' )\n          }\n        }\n      });\n\n      this.multiselectStateSubscription = this.multiSelectService.multiSelectState$.subscribe((option) => {\n        if (option.selected === true && !this.multiple) {\n          const selectedOptions = this.multiSelectOptions.toArray().filter((item) => item.selected);\n          selectedOptions.reverse().forEach((item) => {\n            if (item !== option) {\n              item.selected = false;\n            }\n          });\n          // close dropdown for single select (!multiple)\n          this.visible = false;\n          this.searchValue = '';\n        }\n        // todo?\n        // if (!!option) {\n        this.selectedOptionsUpdate();\n        // }\n      });\n    } else {\n      this.multiselectVisibleSubscription?.unsubscribe();\n      this.multiselectStateSubscription?.unsubscribe();\n    }\n  }\n\n  selectOptions() {\n    this.multiSelectOptions?.forEach((option, index) => {\n      option.optionsStyle = this.optionsStyle;\n      option.selected = option.value !== undefined ? this._value.includes(option.value) : !!option.selected;\n    });\n  }\n\n  clearAllOptions($event?: MouseEvent) {\n    this.selectedOptions.forEach((option) => {\n      if (!option._disabled) {\n        option.selected = false;\n      }\n    });\n    this.selectedOptionsUpdate();\n    if ($event) {\n      this.searchValue = '';\n      this.setFocus('program', 'clearAllOptions');\n    }\n  }\n\n  selectAllOptions() {\n    this.multiSelectOptions.forEach((option, index) => {\n      if (!option.disabled && option.visible) {\n        option.selected = true;\n      }\n    });\n    this.selectedOptionsUpdate();\n  }\n\n  handleTagRemove($event: IOption) {\n    this.setFocus('program', 'handleTagRemove');\n  }\n\n  setFocus(origin: FocusOrigin = 'program', methodName?: string) {\n    if (this.disabled) {\n      return;\n    }\n    const element = this.inputElement ?? this.elementRef;\n    const preventScroll = origin === 'program';\n    this.focusMonitor?.focusVia(element, origin, { preventScroll: preventScroll });\n    // console.log('setFocus', origin, methodName, 'preventScroll:', preventScroll );\n  }\n\n  filterOptions(value: string) {\n    const searchString = value.toLowerCase() ?? '';\n    this.multiSelectOptions?.forEach((item, index) => {\n      if (this.search === 'external' || !searchString) {\n        item.visible = true;\n      } else {\n        item.visible = item.label?.toLowerCase().includes(searchString) ?? true;\n      }\n    });\n    this.visibleOptions = this.multiSelectOptions?.filter((item) => item.visible).length;\n  }\n\n  createNativeSelect() {\n    this.viewContainerRef.clear();\n    this.nativeSelectRef = this.viewContainerRef.createComponent(MultiSelectNativeSelectComponent);\n    this.updateNativeSelect();\n  }\n\n  updateNativeSelect() {\n    if (!this.nativeSelectRef) {\n      return;\n    }\n\n    const options = this.selectedOptions.map(item => {\n      const { selected, value, label } = item;\n      return { selected, value, label };\n    });\n\n    this.nativeSelectRef.instance.multiple = this.multiple;\n    this.nativeSelectRef.instance.name = this.nativeName;\n    this.nativeSelectRef.instance.form = this.nativeId;\n    this.nativeSelectRef.instance.options = [...options];\n    this.nativeSelectRef.instance.disabled = this.disabled;\n    this.nativeSelectRef.instance.changeDetectorRef.markForCheck();\n  }\n\n  inputElementSize() {\n    if (this.inputElement) {\n      if (this.selectedOptions.length > 0 || this.selectionType === 'counter') {\n        this.renderer.setAttribute(this.inputElement.nativeElement, 'size', (this.searchValue.length + 2).toString());\n      } else {\n        this.renderer.removeAttribute(this.inputElement.nativeElement, 'size');\n      }\n    }\n  }\n\n  handleSearchKeyDown($event: KeyboardEvent) {\n    if (this.searchValue.length || this.selectedOptions.length === 0) {\n      return;\n    }\n\n    if (['Backspace', 'Delete'].includes($event.key)) {\n      $event.stopPropagation();\n      const last = this.selectedOptions.filter(option => !option.disabled).pop();\n      this.selectOption(last, false);\n    }\n  }\n\n  private selectOption(option: MultiSelectOptionComponent, selected: boolean) {\n    option.selected = selected;\n    this.selectedOptionsUpdate();\n  }\n\n  private selectedOptionsUpdate() {\n    setTimeout(() => {\n      this.selectedOptions = this.multiSelectOptions?.filter((option) => !!option.selected);\n      this.inputElementSize();\n      this.updateNativeSelect();\n      this.changeDetectorRef.markForCheck();\n    });\n  }\n\n  private setFocusMonitor(monitor: boolean) {\n    if (monitor && !this.disabled) {\n      this.focusMonitorSubscription = this.focusMonitor?.monitor(this.elementRef, true).subscribe((origin) => {\n        // console.log('focusMonitorSubscription', this.elementRef, origin);\n        this.ngZone.run(() => {\n          this.subtreeFocused = this.focusOrigin(origin);\n          this.changeDetectorRef?.markForCheck();\n        });\n      });\n    } else {\n      this.focusMonitor?.stopMonitoring(this.elementRef);\n      this.focusMonitorSubscription?.unsubscribe();\n    }\n  }\n}\n","<c-dropdown #dropdown=\"cDropdown\" [autoClose]=\"'outside'\" class=\"picker\" [ngClass]=\"multiselectClasses\"\n            [(visible)]=\"visible\" [popperOptions]=\"popperjsOptions\">\n  <div [caret]=\"false\" [disabled]=\"disabled\" cDropdownToggle #dropdownToggle=\"cDropdownToggle\">\n    <div class=\"form-multi-select-selection\">\n      <ng-template [ngIf]=\"selectionType === 'tags'\">\n        <c-multi-select-tag\n          *ngFor=\"let option of selectedOptions; index as i\"\n          (remove)=\"handleTagRemove($event)\"\n          [option]=\"option\"\n          tabindex=\"-1\"\n          class=\"form-multi-select-tag\"\n        ></c-multi-select-tag>\n      </ng-template>\n      <ng-template [ngIf]=\"selectionType === 'text' && !!selectedOptionsText\">\n        <span class=\"form-multi-select-search\">{{ selectedOptionsText }}</span>\n      </ng-template>\n      <ng-template [ngIf]=\"selectionType === 'counter'\">\n        <span *ngIf=\"counterTextType === 'string'; else pluralMap\">{{ counterText }}</span>\n        <ng-template #pluralMap>\n          <span>{{selectedOptions.length}} {{ selectedOptions.length | i18nPlural: selectionTypeCounterTextPluralMap ?? { other: counterText } }}</span>\n        </ng-template>\n      </ng-template>\n      <!--      <ng-template [ngIf]=\"!search && selectedOptions.length === 0 && selectionType !== 'counter'\">-->\n      <!--        <span class=\"form-multi-select-search\">{{ placeholder }}</span>-->\n      <!--      </ng-template>-->\n    </div>\n\n    <input\n      #inputElement\n      (keydown)=\"handleSearchKeyDown($event)\"\n      [(ngModel)]=\"searchValue\"\n      [disabled]=\"disabled || !search\"\n      [ngClass]=\"{ 'form-multi-select-search': true, disabled: (disabled || !search) }\"\n      [attr.placeholder]=\"selectedOptions.length === 0 && selectionType !== 'counter' ? placeholder : null\"\n      autocomplete=\"off\"\n      tabindex=\"{{ disabled ? '-1' : '0' }}\"\n      type=\"text\"\n    >\n\n    <button\n      (click)=\"clearAllOptions($event)\"\n      *ngIf=\"cleaner && selectedOptions.length > 0 && !disabled\"\n      [disabled]=\"disabled || !isDropdownVisible\"\n      aria-label=\"Clear all\"\n      class=\"form-multi-select-selection-cleaner\"\n    ></button>\n  </div>\n\n  <div *ngIf=\"!disabled\" class=\"\" cDropdownMenu #dropdownMenu=\"cDropdownMenu\" [visible]=\"dropdown.visible\">\n    <ng-template [ngIfElse]=\"optionsEmpty\" [ngIf]=\"visibleOptions > 0\">\n      <button (click)=\"selectAllOptions()\" *ngIf=\"selectAll && multiple\" class=\"form-multi-select-all\">\n        {{ selectAllLabel }}\n      </button>\n      <div #multiselectOptionsDiv\n           [ngStyle]=\"optionsMaxHeight !== 'auto' ? { 'maxHeight.px': optionsMaxHeight, overflowY: 'scroll' } : {}\"\n           class=\"form-multi-select-options\"\n      >\n        <ng-content></ng-content>\n      </div>\n    </ng-template>\n    <ng-template #optionsEmpty>\n      <div class=\"form-multi-select-options-empty\">{{ searchNoResultsLabel }}</div>\n    </ng-template>\n  </div>\n</c-dropdown>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"multi-select.component.js","sourceRoot":"","sources":["../../../../../../projects/coreui-angular/src/lib/multi-select/multi-select/multi-select.component.ts","../../../../../../projects/coreui-angular/src/lib/multi-select/multi-select/multi-select.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ChangeDetectorRef,\n  Component,\n  ContentChildren,\n  ElementRef,\n  EventEmitter,\n  forwardRef,\n  HostBinding,\n  HostListener,\n  Input,\n  IterableDiffer,\n  IterableDiffers,\n  NgZone,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n  QueryList,\n  Renderer2,\n  SimpleChanges,\n  TemplateRef,\n  ViewChild,\n  ViewChildren,\n  ViewContainerRef\n} from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { FocusableOption, FocusKeyManager, FocusMonitor, FocusOrigin } from '@angular/cdk/a11y';\nimport { BooleanInput, coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';\nimport { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';\nimport { BehaviorSubject, Observable, Subject, Subscription } from 'rxjs';\nimport {\n  combineLatestWith,\n  debounceTime,\n  delay,\n  distinctUntilChanged,\n  filter,\n  map,\n  take,\n  takeUntil,\n  tap\n} from 'rxjs/operators';\nimport { Modifier, ModifierArguments, Options } from '@popperjs/core';\n\nimport { DropdownComponent, DropdownToggleDirective } from '../../dropdown';\nimport { IMultiSelect, IOption, SearchFn } from '../multi-select.type';\nimport { MultiSelectService } from '../multi-select.service';\nimport { MultiSelectOptionComponent } from '../multi-select-option/multi-select-option.component';\nimport { MultiSelectNativeSelectComponent } from '../multi-select-native-select/multi-select-native-select.component';\nimport { TemplateIdDirective } from '../../shared';\n\ninterface IPluralMap {\n  [k: string]: string;\n}\n\n// @ts-ignore\nexport const observeReferenceModifier: Modifier<string, any> = {\n  name: 'observeReferenceModifier', enabled: true, phase: 'main', fn({ state }) {},\n\n  effect: ({ state, instance }: ModifierArguments<Options>) => {\n    const RO_PROP = '__popperjsRO__';\n    const { reference } = state.elements;\n\n    // @ts-ignore\n    reference[RO_PROP] = new ResizeObserver((entries) => {\n      instance.update();\n    });\n\n    // @ts-ignore\n    reference[RO_PROP].observe(reference);\n    return () => {\n      // @ts-ignore\n      reference[RO_PROP].disconnect();\n      // @ts-ignore\n      delete reference[RO_PROP];\n    };\n  }\n};\n\n@Component({\n  selector: 'c-multi-select',\n  templateUrl: './multi-select.component.html',\n  styleUrls: ['./multi-select.component.scss'],\n  exportAs: 'cMultiSelect',\n  providers: [\n    MultiSelectService,\n    {\n      provide: NG_VALUE_ACCESSOR, useExisting: forwardRef(() => MultiSelectComponent), multi: true\n    }\n  ]\n})\nexport class MultiSelectComponent implements IMultiSelect, ControlValueAccessor, AfterViewInit, OnChanges, OnDestroy, OnInit {\n\n  constructor(\n    private elementRef: ElementRef,\n    private renderer: Renderer2,\n    private ngZone: NgZone,\n    private changeDetectorRef: ChangeDetectorRef,\n    private viewContainerRef: ViewContainerRef,\n    private focusMonitor: FocusMonitor,\n    private multiSelectService: MultiSelectService,\n    private iterableDiffers: IterableDiffers\n  ) {\n    this.differ = this.iterableDiffers.find(this.#value).create();\n  }\n\n  private readonly differ!: IterableDiffer<any>;\n\n  static ngAcceptInputType_multiple: BooleanInput;\n  static ngAcceptInputType_disabled: BooleanInput;\n  static ngAcceptInputType_virtualScroller: BooleanInput;\n\n  readonly #destroy$ = new Subject<boolean>();\n  readonly #optionsReady$ = new Subject<boolean>();\n  readonly optionsArray$ = new BehaviorSubject<IOption[]>([]);\n  readonly #options: Map<any, IOption> = new Map();\n  readonly optionsSelected$ = new BehaviorSubject<IOption[]>([]);\n  readonly optionsSelected: Map<any, IOption> = new Map();\n  readonly value$ = new BehaviorSubject<string[]>([]);\n\n  onChange = (value: any) => {};\n  onTouched = () => {};\n\n  writeValue(value: (string | string[])): void {\n    if (value?.length > 0) {\n      this.value = Array.isArray(value) ? [...value] : [value];\n    } else {\n      this.value = Array(0);\n    }\n  }\n\n  registerOnChange(fn: any): void {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn: any): void {\n    this.onTouched = fn;\n  }\n\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n  }\n\n  /**\n   * Enables selection cleaner element\n   * @type boolean\n   * @default true\n   */\n  @Input() cleaner = true;\n\n  /**\n   * Disables multi-select component\n   * @type boolean\n   * @default false\n   */\n  @Input() set disabled(value: boolean) {\n    if (this._disabled !== value) {\n      this._disabled = coerceBooleanProperty(value);\n      this.setFocusMonitor(!value);\n    }\n  }\n\n  get disabled(): boolean {\n    return this._disabled;\n  }\n\n  private _disabled = false;\n\n  /**\n   * Specifies that multiple options can be selected at once\n   * @type boolean\n   * @default false\n   */\n  @Input() set multiple(value: boolean) {\n    this._multiple = coerceBooleanProperty(value);\n  }\n\n  get multiple(): boolean {\n    return this._multiple;\n  }\n\n  private _multiple = false;\n\n  /**\n   * Hidden native select form\n   * @type string\n   * @default ''\n   */\n  @Input() nativeFormId = '';\n\n  /**\n   * Hidden native select id\n   * @type string\n   * @default ''\n   */\n  @Input() nativeId = '';\n\n  /**\n   * Hidden native select name\n   * @type string\n   * @default ''\n   */\n  @Input() nativeName = '';\n\n  /**\n   * List of option elements\n   * @type IOption[]\n   * @default []\n   */\n  @Input()\n  set options(options: IOption[]) {\n    if (Array.isArray(options)) {\n      this.makeOptions(options);\n    }\n  }\n\n  get options() {\n    return [...this.#options.values()];\n  }\n\n  /**\n   * Sets maxHeight of options list in px\n   * @type (string | number)\n   * @default 'auto'\n   */\n  @Input() optionsMaxHeight = 'auto';\n\n  /**\n   * Sets option style\n   * @type 'checkbox' | 'text'\n   * @default 'checkbox'\n   */\n  @Input()\n  set optionsStyle(value: 'checkbox' | 'text') {\n    this.multiSelectService.optionsStyle = value ?? 'checkbox';\n  }\n\n  /**\n   * Specifies a short hint that is visible in the search input\n   * @type string\n   * @default 'Select...'\n   */\n  @Input() placeholder = 'Select...';\n\n  /**\n   * Enables search input element\n   * @type boolean | SearchFn | 'external'\n   * @default true\n   */\n  @Input() search: (boolean | 'external' | SearchFn) = true;\n\n  /**\n   * Sets the label for no results when filtering\n   * @type string\n   * @default 'no items'\n   */\n  @Input() searchNoResultsLabel = 'no items';\n\n  /**\n   * Sets initial search string\n   * @type string\n   * @default ''\n   */\n  @Input()\n  set searchValue(value) {\n    if (this._searchValue !== value.trimStart()) {\n      this._searchValue = value.trimStart();\n      this.visible = !!this.searchValue.length ? true : this.visible;\n      this.filterOptions(this.searchValue);\n      this.inputElementSize();\n      this.searchValueChange.emit(this._searchValue);\n    }\n  }\n\n  get searchValue() {\n    return this._searchValue;\n  }\n\n  private _searchValue: string = '';\n\n  /**\n   * Emits searchValue string for external filtering\n   * @type string\n   */\n  @Output() readonly searchValueChange = new EventEmitter<string>();\n\n  /**\n   * Enables select all button\n   * @type boolean\n   * @default true\n   */\n  @Input() selectAll = true;\n\n  /**\n   * Sets the select all button label\n   * @type string\n   * @default 'Select all options'\n   */\n  @Input() selectAllLabel = 'Select all options';\n\n  /**\n   * Selection type\n   * @type 'counter' | 'tags' | 'text'\n   * @default 'tags'\n   */\n  @Input() selectionType: 'counter' | 'tags' | 'text' = 'tags';\n\n  /**\n   * Counter selection label value\n   * @type string\n   * @default 'item(s) selected'\n   */\n  @Input() selectionTypeCounterText: string = 'item(s) selected';\n\n  /**\n   * Counter selection label plural map for I18nPluralPipe\n   * @type IPluralMap\n   * @default { '=1': 'item selected', 'other': 'items selected' }\n   */\n  @Input() selectionTypeCounterTextPluralMap?: IPluralMap = { '=1': 'item selected', 'other': 'items selected' };\n\n  /**\n   * Size the component small or large.\n   * @type 'sm' | 'lg' | undefined\n   */\n  @Input() size?: 'sm' | 'lg';\n\n  /**\n   * Initial value of multi-select\n   * @type string | string[]\n   */\n  @Input() set value(value: string | string[]) {\n    const newValue = Array.isArray(value) ? [...value] : [value ?? undefined];\n    if (this.differ) {\n      const changes = this.differ.diff(newValue);\n      if (changes) {\n        this.#value = [...newValue];\n        this.value$.next([...newValue]);\n        this.onChange(this.value);\n        // this.valueChange.emit(this.value);\n      }\n    }\n  }\n\n  get value() {\n    const value = this.multiSelectService.selectionModel?.selected ?? [...this.#value];\n    return this.multiple ? [...value] : value?.toString() ?? undefined;\n  }\n\n  #value: string[] = [];\n\n  /**\n   * Emits valueChange\n   * @type string | string[]\n   */\n  @Output() readonly valueChange = new EventEmitter<string | string[]>();\n\n  /**\n   * Toggle visual validation feedback.\n   * @type boolean | undefined\n   * @default undefined\n   */\n  @Input() valid?: boolean;\n\n  /**\n   * Enable virtual scroller for options list.\n   * @type boolean\n   * @default false\n   */\n  @Input()\n  set virtualScroller(value: boolean) {\n    this._virtualScroller = coerceBooleanProperty(value);\n  }\n\n  get virtualScroller() {\n    return this._virtualScroller;\n  }\n\n  private _virtualScroller = false;\n\n  /**\n   * Amount of visible options, if set - overwrites optionsMaxHeight\n   * @type number\n   * @default 8\n   */\n  @Input()\n  set visibleItems(value) {\n    this._visibleItems = coerceNumberProperty(value || 8);\n    this.optionsMaxHeight = ((this.itemSize * this._visibleItems) + 16).toString();\n  }\n\n  get visibleItems() {\n    return this._visibleItems;\n  }\n\n  private _visibleItems = 8;\n\n  /**\n   * The size of the option item in the list (in pixels).\n   * @type number\n   * @default 40\n   */\n  @Input() itemSize: number = 40;\n\n  /**\n   * Min width of the options list (in pixels).\n   * @type number\n   * @default 196\n   */\n  @Input() itemMinWidth: number = 196;\n\n  /**\n   * Toggle the visibility of the dropdown select component.\n   * @type boolean\n   * @default false\n   */\n  @Input() set visible(value: boolean) {\n    const visible = coerceBooleanProperty(value);\n    if (visible !== this._visible) {\n      this._visible = visible;\n      this.multiSelectService.toggleVisible(visible);\n      if (!visible) {\n        // this.searchValue = '';\n      }\n    }\n  }\n\n  get visible() {\n    return this._visible;\n  }\n\n  private _visible = false;\n\n  /**\n   * Emits visibleChange\n   * @type boolean\n   */\n  @Output() readonly visibleChange = new EventEmitter<boolean>();\n\n  /**\n   * Optional popper Options object\n   * @type Partial<Options>\n   */\n  @Input('popperOptions') popperjsOptions: Partial<Options> = {\n    strategy: 'fixed', modifiers: [observeReferenceModifier, {\n      name: 'offset', options: {\n        offset: () => this.selectionType === 'tags' && this.optionsSelected.size ? [-2, 8] : [-12, 12]\n      }\n    }]\n  };\n\n  isDropdownVisible = false;\n\n  get selectedOptions() {\n    return [...this.optionsSelected.values()];\n  }\n\n  get selectedOptionsText() {\n    return this.selectedOptions.map(option => option.label).join(', ');\n  }\n\n  get counterText() {\n    return `${this.selectedOptions.length} ${this.selectionTypeCounterText}`;\n  }\n\n  get counterTextType(): string {\n    return typeof this.selectionTypeCounterTextPluralMap ?? typeof this.selectionTypeCounterText;\n  };\n\n  private focusMonitorSubscription!: Subscription;\n\n  @ContentChildren(MultiSelectOptionComponent, { descendants: true }) multiSelectOptionsContent!: QueryList<MultiSelectOptionComponent>;\n  @ViewChildren(MultiSelectOptionComponent) multiSelectOptionsView!: QueryList<MultiSelectOptionComponent>;\n  @ViewChildren('scrollViewport') scrollViewportView!: QueryList<CdkVirtualScrollViewport>;\n  @ViewChild('options') optionsElementRef!: ElementRef;\n\n  protected scrollViewport!: CdkVirtualScrollViewport;\n\n  protected templates: { [id: string]: TemplateRef<any> } = {};\n  @ContentChildren(TemplateIdDirective, { descendants: true }) contentTemplates!: QueryList<TemplateIdDirective>;\n\n  private listKeyManager!: FocusKeyManager<MultiSelectOptionComponent>;\n\n  @ViewChild('inputElement') inputElement!: ElementRef;\n  @ViewChild('dropdownMenu') dropdownMenu!: ElementRef;\n  @ViewChild(DropdownComponent, { read: ElementRef }) dropdown!: ElementRef;\n  @ViewChild(DropdownToggleDirective, { read: ElementRef }) dropdownToggle!: ElementRef;\n\n  @HostBinding('class')\n  get hostClasses() {\n    return {\n      disabled: this.disabled\n    };\n  }\n\n  get multiselectClasses() {\n    return {\n      'form-multi-select': true,\n      'form-multi-select-selection-tags': this.selectionType === 'tags' && this.optionsSelected.size > 0,\n      [`form-multi-select-${this.size}`]: !!this.size,\n      'form-multi-select-with-cleaner': this.cleaner,\n      show: this.visible,\n      disabled: this.disabled,\n      'is-valid': this.valid === true,\n      'is-invalid': this.valid === false\n    };\n  }\n\n  @HostBinding('attr.aria-multiselectable')\n  private get ariaMultiSelectable() {\n    return this.multiple;\n  }\n\n  @HostBinding('attr.tabindex')\n  private get tabIndex() {\n    return this._tabIndex;\n  }\n\n  private set tabIndex(value) {\n    setTimeout(() => {\n      this._tabIndex = this.disabled || this.search ? -1 : value === null ? null : 0;\n    });\n  }\n\n  private _tabIndex: number | null = -1;\n\n  @HostListener('keyup', ['$event']) onKeyUp($event: KeyboardEvent): void {\n    if (this.disabled) {\n      return;\n    }\n    this.onTouched();\n    const targetTagName = ($event.target as HTMLElement).tagName;\n    if ($event.key === 'Escape') {\n      this.visible = false;\n      this.searchValue = '';\n      this.setFocus('keyboard', 'onKeyUp');\n      return;\n    }\n    if (['Enter', 'Space', 'ArrowDown'].includes($event.code) && [this.inputElement?.nativeElement, this.elementRef.nativeElement].includes($event.target)) {\n      $event.stopPropagation();\n      this.visible = true;\n      if (!this.search) {\n        this.setFocus('keyboard', 'onKeyUp');\n      }\n      return;\n    }\n\n    if (['Tab'].includes($event.key)) {\n\n      if ($event.target === this.elementRef.nativeElement) {\n        this.visible = true;\n        if (!this.search) {\n          this.setFocus('keyboard', 'onKeyUp');\n        }\n        this.tabTarget = targetTagName;\n        return;\n      }\n\n      if (this.visible && this.subtreeFocused) {\n        if (targetTagName === 'C-MULTI-SELECT-OPTION') {\n\n          if (this.tabTarget === 'C-MULTI-SELECT-OPTION') {\n            if ($event.shiftKey && this.listKeyManager.activeItem?.value === this.options.filter(option => option.visible && !option.disabled).slice(0)[0].value) {\n              this.setFocus('keyboard', 'onKeyUp');\n              this.tabTarget = targetTagName;\n              return;\n            }\n\n            if (!$event.shiftKey && this.listKeyManager.activeItem?.value === this.options.filter(option => option.visible && !option.disabled).slice(-1)[0].value) {\n              this.setFocus('keyboard', 'onKeyUp');\n              this.tabTarget = targetTagName;\n              this.updateActiveItem(0);\n              return;\n            }\n          }\n\n          if (!this.listKeyManager.activeItem || this.tabTarget !== targetTagName) {\n            if (this.activeOption) {\n              this.listKeyManager.setActiveItem(this.activeOption);\n            } else {\n              this.setFirstItemActive();\n            }\n          } else {\n            $event.shiftKey ? this.listKeyManager.setPreviousItemActive() : this.listKeyManager.setNextItemActive();\n          }\n        }\n        this.tabTarget = targetTagName;\n        return;\n      }\n    }\n  }\n\n  @HostListener('keydown', ['$event']) onKeyDown($event: KeyboardEvent) {\n    const targetTagName = ($event.target as HTMLElement).tagName;\n    if ($event.key === 'Enter' && targetTagName === 'INPUT') {\n      $event.preventDefault();\n    }\n    if ($event.key === 'Tab') {\n      this.tabTarget = targetTagName;\n      return;\n    }\n    if ($event.key === 'ArrowDown' && targetTagName !== 'C-MULTI-SELECT-OPTION') {\n      $event.preventDefault();\n      return;\n    }\n    if ($event.key === 'Escape') {\n      this.visible = false;\n      this.searchValue = '';\n      this.setFocus('keyboard', 'onKeyUp');\n      return;\n    }\n    if (this.disabled) {\n      return;\n    }\n    // avoid setting focus to option while on input element\n    if ($event.target === this.inputElement.nativeElement) {\n      return;\n    }\n    if ($event.key !== 'Tab') {\n      this.listKeyManager?.onKeydown($event);\n    }\n  }\n\n  @HostListener('click', ['$event'])\n  onClick($event: MouseEvent): void {\n    if (this.disabled) {\n      return;\n    }\n    if ([this.dropdown.nativeElement].includes($event.target)) {\n      this.visible = !this.visible;\n    } else {\n      this.visible = true;\n    }\n    this.onTouched();\n    this.setFocus('mouse', 'onClick');\n  }\n\n  public visibleOptions = 0;\n\n  get subtreeFocused() {\n    return this._subtreeFocused;\n  }\n\n  set subtreeFocused(focused: boolean) {\n    this._subtreeFocused = this.disabled ? false : focused;\n    if (!focused) {\n      this.searchValue = '';\n    }\n    if (!this.virtualScroller) {\n      this.visible = focused === false ? false : this.visible;\n    }\n  }\n\n  private _subtreeFocused = this.focusOrigin(null);\n\n  private nativeSelectRef!: any;\n\n  focusOrigin(origin: FocusOrigin): boolean {\n    if (this.disabled) {\n      return false;\n    }\n    return !!origin;\n  }\n\n  ngOnInit(): void {\n\n    this.multiSelectService.setSelectionModel(this.multiple);\n\n    this.multiSelectService.selectionModel.changed\n      .pipe(\n        takeUntil(this.#destroy$),\n        filter(() => !this.multiple),\n        delay(0),\n        tap(change => {\n          if (change.added.length) {\n            // close dropdown for single select (!multiple)\n            this.visible = false;\n            this.searchValue = '';\n          }\n        })\n      )\n      .subscribe();\n\n    this.multiSelectService.selectionModel.changed\n      .pipe(\n        takeUntil(this.#destroy$),\n        // delay(0),\n        combineLatestWith(this.#optionsReady$),\n        tap(([change, ready]) => {\n          const { added, removed } = { ...change };\n          // added.forEach(key => {\n          //   const value = this.#options.get(key);\n          //   if (value) {\n          //     this.optionsSelected.set(key, value);\n          //   }\n          // });\n          removed.forEach(value => {\n            this.optionsSelected.delete(value);\n          });\n          this.multiSelectService.selectionModel.selected.forEach(key => {\n            const value = this.#options.get(key);\n            if (value) {\n              this.optionsSelected.set(key, value);\n            }\n          });\n\n          this.optionsSelected$.next(Array.from(this.optionsSelected.values()));\n          this.value = [...this.multiSelectService.selectionModel.selected];\n\n          this.inputElementSize();\n          this.updateNativeSelect();\n        })\n      )\n      .subscribe();\n\n    // set initial values\n    this.multiSelectService.selectionModel.select(...this.#value);\n\n    this.value$\n      .pipe(\n        takeUntil(this.#destroy$)\n      )\n      .subscribe(value => {\n        if (!value.length) {\n          this.clearAllOptions();\n          return;\n        }\n\n        value.forEach(value => {\n          this.multiSelectService.selectionModel.select(value);\n        });\n      });\n\n    this.value$\n      .pipe(\n        takeUntil(this.#destroy$),\n        debounceTime(100),\n        tap(value => {\n          this.valueChange.emit(this.value);\n        })\n      )\n      .subscribe();\n\n    this.optionsArray$\n      .pipe(\n        takeUntil(this.#destroy$),\n        tap(options => {\n          this.visibleOptions = options.filter((item) => item.visible).length;\n          this.activeOption = null;\n\n          if (this.virtualScroller) {\n            this.multiSelectOptionsContent?.forEach(option => {\n              option.active = false;\n            });\n            this.scrollViewport?.setRenderedRange({ start: 0, end: this.visibleItems });\n            this.scrollViewport?.scrollToIndex(0);\n          } else {\n            this.multiSelectOptionsContent?.forEach(option => {\n              const found = options.find(item => item.value === option.value);\n              option.visible = found?.visible ?? false;\n              option.active = false;\n            });\n            const firstFocusable = this.firstFocusableItem;\n            if (firstFocusable) {\n              this.updateActiveItem(firstFocusable);\n            }\n          }\n          if (!this.activeOption) {\n            setTimeout(() => {\n              this.updateActiveItem(0);\n            });\n          }\n          this.multiSelectOptionsContent?.notifyOnChanges();\n          // console.log('=> optionsArray$', options.length);\n        })\n      )\n      .subscribe();\n\n    this.tabIndex = 0;\n  }\n\n  ngOnDestroy(): void {\n    this.#destroy$.next(true);\n    this.#destroy$.complete();\n    this.setFocusMonitor(false);\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['value']) {\n      const valueChanges = changes['value'];\n      if (valueChanges.currentValue.length === 0) {\n        this.clearAllOptions();\n      }\n      this.inputElementSize();\n    }\n  }\n\n  makeOptions(options: IOption[]) {\n\n    if (this.search === 'external' && this.searchValue.length) {\n      this.#options.forEach((value, key) => {\n        value.visible = false;\n      });\n    }\n\n    options.forEach(option => {\n      const key = option.value;\n      const value = {\n        value: option.value ?? option.label,\n        label: option.label ?? option.value,\n        disabled: option.disabled === true,\n        visible: this.search === 'external' ? true : option.visible !== false,\n        text: option.text ?? option.label ?? option.value,\n        selected: option.selected\n        // selected: this.multiSelectService.selectionModel.isSelected(option.value),\n        // id: option.id\n      };\n      this.#options.set(key, { ...value });\n    });\n\n    this.filterOptions(this.searchValue);\n\n    this.#optionsReady$.next(true);\n    // console.log('makeOptions', this.#options.size);\n    this.multiSelectOptionsContent?.notifyOnChanges();\n  }\n\n  ngAfterViewInit(): void {\n\n    this.setVirtualScroller();\n\n    this.multiSelectOptionsContent?.changes\n      .pipe(\n        takeUntil(this.#destroy$),\n        delay(0),\n        distinctUntilChanged((previous: QueryList<MultiSelectOptionComponent>, current) => {\n          const prev = previous.toArray().map(option => option.value);\n          const curr = current.toArray().map(option => option.value);\n          return JSON.stringify(prev) === JSON.stringify(curr);\n        })\n      )\n      .subscribe(next => {\n        this.visibleOptions = this.multiSelectOptionsContent?.filter((option) => option.visible).length;\n        if (this.visibleOptions) {\n          this.makeOptions(this.multiSelectOptionsContent.toArray());\n        }\n      });\n\n    this.visibleOptions = this.multiSelectOptionsContent?.length;\n    if (this.visibleOptions) {\n      this.multiSelectOptionsContent.notifyOnChanges();\n    }\n\n    this.multiselectSubscribe();\n\n    this.setFocusMonitor(!this.disabled);\n\n    this.setListKeyManager();\n\n    this.inputElementSize();\n\n    this.multiSelectOptionsContent.notifyOnChanges();\n\n    setTimeout(() => {\n      this.createNativeSelect();\n    });\n\n    this.multiSelectService.multiSelectFocus$\n      .pipe(takeUntil(this.#destroy$))\n      .subscribe((option: any) => {\n          if (this.activeOption?.value !== option.value) {\n            this.listKeyManager.setActiveItem(option);\n          }\n        }\n      );\n  }\n\n  private tabTarget!: string;\n\n  private multiselectSubscribe(subscribe: boolean = true) {\n\n    this.multiSelectService.multiSelectVisible$\n      .pipe(\n        takeUntil(this.#destroy$),\n        debounceTime(100),\n        distinctUntilChanged()\n      )\n      .subscribe((visible) => {\n        if (this.isDropdownVisible !== visible) {\n          this.isDropdownVisible = visible;\n          this.visibleChange.emit(visible);\n          if (!visible) {\n          } else {\n            if (this.virtualScroller) {\n              this.scrollViewport?.setRenderedRange({ start: 0, end: this.visibleItems });\n              this.scrollViewport?.scrollToIndex(0);\n            }\n          }\n          this.multiSelectOptionsContent.notifyOnChanges();\n        }\n        this.updateActiveItem(0);\n      });\n\n  }\n\n  clearAllOptions($event?: MouseEvent) {\n    setTimeout(() => {\n      const enabledOptions = Array.from(this.optionsSelected.values()).filter(option => !option.disabled).map(option => option.value);\n      this.multiSelectService.selectionModel.deselect(...enabledOptions);\n    });\n\n    this.searchValue = '';\n    if ($event) {\n      this.setFocus('program', 'clearAllOptions');\n    }\n  }\n\n  selectAllOptions() {\n    const enabledOptions = Array.from(this.#options.values()).filter(option => option.visible && !option.disabled).map(option => option.value);\n    this.multiSelectService.selectionModel.select(...enabledOptions);\n    this.inputElementSize();\n  }\n\n  handleTagRemove(value: any) {\n    this.multiSelectService.selectionModel.deselect(value);\n    this.setFocus('program', 'handleTagRemove');\n  }\n\n  setFocus(origin: FocusOrigin = 'program', methodName?: string) {\n    if (this.disabled) {\n      return;\n    }\n    const element = <HTMLElement>(this.inputElement.nativeElement ?? this.elementRef.nativeElement);\n    const preventScroll = origin === 'program';\n    this.focusMonitor?.focusVia(element, origin, { preventScroll: preventScroll });\n    // console.log('setFocus', origin, methodName, 'preventScroll:', preventScroll, element.tagName);\n  }\n\n  filterOptions(value: string) {\n    const searchString = value.toLowerCase() ?? '';\n    this.#options.forEach((item, index) => {\n      if (searchString === '') {\n        item.visible = true;\n        return;\n      }\n      if (typeof this.search === 'function') {\n        item.visible = this.search(item, searchString);\n        return;\n      }\n      if (this.search === 'external' || !searchString) {\n        // item.visible = true;\n        return;\n      }\n      item.visible = item.label?.toLowerCase().includes(searchString) ?? true;\n    });\n    this.optionsArray$.next(Array.from(this.#options.values()).filter((item) => item.visible));\n\n  }\n\n  createNativeSelect() {\n    if (!this.nativeId) {\n      return;\n    }\n    this.viewContainerRef.clear();\n    this.nativeSelectRef = this.viewContainerRef.createComponent(MultiSelectNativeSelectComponent);\n    this.updateNativeSelect();\n  }\n\n  updateNativeSelect() {\n    if (!this.nativeSelectRef || !this.nativeId) {\n      return;\n    }\n    const options = Array.from(this.optionsSelected).map(item => {\n      const { selected, value, label } = item[1];\n      return { selected, value, label };\n    });\n\n    this.nativeSelectRef.instance.multiple = this.multiple;\n    this.nativeSelectRef.instance.form = this.nativeFormId;\n    this.nativeSelectRef.instance.id = this.nativeId;\n    this.nativeSelectRef.instance.name = this.nativeName;\n    this.nativeSelectRef.instance.options = [...options];\n    this.nativeSelectRef.instance.disabled = this.disabled;\n    this.nativeSelectRef.instance.changeDetectorRef.markForCheck();\n  }\n\n  inputElementSize() {\n    setTimeout(() => {\n      if (this.inputElement) {\n        if ((this.optionsSelected.size > 0 || this.selectionType === 'counter') && !this.inputElement.nativeElement?.disabled) {\n          this.renderer.setAttribute(this.inputElement.nativeElement, 'size', (this.searchValue.length + 2).toString());\n        } else {\n          this.renderer.removeAttribute(this.inputElement.nativeElement, 'size');\n        }\n      }\n    });\n  }\n\n  handleSearchKeyDown($event: KeyboardEvent) {\n    if (this.searchValue.length || this.optionsSelected.size === 0) {\n      return;\n    }\n\n    if (['Backspace', 'Delete'].includes($event.key)) {\n      $event.stopPropagation();\n      const last = this.selectedOptions.filter(option => !option.disabled).pop();\n      if (last) {\n        this.multiSelectService.selectionModel.deselect(last.value);\n      }\n    }\n  }\n\n  private setFocusMonitor(monitor: boolean) {\n    if (monitor && !this.disabled) {\n      this.focusMonitorSubscription = this.focusMonitor?.monitor(this.elementRef, true)\n        .pipe(\n          // to avoid focus lost on speed scrolling with virtualScroll\n          debounceTime(100)\n        )\n        .subscribe((origin) => {\n          this.ngZone.run(() => {\n            this.subtreeFocused = this.focusOrigin(origin);\n            this.changeDetectorRef?.markForCheck();\n          });\n        });\n    } else {\n      this.focusMonitor?.stopMonitoring(this.elementRef);\n      this.focusMonitorSubscription?.unsubscribe();\n    }\n  }\n\n  activeOption: (FocusableOption & MultiSelectOptionComponent) | null = null;\n\n  handleScrolledIndexChange(scrolledIndex: number, scrollViewport: CdkVirtualScrollViewport) {\n\n    if (!this.scrollViewport) {\n      this.scrollViewport = scrollViewport;\n    }\n\n    const availableOptions = this.options.filter(option => option.visible);\n    const firstVisibleOption = availableOptions[scrolledIndex];\n    const activeOptionIndex = availableOptions.findIndex(option => option.value === this.activeOption?.value);\n    const optionsArray = this.multiSelectOptionsContent.toArray();\n\n    if (scrolledIndex > activeOptionIndex) {\n      const firstVisibleItem = optionsArray.find(option => option.value === firstVisibleOption?.value);\n      if (firstVisibleItem && scrolledIndex) {\n        this.listKeyManager.setActiveItem(firstVisibleItem);\n      }\n      return;\n    }\n\n    if (scrolledIndex + this.visibleItems - 2 <= activeOptionIndex) {\n      const lastVisibleItem = optionsArray.findIndex(option => option.value === firstVisibleOption.value);\n      if (lastVisibleItem > -1) {\n        this.listKeyManager.setActiveItem(lastVisibleItem + this.visibleItems - 2);\n      }\n      return;\n    }\n\n  }\n\n  trackByFn(index: number, option: IOption) {\n    return option.value;\n  }\n\n  handleSearchValueChange(searchValue: string) {\n    this.searchValue = searchValue;\n    if (!searchValue) {\n      this.scrollViewport?.scrollToIndex(0);\n      this.multiSelectOptionsContent.notifyOnChanges();\n    }\n  }\n\n  private setVirtualScroller() {\n\n    if (!this.virtualScroller) {\n      return;\n    }\n\n    // multiSelectOptionTemplate for virtualScroller\n    this.contentTemplates.forEach((child: TemplateIdDirective) => {\n      this.templates[child.id] = child.templateRef;\n    });\n\n    // if no template found, get defaultMultiSelectOptionTemplate from view\n    if (!this.templates['multiSelectOptionTemplate']) {\n      this.multiSelectOptionsContent = this.multiSelectOptionsView;\n    }\n\n    // multiSelectOptionsContent gets out of order on changes\n    // do sort() and reset()\n    const indexOfOption = (option: MultiSelectOptionComponent) => {\n      return [...option.elementRef.nativeElement.parentElement.children]?.indexOf(option.elementRef.nativeElement);\n    };\n\n    const optionsChange$: Observable<QueryList<MultiSelectOptionComponent>> = this.multiSelectOptionsContent.changes;\n\n    const sortedOptions$ = optionsChange$.pipe(\n      takeUntil(this.#destroy$),\n      map(options => options.toArray()),\n      filter(options => options.length > 0),\n      map(options => options.sort((a, b) => indexOfOption(a) - indexOfOption(b)))\n    );\n\n    sortedOptions$\n      .pipe(takeUntil(this.#destroy$))\n      .subscribe(sortedOptions => {\n        return this.multiSelectOptionsContent.reset(sortedOptions);\n      });\n\n    this.scrollViewportView.changes\n      .pipe(\n        takeUntil(this.#destroy$),\n        take(1),\n        map(changes => changes.toArray()[0]),\n        tap((scrollViewport) => {\n            if (!this.scrollViewport) {\n              this.scrollViewport = scrollViewport;\n\n              const cdkVirtualScrollContentWrapper = this.scrollViewport.getElementRef().nativeElement?.firstElementChild;\n              if (cdkVirtualScrollContentWrapper) {\n\n                const style = getComputedStyle(cdkVirtualScrollContentWrapper, null);\n                const padding = parseInt(style.getPropertyValue('padding-left') ?? '12px') * 3;\n\n                const observer = new MutationObserver((mutationRecords) => {\n                  mutationRecords.forEach(child => {\n                    child.addedNodes.forEach(node => {\n                      if (node.nodeName === 'C-MULTI-SELECT-OPTION') {\n                        const width = (node as HTMLElement).offsetWidth;\n                        if (width > this.itemMinWidth) {\n                          this.itemMinWidth = width + padding;\n                        }\n                      }\n                    });\n                  });\n                });\n\n                observer.observe(cdkVirtualScrollContentWrapper, { childList: true });\n\n                this.#destroy$.subscribe(() => {\n                  observer.disconnect();\n                });\n              }\n            }\n          }\n        )\n      )\n      .subscribe();\n  }\n\n  private setListKeyManager() {\n\n    // run once on multiSelectOptionsContent first set\n    this.multiSelectOptionsContent.changes\n      .pipe(\n        takeUntil(this.#destroy$),\n        take(1)\n      )\n      .subscribe(change => {\n\n        this.listKeyManager = new FocusKeyManager(this.multiSelectOptionsContent)\n          .withHomeAndEnd()\n          .skipPredicate((option) => (option.disabled || !option.visible));\n\n        if (!this._virtualScroller) {\n          this.listKeyManager.withTypeAhead(300);\n        }\n\n        this.listKeyManager.change\n          .pipe(\n            takeUntil(this.#destroy$)\n          )\n          .subscribe(change => {\n            if (change < 0) {\n              this.activeOption ? this.listKeyManager.setActiveItem(this.activeOption) : this.setFirstItemActive();\n            }\n            if (this.listKeyManager.activeItem) {\n              this.listKeyManager.activeItem.active = true;\n            }\n            this.activeOption = this.listKeyManager.activeItem;\n            this.multiSelectOptionsContent.notifyOnChanges();\n          });\n\n        if (!this.listKeyManager.activeItem) {\n          this.setFirstItemActive();\n        }\n      });\n  }\n\n  get firstFocusableItem() {\n    return this.multiSelectOptionsContent?.find(option => option.visible && !option.disabled);\n  }\n\n  private setFirstItemActive() {\n    const firstFocusableItem = this.firstFocusableItem;\n    firstFocusableItem ? this.listKeyManager?.setActiveItem(firstFocusableItem) : this.listKeyManager?.setFirstItemActive();\n    this.activeOption = this.listKeyManager?.activeItem ?? null;\n  }\n\n  updateActiveItem(index: number): void;\n\n  updateActiveItem<T extends (MultiSelectOptionComponent & FocusableOption)>(item: T): void;\n\n  updateActiveItem(item: any) {\n    const firstFocusableItem = this.firstFocusableItem ?? item;\n    firstFocusableItem ? this.listKeyManager?.updateActiveItem(firstFocusableItem) : this.listKeyManager?.updateActiveItem(0);\n    if (this.listKeyManager?.activeItem) {\n      this.multiSelectOptionsContent?.forEach(option => {\n        option.active = false;\n      });\n      this.listKeyManager.activeItem.active = true;\n    }\n    this.activeOption = this.listKeyManager?.activeItem ?? null;\n  }\n}\n","<c-dropdown #dropdown=\"cDropdown\"\n            [(visible)]=\"visible\"\n            [autoClose]=\"'outside'\"\n            [ngClass]=\"multiselectClasses\"\n            [popperOptions]=\"popperjsOptions\"\n            class=\"picker\">\n  <div #dropdownToggle=\"cDropdownToggle\" [caret]=\"false\" [disabled]=\"disabled\" cDropdownToggle>\n    <div class=\"form-multi-select-selection\">\n      <ng-template [ngIf]=\"selectionType === 'tags'\">\n        <ng-container *ngIf=\"(optionsSelected$ | async) as optionTags\">\n          <c-multi-select-tag\n            (remove)=\"handleTagRemove($event)\"\n            *ngFor=\"let option of optionTags; index as i\"\n            [disabled]=\"option.disabled ?? false\"\n            [label]=\"option.label\"\n            [option]=\"option\"\n            [value]=\"option.value\"\n            class=\"form-multi-select-tag\"\n            tabindex=\"-1\">\n          </c-multi-select-tag>\n        </ng-container>\n      </ng-template>\n      <ng-template [ngIf]=\"selectionType === 'text' && !!selectedOptionsText\">\n        <span class=\"form-multi-select-search\">{{ selectedOptionsText }}</span>\n      </ng-template>\n      <ng-template [ngIf]=\"selectionType === 'counter'\">\n        <span *ngIf=\"counterTextType === 'string'; else pluralMap\">{{ counterText }}</span>\n        <ng-template #pluralMap>\n          <span>{{selectedOptions.length}} {{ selectedOptions.length | i18nPlural: selectionTypeCounterTextPluralMap ?? { other: counterText } }}</span>\n        </ng-template>\n      </ng-template>\n      <!--      <ng-template [ngIf]=\"!search && selectedOptions.length === 0 && selectionType !== 'counter'\">-->\n      <!--        <span class=\"form-multi-select-search\">{{ placeholder }}</span>-->\n      <!--      </ng-template>-->\n    </div>\n\n    <input\n      #inputElement\n      (keydown)=\"handleSearchKeyDown($event)\"\n      (valueChange)=\"handleSearchValueChange($event)\"\n      [attr.placeholder]=\"optionsSelected.size === 0 && selectionType !== 'counter' ? placeholder : null\"\n      [disabled]=\"disabled || !search\"\n      [ngClass]=\"{ 'form-multi-select-search': true, disabled: (disabled || !search) }\"\n      [ngModel]=\"searchValue\"\n      [value]=\"searchValue\"\n      autocomplete=\"off\"\n      cMultiSelectSearch\n      size=\"3\"\n      tabindex=\"{{ disabled ? -1 : 0 }}\"\n      type=\"text\"\n    >\n\n    <button\n      (click)=\"clearAllOptions($event)\"\n      *ngIf=\"cleaner && optionsSelected.size > 0 && !disabled\"\n      [disabled]=\"disabled || !isDropdownVisible\"\n      aria-label=\"Clear all\"\n      class=\"form-multi-select-selection-cleaner\"\n    ></button>\n  </div>\n  <div #dropdownMenu=\"cDropdownMenu\" *ngIf=\"!disabled\" [visible]=\"dropdown.visible\" cDropdownMenu>\n    <ng-template [ngIfElse]=\"optionsEmpty\" [ngIf]=\"visibleOptions > 0 && options.length > 0\">\n      <button (click)=\"selectAllOptions()\"\n              *ngIf=\"selectAll && multiple && !virtualScroller\"\n              class=\"form-multi-select-all\"\n      >\n        {{ selectAllLabel }}\n      </button>\n      <ng-container\n        *ngTemplateOutlet=\"virtualScroller ? multiselectVirtualScroller : multiselectOptionsDiv\"></ng-container>\n    </ng-template>\n    <ng-template #optionsEmpty>\n      <div class=\"form-multi-select-options-empty\">{{ searchNoResultsLabel }}</div>\n    </ng-template>\n  </div>\n</c-dropdown>\n\n<ng-template #multiselectVirtualScroller>\n  <cdk-virtual-scroll-viewport\n    #scrollViewport\n    (scrolledIndexChange)=\"handleScrolledIndexChange($event, scrollViewport)\"\n    *ngIf=\"optionsArray$ | async as optionsArray\"\n    [itemSize]=\"itemSize\"\n    [ngStyle]=\"optionsMaxHeight !== 'auto' ? { 'height.px': optionsMaxHeight, 'maxHeight.px': optionsMaxHeight, 'minWidth.px': itemMinWidth ?? 196, overflowX: 'hidden' } : { 'minWidth.px': itemMinWidth ?? 196, overflowX: 'hidden'}\"\n    maxBufferPx=\"{{itemSize * visibleItems}}\"\n    minBufferPx=\"{{itemSize * visibleItems}}\"\n  >\n    <ng-container\n      #cdkVirtualFor\n      *cdkVirtualFor=\"let option of optionsArray; trackBy: trackByFn; templateCacheSize: 0; even as even; odd as odd; index as index; count as count; first as first; last as last;\"\n      [ngTemplateOutletContext]=\"{$implicit: option, even, odd, index, count, first, last}\"\n      [ngTemplateOutlet]=\"templates['multiSelectOptionTemplate'] || defaultMultiSelectOptionTemplate\"\n    >\n    </ng-container>\n  </cdk-virtual-scroll-viewport>\n\n</ng-template>\n\n<ng-template #multiselectOptionsDiv>\n  <div\n    [ngStyle]=\"optionsMaxHeight !== 'auto' ? { 'maxHeight.px': optionsMaxHeight, overflowY: 'scroll' } : {}\"\n    class=\"form-multi-select-options\"\n  >\n    <ng-content></ng-content>\n  </div>\n</ng-template>\n\n<ng-template #defaultMultiSelectOptionTemplate let-option>\n  <c-multi-select-option\n    [disabled]=\"option.disabled\"\n    [label]=\"option.label\"\n    [selected]=\"option.selected\"\n    [text]=\"option.text\"\n    [value]=\"option.value\"\n    [visible]=\"option.visible\"\n  >\n    {{option.text}}\n  </c-multi-select-option>\n</ng-template>\n"]}