@marcura/marcura-combobox 4.6.2 → 6.0.0

package/esm2020/lib/combobox.module.mjs

@@ -0,0 +1,103 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ReactiveFormsModule } from '@angular/forms';
+import { TagModule } from '@marcura/marcura-tag';
+import { ComboBoxModule, DropDownListModule, MultiSelectModule } from '@progress/kendo-angular-dropdowns';
+import { PopupModule, POPUP_CONTAINER } from '@progress/kendo-angular-popup';
+import { ComboboxItemTemplateDirective } from '../lib/directives/combobox-item-template.directive';
+import { DropdownItemTemplateDirective } from '../lib/directives/dropdown-item-template.directive';
+import { DropdownValueTemplateDirective } from '../lib/directives/dropdown-value-template.directive';
+import { MultiselectItemTemplateDirective } from '../lib/directives/multiselect-item-template.directive';
+import { MultiselectTagTemplateDirective } from '../lib/directives/multiselect-tag-template.directive';
+import { MultiselectTagWrapperDirective } from '../lib/directives/multiselect-tag-wrapper.directive';
+import { AbstractComboboxComponent } from './components/abstract-combobox/abstract-combobox.component';
+import { AbstractDropdownComponent } from './components/abstract-dropdown/abstract-dropdown.component';
+import { ComboboxPopupFooterComponent } from './components/combobox-popup-footer/combobox-popup-footer.component';
+import { ComboboxComponent } from './components/combobox/combobox.component';
+import { DropdownComponent } from './components/dropdown/dropdown.component';
+import { MultiselectComponent } from './components/multiselect/multiselect.component';
+import * as i0 from "@angular/core";
+const components = [
+    AbstractComboboxComponent,
+    AbstractDropdownComponent,
+    ComboboxComponent,
+    ComboboxPopupFooterComponent,
+    MultiselectComponent,
+    DropdownComponent,
+];
+const directives = [
+    ComboboxItemTemplateDirective,
+    MultiselectItemTemplateDirective,
+    MultiselectTagTemplateDirective,
+    MultiselectTagWrapperDirective,
+    DropdownItemTemplateDirective,
+    DropdownValueTemplateDirective,
+];
+export function getPopupContainer() {
+    return { nativeElement: document.body };
+}
+export class ComboboxModule {
+}
+ComboboxModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ComboboxModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ComboboxModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.0", ngImport: i0, type: ComboboxModule, declarations: [AbstractComboboxComponent,
+        AbstractDropdownComponent,
+        ComboboxComponent,
+        ComboboxPopupFooterComponent,
+        MultiselectComponent,
+        DropdownComponent, ComboboxItemTemplateDirective,
+        MultiselectItemTemplateDirective,
+        MultiselectTagTemplateDirective,
+        MultiselectTagWrapperDirective,
+        DropdownItemTemplateDirective,
+        DropdownValueTemplateDirective], imports: [CommonModule,
+        ReactiveFormsModule,
+        ComboBoxModule,
+        MultiSelectModule,
+        PopupModule,
+        TagModule,
+        DropDownListModule], exports: [AbstractComboboxComponent,
+        AbstractDropdownComponent,
+        ComboboxComponent,
+        ComboboxPopupFooterComponent,
+        MultiselectComponent,
+        DropdownComponent, ComboboxItemTemplateDirective,
+        MultiselectItemTemplateDirective,
+        MultiselectTagTemplateDirective,
+        MultiselectTagWrapperDirective,
+        DropdownItemTemplateDirective,
+        DropdownValueTemplateDirective] });
+ComboboxModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ComboboxModule, providers: [
+        {
+            provide: POPUP_CONTAINER,
+            useFactory: getPopupContainer,
+        },
+    ], imports: [CommonModule,
+        ReactiveFormsModule,
+        ComboBoxModule,
+        MultiSelectModule,
+        PopupModule,
+        TagModule,
+        DropDownListModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.0", ngImport: i0, type: ComboboxModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [...components, ...directives],
+                    imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        ComboBoxModule,
+                        MultiSelectModule,
+                        PopupModule,
+                        TagModule,
+                        DropDownListModule,
+                    ],
+                    exports: [...components, ...directives],
+                    providers: [
+                        {
+                            provide: POPUP_CONTAINER,
+                            useFactory: getPopupContainer,
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +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
+            }] } });
+//# 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';\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<TItem[] | GroupResult[]> = new BehaviorSubject<TItem[] | GroupResult[]>([]);\n  protected _valueNormalizerItems: TItem[] | GroupResult[] = [];\n  protected _isSync: boolean = false;\n  protected readonly _loadedItems: BehaviorSubject<TItem[] | GroupResult[]> = new BehaviorSubject<TItem[] | GroupResult[]>([]);\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(): TItem[] | GroupResult[] {\n    return this._items;\n  }\n  public override set items(items: TItem[] | GroupResult[]) {\n    this._isSync = true;\n    this._items = items || [];\n    this._listenToSearched();\n    this._loadedItems.next(this._items);\n  }\n  @Input()\n  public get additionalItems(): TItem[] | GroupResult[] {\n    return this._additionalItems.value;\n  }\n  public set additionalItems(additionalItems: TItem[] | GroupResult[]) {\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: TItem[] | GroupResult[], 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): TItem[] | GroupResult[] {\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, item2: TItem): 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"]}