@updevs/components 1.0.0-alpha.95 → 1.0.0-alpha.97

package/esm2022/table/services/current-search-request.service.mjs

@@ -0,0 +1,254 @@
+import { Injectable, signal, computed } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Service to manage the current search request state across table components.
+ * Uses Angular signals for reactive state management, eliminating the need for prop drilling.
+ * Should be provided at the table component level so each table instance has its own state.
+ */
+export class CurrentSearchRequestService {
+    constructor() {
+        this._searchRequest = signal({});
+        this._isSearching = signal(false);
+        this._hasChanges = signal(false);
+        /**
+         * Read-only signal for the current search request
+         */
+        this.searchRequest = this._searchRequest.asReadonly();
+        /**
+         * Read-only signal for the searching state
+         */
+        this.isSearching = this._isSearching.asReadonly();
+        /**
+         * Read-only signal indicating if the search request has changed from default
+         */
+        this.hasChanges = this._hasChanges.asReadonly();
+        /**
+         * Subject to trigger search operations
+         */
+        this.searchRequestSubject = new Subject();
+        /**
+         * Count of active filters (non-hidden)
+         */
+        this.activeFilterCount = computed(() => this.searchRequest().filters?.filter(f => !f.isHidden).length || 0);
+        /**
+         * Whether there are any active filters
+         */
+        this.hasFilters = computed(() => (this.searchRequest().filters?.length || 0) > 0);
+        /**
+         * Count of visible (non-hidden) filters
+         */
+        this.visibleFilterCount = computed(() => this.searchRequest().filters?.filter(f => !f.isHidden).length || 0);
+        /**
+         * Whether there's a search description/text query
+         */
+        this.hasDescription = computed(() => !!this.searchRequest().description && this.searchRequest().description.length > 0);
+        /**
+         * Whether there are any sortings applied
+         */
+        this.hasSorting = computed(() => (this.searchRequest().sortings?.length || 0) > 0);
+        /**
+         * The current sorting (first one if multiple exist)
+         */
+        this.currentSorting = computed(() => this.hasSorting() ? this.searchRequest().sortings[0] : undefined);
+        /**
+         * Whether any search criteria is active (filters, description, or sorting)
+         */
+        this.hasAnySearchCriteria = computed(() => this.hasFilters() || this.hasDescription() || this.hasSorting());
+        /**
+         * Current page number (1-indexed for display)
+         */
+        this.currentPageNumber = computed(() => (this.searchRequest().pageIndex || 0) + 1);
+        /**
+         * Whether pagination is configured
+         */
+        this.hasPagination = computed(() => !!this.searchRequest().pageSize && this.searchRequest().pageSize > 0);
+    }
+    /**
+     * Updates the entire search request
+     * @param request The new search request
+     */
+    updateSearchRequest(request) {
+        const previousRequest = this._searchRequest();
+        this._searchRequest.set(request);
+        // Only mark as changed if the new request is actually different from previous
+        if (!this.areSearchRequestsEqual(previousRequest, request)) {
+            this._hasChanges.set(true);
+        }
+    }
+    /**
+     * Partially updates the search request
+     * @param partial Partial search request properties to update
+     */
+    patchSearchRequest(partial) {
+        const previousRequest = this._searchRequest();
+        const newRequest = { ...previousRequest, ...partial };
+        this._searchRequest.set(newRequest);
+        // Only mark as changed if the patch actually changed something
+        if (!this.areSearchRequestsEqual(previousRequest, newRequest)) {
+            this._hasChanges.set(true);
+        }
+    }
+    /**
+     * Sets the searching state
+     * @param isSearching Whether a search is in progress
+     */
+    setSearching(isSearching) {
+        this._isSearching.set(isSearching);
+    }
+    /**
+     * Resets the search request to default state
+     */
+    reset() {
+        this._searchRequest.set({});
+        this._isSearching.set(false);
+        this._hasChanges.set(false);
+    }
+    /**
+     * Triggers a search operation by emitting on the searchRequestSubject
+     */
+    triggerSearch() {
+        this.searchRequestSubject.next(this._searchRequest());
+    }
+    /**
+     * Manually sets the hasChanges flag
+     * Useful for changes that aren't part of the search request but should enable Save View
+     * (e.g., column visibility changes)
+     * @param hasChanges Whether there are changes
+     */
+    setHasChanges(hasChanges) {
+        this._hasChanges.set(hasChanges);
+    }
+    /**
+     * Adds a filter to the search request
+     * @param filter The filter to add
+     */
+    addFilter(filter) {
+        const currentFilters = this.searchRequest().filters || [];
+        this.patchSearchRequest({ filters: [...currentFilters, filter] });
+    }
+    /**
+     * Removes a filter by name
+     * @param filterName The name of the filter column to remove
+     */
+    removeFilter(filterName) {
+        const currentFilters = this.searchRequest().filters || [];
+        this.patchSearchRequest({ filters: currentFilters.filter(f => f.column !== filterName) });
+    }
+    /**
+     * Removes a filter by index
+     * @param index The index of the filter to remove
+     */
+    removeFilterByIndex(index) {
+        const currentFilters = this.searchRequest().filters || [];
+        this.patchSearchRequest({ filters: currentFilters.filter((_, i) => i !== index) });
+    }
+    /**
+     * Updates a specific filter by column name
+     * @param columnName The column name of the filter to update
+     * @param newData Partial filter properties to update
+     */
+    updateFilter(columnName, newData) {
+        const currentFilters = this.searchRequest().filters || [];
+        this.patchSearchRequest({ filters: currentFilters.map(f => f.column === columnName ? { ...f, ...newData } : f) });
+    }
+    /**
+     * Updates a filter by its index position
+     * @param index The index of the filter to update
+     * @param newData Partial filter properties to update
+     */
+    updateFilterByIndex(index, newData) {
+        const currentFilters = this.searchRequest().filters || [];
+        if (index >= 0 && index < currentFilters.length) {
+            this.patchSearchRequest({ filters: currentFilters.map((f, i) => i === index ? { ...f, ...newData } : f) });
+        }
+    }
+    /**
+     * Clears all filters
+     */
+    clearFilters() {
+        this.patchSearchRequest({ filters: [] });
+    }
+    /**
+     * Sets the sorting (replaces existing sortings)
+     * @param column The column name to sort by
+     * @param direction The sort direction
+     */
+    setSorting(column, direction) {
+        this.patchSearchRequest({ sortings: [{ column, direction }] });
+    }
+    /**
+     * Clears all sorting
+     */
+    clearSorting() {
+        this.patchSearchRequest({ sortings: [] });
+    }
+    /**
+     * Sets the search description/text query
+     * @param description The search text
+     */
+    setDescription(description) {
+        this.patchSearchRequest({ description });
+    }
+    /**
+     * Clears the search description
+     */
+    clearDescription() {
+        this.patchSearchRequest({ description: '' });
+    }
+    /**
+     * Clears ALL search criteria (filters, description, sorting)
+     * Note: Does not reset pagination - use reset() for that
+     */
+    clearAll() {
+        this.patchSearchRequest({ filters: [], description: '', sortings: [] });
+    }
+    /**
+     * Clears all search criteria except pagination
+     * Useful when you want to reset search but maintain current page
+     */
+    clearAllExceptPagination() {
+        this.clearAll();
+    }
+    /**
+     * Deep comparison of two search requests
+     * @param a First search request
+     * @param b Second search request
+     * @returns true if they are equal, false otherwise
+     */
+    areSearchRequestsEqual(a, b) {
+        if ((a.description || '') !== (b.description || '')) {
+            return false;
+        }
+        const aFilters = a.filters || [];
+        const bFilters = b.filters || [];
+        if (aFilters.length !== bFilters.length) {
+            return false;
+        }
+        for (let i = 0; i < aFilters.length; i++) {
+            if (JSON.stringify(aFilters[i]) !== JSON.stringify(bFilters[i])) {
+                return false;
+            }
+        }
+        const aSortings = a.sortings || [];
+        const bSortings = b.sortings || [];
+        if (aSortings.length !== bSortings.length) {
+            return false;
+        }
+        for (let i = 0; i < aSortings.length; i++) {
+            if (JSON.stringify(aSortings[i]) !== JSON.stringify(bSortings[i])) {
+                return false;
+            }
+        }
+        if (a.pageSize !== b.pageSize || a.pageIndex !== b.pageIndex) {
+            return false;
+        }
+        return true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: CurrentSearchRequestService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: CurrentSearchRequestService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: CurrentSearchRequestService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"current-search-request.service.js","sourceRoot":"","sources":["../../../../../../libs/components/table/src/services/current-search-request.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, signal, computed } from '@angular/core';\nimport { BaseFilter, SearchRequestModel } from '@updevs/sdk/stores';\nimport { Subject } from 'rxjs';\n\n/**\n * Service to manage the current search request state across table components.\n * Uses Angular signals for reactive state management, eliminating the need for prop drilling.\n * Should be provided at the table component level so each table instance has its own state.\n */\n@Injectable()\nexport class CurrentSearchRequestService {\n    private readonly _searchRequest = signal<SearchRequestModel>({});\n    private readonly _isSearching = signal(false);\n    private readonly _hasChanges = signal(false);\n\n    /**\n     * Read-only signal for the current search request\n     */\n    readonly searchRequest = this._searchRequest.asReadonly();\n\n    /**\n     * Read-only signal for the searching state\n     */\n    readonly isSearching = this._isSearching.asReadonly();\n\n    /**\n     * Read-only signal indicating if the search request has changed from default\n     */\n    readonly hasChanges = this._hasChanges.asReadonly();\n\n    /**\n     * Subject to trigger search operations\n     */\n    readonly searchRequestSubject = new Subject<SearchRequestModel>();\n\n    /**\n     * Count of active filters (non-hidden)\n     */\n    readonly activeFilterCount = computed(() => this.searchRequest().filters?.filter(f => !f.isHidden).length || 0);\n\n    /**\n     * Whether there are any active filters\n     */\n    readonly hasFilters = computed(() => (this.searchRequest().filters?.length || 0) > 0);\n\n    /**\n     * Count of visible (non-hidden) filters\n     */\n    readonly visibleFilterCount = computed(() => this.searchRequest().filters?.filter(f => !f.isHidden).length || 0);\n\n    /**\n     * Whether there's a search description/text query\n     */\n    readonly hasDescription = computed(() => !!this.searchRequest().description && this.searchRequest().description!.length > 0);\n\n    /**\n     * Whether there are any sortings applied\n     */\n    readonly hasSorting = computed(() => (this.searchRequest().sortings?.length || 0) > 0);\n\n    /**\n     * The current sorting (first one if multiple exist)\n     */\n    readonly currentSorting = computed(() => this.hasSorting() ? this.searchRequest().sortings![0] : undefined);\n\n    /**\n     * Whether any search criteria is active (filters, description, or sorting)\n     */\n    readonly hasAnySearchCriteria = computed(() => this.hasFilters() || this.hasDescription() || this.hasSorting());\n\n    /**\n     * Current page number (1-indexed for display)\n     */\n    readonly currentPageNumber = computed(() => (this.searchRequest().pageIndex || 0) + 1);\n\n    /**\n     * Whether pagination is configured\n     */\n    readonly hasPagination = computed(() => !!this.searchRequest().pageSize && this.searchRequest().pageSize! > 0);\n\n    /**\n     * Updates the entire search request\n     * @param request The new search request\n     */\n    updateSearchRequest(request: SearchRequestModel): void {\n        const previousRequest = this._searchRequest();\n        this._searchRequest.set(request);\n\n        // Only mark as changed if the new request is actually different from previous\n        if (!this.areSearchRequestsEqual(previousRequest, request)) {\n            this._hasChanges.set(true);\n        }\n    }\n\n    /**\n     * Partially updates the search request\n     * @param partial Partial search request properties to update\n     */\n    patchSearchRequest(partial: Partial<SearchRequestModel>): void {\n        const previousRequest = this._searchRequest();\n        const newRequest = { ...previousRequest, ...partial };\n        this._searchRequest.set(newRequest);\n\n        // Only mark as changed if the patch actually changed something\n        if (!this.areSearchRequestsEqual(previousRequest, newRequest)) {\n            this._hasChanges.set(true);\n        }\n    }\n\n    /**\n     * Sets the searching state\n     * @param isSearching Whether a search is in progress\n     */\n    setSearching(isSearching: boolean): void {\n        this._isSearching.set(isSearching);\n    }\n\n    /**\n     * Resets the search request to default state\n     */\n    reset(): void {\n        this._searchRequest.set({});\n        this._isSearching.set(false);\n        this._hasChanges.set(false);\n    }\n\n    /**\n     * Triggers a search operation by emitting on the searchRequestSubject\n     */\n    triggerSearch(): void {\n        this.searchRequestSubject.next(this._searchRequest());\n    }\n\n    /**\n     * Manually sets the hasChanges flag\n     * Useful for changes that aren't part of the search request but should enable Save View\n     * (e.g., column visibility changes)\n     * @param hasChanges Whether there are changes\n     */\n    setHasChanges(hasChanges: boolean): void {\n        this._hasChanges.set(hasChanges);\n    }\n\n    /**\n     * Adds a filter to the search request\n     * @param filter The filter to add\n     */\n    addFilter(filter: BaseFilter): void {\n        const currentFilters = this.searchRequest().filters || [];\n        this.patchSearchRequest({ filters: [...currentFilters, filter] });\n    }\n\n    /**\n     * Removes a filter by name\n     * @param filterName The name of the filter column to remove\n     */\n    removeFilter(filterName: string): void {\n        const currentFilters = this.searchRequest().filters || [];\n        this.patchSearchRequest({ filters: currentFilters.filter(f => f.column !== filterName) });\n    }\n\n    /**\n     * Removes a filter by index\n     * @param index The index of the filter to remove\n     */\n    removeFilterByIndex(index: number): void {\n        const currentFilters = this.searchRequest().filters || [];\n        this.patchSearchRequest({ filters: currentFilters.filter((_, i) => i !== index) });\n    }\n\n    /**\n     * Updates a specific filter by column name\n     * @param columnName The column name of the filter to update\n     * @param newData Partial filter properties to update\n     */\n    updateFilter(columnName: string, newData: Partial<BaseFilter>): void {\n        const currentFilters = this.searchRequest().filters || [];\n        this.patchSearchRequest({ filters: currentFilters.map(f => f.column === columnName ? { ...f, ...newData } as any : f) });\n    }\n\n    /**\n     * Updates a filter by its index position\n     * @param index The index of the filter to update\n     * @param newData Partial filter properties to update\n     */\n    updateFilterByIndex(index: number, newData: Partial<BaseFilter>): void {\n        const currentFilters = this.searchRequest().filters || [];\n\n        if (index >= 0 && index < currentFilters.length) {\n            this.patchSearchRequest({ filters: currentFilters.map((f, i) => i === index ? { ...f, ...newData } as any : f) });\n        }\n    }\n\n    /**\n     * Clears all filters\n     */\n    clearFilters(): void {\n        this.patchSearchRequest({ filters: [] });\n    }\n\n    /**\n     * Sets the sorting (replaces existing sortings)\n     * @param column The column name to sort by\n     * @param direction The sort direction\n     */\n    setSorting(column: string, direction: any): void {\n        this.patchSearchRequest({ sortings: [{ column, direction }] });\n    }\n\n    /**\n     * Clears all sorting\n     */\n    clearSorting(): void {\n        this.patchSearchRequest({ sortings: [] });\n    }\n\n    /**\n     * Sets the search description/text query\n     * @param description The search text\n     */\n    setDescription(description: string): void {\n        this.patchSearchRequest({ description });\n    }\n\n    /**\n     * Clears the search description\n     */\n    clearDescription(): void {\n        this.patchSearchRequest({ description: '' });\n    }\n\n    /**\n     * Clears ALL search criteria (filters, description, sorting)\n     * Note: Does not reset pagination - use reset() for that\n     */\n    clearAll(): void {\n        this.patchSearchRequest({ filters: [], description: '', sortings: [] });\n    }\n\n    /**\n     * Clears all search criteria except pagination\n     * Useful when you want to reset search but maintain current page\n     */\n    clearAllExceptPagination(): void {\n        this.clearAll();\n    }\n\n    /**\n     * Deep comparison of two search requests\n     * @param a First search request\n     * @param b Second search request\n     * @returns true if they are equal, false otherwise\n     */\n    private areSearchRequestsEqual(a: SearchRequestModel, b: SearchRequestModel): boolean {\n        if ((a.description || '') !== (b.description || '')) {\n            return false;\n        }\n\n        const aFilters = a.filters || [];\n        const bFilters = b.filters || [];\n\n        if (aFilters.length !== bFilters.length) {\n            return false;\n        }\n\n        for (let i = 0; i < aFilters.length; i++) {\n            if (JSON.stringify(aFilters[i]) !== JSON.stringify(bFilters[i])) {\n                return false;\n            }\n        }\n\n        const aSortings = a.sortings || [];\n        const bSortings = b.sortings || [];\n\n        if (aSortings.length !== bSortings.length) {\n            return false;\n        }\n\n        for (let i = 0; i < aSortings.length; i++) {\n            if (JSON.stringify(aSortings[i]) !== JSON.stringify(bSortings[i])) {\n                return false;\n            }\n        }\n\n        if (a.pageSize !== b.pageSize || a.pageIndex !== b.pageIndex) {\n            return false;\n        }\n\n        return true;\n    }\n}\n"]}

package/esm2022/table/services/default-filters-operands.service.mjs

@@ -1,5 +1,5 @@
 import { Injectable, inject } from '@angular/core';
-import { DataTypeEnum } from '@updevs/sdk/stores';
+import { FilterTypeEnum } from '@updevs/sdk/stores';
 import { forkJoin } from 'rxjs';
 import { FiltersOperandsService } from '../abstractions/filters-operands.service';
 import { UpdTableConfigService } from './upd-table-config.service';
@@ -9,6 +9,7 @@ import { NumberFilterOperandsListModel } from '../models/operands-lists/number-f
 import { BooleanFilterOperandsListModel } from '../models/operands-lists/boolean-filter-operands-list.model';
 import { DateFilterOperandsListModel } from '../models/operands-lists/date-filter-operands-list.model';
 import { GuidFilterOperandsListModel } from '../models/operands-lists/guid-filter-operands-list.model';
+import { SelectFilterOperandsListModel } from '../models/operands-lists/select-filter-operands-list.model';
 import * as i0 from "@angular/core";
 export class DefaultFiltersOperandsService extends FiltersOperandsService {
     get isLoaded() {
@@ -22,26 +23,29 @@ export class DefaultFiltersOperandsService extends FiltersOperandsService {
         this.cachedData = {};
         if (!!this.configService.config.urlToLoadOperandsFromServer) {
             forkJoin({
-                guidOps: this.filterOperandsStore.load(DataTypeEnum.Guid),
-                stringOps: this.filterOperandsStore.load(DataTypeEnum.String),
-                numberOps: this.filterOperandsStore.load(DataTypeEnum.Number),
-                dateOps: this.filterOperandsStore.load(DataTypeEnum.Date),
-                booleanOps: this.filterOperandsStore.load(DataTypeEnum.Boolean)
+                guidOps: this.filterOperandsStore.load(FilterTypeEnum.Guid),
+                stringOps: this.filterOperandsStore.load(FilterTypeEnum.Text),
+                numberOps: this.filterOperandsStore.load(FilterTypeEnum.Number),
+                dateOps: this.filterOperandsStore.load(FilterTypeEnum.Date),
+                booleanOps: this.filterOperandsStore.load(FilterTypeEnum.Boolean),
+                selectOps: this.filterOperandsStore.load(FilterTypeEnum.Select)
             }).subscribe(resp => {
-                this.cachedData[DataTypeEnum.Guid] = resp.guidOps;
-                this.cachedData[DataTypeEnum.String] = resp.stringOps;
-                this.cachedData[DataTypeEnum.Number] = resp.numberOps;
-                this.cachedData[DataTypeEnum.Date] = resp.dateOps;
-                this.cachedData[DataTypeEnum.Boolean] = resp.booleanOps;
+                this.cachedData[FilterTypeEnum.Guid] = resp.guidOps;
+                this.cachedData[FilterTypeEnum.Text] = resp.stringOps;
+                this.cachedData[FilterTypeEnum.Number] = resp.numberOps;
+                this.cachedData[FilterTypeEnum.Date] = resp.dateOps;
+                this.cachedData[FilterTypeEnum.Boolean] = resp.booleanOps;
+                this.cachedData[FilterTypeEnum.Select] = resp.selectOps;
                 this._isLoaded = true;
             });
         }
         else {
-            this.cachedData[DataTypeEnum.Guid] = GuidFilterOperandsListModel.optionsAsList;
-            this.cachedData[DataTypeEnum.String] = StringFilterOperandsListModel.optionsAsList;
-            this.cachedData[DataTypeEnum.Number] = NumberFilterOperandsListModel.optionsAsList;
-            this.cachedData[DataTypeEnum.Date] = DateFilterOperandsListModel.optionsAsList;
-            this.cachedData[DataTypeEnum.Boolean] = BooleanFilterOperandsListModel.optionsAsList;
+            this.cachedData[FilterTypeEnum.Guid] = GuidFilterOperandsListModel.optionsAsList;
+            this.cachedData[FilterTypeEnum.Text] = StringFilterOperandsListModel.optionsAsList;
+            this.cachedData[FilterTypeEnum.Number] = NumberFilterOperandsListModel.optionsAsList;
+            this.cachedData[FilterTypeEnum.Date] = DateFilterOperandsListModel.optionsAsList;
+            this.cachedData[FilterTypeEnum.Boolean] = BooleanFilterOperandsListModel.optionsAsList;
+            this.cachedData[FilterTypeEnum.Select] = SelectFilterOperandsListModel.optionsAsList;
             this._isLoaded = true;
         }
     }
@@ -57,4 +61,4 @@ export class DefaultFiltersOperandsService extends FiltersOperandsService {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: DefaultFiltersOperandsService, decorators: [{
             type: Injectable
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"default-filters-operands.service.js","sourceRoot":"","sources":["../../../../../../libs/components/table/src/services/default-filters-operands.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { FilterTypeEnum } from '@updevs/sdk/stores';\nimport { NonNullableDictionaryType } from '@updevs/sdk/types';\nimport { forkJoin } from 'rxjs';\n\nimport { FiltersOperandsService } from '../abstractions/filters-operands.service';\nimport { UpdTableConfigService } from './upd-table-config.service';\nimport { FilterOperandConfig } from '../models/filter-operand.config';\nimport { FiltersOperandsStore } from './stores/filters-operands.store';\nimport { StringFilterOperandsListModel } from '../models/operands-lists/string-filter-operands-list.model';\nimport { NumberFilterOperandsListModel } from '../models/operands-lists/number-filter-operands-list.model';\nimport { BooleanFilterOperandsListModel } from '../models/operands-lists/boolean-filter-operands-list.model';\nimport { DateFilterOperandsListModel } from '../models/operands-lists/date-filter-operands-list.model';\nimport { GuidFilterOperandsListModel } from '../models/operands-lists/guid-filter-operands-list.model';\nimport { SelectFilterOperandsListModel } from '../models/operands-lists/select-filter-operands-list.model';\n\n@Injectable()\nexport class DefaultFiltersOperandsService extends FiltersOperandsService {\n    get isLoaded(): boolean {\n        return this._isLoaded;\n    }\n\n    private _isLoaded = false;\n    private readonly configService = inject(UpdTableConfigService);\n    private readonly filterOperandsStore = inject(FiltersOperandsStore);\n    private readonly cachedData: NonNullableDictionaryType<FilterOperandConfig[]> = {};\n\n    constructor() {\n        super();\n\n        if (!!this.configService.config.urlToLoadOperandsFromServer) {\n            forkJoin({\n                guidOps: this.filterOperandsStore.load(FilterTypeEnum.Guid),\n                stringOps: this.filterOperandsStore.load(FilterTypeEnum.Text),\n                numberOps: this.filterOperandsStore.load(FilterTypeEnum.Number),\n                dateOps: this.filterOperandsStore.load(FilterTypeEnum.Date),\n                booleanOps: this.filterOperandsStore.load(FilterTypeEnum.Boolean),\n                selectOps: this.filterOperandsStore.load(FilterTypeEnum.Select)\n            }).subscribe(resp => {\n                this.cachedData[FilterTypeEnum.Guid] = resp.guidOps;\n                this.cachedData[FilterTypeEnum.Text] = resp.stringOps;\n                this.cachedData[FilterTypeEnum.Number] = resp.numberOps;\n                this.cachedData[FilterTypeEnum.Date] = resp.dateOps;\n                this.cachedData[FilterTypeEnum.Boolean] = resp.booleanOps;\n                this.cachedData[FilterTypeEnum.Select] = resp.selectOps;\n                this._isLoaded = true;\n            });\n        } else {\n            this.cachedData[FilterTypeEnum.Guid] = GuidFilterOperandsListModel.optionsAsList;\n            this.cachedData[FilterTypeEnum.Text] = StringFilterOperandsListModel.optionsAsList;\n            this.cachedData[FilterTypeEnum.Number] = NumberFilterOperandsListModel.optionsAsList;\n            this.cachedData[FilterTypeEnum.Date] = DateFilterOperandsListModel.optionsAsList;\n            this.cachedData[FilterTypeEnum.Boolean] = BooleanFilterOperandsListModel.optionsAsList;\n            this.cachedData[FilterTypeEnum.Select] = SelectFilterOperandsListModel.optionsAsList;\n            this._isLoaded = true;\n        }\n    }\n\n    override getOperands(type: FilterTypeEnum): FilterOperandConfig[] {\n        return this._isLoaded ? this.cachedData[type] : [];\n    }\n\n    override getAllOperands(): NonNullableDictionaryType<FilterOperandConfig[]> {\n        return this.cachedData;\n    }\n}\n"]}

package/esm2022/table/services/stores/filters-operands.store.mjs

@@ -16,4 +16,4 @@ export class FiltersOperandsStore extends BaseStore {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: FiltersOperandsStore, decorators: [{
             type: Injectable
         }], ctorParameters: () => [{ type: i1.UpdTableConfigService }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVycy1vcGVyYW5kcy5zdG9yZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy90YWJsZS9zcmMvc2VydmljZXMvc3RvcmVzL2ZpbHRlcnMtb3BlcmFuZHMuc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsU0FBUyxFQUFnQixNQUFNLG9CQUFvQixDQUFDO0FBRzdELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDZCQUE2QixDQUFDOzs7QUFJcEUsTUFBTSxPQUFPLG9CQUFxQixTQUFRLFNBQVM7SUFDL0MsWUFBWSxhQUFvQztRQUM1QyxLQUFLLENBQUMsRUFBRSxPQUFPLEVBQUUsYUFBYSxDQUFDLE1BQU0sQ0FBQywyQkFBMkIsSUFBSSxFQUFFLEVBQUUsQ0FBQyxDQUFDO0lBQy9FLENBQUM7SUFFRCxJQUFJLENBQUMsU0FBdUI7UUFDeEIsT0FBTyxJQUFJLENBQUMsZUFBZSxDQUFDLE9BQU8sQ0FBd0IsSUFBSSxDQUFDLGVBQWUsQ0FBQyxTQUFTLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQzNHLENBQUM7OEdBUFEsb0JBQW9CO2tIQUFwQixvQkFBb0I7OzJGQUFwQixvQkFBb0I7a0JBRGhDLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBCYXNlU3RvcmUsIERhdGFUeXBlRW51bSB9IGZyb20gJ0B1cGRldnMvc2RrL3N0b3Jlcyc7XG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XG5cbmltcG9ydCB7IFVwZFRhYmxlQ29uZmlnU2VydmljZSB9IGZyb20gJy4uL3VwZC10YWJsZS1jb25maWcuc2VydmljZSc7XG5pbXBvcnQgeyBGaWx0ZXJPcGVyYW5kQ29uZmlnIH0gZnJvbSAnLi4vLi4vbW9kZWxzL2ZpbHRlci1vcGVyYW5kLmNvbmZpZyc7XG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBGaWx0ZXJzT3BlcmFuZHNTdG9yZSBleHRlbmRzIEJhc2VTdG9yZSB7XG4gICAgY29uc3RydWN0b3IoY29uZmlnU2VydmljZTogVXBkVGFibGVDb25maWdTZXJ2aWNlKSB7XG4gICAgICAgIHN1cGVyKHsgYmFzZVVybDogY29uZmlnU2VydmljZS5jb25maWcudXJsVG9Mb2FkT3BlcmFuZHNGcm9tU2VydmVyIHx8ICcnIH0pO1xuICAgIH1cblxuICAgIGxvYWQoZmllbGRUeXBlOiBEYXRhVHlwZUVudW0pOiBPYnNlcnZhYmxlPEZpbHRlck9wZXJhbmRDb25maWdbXT4ge1xuICAgICAgICByZXR1cm4gdGhpcy5fcmVxdWVzdFNlcnZpY2UubWFrZUdldDxGaWx0ZXJPcGVyYW5kQ29uZmlnW10+KHRoaXMuZ2V0UmVxdWVzdE1vZGVsKGZpZWxkVHlwZS50b1N0cmluZygpKSk7XG4gICAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVycy1vcGVyYW5kcy5zdG9yZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy90YWJsZS9zcmMvc2VydmljZXMvc3RvcmVzL2ZpbHRlcnMtb3BlcmFuZHMuc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsU0FBUyxFQUFrQixNQUFNLG9CQUFvQixDQUFDO0FBRy9ELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDZCQUE2QixDQUFDOzs7QUFJcEUsTUFBTSxPQUFPLG9CQUFxQixTQUFRLFNBQVM7SUFDL0MsWUFBWSxhQUFvQztRQUM1QyxLQUFLLENBQUMsRUFBRSxPQUFPLEVBQUUsYUFBYSxDQUFDLE1BQU0sQ0FBQywyQkFBMkIsSUFBSSxFQUFFLEVBQUUsQ0FBQyxDQUFDO0lBQy9FLENBQUM7SUFFRCxJQUFJLENBQUMsU0FBeUI7UUFDMUIsT0FBTyxJQUFJLENBQUMsZUFBZSxDQUFDLE9BQU8sQ0FBd0IsSUFBSSxDQUFDLGVBQWUsQ0FBQyxTQUFTLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQzNHLENBQUM7OEdBUFEsb0JBQW9CO2tIQUFwQixvQkFBb0I7OzJGQUFwQixvQkFBb0I7a0JBRGhDLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBCYXNlU3RvcmUsIEZpbHRlclR5cGVFbnVtIH0gZnJvbSAnQHVwZGV2cy9zZGsvc3RvcmVzJztcbmltcG9ydCB7IE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcblxuaW1wb3J0IHsgVXBkVGFibGVDb25maWdTZXJ2aWNlIH0gZnJvbSAnLi4vdXBkLXRhYmxlLWNvbmZpZy5zZXJ2aWNlJztcbmltcG9ydCB7IEZpbHRlck9wZXJhbmRDb25maWcgfSBmcm9tICcuLi8uLi9tb2RlbHMvZmlsdGVyLW9wZXJhbmQuY29uZmlnJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIEZpbHRlcnNPcGVyYW5kc1N0b3JlIGV4dGVuZHMgQmFzZVN0b3JlIHtcbiAgICBjb25zdHJ1Y3Rvcihjb25maWdTZXJ2aWNlOiBVcGRUYWJsZUNvbmZpZ1NlcnZpY2UpIHtcbiAgICAgICAgc3VwZXIoeyBiYXNlVXJsOiBjb25maWdTZXJ2aWNlLmNvbmZpZy51cmxUb0xvYWRPcGVyYW5kc0Zyb21TZXJ2ZXIgfHwgJycgfSk7XG4gICAgfVxuXG4gICAgbG9hZChmaWVsZFR5cGU6IEZpbHRlclR5cGVFbnVtKTogT2JzZXJ2YWJsZTxGaWx0ZXJPcGVyYW5kQ29uZmlnW10+IHtcbiAgICAgICAgcmV0dXJuIHRoaXMuX3JlcXVlc3RTZXJ2aWNlLm1ha2VHZXQ8RmlsdGVyT3BlcmFuZENvbmZpZ1tdPih0aGlzLmdldFJlcXVlc3RNb2RlbChmaWVsZFR5cGUudG9TdHJpbmcoKSkpO1xuICAgIH1cbn1cbiJdfQ==