@intellegens/cornerstone-client 0.0.9999-alpha-19 → 0.0.9999-alpha-21

package/dist/adapters/SearchAdapter/index.d.ts

@@ -1,32 +1,49 @@
 import { IIdentifiable } from '../../data';
-export declare class SearchAdapter<TKey, TDto extends IIdentifiable<TKey>> {
+export type SearchAdapterOptions = {
+    controllerName: string;
+    typesToSearch: string[];
+    multiselect: boolean;
+    searchTriggerMinLength: number;
+    searchDebounceDelay: number;
+    limitSearchToSelectedType: boolean;
+    resultsLimit: number;
+};
+declare class SingularEventTarget<T> {
+    private _target;
+    addEventListener(callback: EventListenerOrEventListenerObject, options?: AddEventListenerOptions | boolean): void;
+    dispatchEvent(value: T): void;
+}
+export interface IGlobalSearchable<TKey> extends IIdentifiable<TKey> {
+    type: string;
+}
+export declare class SearchAdapter<TKey, TDto extends IGlobalSearchable<TKey>> {
     private _readClient;
+    private _options;
     private _isLoading;
+    private _currentAbortController?;
+    constructor(options: SearchAdapterOptions);
+    onChange: SingularEventTarget<string>;
+    private _emitChange;
+    get multiselect(): boolean;
+    private _searchText;
+    get searchText(): string;
+    set searchText(searchText: string);
     private _searchResults;
-    private _totalItemCount;
-    private _searchTerm;
-    private _selectedType?;
-    private _lastInputSearchTerm?;
-    private _lastInputType?;
-    private _searchTriggerLength;
-    private _searchTriggerDelay;
-    private _triggeredSearch;
-    private _selection;
-    private _multiSelectMode;
-    constructor(controllerName: string, multiSelect: boolean, searchTriggerLength: number, searchTriggerDelay: number, dataChangedCallback: (isLoading: boolean, data: TDto[] | undefined, error: string | undefined) => void);
-    getSelectedItems(): TDto[];
-    getSelectedType(): string | undefined;
-    getSelectMode(): boolean;
+    get searchResults(): TDto[];
+    protected set searchResults(searchResults: TDto[]);
+    private _selectedItems;
+    get selectedItems(): TDto[];
+    set selectedItems(selectedItems: TDto[]);
     addToSelection(item: TDto): void;
     removeFromSelection(item: TDto): void;
-    search(searchTerm: string, type?: string): Promise<TDto[]>;
-    clearSearch(): void;
-    private readonly _dataChangedCallback;
-    private _fetchCurrentPageDataTimeout?;
-    private _fetchCurrentPageDataPromises;
-    private _currentAbortController?;
-    private _fetchCurrentPageData;
-    private _fetchCurrentPageDataDebounced;
+    private _lastSearchedValue;
+    private _typesToSearch;
+    private _trySearch;
+    private _fetchResultsDataTimeout?;
+    private _fetchResultsPromises;
+    private _fetchResults;
+    private _fetchResultsDebounced;
     private _parseToSearchDefinition;
     private _sortByName;
 }
+export {};

package/dist/adapters/SearchAdapter/index.js

@@ -1,144 +1,122 @@
 import { ReadSelectedComparisonOperator, ReadSelectedLogicalOperator, ReadSelectedOrderingDirection, ReadSelectedPropertyType, } from '../../data';
 import { ApiReadControllerClient } from '../../services';
+class SingularEventTarget {
+    _target = new EventTarget();
+    addEventListener(callback, options) {
+        this._target.addEventListener('change', callback, options);
+    }
+    dispatchEvent(value) {
+        this._target.dispatchEvent(new CustomEvent('change', { detail: value }));
+    }
+}
 export class SearchAdapter {
+    // inputs
     _readClient;
+    _options;
     _isLoading = false;
+    _currentAbortController;
+    constructor(options) {
+        this._options = options;
+        this._readClient = new ApiReadControllerClient(options.controllerName);
+    }
+    onChange = new SingularEventTarget();
+    _emitChange() {
+        this.onChange.dispatchEvent('onChange');
+    }
+    get multiselect() {
+        return this._options.multiselect;
+    }
+    _searchText = '';
+    get searchText() {
+        return this._searchText;
+    }
+    set searchText(searchText) {
+        this._searchText = searchText;
+        this._trySearch();
+        this._emitChange();
+    }
     _searchResults = [];
-    _totalItemCount = 1000;
-    _searchTerm = '';
-    _selectedType;
-    _lastInputSearchTerm;
-    _lastInputType;
-    _searchTriggerLength;
-    _searchTriggerDelay;
-    _triggeredSearch = false;
-    _selection;
-    _multiSelectMode = true;
-    constructor(controllerName, multiSelect, searchTriggerLength, searchTriggerDelay, dataChangedCallback) {
-        this._readClient = new ApiReadControllerClient(controllerName);
-        this._searchTriggerLength = searchTriggerLength;
-        this._searchTriggerDelay = searchTriggerDelay;
-        this._multiSelectMode = multiSelect;
-        this._dataChangedCallback = dataChangedCallback;
-        this._fetchCurrentPageData();
-    }
-    //#region Public methods
-    getSelectedItems() {
-        return this._selection || [];
-    }
-    getSelectedType() {
-        return this._selectedType;
-    }
-    getSelectMode() {
-        return this._multiSelectMode;
+    get searchResults() {
+        return this._searchResults;
+    }
+    set searchResults(searchResults) {
+        this._searchResults = [...searchResults];
+        this._emitChange();
+    }
+    _selectedItems = [];
+    get selectedItems() {
+        return this._selectedItems;
+    }
+    set selectedItems(selectedItems) {
+        this._selectedItems = [...selectedItems];
+        this._emitChange();
     }
     addToSelection(item) {
-        if (!this._selection) {
-            this._selection = [];
+        if (!this._selectedItems) {
+            this.selectedItems = [];
         }
-        if (this._multiSelectMode) {
-            if (!this._selection.find(s => s.id === item.id)) {
-                this._selection.push(item);
+        // selection mode
+        if (this._options.multiselect) {
+            if (!this._selectedItems.find(s => s.id === item.id)) {
+                this.selectedItems = [...this.selectedItems, item];
             }
         }
         else {
             // single-select mode - replace the item and return the old one to shown results
-            if (this._selection.length > 0) {
-                this._searchResults = [...this._searchResults, ...this._selection];
+            if (this._selectedItems.length > 0) {
+                this.searchResults = this._sortByName([...this._searchResults, ...this._selectedItems]); // return the to-be-replaced selected item back to shown results list
             }
-            this._selection = [item];
+            this.selectedItems = [item];
         }
-        this._searchResults = this._searchResults.filter(d => d.id !== item.id);
-        this._dataChangedCallback(this._isLoading, this._sortByName(this._searchResults), undefined);
+        this.searchResults = this._sortByName(this._searchResults.filter(d => d.id !== item.id)); // remove the new selection from the shown results
     }
     removeFromSelection(item) {
-        if (!this._selection) {
-            this._selection = [];
+        if (!this._selectedItems) {
+            this.selectedItems = [];
             return;
         }
-        this._selection = this._selection.filter(s => s.id !== item.id);
-        this._searchResults = [...this._searchResults, item];
-        this._dataChangedCallback(this._isLoading, this._sortByName(this._searchResults), undefined);
-    }
-    search(searchTerm, type) {
-        if (this._lastInputSearchTerm === searchTerm && this._lastInputType === type) {
-            // no changes to search condition
-            return Promise.resolve(this._searchResults);
-        }
-        this._lastInputSearchTerm = searchTerm;
-        this._lastInputType = type;
-        if (type !== undefined && type !== null) {
-            // has type selected -> single-select mode
-            if (searchTerm.length >= this._searchTriggerLength) {
-                // include search by string
-                this._searchTerm = searchTerm;
-                this._selectedType = type;
-                this._triggeredSearch = true;
-                return this._fetchCurrentPageData();
-            }
-            else {
-                // search all by type
-                this._searchTerm = '';
-                this._selectedType = type;
-                this._triggeredSearch = true;
-                return this._fetchCurrentPageData();
-            }
-        }
-        else if (searchTerm.length >= this._searchTriggerLength) {
-            // no type involved -> search by input string only
-            this._searchTerm = searchTerm;
-            this._selectedType = type;
-            this._triggeredSearch = true;
-            return this._fetchCurrentPageData();
-        }
-        else if (this._triggeredSearch && searchTerm.length < this._searchTriggerLength) {
-            // user has deleted part of the search term after having seen some results - fetch everything to show
-            this._searchTerm = '';
-            this._selectedType = type;
-            return this._fetchCurrentPageData();
-        }
-        else {
-            // no type, searchTerm < this._searchTriggerLength
-            return Promise.resolve([]);
-        }
+        this.selectedItems = this._selectedItems.filter(s => s.id !== item.id);
+        this.searchResults = this._sortByName([...this._searchResults, item]);
     }
-    clearSearch() {
-        this._selection = [];
-        this._selectedType = undefined;
-        this._searchTerm = '';
-        this._dataChangedCallback(this._isLoading, [], undefined);
-        this._triggeredSearch = false;
-    }
-    //#endregion
-    //#region Private methods
-    _dataChangedCallback;
-    _fetchCurrentPageDataTimeout;
-    _fetchCurrentPageDataPromises = [];
-    _currentAbortController;
-    async _fetchCurrentPageData() {
+    _lastSearchedValue = '';
+    _typesToSearch = [];
+    async _trySearch() {
+        const options = this._options;
+        this.searchResults = [];
+        if (this._searchText.length < options.searchTriggerMinLength)
+            return;
+        if (this._searchText == this._lastSearchedValue)
+            return;
+        this._lastSearchedValue = this._searchText;
+        this._typesToSearch =
+            options.limitSearchToSelectedType && this._selectedItems.length ? [this._selectedItems[0].type] : this._options.typesToSearch;
+        this.searchResults = this._sortByName(await this._fetchResults(options.searchDebounceDelay));
+    }
+    _fetchResultsDataTimeout;
+    _fetchResultsPromises = [];
+    async _fetchResults(debounceDelay) {
         return new Promise((resolve, reject) => {
-            this._fetchCurrentPageDataPromises.push({ resolve, reject });
-            if (this._fetchCurrentPageDataTimeout !== undefined) {
-                clearTimeout(this._fetchCurrentPageDataTimeout);
+            this._fetchResultsPromises.push({ resolve, reject });
+            if (this._fetchResultsDataTimeout !== undefined) {
+                clearTimeout(this._fetchResultsDataTimeout);
             }
-            this._fetchCurrentPageDataTimeout = setTimeout(async () => {
+            this._fetchResultsDataTimeout = setTimeout(async () => {
                 try {
-                    const result = await this._fetchCurrentPageDataDebounced();
-                    const promises = this._fetchCurrentPageDataPromises.splice(0, this._fetchCurrentPageDataPromises.length);
+                    const result = await this._fetchResultsDebounced();
+                    const promises = this._fetchResultsPromises.splice(0, this._fetchResultsPromises.length);
                     for (const p of promises)
                         p.resolve(result);
                 }
                 catch (err) {
-                    const promises = this._fetchCurrentPageDataPromises.splice(0, this._fetchCurrentPageDataPromises.length);
+                    const promises = this._fetchResultsPromises.splice(0, this._fetchResultsPromises.length);
                     for (const p of promises)
                         p.reject(err);
                 }
-            }, this._searchTriggerDelay);
+            }, debounceDelay);
         });
     }
-    async _fetchCurrentPageDataDebounced() {
+    async _fetchResultsDebounced() {
         this._isLoading = true;
-        this._dataChangedCallback(this._isLoading, undefined, undefined);
         let abortController;
         let caughtError;
         try {
@@ -158,10 +136,9 @@ export class SearchAdapter {
             if (!response.ok) {
                 throw response.error;
             }
-            // Filter out selected items from results
-            const selectedIds = new Set((this._selection || []).map(item => item.id));
-            this._searchResults = response.result.filter(item => !selectedIds.has(item.id));
-            return this._searchResults;
+            // Filter out selected items from new results
+            const selectedIds = new Set((this.selectedItems || []).map(item => item.id));
+            return response.result.filter(item => !selectedIds.has(item.id));
         }
         catch (error) {
             caughtError = error;
@@ -178,7 +155,6 @@ export class SearchAdapter {
             if (caughtError && !(caughtError instanceof DOMException && caughtError.name === 'AbortError')) {
                 errorName = caughtError instanceof Error ? caughtError.name : undefined;
             }
-            this._dataChangedCallback(this._isLoading, this._searchResults, errorName);
             // Clear the abort controller only if it belongs to this request (avoid racing with a newer one)
             if (abortController && this._currentAbortController === abortController) {
                 this._currentAbortController = undefined;
@@ -189,7 +165,7 @@ export class SearchAdapter {
         const definition = {
             paginationDefinition: {
                 skip: 0,
-                limit: this._totalItemCount,
+                limit: this._options.resultsLimit,
             },
         };
         // Apply ordering
@@ -207,21 +183,26 @@ export class SearchAdapter {
                 propertyName: 'Name',
                 comparisonOperator: ReadSelectedComparisonOperator.IContains,
                 valueType: ReadSelectedPropertyType.String,
-                value: this._searchTerm,
+                value: this._searchText,
             },
         ];
-        if (this._selectedType !== undefined) {
-            propertyCriteria.push({
-                propertyName: 'Type',
-                comparisonOperator: ReadSelectedComparisonOperator.Equal,
-                valueType: ReadSelectedPropertyType.String,
-                value: this._selectedType,
-            });
-        }
         definition.searchDefinition = {
             logicalOperator: ReadSelectedLogicalOperator.And,
             propertyCriteria: propertyCriteria,
         };
+        if (this._typesToSearch !== undefined && this._typesToSearch.length > 0) {
+            definition.searchDefinition.searches = [
+                {
+                    logicalOperator: ReadSelectedLogicalOperator.Or,
+                    propertyCriteria: this._typesToSearch.map(type => ({
+                        propertyName: 'Type',
+                        comparisonOperator: ReadSelectedComparisonOperator.IEqual,
+                        valueType: ReadSelectedPropertyType.String,
+                        value: type,
+                    })),
+                },
+            ];
+        }
         return definition;
     }
     _sortByName(array) {

package/dist/data/api/interface/ICommonIdentifiable.d.ts

@@ -0,0 +1,7 @@
+import { IIdentifiable } from "../..";
+export interface ICommonIdentifiable<TKey> extends IIdentifiable<TKey> {
+    /**
+     * Gets or sets the type of the entity.
+     */
+    type: string;
+}

package/dist/data/api/interface/ICommonIdentifiable.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intellegens/cornerstone-client",
-  "version": "0.0.9999-alpha-19",
+  "version": "0.0.9999-alpha-21",
   "private": false,
   "publishable": true,
   "main": "./dist/index.js",

package/src/adapters/SearchAdapter/index.ts

@@ -10,174 +10,157 @@ import {
 } from '@data';
 import { ApiReadControllerClient } from '@services';
 
-export class SearchAdapter<TKey, TDto extends IIdentifiable<TKey>> {
+export type SearchAdapterOptions = {
+  controllerName: string;
+  typesToSearch: string[]; // provide known searchable types
+  multiselect: boolean;
+  searchTriggerMinLength: number;
+  searchDebounceDelay: number;
+  limitSearchToSelectedType: boolean; // when item is selected, limit results to items of same type
+  resultsLimit: number;
+};
+
+class SingularEventTarget<T> {
+  private _target = new EventTarget();
+
+  public addEventListener(callback: EventListenerOrEventListenerObject, options?: AddEventListenerOptions | boolean): void {
+    this._target.addEventListener('change', callback, options);
+  }
+
+  public dispatchEvent(value: T) {
+    this._target.dispatchEvent(new CustomEvent('change', { detail: value }));
+  }
+}
+
+export interface IGlobalSearchable<TKey> extends IIdentifiable<TKey> {
+  type: string;
+}
+
+export class SearchAdapter<TKey, TDto extends IGlobalSearchable<TKey>> {
+  // inputs
   private _readClient!: ApiReadControllerClient<TKey, TDto, TDto>;
+  private _options!: SearchAdapterOptions;
 
   private _isLoading = false;
-  private _searchResults: TDto[] = [];
-  private _totalItemCount: number = 1000;
-
-  private _searchTerm: string = '';
-  private _selectedType?: string;
-  private _lastInputSearchTerm?: string;
-  private _lastInputType?: string;
-
-  private _searchTriggerLength!: number;
-  private _searchTriggerDelay!: number;
-  private _triggeredSearch = false;
-
-  private _selection!: TDto[];
-  private _multiSelectMode = true;
-
-  constructor(
-    controllerName: string,
-    multiSelect: boolean,
-    searchTriggerLength: number,
-    searchTriggerDelay: number,
-    dataChangedCallback: (isLoading: boolean, data: TDto[] | undefined, error: string | undefined) => void,
-  ) {
-    this._readClient = new ApiReadControllerClient<TKey, TDto, TDto>(controllerName);
-
-    this._searchTriggerLength = searchTriggerLength;
-    this._searchTriggerDelay = searchTriggerDelay;
-    this._multiSelectMode = multiSelect;
-
-    this._dataChangedCallback = dataChangedCallback;
-    this._fetchCurrentPageData();
+  private _currentAbortController?: AbortController;
+
+  constructor(options: SearchAdapterOptions) {
+    this._options = options;
+    this._readClient = new ApiReadControllerClient<TKey, TDto, TDto>(options.controllerName);
   }
 
-  //#region Public methods
+  public onChange = new SingularEventTarget<string>();
+  private _emitChange() {
+    this.onChange.dispatchEvent('onChange');
+  }
 
-  public getSelectedItems(): TDto[] {
-    return this._selection || [];
+  public get multiselect() {
+    return this._options.multiselect;
   }
 
-  public getSelectedType(): string | undefined {
-    return this._selectedType;
+  private _searchText: string = '';
+  public get searchText() {
+    return this._searchText;
+  }
+  public set searchText(searchText: string) {
+    this._searchText = searchText;
+    this._trySearch();
+    this._emitChange();
   }
 
-  public getSelectMode(): boolean {
-    return this._multiSelectMode;
+  private _searchResults: TDto[] = [];
+  public get searchResults() {
+    return this._searchResults;
+  }
+  protected set searchResults(searchResults: TDto[]) {
+    this._searchResults = [...searchResults];
+    this._emitChange();
+  }
+
+  private _selectedItems: TDto[] = [];
+  public get selectedItems() {
+    return this._selectedItems;
+  }
+  public set selectedItems(selectedItems: TDto[]) {
+    this._selectedItems = [...selectedItems];
+    this._emitChange();
   }
 
   public addToSelection(item: TDto): void {
-    if (!this._selection) {
-      this._selection = [];
+    if (!this._selectedItems) {
+      this.selectedItems = [];
     }
 
-    if (this._multiSelectMode) {
-      if (!this._selection.find(s => s.id === item.id)) {
-        this._selection.push(item);
+    // selection mode
+    if (this._options.multiselect) {
+      if (!this._selectedItems.find(s => s.id === item.id)) {
+        this.selectedItems = [...this.selectedItems, item];
       }
     } else {
       // single-select mode - replace the item and return the old one to shown results
-      if (this._selection.length > 0) {
-        this._searchResults = [...this._searchResults, ...this._selection];
+      if (this._selectedItems.length > 0) {
+        this.searchResults = this._sortByName([...this._searchResults, ...this._selectedItems]); // return the to-be-replaced selected item back to shown results list
       }
-      this._selection = [item];
+      this.selectedItems = [item];
     }
-    this._searchResults = this._searchResults.filter(d => d.id !== item.id);
-    this._dataChangedCallback(this._isLoading, this._sortByName(this._searchResults), undefined);
+    this.searchResults = this._sortByName(this._searchResults.filter(d => d.id !== item.id)); // remove the new selection from the shown results
   }
 
   public removeFromSelection(item: TDto): void {
-    if (!this._selection) {
-      this._selection = [];
+    if (!this._selectedItems) {
+      this.selectedItems = [];
       return;
     }
 
-    this._selection = this._selection.filter(s => s.id !== item.id);
-    this._searchResults = [...this._searchResults, item];
-
-    this._dataChangedCallback(this._isLoading, this._sortByName(this._searchResults), undefined);
+    this.selectedItems = this._selectedItems.filter(s => s.id !== item.id);
+    this.searchResults = this._sortByName([...this._searchResults, item]);
   }
 
-  public search(searchTerm: string, type?: string) {
-    if (this._lastInputSearchTerm === searchTerm && this._lastInputType === type) {
-      // no changes to search condition
-      return Promise.resolve(this._searchResults);
-    }
-
-    this._lastInputSearchTerm = searchTerm;
-    this._lastInputType = type;
-
-    if (type !== undefined && type !== null) {
-      // has type selected -> single-select mode
-      if (searchTerm.length >= this._searchTriggerLength) {
-        // include search by string
-        this._searchTerm = searchTerm;
-        this._selectedType = type;
-        this._triggeredSearch = true;
-        return this._fetchCurrentPageData();
-      } else {
-        // search all by type
-        this._searchTerm = '';
-        this._selectedType = type;
-        this._triggeredSearch = true;
-        return this._fetchCurrentPageData();
-      }
-    } else if (searchTerm.length >= this._searchTriggerLength) {
-      // no type involved -> search by input string only
-      this._searchTerm = searchTerm;
-      this._selectedType = type;
-      this._triggeredSearch = true;
-      return this._fetchCurrentPageData();
-    } else if (this._triggeredSearch && searchTerm.length < this._searchTriggerLength) {
-      // user has deleted part of the search term after having seen some results - fetch everything to show
-      this._searchTerm = '';
-      this._selectedType = type;
-      return this._fetchCurrentPageData();
-    } else {
-      // no type, searchTerm < this._searchTriggerLength
-      return Promise.resolve([]);
-    }
-  }
+  private _lastSearchedValue = '';
+  private _typesToSearch: string[] = [];
 
-  public clearSearch(): void {
-    this._selection = [];
-    this._selectedType = undefined;
-    this._searchTerm = '';
-    this._dataChangedCallback(this._isLoading, [], undefined);
-    this._triggeredSearch = false;
-  }
+  private async _trySearch() {
+    const options = this._options;
 
-  //#endregion
+    this.searchResults = [];
+    if (this._searchText.length < options.searchTriggerMinLength) return;
+    if (this._searchText == this._lastSearchedValue) return;
+    this._lastSearchedValue = this._searchText;
 
-  //#region Private methods
+    this._typesToSearch =
+      options.limitSearchToSelectedType && this._selectedItems.length ? [(this._selectedItems[0] as TDto).type] : this._options.typesToSearch;
 
-  private readonly _dataChangedCallback!: (isLoading: boolean, data: TDto[] | undefined, errorMessage: string | undefined) => void;
+    this.searchResults = this._sortByName(await this._fetchResults(options.searchDebounceDelay));
+  }
 
-  private _fetchCurrentPageDataTimeout?: any;
+  private _fetchResultsDataTimeout?: any;
 
-  private _fetchCurrentPageDataPromises: {
+  private _fetchResultsPromises: {
     resolve: (value: TDto[] | PromiseLike<TDto[]>) => void;
     reject: (reason?: unknown) => void;
   }[] = [];
 
-  private _currentAbortController?: AbortController;
-
-  private async _fetchCurrentPageData(): Promise<TDto[]> {
+  private async _fetchResults(debounceDelay: number): Promise<TDto[]> {
     return new Promise((resolve, reject) => {
-      this._fetchCurrentPageDataPromises.push({ resolve, reject });
-      if (this._fetchCurrentPageDataTimeout !== undefined) {
-        clearTimeout(this._fetchCurrentPageDataTimeout);
+      this._fetchResultsPromises.push({ resolve, reject });
+      if (this._fetchResultsDataTimeout !== undefined) {
+        clearTimeout(this._fetchResultsDataTimeout);
       }
-      this._fetchCurrentPageDataTimeout = setTimeout(async () => {
+      this._fetchResultsDataTimeout = setTimeout(async () => {
         try {
-          const result = await this._fetchCurrentPageDataDebounced();
-          const promises = this._fetchCurrentPageDataPromises.splice(0, this._fetchCurrentPageDataPromises.length);
+          const result = await this._fetchResultsDebounced();
+          const promises = this._fetchResultsPromises.splice(0, this._fetchResultsPromises.length);
           for (const p of promises) p.resolve(result);
         } catch (err) {
-          const promises = this._fetchCurrentPageDataPromises.splice(0, this._fetchCurrentPageDataPromises.length);
+          const promises = this._fetchResultsPromises.splice(0, this._fetchResultsPromises.length);
           for (const p of promises) p.reject(err);
         }
-      }, this._searchTriggerDelay);
+      }, debounceDelay);
     });
   }
 
-  private async _fetchCurrentPageDataDebounced(): Promise<TDto[]> {
+  private async _fetchResultsDebounced(): Promise<TDto[]> {
     this._isLoading = true;
-    this._dataChangedCallback(this._isLoading, undefined, undefined);
     let abortController: AbortController | undefined;
     let caughtError: unknown;
 
@@ -200,11 +183,9 @@ export class SearchAdapter<TKey, TDto extends IIdentifiable<TKey>> {
         throw response.error;
       }
 
-      // Filter out selected items from results
-      const selectedIds = new Set((this._selection || []).map(item => item.id));
-      this._searchResults = response.result.filter(item => !selectedIds.has(item.id));
-
-      return this._searchResults;
+      // Filter out selected items from new results
+      const selectedIds = new Set((this.selectedItems || []).map(item => item.id));
+      return response.result.filter(item => !selectedIds.has(item.id));
     } catch (error: unknown) {
       caughtError = error;
 
@@ -222,10 +203,8 @@ export class SearchAdapter<TKey, TDto extends IIdentifiable<TKey>> {
       if (caughtError && !(caughtError instanceof DOMException && caughtError.name === 'AbortError')) {
         errorName = caughtError instanceof Error ? caughtError.name : undefined;
       }
-      this._dataChangedCallback(this._isLoading, this._searchResults, errorName);
 
       // Clear the abort controller only if it belongs to this request (avoid racing with a newer one)
-
       if (abortController && this._currentAbortController === abortController) {
         this._currentAbortController = undefined;
       }
@@ -236,7 +215,7 @@ export class SearchAdapter<TKey, TDto extends IIdentifiable<TKey>> {
     const definition: ReadSelectedDefinitionDto<TDto> = {
       paginationDefinition: {
         skip: 0,
-        limit: this._totalItemCount,
+        limit: this._options.resultsLimit,
       },
     };
 
@@ -256,24 +235,32 @@ export class SearchAdapter<TKey, TDto extends IIdentifiable<TKey>> {
         propertyName: 'Name' as any,
         comparisonOperator: ReadSelectedComparisonOperator.IContains,
         valueType: ReadSelectedPropertyType.String,
-        value: this._searchTerm,
+        value: this._searchText,
       },
     ];
 
-    if (this._selectedType !== undefined) {
-      propertyCriteria.push({
-        propertyName: 'Type',
-        comparisonOperator: ReadSelectedComparisonOperator.Equal,
-        valueType: ReadSelectedPropertyType.String,
-        value: this._selectedType,
-      } as ReadSelectedSearchPropertyDefinitionDto<TDto, keyof TDto>);
-    }
-
     definition.searchDefinition = {
       logicalOperator: ReadSelectedLogicalOperator.And,
       propertyCriteria: propertyCriteria,
     } as ReadSelectedSearchDefinitionDto<TDto>;
 
+    if (this._typesToSearch !== undefined && this._typesToSearch.length > 0) {
+      definition.searchDefinition.searches = [
+        {
+          logicalOperator: ReadSelectedLogicalOperator.Or,
+          propertyCriteria: this._typesToSearch.map(
+            type =>
+              ({
+                propertyName: 'Type',
+                comparisonOperator: ReadSelectedComparisonOperator.IEqual,
+                valueType: ReadSelectedPropertyType.String,
+                value: type,
+              }) as ReadSelectedSearchPropertyDefinitionDto<TDto, keyof TDto>,
+          ),
+        },
+      ];
+    }
+
     return definition;
   }
 
@@ -284,6 +271,4 @@ export class SearchAdapter<TKey, TDto extends IIdentifiable<TKey>> {
       return nameA.localeCompare(nameB);
     });
   }
-
-  //#endregion
 }

package/src/data/api/interface/ICommonIdentifiable.ts

@@ -0,0 +1,9 @@
+import {IIdentifiable} from "@data";
+
+
+export interface ICommonIdentifiable<TKey> extends IIdentifiable<TKey> {
+    /**
+     * Gets or sets the type of the entity.
+     */
+    type: string;
+}