@updevs/components 1.0.0-alpha.96 → 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"]}