@marcura/marcura-combobox 6.1.0 → 6.1.1

package/esm2020/lib/components/abstract-combobox/abstract-combobox.component.mjs

@@ -1,241 +1,241 @@
-import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Input, Output, Renderer2, } from '@angular/core';
-import { isFalse, Is, Observer, Worker, flatten } from '@marcura/marcura-common';
-import { combineLatest, BehaviorSubject } from 'rxjs';
-import { debounceTime, distinctUntilChanged, filter, map, skip, tap } from 'rxjs/operators';
-import { AbstractDropdownComponent } from '../../components/abstract-dropdown/abstract-dropdown.component';
-import { ComboboxSearchSettingsOperator } from '../../model/combobox-search-settings-operator.enum';
-import * as i0 from "@angular/core";
-export class AbstractComboboxComponent extends AbstractDropdownComponent {
-    get debounceTime() {
-        return this._debounceTime;
-    }
-    set debounceTime(value) {
-        this._debounceTime = value;
-        this._listenToSearched();
-    }
-    get items() {
-        return this._items;
-    }
-    set items(items) {
-        this._isSync = true;
-        this._items = items || [];
-        this._listenToSearched();
-        this._loadedItems.next(this._items);
-    }
-    get additionalItems() {
-        return this._additionalItems.value;
-    }
-    set additionalItems(additionalItems) {
-        this._additionalItems.next(additionalItems || []);
-    }
-    _disableChromeAutocomplete() {
-        if (this._component.searchbar && this._component.searchbar.input) {
-            this._renderer.setAttribute(this._component.searchbar.input.nativeElement, 'autocomplete', 'disabled');
-        }
-    }
-    _listenToSearched() {
-        this._debounceObserver.clear();
-        this._debounceObserver.listen(this._searchText.pipe(distinctUntilChanged(), skip(1), tap((searchText) => {
-            this.searched.emit(searchText);
-            this._isSearching.next(this.canLoadItems(searchText) && this._isOpen.value.isOpen);
-        }), debounceTime(this._isSync ? 0 : this.debounceTime), filter(() => this._isOpen.value.isOpen)), this.loadItems);
-    }
-    _filterItems(items, searchText) {
-        if (!items || !items.length) {
-            return [];
-        }
-        // TODO: technical-debt - fix group result case to avoid any
-        return items.filter((item) => {
-            let itemText = (item[this.textField] || '').toString().trim() ?? '';
-            itemText = this.searchSettings.isCaseSensitive ? itemText : itemText.toLowerCase();
-            return this.searchSettings.operator === ComboboxSearchSettingsOperator.Contains
-                ? itemText.indexOf(searchText) !== -1
-                : itemText.substring(0, searchText.length) === searchText;
-        });
-    }
-    _setComponent(component) {
-        this._component = component;
-        this._disableChromeAutocomplete();
-    }
-    searchItems(searchText) {
-        if (!this.searchSettings || !searchText || !this._items.length) {
-            return this._items;
-        }
-        searchText = this.searchSettings.isCaseSensitive ? searchText : searchText.toLowerCase();
-        if (this.isGroupable) {
-            const groups = this._items;
-            const filteredGroups = groups
-                .map((group) => ({
-                ...group,
-                items: this._filterItems(group.items, searchText),
-            }))
-                .filter((group) => group.items.length > 0);
-            return filteredGroups;
-        }
-        return this._filterItems(this._items, searchText);
-    }
-    canLoadItems(searchText) {
-        return searchText.length >= this.minSearchCharacters && !this._isSync;
-    }
-    getItem(items, text) {
-        text = text.toLowerCase();
-        return this._unwrapGroups(items).find((item) => `${item[this.textField]}`.toLowerCase() === text) ?? null;
-    }
-    _unwrapGroups(items) {
-        return flatten(items.map(item => this._isGroupResult(item) ? item.items : [item]));
-    }
-    _isGroupResult(item) {
-        const object = item;
-        return object.items !== undefined && object.aggregates !== undefined && object.field !== undefined && object.value !== undefined;
-    }
-    isItemEqual(item1, item2) {
-        const isItem1Empty = item1 === null || item1 === undefined;
-        const isItem2Empty = item2 === null || item2 === undefined;
-        if (isItem1Empty && isItem2Empty) {
-            return true;
-        }
-        if (isItem1Empty || isItem2Empty) {
-            return false;
-        }
-        return this.isPrimitiveValue ? item1 === item2 : item1[this.valueField] === item2[this.valueField];
-    }
-    constructor(changeDetectorRef, _renderer) {
-        super(changeDetectorRef);
-        this._renderer = _renderer;
-        this._debounceTime = 500;
-        this._debounceObserver = new Observer();
-        this._worker = new Worker();
-        this._additionalItems = new BehaviorSubject([]);
-        this._valueNormalizerItems = [];
-        this._isSync = false;
-        this._loadedItems = new BehaviorSubject([]);
-        this._hasSearched = new BehaviorSubject(false);
-        this._isSearching = new BehaviorSubject(false);
-        this._searchText = new BehaviorSubject('');
-        this.combinedItems = combineLatest([this._loadedItems, this._additionalItems]).pipe(map(([items, additionalItems]) => [...items, ...additionalItems].filter(Is.truthy)));
-        this.isSearchable = true;
-        this.minSearchCharacters = 1;
-        this.search = null;
-        this.areItemsCached = false;
-        this.searchSettings = {
-            isCaseSensitive: false,
-            operator: ComboboxSearchSettingsOperator.Contains,
-        };
-        this.isGroupable = false;
-        this.searched = new EventEmitter();
-        this.isNoItemsTextVisible = combineLatest([
-            this._isSearching,
-            this._hasSearched,
-            this._isFocused,
-            this.combinedItems,
-        ]).pipe(map(([isSearching, hasSearched, isFocused, combinedItems]) => {
-            return !isSearching && hasSearched && isFocused && combinedItems.length === 0;
-        }));
-        this.isMinSearchTextVisible = combineLatest([
-            this._isSearching,
-            this._hasSearched,
-            this._isFocused,
-        ]).pipe(map(([isSearching, hasSearched, isFocused]) => {
-            return !this._isSync && !isSearching && !hasSearched && isFocused;
-        }));
-        this.isLoadingSpinnerVisible = combineLatest([
-            this._isLoading,
-            this._isSearching,
-        ]).pipe(map(([isLoading, isSearching]) => isLoading || isSearching));
-        // To show loading properly we are to use loadedItems as they don't include additionalItems.
-        this.isLoadingTextVisible = combineLatest([
-            this.isLoadingSpinnerVisible,
-            this._loadedItems,
-        ]).pipe(map(([isLoadingSpinnerVisible, loadedItems]) => isLoadingSpinnerVisible && loadedItems.length === 0));
-        this.loadItems = (searchText) => {
-            searchText = (searchText || '').trim();
-            if (this._isSync) {
-                this._hasSearched.next(!!searchText);
-                this._loadedItems.next(this.searchItems(searchText));
-            }
-            else {
-                if (this.canLoadItems(searchText)) {
-                    this._isSearching.next(true);
-                    this._worker.handle(this.search ? this.search(searchText) : new BehaviorSubject([]), (items) => {
-                        this._hasSearched.next(true);
-                        this._loadedItems.next(items);
-                        this._valueNormalizerItems = [...items, ...this._additionalItems.value];
-                        this._isSearching.next(false);
-                    });
-                }
-                else {
-                    this._hasSearched.next(false);
-                    this._loadedItems.next([]);
-                    this._valueNormalizerItems = [];
-                    this._isSearching.next(false);
-                }
-            }
-        };
-    }
-    ngOnDestroy() {
-        this._debounceObserver.destroy();
-        this._worker.destroy();
-        super.ngOnDestroy();
-    }
-    init() {
-        super.init();
-        this._listenToSearched();
-        if (this._isSync) {
-            this._loadedItems.next(this._items);
-        }
-        // Closed.
-        this._observer.listen(this._isOpen.pipe(filter((event) => !event.isOpen), skip(1)), (event) => {
-            if (!this.areItemsCached && !this._isSync) {
-                this._loadedItems.next([]);
-            }
-            this._worker.cancel();
-            this._isSearching.next(false);
-            if (event.shouldEmit) {
-                this.closed.emit();
-            }
-        });
-        // Blurred.
-        this._observer.listen(this._isFocused.pipe(filter(isFalse)), () => {
-            // Restore original unfiltered items when the component is blurred
-            // after some search text entered. Consider a case:
-            // 1. Search with text that gives 0 items.
-            // 2. Blur and focus.
-            // 3. Search text is cleared, but items remain empty, so the list won't show up.
-            this._loadedItems.next(this._items);
-            this._hasSearched.next(false);
-        });
-    }
-    onSearched(searchText) {
-        this._searchText.next(searchText);
-    }
-}
-AbstractComboboxComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AbstractComboboxComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
-AbstractComboboxComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.1.0", type: AbstractComboboxComponent, selector: "ng-component", inputs: { isSearchable: "isSearchable", minSearchCharacters: "minSearchCharacters", search: "search", areItemsCached: "areItemsCached", debounceTime: "debounceTime", items: "items", additionalItems: "additionalItems", searchSettings: "searchSettings", isGroupable: "isGroupable" }, outputs: { searched: "searched" }, usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AbstractComboboxComponent, decorators: [{
-            type: Component,
-            args: [{
-                    template: '',
-                    changeDetection: ChangeDetectionStrategy.OnPush,
-                }]
-        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.Renderer2 }]; }, propDecorators: { isSearchable: [{
-                type: Input
-            }], minSearchCharacters: [{
-                type: Input
-            }], search: [{
-                type: Input
-            }], areItemsCached: [{
-                type: Input
-            }], debounceTime: [{
-                type: Input
-            }], items: [{
-                type: Input
-            }], additionalItems: [{
-                type: Input
-            }], searchSettings: [{
-                type: Input
-            }], isGroupable: [{
-                type: Input
-            }], searched: [{
-                type: Output
-            }] } });
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Input, Output, Renderer2, } from '@angular/core';
+import { isFalse, Is, Observer, Worker, flatten } from '@marcura/marcura-common';
+import { combineLatest, BehaviorSubject } from 'rxjs';
+import { debounceTime, distinctUntilChanged, filter, map, skip, tap } from 'rxjs/operators';
+import { AbstractDropdownComponent } from '../../components/abstract-dropdown/abstract-dropdown.component';
+import { ComboboxSearchSettingsOperator } from '../../model/combobox-search-settings-operator.enum';
+import * as i0 from "@angular/core";
+export class AbstractComboboxComponent extends AbstractDropdownComponent {
+    get debounceTime() {
+        return this._debounceTime;
+    }
+    set debounceTime(value) {
+        this._debounceTime = value;
+        this._listenToSearched();
+    }
+    get items() {
+        return this._items;
+    }
+    set items(items) {
+        this._isSync = true;
+        this._items = items || [];
+        this._listenToSearched();
+        this._loadedItems.next(this._items);
+    }
+    get additionalItems() {
+        return this._additionalItems.value;
+    }
+    set additionalItems(additionalItems) {
+        this._additionalItems.next(additionalItems || []);
+    }
+    _disableChromeAutocomplete() {
+        if (this._component.searchbar && this._component.searchbar.input) {
+            this._renderer.setAttribute(this._component.searchbar.input.nativeElement, 'autocomplete', 'disabled');
+        }
+    }
+    _listenToSearched() {
+        this._debounceObserver.clear();
+        this._debounceObserver.listen(this._searchText.pipe(distinctUntilChanged(), skip(1), tap((searchText) => {
+            this.searched.emit(searchText);
+            this._isSearching.next(this.canLoadItems(searchText) && this._isOpen.value.isOpen);
+        }), debounceTime(this._isSync ? 0 : this.debounceTime), filter(() => this._isOpen.value.isOpen)), this.loadItems);
+    }
+    _filterItems(items, searchText) {
+        if (!items || !items.length) {
+            return [];
+        }
+        // TODO: technical-debt - fix group result case to avoid any
+        return items.filter((item) => {
+            let itemText = (item[this.textField] || '').toString().trim() ?? '';
+            itemText = this.searchSettings.isCaseSensitive ? itemText : itemText.toLowerCase();
+            return this.searchSettings.operator === ComboboxSearchSettingsOperator.Contains
+                ? itemText.indexOf(searchText) !== -1
+                : itemText.substring(0, searchText.length) === searchText;
+        });
+    }
+    _setComponent(component) {
+        this._component = component;
+        this._disableChromeAutocomplete();
+    }
+    searchItems(searchText) {
+        if (!this.searchSettings || !searchText || !this._items.length) {
+            return this._items;
+        }
+        searchText = this.searchSettings.isCaseSensitive ? searchText : searchText.toLowerCase();
+        if (this.isGroupable) {
+            const groups = this._items;
+            const filteredGroups = groups
+                .map((group) => ({
+                ...group,
+                items: this._filterItems(group.items, searchText),
+            }))
+                .filter((group) => group.items.length > 0);
+            return filteredGroups;
+        }
+        return this._filterItems(this._items, searchText);
+    }
+    canLoadItems(searchText) {
+        return searchText.length >= this.minSearchCharacters && !this._isSync;
+    }
+    getItem(items, text) {
+        text = text.toLowerCase();
+        return this._unwrapGroups(items).find((item) => `${item[this.textField]}`.toLowerCase() === text) ?? null;
+    }
+    _unwrapGroups(items) {
+        return flatten(items.map(item => this._isGroupResult(item) ? item.items : [item]));
+    }
+    _isGroupResult(item) {
+        const object = item;
+        return object.items !== undefined && object.aggregates !== undefined && object.field !== undefined && object.value !== undefined;
+    }
+    isItemEqual(item1, item2) {
+        const isItem1Empty = item1 === null || item1 === undefined;
+        const isItem2Empty = item2 === null || item2 === undefined;
+        if (isItem1Empty && isItem2Empty) {
+            return true;
+        }
+        if (isItem1Empty || isItem2Empty) {
+            return false;
+        }
+        return this.isPrimitiveValue ? item1 === item2 : item1[this.valueField] === item2[this.valueField];
+    }
+    constructor(changeDetectorRef, _renderer) {
+        super(changeDetectorRef);
+        this._renderer = _renderer;
+        this._debounceTime = 500;
+        this._debounceObserver = new Observer();
+        this._worker = new Worker();
+        this._additionalItems = new BehaviorSubject([]);
+        this._valueNormalizerItems = [];
+        this._isSync = false;
+        this._loadedItems = new BehaviorSubject([]);
+        this._hasSearched = new BehaviorSubject(false);
+        this._isSearching = new BehaviorSubject(false);
+        this._searchText = new BehaviorSubject('');
+        this.combinedItems = combineLatest([this._loadedItems, this._additionalItems]).pipe(map(([items, additionalItems]) => [...items, ...additionalItems].filter(Is.truthy)));
+        this.isSearchable = true;
+        this.minSearchCharacters = 1;
+        this.search = null;
+        this.areItemsCached = false;
+        this.searchSettings = {
+            isCaseSensitive: false,
+            operator: ComboboxSearchSettingsOperator.Contains,
+        };
+        this.isGroupable = false;
+        this.searched = new EventEmitter();
+        this.isNoItemsTextVisible = combineLatest([
+            this._isSearching,
+            this._hasSearched,
+            this._isFocused,
+            this.combinedItems,
+        ]).pipe(map(([isSearching, hasSearched, isFocused, combinedItems]) => {
+            return !isSearching && hasSearched && isFocused && combinedItems.length === 0;
+        }));
+        this.isMinSearchTextVisible = combineLatest([
+            this._isSearching,
+            this._hasSearched,
+            this._isFocused,
+        ]).pipe(map(([isSearching, hasSearched, isFocused]) => {
+            return !this._isSync && !isSearching && !hasSearched && isFocused;
+        }));
+        this.isLoadingSpinnerVisible = combineLatest([
+            this._isLoading,
+            this._isSearching,
+        ]).pipe(map(([isLoading, isSearching]) => isLoading || isSearching));
+        // To show loading properly we are to use loadedItems as they don't include additionalItems.
+        this.isLoadingTextVisible = combineLatest([
+            this.isLoadingSpinnerVisible,
+            this._loadedItems,
+        ]).pipe(map(([isLoadingSpinnerVisible, loadedItems]) => isLoadingSpinnerVisible && loadedItems.length === 0));
+        this.loadItems = (searchText) => {
+            searchText = (searchText || '').trim();
+            if (this._isSync) {
+                this._hasSearched.next(!!searchText);
+                this._loadedItems.next(this.searchItems(searchText));
+            }
+            else {
+                if (this.canLoadItems(searchText)) {
+                    this._isSearching.next(true);
+                    this._worker.handle(this.search ? this.search(searchText) : new BehaviorSubject([]), (items) => {
+                        this._hasSearched.next(true);
+                        this._loadedItems.next(items);
+                        this._valueNormalizerItems = [...items, ...this._additionalItems.value];
+                        this._isSearching.next(false);
+                    });
+                }
+                else {
+                    this._hasSearched.next(false);
+                    this._loadedItems.next([]);
+                    this._valueNormalizerItems = [];
+                    this._isSearching.next(false);
+                }
+            }
+        };
+    }
+    ngOnDestroy() {
+        this._debounceObserver.destroy();
+        this._worker.destroy();
+        super.ngOnDestroy();
+    }
+    init() {
+        super.init();
+        this._listenToSearched();
+        if (this._isSync) {
+            this._loadedItems.next(this._items);
+        }
+        // Closed.
+        this._observer.listen(this._isOpen.pipe(filter((event) => !event.isOpen), skip(1)), (event) => {
+            if (!this.areItemsCached && !this._isSync) {
+                this._loadedItems.next([]);
+            }
+            this._worker.cancel();
+            this._isSearching.next(false);
+            if (event.shouldEmit) {
+                this.closed.emit();
+            }
+        });
+        // Blurred.
+        this._observer.listen(this._isFocused.pipe(filter(isFalse)), () => {
+            // Restore original unfiltered items when the component is blurred
+            // after some search text entered. Consider a case:
+            // 1. Search with text that gives 0 items.
+            // 2. Blur and focus.
+            // 3. Search text is cleared, but items remain empty, so the list won't show up.
+            this._loadedItems.next(this._items);
+            this._hasSearched.next(false);
+        });
+    }
+    onSearched(searchText) {
+        this._searchText.next(searchText);
+    }
+}
+AbstractComboboxComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AbstractComboboxComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+AbstractComboboxComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.1.0", type: AbstractComboboxComponent, selector: "ng-component", inputs: { isSearchable: "isSearchable", minSearchCharacters: "minSearchCharacters", search: "search", areItemsCached: "areItemsCached", debounceTime: "debounceTime", items: "items", additionalItems: "additionalItems", searchSettings: "searchSettings", isGroupable: "isGroupable" }, outputs: { searched: "searched" }, usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: AbstractComboboxComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.Renderer2 }]; }, propDecorators: { isSearchable: [{
+                type: Input
+            }], minSearchCharacters: [{
+                type: Input
+            }], search: [{
+                type: Input
+            }], areItemsCached: [{
+                type: Input
+            }], debounceTime: [{
+                type: Input
+            }], items: [{
+                type: Input
+            }], additionalItems: [{
+                type: Input
+            }], searchSettings: [{
+                type: Input
+            }], isGroupable: [{
+                type: Input
+            }], searched: [{
+                type: Output
+            }] } });
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-combobox.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/abstract-combobox/abstract-combobox.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  Output,\n  Renderer2,\n} from '@angular/core';\nimport {ControlValueAccessor} from '@angular/forms';\nimport {isFalse, Is, Observer, Worker, ControlChangedEvent, flatten} from '@marcura/marcura-common';\nimport {GroupResult} from '@progress/kendo-data-query';\nimport {combineLatest, BehaviorSubject, Observable} from 'rxjs';\nimport {debounceTime, distinctUntilChanged, filter, map, skip, tap} from 'rxjs/operators';\nimport {AbstractDropdownComponent} from '../../components/abstract-dropdown/abstract-dropdown.component';\nimport {IComboboxKendoComponent} from '../../model/combobox-kendo-component.interface';\nimport {ComboboxSearchFn} from '../../model/combobox-search-fn.type';\nimport {ComboboxSearchSettingsOperator} from '../../model/combobox-search-settings-operator.enum';\nimport {IComboboxSearchSettings} from '../../model/combobox-search-settings.interface';\nimport {ComboboxItem} from '../../model/combobox-item.type';\n\n@Component({\n  template: '',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class AbstractComboboxComponent<TItem, TValue, TChangedEvent extends ControlChangedEvent<TValue> = ControlChangedEvent<TValue>>\n  extends AbstractDropdownComponent<TItem, TValue, IComboboxKendoComponent, TChangedEvent>\n  implements ControlValueAccessor, OnDestroy {\n  private _debounceTime: number = 500;\n  private readonly _debounceObserver: Observer = new Observer();\n  private readonly _worker: Worker = new Worker();\n  private readonly _additionalItems: BehaviorSubject<ComboboxItem<TItem>[]> = new BehaviorSubject<ComboboxItem<TItem>[]>([]);\n  protected _valueNormalizerItems: (TItem | GroupResult)[] = [];\n  protected _isSync: boolean = false;\n  protected readonly _loadedItems: BehaviorSubject<ComboboxItem<TItem>[]> = new BehaviorSubject<ComboboxItem<TItem>[]>([]);\n  protected readonly _hasSearched: BehaviorSubject<boolean> = new BehaviorSubject(false);\n  protected readonly _isSearching: BehaviorSubject<boolean> = new BehaviorSubject(false);\n  protected readonly _searchText: BehaviorSubject<string> = new BehaviorSubject('');\n  public readonly combinedItems: Observable<(TItem | GroupResult)[]> = combineLatest([this._loadedItems, this._additionalItems]).pipe(\n    map(([items, additionalItems]): (TItem | GroupResult)[] => [...items, ...additionalItems].filter(Is.truthy) as (TItem | GroupResult)[])\n  );\n  @Input()\n  public isSearchable: boolean = true;\n  @Input()\n  public minSearchCharacters: number = 1;\n  @Input()\n  public search: ComboboxSearchFn<TItem> | null = null;\n  @Input()\n  public areItemsCached: boolean = false;\n  @Input()\n  public get debounceTime(): number {\n    return this._debounceTime;\n  }\n  public set debounceTime(value: number) {\n    this._debounceTime = value;\n    this._listenToSearched();\n  }\n  @Input()\n  public override get items(): ComboboxItem<TItem>[] {\n    return this._items;\n  }\n  public override set items(items: ComboboxItem<TItem>[]) {\n    this._isSync = true;\n    this._items = items || [];\n    this._listenToSearched();\n    this._loadedItems.next(this._items);\n  }\n  @Input()\n  public get additionalItems(): ComboboxItem<TItem>[] {\n    return this._additionalItems.value;\n  }\n  public set additionalItems(additionalItems: ComboboxItem<TItem>[]) {\n    this._additionalItems.next(additionalItems || []);\n  }\n  @Input()\n  public searchSettings: IComboboxSearchSettings = {\n    isCaseSensitive: false,\n    operator: ComboboxSearchSettingsOperator.Contains,\n  };\n  @Input()\n  public isGroupable: boolean = false;\n  @Output()\n  public searched: EventEmitter<string> = new EventEmitter();\n  public readonly isNoItemsTextVisible: Observable<boolean> = combineLatest([\n    this._isSearching,\n    this._hasSearched,\n    this._isFocused,\n    this.combinedItems,\n  ]).pipe(\n    map(([isSearching, hasSearched, isFocused, combinedItems]) => {\n      return !isSearching && hasSearched && isFocused && combinedItems.length === 0;\n    })\n  );\n  public readonly isMinSearchTextVisible: Observable<boolean> = combineLatest([\n    this._isSearching,\n    this._hasSearched,\n    this._isFocused,\n  ]).pipe(\n    map(([isSearching, hasSearched, isFocused]) => {\n      return !this._isSync && !isSearching && !hasSearched && isFocused;\n    })\n  );\n  public readonly isLoadingSpinnerVisible: Observable<boolean> = combineLatest([\n    this._isLoading,\n    this._isSearching,\n  ]).pipe(map(([isLoading, isSearching]) => isLoading || isSearching));\n  // To show loading properly we are to use loadedItems as they don't include additionalItems.\n  public readonly isLoadingTextVisible: Observable<boolean> = combineLatest([\n    this.isLoadingSpinnerVisible,\n    this._loadedItems,\n  ]).pipe(map(([isLoadingSpinnerVisible, loadedItems]) => isLoadingSpinnerVisible && loadedItems.length === 0));\n\n  private _disableChromeAutocomplete(): void {\n    if (this._component.searchbar && this._component.searchbar.input) {\n      this._renderer.setAttribute(this._component.searchbar.input.nativeElement, 'autocomplete', 'disabled');\n    }\n  }\n\n  private _listenToSearched(): void {\n    this._debounceObserver.clear();\n    this._debounceObserver.listen(\n      this._searchText.pipe(\n        distinctUntilChanged(),\n        skip(1),\n        tap((searchText) => {\n          this.searched.emit(searchText);\n          this._isSearching.next(this.canLoadItems(searchText) && this._isOpen.value.isOpen);\n        }),\n        debounceTime(this._isSync ? 0 : this.debounceTime),\n        filter(() => this._isOpen.value.isOpen)\n      ),\n      this.loadItems\n    );\n  }\n\n  private _filterItems(items: ComboboxItem<TItem>[], searchText: string): TItem[] {\n    if (!items || !items.length) {\n      return [];\n    }\n\n    // TODO: technical-debt - fix group result case to avoid any\n    return (items as any[]).filter((item) => {\n      let itemText: string = (item[this.textField] || '').toString().trim() ?? '';\n      itemText = this.searchSettings.isCaseSensitive ? itemText : itemText.toLowerCase();\n\n      return this.searchSettings.operator === ComboboxSearchSettingsOperator.Contains\n        ? itemText.indexOf(searchText) !== -1\n        : itemText.substring(0, searchText.length) === searchText;\n    });\n  }\n\n  protected override _setComponent(component: IComboboxKendoComponent): void {\n    this._component = component;\n    this._disableChromeAutocomplete();\n  }\n\n  protected searchItems(searchText: string): ComboboxItem<TItem>[] {\n    if (!this.searchSettings || !searchText || !this._items.length) {\n      return this._items;\n    }\n\n    searchText = this.searchSettings.isCaseSensitive ? searchText : searchText.toLowerCase();\n\n    if (this.isGroupable) {\n      const groups: GroupResult[] = <any>this._items;\n      const filteredGroups: GroupResult[] = groups\n        .map((group): GroupResult => ({\n          ...group,\n          items: this._filterItems(<TItem[]>group.items, searchText) as any,\n        }))\n        .filter((group) => group.items.length > 0);\n\n      return <any>filteredGroups;\n    }\n\n    return this._filterItems(this._items, searchText);\n  }\n\n  protected canLoadItems(searchText: string): boolean {\n    return searchText.length >= this.minSearchCharacters && !this._isSync;\n  }\n\n  protected getItem(items: (TItem | GroupResult)[], text: string): TItem | null {\n    text = text.toLowerCase();\n    return this._unwrapGroups(items).find((item) => `${item[this.textField]}`.toLowerCase() === text) ?? null;\n  }\n\n  private _unwrapGroups(items: (TItem | GroupResult)[]): TItem[] {\n    return flatten(\n      items.map(item => this._isGroupResult(item) ? item.items as TItem[] : [item])\n    );\n  }\n\n  private _isGroupResult(item: TItem | GroupResult): item is GroupResult {\n    const object: any = item;\n    return object.items !== undefined && object.aggregates !== undefined && object.field !== undefined && object.value !== undefined;\n  }\n\n  protected isItemEqual(item1: TItem | null | undefined, item2: TItem | null | undefined): boolean {\n    const isItem1Empty: boolean = item1 === null || item1 === undefined;\n    const isItem2Empty: boolean = item2 === null || item2 === undefined;\n\n    if (isItem1Empty && isItem2Empty) {\n      return true;\n    }\n\n    if (isItem1Empty || isItem2Empty) {\n      return false;\n    }\n\n    return this.isPrimitiveValue ? item1 === item2 : item1![this.valueField] === item2![this.valueField];\n  }\n\n  protected loadItems = (searchText?: string): void => {\n    searchText = (searchText || '').trim();\n\n    if (this._isSync) {\n      this._hasSearched.next(!!searchText);\n      this._loadedItems.next(this.searchItems(searchText));\n    } else {\n      if (this.canLoadItems(searchText)) {\n        this._isSearching.next(true);\n        this._worker.handle(this.search ? this.search(searchText) : new BehaviorSubject([]), (items) => {\n          this._hasSearched.next(true);\n          this._loadedItems.next(items);\n          this._valueNormalizerItems = [...items, ...this._additionalItems.value] as (TItem | GroupResult)[];\n          this._isSearching.next(false);\n        });\n      } else {\n        this._hasSearched.next(false);\n        this._loadedItems.next([]);\n        this._valueNormalizerItems = [];\n        this._isSearching.next(false);\n      }\n    }\n  };\n\n  public constructor(changeDetectorRef: ChangeDetectorRef, protected readonly _renderer: Renderer2) {\n    super(changeDetectorRef);\n  }\n\n  public override ngOnDestroy(): void {\n    this._debounceObserver.destroy();\n    this._worker.destroy();\n    super.ngOnDestroy();\n  }\n\n  public override init(): void {\n    super.init();\n    this._listenToSearched();\n\n    if (this._isSync) {\n      this._loadedItems.next(this._items);\n    }\n\n    // Closed.\n    this._observer.listen(\n      this._isOpen.pipe(\n        filter((event) => !event.isOpen),\n        skip(1)\n      ),\n      (event) => {\n        if (!this.areItemsCached && !this._isSync) {\n          this._loadedItems.next([]);\n        }\n\n        this._worker.cancel();\n        this._isSearching.next(false);\n\n        if (event.shouldEmit) {\n          this.closed.emit();\n        }\n      }\n    );\n\n    // Blurred.\n    this._observer.listen(this._isFocused.pipe(filter(isFalse)), () => {\n      // Restore original unfiltered items when the component is blurred\n      // after some search text entered. Consider a case:\n      // 1. Search with text that gives 0 items.\n      // 2. Blur and focus.\n      // 3. Search text is cleared, but items remain empty, so the list won't show up.\n      this._loadedItems.next(this._items);\n      this._hasSearched.next(false);\n    });\n  }\n\n  public onSearched(searchText: string): void {\n    this._searchText.next(searchText);\n  }\n}\n"]}