http-request-manager 18.16.23 → 18.16.25

package/fesm2022/http-request-manager.mjs

@@ -1,11 +1,11 @@
 import * as i0 from '@angular/core';
-import { inject, Injectable, APP_ID, Inject, InjectionToken, isDevMode, signal, effect, computed, Injector, Optional, DestroyRef, EventEmitter, Input, Output, ViewEncapsulation, Component, NgModule, ViewChild } from '@angular/core';
+import { inject, Injectable, APP_ID, Inject, InjectionToken, isDevMode, signal, DestroyRef, computed, effect, Injector, Optional, EventEmitter, Input, Output, ViewEncapsulation, Component, NgModule, ViewChild } from '@angular/core';
 import { ComponentStore } from '@ngrx/component-store';
 import { map, catchError, filter, take, tap, finalize, takeWhile, retry, startWith, mergeMap, takeUntil, concatMap, toArray, withLatestFrom, switchMap, delay, scan, distinctUntilChanged } from 'rxjs/operators';
 import { HttpClient, HttpHeaders, HttpEventType, HttpHeaderResponse, HttpErrorResponse, HTTP_INTERCEPTORS } from '@angular/common/http';
 import * as CryptoJS from 'crypto-js';
 import { from, BehaviorSubject, EMPTY, timer, throwError, defer, interval, Subject, of, merge, Subscription, take as take$1, firstValueFrom, catchError as catchError$1, map as map$1, tap as tap$1, switchMap as switchMap$1, startWith as startWith$1, distinctUntilChanged as distinctUntilChanged$1, combineLatest, filter as filter$1, takeUntil as takeUntil$1, ReplaySubject } from 'rxjs';
-import { toObservable, takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { takeUntilDestroyed, toObservable, toSignal } from '@angular/core/rxjs-interop';
 import { ToastMessageDisplayService, ToastDisplay, ToastColors, ToastMessageDisplayModule } from 'toast-message-display';
 import Dexie from 'dexie';
 import { Parser } from 'node-sql-parser/build/mysql';
@@ -2629,29 +2629,41 @@ class WebSocketSignalsManagerService {
     static { this.connectionStatusSignal = signal(false); }
     static { this.messagesSignal = signal(null); }
     static { this.subscribedChannelsSignal = signal(new Set()); }
+    static { this.isConnectingSignal = signal(false); }
+    static { this.retryCountSignal = signal(0); }
+    static { this.maxRetriesSignal = signal(0); }
+    static { this.connectionErrorSignal = signal(null); }
     constructor() {
         this.wsManager = inject(WebSocketManagerService);
+        this.destroyRef = inject(DestroyRef);
         this.connectionStatus = WebSocketSignalsManagerService.connectionStatusSignal.asReadonly();
-        this.connectionStatus$ = toObservable(WebSocketSignalsManagerService.connectionStatusSignal);
         this.messages = WebSocketSignalsManagerService.messagesSignal.asReadonly();
-        this.messages$ = toObservable(WebSocketSignalsManagerService.messagesSignal);
         this.subscribedChannels = WebSocketSignalsManagerService.subscribedChannelsSignal.asReadonly();
-        this.subscribedChannels$ = toObservable(WebSocketSignalsManagerService.subscribedChannelsSignal);
-        // Sync with WebSocketManagerService state
-        effect(() => {
-            // This effect keeps our signals in sync with the BehaviorSubject-based manager
-            // In a future refactor, we can make WebSocketManagerService signal-based too
-        });
-        // Subscribe to WebSocket messages and update signals
-        this.wsManager.messages$.subscribe(message => {
+        this.isConnecting = WebSocketSignalsManagerService.isConnectingSignal.asReadonly();
+        this.retryCount = WebSocketSignalsManagerService.retryCountSignal.asReadonly();
+        this.maxRetries = WebSocketSignalsManagerService.maxRetriesSignal.asReadonly();
+        this.connectionError = WebSocketSignalsManagerService.connectionErrorSignal.asReadonly();
+        this.wsManager.messages$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(message => {
             WebSocketSignalsManagerService.messagesSignal.set(message);
         });
-        this.wsManager.connectionStatus$.subscribe(status => {
+        this.wsManager.connectionStatus$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(status => {
             WebSocketSignalsManagerService.connectionStatusSignal.set(status);
         });
-        this.wsManager.subscribedChannels$.subscribe(channels => {
+        this.wsManager.subscribedChannels$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(channels => {
             WebSocketSignalsManagerService.subscribedChannelsSignal.set(channels);
         });
+        this.wsManager.isConnecting$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(status => {
+            WebSocketSignalsManagerService.isConnectingSignal.set(status);
+        });
+        this.wsManager.retryCount$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(count => {
+            WebSocketSignalsManagerService.retryCountSignal.set(count);
+        });
+        this.wsManager.maxRetries$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(max => {
+            WebSocketSignalsManagerService.maxRetriesSignal.set(max);
+        });
+        this.wsManager.connectionError$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(err => {
+            WebSocketSignalsManagerService.connectionErrorSignal.set(err);
+        });
     }
     // Connection Management
     connect(options, jwtToken) {
@@ -2731,12 +2743,140 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
                 }]
         }], ctorParameters: () => [] });
 
+/**
+ * ChannelPresenceSignalsService - Signal-based channel presence and metadata tracking.
+ *
+ * Tracks WebSocket messages, channel metadata, and user presence using pure signals.
+ * No Observable bridges — consumers use `toObservable()` at the call site if needed.
+ */
+class ChannelPresenceSignalsService {
+    constructor() {
+        this.wsManager = inject(WebSocketSignalsManagerService);
+        // Signal-based state
+        this.messagesSignal = signal(null);
+        this.messages = this.messagesSignal.asReadonly();
+        this.channelMetadataSignal = signal(new Map());
+        this.channelMetadata = this.channelMetadataSignal.asReadonly();
+        this.usersInChannelsSignal = signal(new Map());
+        this.usersInChannels = this.usersInChannelsSignal.asReadonly();
+        // Computed signals for derived state
+        this.messageCount = computed(() => {
+            const metadata = this.channelMetadataSignal();
+            let count = 0;
+            metadata.forEach(data => count += data.count);
+            return count;
+        });
+        this.activeChannels = computed(() => {
+            return Array.from(this.channelMetadataSignal().keys());
+        });
+        // Track messages from WebSocket
+        effect(() => {
+            const message = this.wsManager.messages();
+            if (message) {
+                this.trackMessage(message);
+            }
+        });
+        // Track connection status
+        effect(() => {
+            const connected = this.wsManager.connectionStatus();
+            if (!connected) {
+                this.onDisconnect();
+            }
+        });
+    }
+    trackMessage(message) {
+        this.messagesSignal.set(message);
+        if (message.channel) {
+            this.updateChannelMetadata(message.channel, message);
+        }
+        if (message.user && message.channel) {
+            this.updateUserPresence(message.channel, message.user);
+        }
+    }
+    updateChannelMetadata(channel, message) {
+        this.channelMetadataSignal.update(metadata => {
+            const updated = new Map(metadata);
+            const current = updated.get(channel) || { count: 0, lastMessage: null, lastUpdated: 0 };
+            updated.set(channel, {
+                ...current,
+                count: current.count + 1,
+                lastMessage: message,
+                lastUpdated: Date.now()
+            });
+            return updated;
+        });
+    }
+    updateUserPresence(channel, user) {
+        this.usersInChannelsSignal.update(users => {
+            const updated = new Map(users);
+            const channelUsers = new Set(updated.get(channel) || []);
+            channelUsers.add(user);
+            updated.set(channel, channelUsers);
+            return updated;
+        });
+    }
+    removeUserFromChannel(channel, user) {
+        this.usersInChannelsSignal.update(users => {
+            const updated = new Map(users);
+            const channelUsers = updated.get(channel);
+            if (channelUsers) {
+                channelUsers.delete(user);
+                updated.set(channel, channelUsers);
+            }
+            return updated;
+        });
+    }
+    subscribeToChannel(channel) {
+        this.wsManager.subscribeToChannel(channel);
+    }
+    unsubscribeFromChannel(channel) {
+        this.wsManager.unsubscribeFromChannel(channel);
+        this.removeUserFromChannel(channel, 'current-user');
+    }
+    // Selectors
+    getMessageCount(channel) {
+        const metadata = this.channelMetadataSignal();
+        return metadata.get(channel)?.count || 0;
+    }
+    getLastMessage(channel) {
+        const metadata = this.channelMetadataSignal();
+        return metadata.get(channel)?.lastMessage || null;
+    }
+    getActiveChannels() {
+        return Array.from(this.channelMetadataSignal().keys());
+    }
+    getUsersInChannel(channel) {
+        const users = this.usersInChannelsSignal().get(channel);
+        return users ? Array.from(users) : [];
+    }
+    onDisconnect() {
+        this.messagesSignal.set(null);
+        this.channelMetadataSignal.set(new Map());
+        this.usersInChannelsSignal.set(new Map());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChannelPresenceSignalsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChannelPresenceSignalsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChannelPresenceSignalsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * @deprecated Use `ChannelPresenceSignalsService` instead.
+ * This file is kept for backwards compatibility only.
+ */
 /**
  * MessageTrackerSignalsService - Signal-based message tracking
  *
  * Tracks WebSocket messages, channel metadata, and user presence using signals.
  * Provides real-time reactivity for message-driven applications.
  */
+/**
+ * @deprecated Use `ChannelPresenceSignalsService` from `channel-presence-signals.service.ts` instead.
+ */
 class MessageTrackerSignalsService {
     constructor() {
         this.wsManager = inject(WebSocketSignalsManagerService);
@@ -4301,6 +4441,7 @@ class RequestSignalsService extends WebsocketService {
         this.headersService = inject(HeadersService);
         this.isPending = signal(false);
         this.progress = signal(0);
+        this.streamProgress = signal(new StreamProgressModel());
         this.isIdle = computed(() => !this.isPending());
     }
     // Implementation
@@ -4314,7 +4455,7 @@ class RequestSignalsService extends WebsocketService {
                 observe: 'events',
                 responseType: 'text',
                 reportProgress: true
-            }).pipe(requestStreaming(StreamConfigModel.adapt({ streamType: options.streamType || StreamType.AI_STREAMING })), this.requestStreamingOperator(options), this.handleFinalize())
+            }).pipe(requestStreaming(StreamConfigModel.adapt({ streamType: options.streamType || StreamType.NDJSON, totalHeader: 'X-Total-Count' })), this.requestStreamingOperator(options), this.handleFinalize())
             : this.http.get(urlPath, headers).pipe(this.request(options), this.handleFinalize());
     }
     // Implementation
@@ -4328,7 +4469,7 @@ class RequestSignalsService extends WebsocketService {
                 observe: 'events',
                 responseType: 'text',
                 reportProgress: true
-            }).pipe(requestStreaming(StreamConfigModel.adapt({ streamType: options.streamType || StreamType.AI_STREAMING })), this.requestStreamingOperator(options), this.handleFinalize())
+            }).pipe(requestStreaming(StreamConfigModel.adapt({ streamType: options.streamType || StreamType.NDJSON, totalHeader: 'X-Total-Count' })), this.requestStreamingOperator(options), this.handleFinalize())
             : this.http.post(urlPath, data, headers).pipe(this.request(options), this.handleFinalize());
     }
     updateRecordRequest(options, data) {
@@ -4372,6 +4513,7 @@ class RequestSignalsService extends WebsocketService {
         return (source$) => {
             return source$.pipe(tap(output => {
                 this.progress.set(output.progress.received);
+                this.streamProgress.set({ ...output.progress, stage: 'streaming' });
             }), map(output => {
                 const data = output.data;
                 if (!data || (Array.isArray(data) && data.length === 0)) {
@@ -4381,6 +4523,9 @@ class RequestSignalsService extends WebsocketService {
                     return data.map((item) => options.adapter(item));
                 }
                 return data;
+            }), finalize(() => this.streamProgress.update(p => ({ ...p, stage: 'complete' }))), catchError(err => {
+                this.streamProgress.update(p => ({ ...p, stage: 'error' }));
+                return throwError(() => err);
             }));
         };
     }
@@ -4404,9 +4549,10 @@ class RequestSignalsService extends WebsocketService {
                 case HttpEventType.Response:
                     try {
                         const fileNamePath = (options?.saveAs) ? options.saveAs : (options.path) ? options.path[options.path.length - 1] : [];
-                        const header_content = event.headers.get('Content-Disposition') || '';
+                        const fileContentHeader = options.fileContentHeader || 'Content-Disposition';
+                        const header_content = event.headers.get(fileContentHeader) || '';
                         const file = (header_content) ? header_content.split('=')[1].substring(0, header_content.split('=')[1].length) : '';
-                        const fileName = (fileNamePath !== '') ? fileNamePath : file;
+                        const fileName = file ? file : fileNamePath;
                         if (fileName === '') {
                             this.isPending.set(false);
                             throw new Error('Save File: (file name and extension) not found in Headers or Path');
@@ -4588,6 +4734,10 @@ class HTTPManagerSignalsService extends RequestSignalsService {
         this.countdown = signal(0);
         this.error = signal(false);
         this.data = signal(null);
+        this.isConnecting = toSignal(this.wsManager.isConnecting$, { initialValue: false });
+        this.retryCount = toSignal(this.wsManager.retryCount$, { initialValue: 0 });
+        this.maxRetries = toSignal(this.wsManager.maxRetries$, { initialValue: 0 });
+        this.connectionError = toSignal(this.wsManager.connectionError$, { initialValue: null });
         this.polling$ = new Subject();
         this.config = ApiRequest.adapt();
         this.config = configOptions
@@ -4727,6 +4877,7 @@ class HTTPManagerSignalsService extends RequestSignalsService {
     getRequest(options, params) {
         this.isPending.set(true);
         this.data.set(null);
+        this.streamProgress.set(new StreamProgressModel());
         const updatedOptions = this.defineReqOptions(options, params);
         const func = this.getRecordRequest;
         const requests = this.createRequest(func, updatedOptions);
@@ -4798,6 +4949,7 @@ class HTTPManagerSignalsService extends RequestSignalsService {
     }
     downloadRequest(options, params, saveAs) {
         this.isPending.set(true);
+        this.streamProgress.set(new StreamProgressModel());
         const updatedOptions = this.defineReqOptions(options, params);
         const func = this.downloadFileRequest;
         const requests = this.createRequest(func, updatedOptions);
@@ -4891,7 +5043,7 @@ class HTTPManagerSignalsService extends RequestSignalsService {
         return { options: options, data: data };
     }
     handleError(error) {
-        this.error.set(error.message || `${error.status} - ${error.statusText}`);
+        this.error.set(true);
         return throwError(() => error);
     }
     handleErrorWithSnackBar(error, message) {
@@ -5536,6 +5688,18 @@ class LocalStorageManagerService extends ComponentStore {
             }
         }
         settings.forEach(store => {
+            // normalize expiresIn → expires so TTL is always a numeric timestamp
+            if ((!store.options?.expires || store.options.expires === 0) && store.options?.expiresIn) {
+                try {
+                    const computed = this.utils.expires(store.options.expiresIn);
+                    if (store.options)
+                        store.options.expires = computed || 0;
+                }
+                catch {
+                    if (store.options)
+                        store.options.expires = 0;
+                }
+            }
             const expired = (store.options?.expires || 0) > 0 && this.utils.hasExpired(store.options?.expires || 0);
             if (!expired) {
                 const hasStorage = this.hasGlobalStorage(store.options?.storage, store.id || '');
@@ -5708,7 +5872,7 @@ class LocalStorageSignalsManagerService {
         this.storeExists = (store) => computed(() => !!this.state().settings.find(item => item.name === store));
         this.store = (store) => computed(() => {
             const data = this.state();
-            const foundStore = data.settings.find(item => item.name === store);
+            const foundStore = [...data.settings].reverse().find(item => item.name === store);
             if (!foundStore)
                 return null;
             const options = SettingOptions.adapt(foundStore.options);
@@ -5782,6 +5946,9 @@ class LocalStorageSignalsManagerService {
             const settings = StorageOption.adapt(store);
             settings.options = this.objectMergerService.mergeStorageOptions(settings.options);
             store.name = this.validStoreName(store.name);
+            if (!this.hasGlobalStorage(store.options?.storage, store.id)) {
+                return state;
+            }
             const str = this.encryptionTest.isEncrypted(store.data) ? store.data : JSON.stringify(store.data);
             const dataStr = this.isObjectOrArray(str) && store.options.encrypted
                 ? this.encryption.encrypt(str, this.app.appID)
@@ -6514,6 +6681,54 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
                 }]
         }], ctorParameters: () => [] });
 
+class DatabaseManagerSignalsService {
+    constructor() {
+        this.dbManager = inject(DatabaseManagerService);
+        this.isPendingSignal = signal(false);
+        this.tablesSignal = signal([]);
+        this.databaseReadySignal = signal(false);
+        this.isPending = this.isPendingSignal.asReadonly();
+        this.tables = this.tablesSignal.asReadonly();
+        this.databaseReady = this.databaseReadySignal.asReadonly();
+    }
+    getDatabaseTables() {
+        this.isPendingSignal.set(true);
+        return this.dbManager.getDatabaseTables().pipe(tap((t) => this.tablesSignal.set(t)), finalize(() => this.isPendingSignal.set(false)));
+    }
+    databaseExists() {
+        this.isPendingSignal.set(true);
+        return this.dbManager.databaseExists().pipe(tap((exists) => this.databaseReadySignal.set(exists)), finalize(() => this.isPendingSignal.set(false)));
+    }
+    hasDatabaseTable(table) {
+        this.isPendingSignal.set(true);
+        return this.dbManager.hasDatabaseTable(table).pipe(finalize(() => this.isPendingSignal.set(false)));
+    }
+    getDatabaseTable(table) {
+        this.isPendingSignal.set(true);
+        return this.dbManager.getDatabaseTable(table).pipe(finalize(() => this.isPendingSignal.set(false)));
+    }
+    getDatabaseTableSchema(table) {
+        this.isPendingSignal.set(true);
+        return this.dbManager.getDatabaseTableSchema(table).pipe(finalize(() => this.isPendingSignal.set(false)));
+    }
+    createDatabaseTable(tableDef) {
+        this.isPendingSignal.set(true);
+        return this.dbManager.createDatabaseTable(tableDef).pipe(tap(() => this.getDatabaseTables().subscribe()), finalize(() => this.isPendingSignal.set(false)));
+    }
+    updateDatabaseTableSchema(tableDef) {
+        this.isPendingSignal.set(true);
+        return this.dbManager.updateDatabaseTableSchema(tableDef).pipe(finalize(() => this.isPendingSignal.set(false)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DatabaseManagerSignalsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DatabaseManagerSignalsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DatabaseManagerSignalsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
 class ChannelMessage {
     constructor(messageId, channel, isReplay, sessionId = null, content = null, timestamp) {
         this.messageId = messageId;
@@ -7363,7 +7578,7 @@ class HTTPManagerStateService extends ComponentStore {
                                     Object.keys(currentStateData).length > 0) {
                                     return of({ data: currentStateData, fromCache: true });
                                 }
-                                return of({ data: this.dataType === DataType.ARRAY ? [] : {}, fromCache: true });
+                                return fetchStreamFromAPI();
                             }));
                         }
                         return fetchStreamFromAPI();
@@ -8036,6 +8251,7 @@ class HTTPManagerStateService extends ComponentStore {
             data: { ...this.databaseOptions, expires: 0 }
         });
         this._requestCachePaths.delete(tableName);
+        this.clearRequestCacheMetadata(tableName);
         this.dbManagerService.clearTable(tableName).subscribe({
             next: () => {
                 if (this.dataType === DataType.ARRAY) {
@@ -8188,6 +8404,7 @@ class HTTPManagerStateService extends ComponentStore {
             const currentCache = storeData?.requestCache || {};
             const currentEntry = currentCache[type] || {};
             const currentQueryParams = { ...(currentEntry.queryParams || {}) };
+            const currentQueryCombinations = [...(currentEntry.queryCombinations || [])];
             const currentQueryParamsExpires = currentEntry.queryParamsExpires ?? null;
             this.localStorageManagerService.updateStore({
                 name: tableName,
@@ -8201,6 +8418,7 @@ class HTTPManagerStateService extends ComponentStore {
                             savedAt: Date.now(),
                             path: this.resolvePath(options?.path),
                             headers: this.filterHeaders(options?.headers),
+                            queryCombinations: currentQueryCombinations,
                             queryParams: currentQueryParams,
                             queryParamsExpires: currentQueryParamsExpires,
                         }
@@ -8252,10 +8470,13 @@ class HTTPManagerStateService extends ComponentStore {
                 });
             }
         });
+        const sortedKeys = Object.keys(query).sort();
+        const queryString = sortedKeys.map((k) => `${k}=${query[k]}`).join('&');
         return {
             pathKey: this.trackerNormalizePathSegments(pathSegments),
             query,
-            hasQuery: Object.keys(query).length > 0,
+            queryString,
+            hasQuery: sortedKeys.length > 0,
         };
     }
     trackerParsePathSegment(rawSegment) {
@@ -8352,27 +8573,57 @@ class HTTPManagerStateService extends ComponentStore {
         }
         const meta = this.getRequestCacheMetadata(storeData, type) || {};
         const now = Math.floor(Date.now() / 1000);
-        let queryParams = { ...(meta.queryParams || {}) };
+        // Build the combination string from the filtered query (deterministic because keys are sorted)
+        const combinationString = keys.sort().map((k) => `${k}=${filtered[k]}`).join('&');
+        // Legacy per-key queryParams for backward compatibility (read-only)
+        const queryParams = { ...(meta.queryParams || {}) };
         let queryParamsExpires = meta.queryParamsExpires ?? null;
-        // Reset queryParams if the request path has changed (different endpoint)
-        const storedPathKey = meta.path ? this.trackerNormalizePathSegments(meta.path.filter((p) => typeof p === 'string' || typeof p === 'number').map(String)) : null;
+        // New combination-based tracking
+        let queryCombinations = [...(meta.queryCombinations || [])];
+        // Reset combinations if the request path has changed (different endpoint)
+        // Use trackerNormalizePath so inline query strings (e.g. 'items?a=1') are stripped
+        // before comparing, matching the same normalization applied to the current request.
+        const storedPathKey = meta.path
+            ? this.trackerNormalizePath(meta.path.filter((p) => typeof p === 'string' || typeof p === 'number').map(String)).pathKey
+            : null;
         if (storedPathKey && storedPathKey !== normalized.pathKey) {
-            queryParams = {};
+            queryCombinations = [];
+            // Also clear legacy per-key tracking so old data from a different path doesn't block
+            Object.keys(queryParams).forEach((k) => delete queryParams[k]);
             queryParamsExpires = null;
         }
         if (queryParamsExpires !== null && queryParamsExpires <= now) {
-            queryParams = {};
+            queryCombinations = [];
             queryParamsExpires = null;
+            Object.keys(queryParams).forEach((k) => delete queryParams[k]);
+        }
+        // Determine if request is accepted (not yet tracked)
+        // Use combination-based tracking when available; fall back to legacy per-key tracking
+        let accepted;
+        if (queryCombinations.length > 0) {
+            accepted = !queryCombinations.includes(combinationString);
+        }
+        else if (Object.keys(queryParams).length > 0) {
+            // Legacy per-key backward compatibility
+            accepted = !keys.every((key) => {
+                const consumed = queryParams[key] || [];
+                return consumed.includes(filtered[key]);
+            });
+        }
+        else {
+            accepted = true;
+        }
+        if (accepted) {
+            queryCombinations = [...queryCombinations, combinationString];
+            // Also update legacy queryParams so existing consumers still work
+            keys.forEach(key => {
+                const value = filtered[key];
+                const consumed = queryParams[key] || [];
+                if (!consumed.includes(value)) {
+                    queryParams[key] = [...consumed, value];
+                }
+            });
         }
-        let accepted = false;
-        keys.forEach(key => {
-            const value = filtered[key];
-            const consumed = queryParams[key] || [];
-            if (!consumed.includes(value)) {
-                queryParams[key] = [...consumed, value];
-                accepted = true;
-            }
-        });
         const newExpiry = this.trackerBuildExpiryEpoch(options?.queryParamsExpiresIn);
         if (newExpiry !== null) {
             queryParamsExpires = newExpiry;
@@ -8389,6 +8640,7 @@ class HTTPManagerStateService extends ComponentStore {
                             ...currentCache,
                             [type]: {
                                 ...currentEntry,
+                                queryCombinations,
                                 queryParams,
                                 queryParamsExpires,
                             }
@@ -8412,6 +8664,214 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
                     args: ["dataType"]
                 }] }, { type: DatabaseStorage }] });
 
+class HTTPManagerStateSignalsService {
+    constructor() {
+        // --- Injected services ---
+        this.httpManagerSignalsService = inject(HTTPManagerSignalsService);
+        this.databaseManagerSignalsService = inject(DatabaseManagerSignalsService);
+        this.localStorageSignalsManagerService = inject(LocalStorageSignalsManagerService);
+        this.utils = inject(UtilsService);
+        this.logger = inject(LoggerService);
+        this.destroyRef = inject(DestroyRef);
+        this.injector = inject(Injector);
+        // --- Own state signals (private writable, public readonly) ---
+        this.dataSignal = signal([]);
+        this.dataObjectSignal = signal(null);
+        this.operationSuccessSignal = signal(null);
+        this.pageSignal = signal(0);
+        this.totalPagesSignal = signal(0);
+        this.percentageSignal = signal(0);
+        this.streamedResponseSignal = signal([]);
+        this.messagesSignal = signal([]);
+        // --- Public readonly state ---
+        this.data = this.dataSignal.asReadonly();
+        this.dataObject = this.dataObjectSignal.asReadonly();
+        this.operationSuccess = this.operationSuccessSignal.asReadonly();
+        this.page = this.pageSignal.asReadonly();
+        this.totalPages = this.totalPagesSignal.asReadonly();
+        this.percentage = this.percentageSignal.asReadonly();
+        this.streamedResponse = this.streamedResponseSignal.asReadonly();
+        this.messages = this.messagesSignal.asReadonly();
+        // --- Delegated signals from HTTPManagerSignalsService ---
+        this.error = this.httpManagerSignalsService.error;
+        this.isPending = this.httpManagerSignalsService.isPending;
+        this.isConnecting = this.httpManagerSignalsService.isConnecting;
+        this.retryCount = this.httpManagerSignalsService.retryCount;
+        this.maxRetries = this.httpManagerSignalsService.maxRetries;
+        this.connectionError = this.httpManagerSignalsService.connectionError;
+        // Accumulate WS messages via effect instead of scan() operators
+        effect(() => {
+            const msg = this.httpManagerSignalsService.data();
+            if (msg !== null && msg !== undefined) {
+                this.messagesSignal.update(msgs => [...msgs, msg]);
+            }
+        }, { injector: this.injector });
+    }
+    // --- State setters ---
+    setData(items) {
+        this.dataSignal.set(items);
+    }
+    setDataObject(item) {
+        this.dataObjectSignal.set(item);
+    }
+    setOperationSuccess(result) {
+        this.operationSuccessSignal.set(result);
+    }
+    setPage(n) {
+        this.pageSignal.set(n);
+    }
+    setTotalPages(n) {
+        this.totalPagesSignal.set(n);
+    }
+    setPercentage(n) {
+        this.percentageSignal.set(n);
+    }
+    appendStreamedItem(item) {
+        this.streamedResponseSignal.update(items => [...items, item]);
+    }
+    clearStreamedResponse() {
+        this.streamedResponseSignal.set([]);
+    }
+    clearMessages() {
+        this.messagesSignal.set([]);
+    }
+    // --- HTTP methods delegated to HTTPManagerSignalsService ---
+    getRequest(options, params) {
+        return this.httpManagerSignalsService.getRequest(options, params);
+    }
+    postRequest(data, options, params) {
+        return this.httpManagerSignalsService.postRequest(data, options, params);
+    }
+    putRequest(data, options, params) {
+        return this.httpManagerSignalsService.putRequest(data, options, params);
+    }
+    deleteRequest(options, params) {
+        return this.httpManagerSignalsService.deleteRequest(options, params);
+    }
+    downloadRequest(options, params, saveAs) {
+        return this.httpManagerSignalsService.downloadRequest(options, params, saveAs);
+    }
+    uploadRequest(files, options, params) {
+        return this.httpManagerSignalsService.uploadRequest(files, options, params);
+    }
+    getBatchRequests(requests, options) {
+        return this.httpManagerSignalsService.getBatchRequests(requests, options);
+    }
+    getSequentialRequest(requests, options) {
+        return this.httpManagerSignalsService.getSequentialRequest(requests, options);
+    }
+    getParallelRequest(requests, options) {
+        return this.httpManagerSignalsService.getParallelRequest(requests, options);
+    }
+    // --- WS control methods delegated to HTTPManagerSignalsService ---
+    connect(options, jwtToken) {
+        this.httpManagerSignalsService.connect(options, jwtToken);
+    }
+    disconnect() {
+        this.httpManagerSignalsService.disconnect();
+    }
+    subscribeToChannel(channel, userData) {
+        this.httpManagerSignalsService.subscribeToChannel(channel, userData);
+    }
+    subscribeToChannels(channels, userData) {
+        this.httpManagerSignalsService.subscribeToChannels(channels, userData);
+    }
+    unsubscribeFromChannel(channel) {
+        this.httpManagerSignalsService.unsubscribeFromChannel(channel);
+    }
+    getSubscribedChannels() {
+        return this.httpManagerSignalsService.getSubscribedChannels();
+    }
+    sendBroadcast(content) {
+        this.httpManagerSignalsService.sendBroadcast(content);
+    }
+    sendMessageInChannel(channel, content) {
+        this.httpManagerSignalsService.sendMessageInChannel(channel, content);
+    }
+    sendChannelMessage(channel, content) {
+        this.httpManagerSignalsService.sendChannelMessage(channel, content);
+    }
+    sendChannelMessageToChannels(channels, content) {
+        this.httpManagerSignalsService.sendChannelMessageToChannels(channels, content);
+    }
+    sendMessageToUser(user, content) {
+        this.httpManagerSignalsService.sendMessageToUser(user, content);
+    }
+    getAllChannels() {
+        this.httpManagerSignalsService.getAllChannels();
+    }
+    createChannel(channel) {
+        this.httpManagerSignalsService.createChannel(channel);
+    }
+    deleteChannel(channel) {
+        this.httpManagerSignalsService.deleteChannel(channel);
+    }
+    getUsersInChannel(channel) {
+        this.httpManagerSignalsService.getUsersInChannel(channel);
+    }
+    createNotificationChannel(channel) {
+        this.httpManagerSignalsService.createNotificationChannel(channel);
+    }
+    getNotificationChannels() {
+        this.httpManagerSignalsService.getNotificationChannels();
+    }
+    getTodaysNotificationChannels() {
+        this.httpManagerSignalsService.getTodaysNotificationChannels();
+    }
+    subscribeToNotificationChannel(channel, options, user) {
+        this.httpManagerSignalsService.subscribeToNotificationChannel(channel, options, user);
+    }
+    unsubscribeFromNotificationChannel(channel) {
+        this.httpManagerSignalsService.unsubscribeFromNotificationChannel(channel);
+    }
+    sendNotification(channel, content) {
+        this.httpManagerSignalsService.sendNotification(channel, content);
+    }
+    // --- DB methods delegated to DatabaseManagerSignalsService ---
+    getDatabaseTables() {
+        return this.databaseManagerSignalsService.getDatabaseTables();
+    }
+    databaseExists() {
+        return this.databaseManagerSignalsService.databaseExists();
+    }
+    hasDatabaseTable(table) {
+        return this.databaseManagerSignalsService.hasDatabaseTable(table);
+    }
+    getDatabaseTable(table) {
+        return this.databaseManagerSignalsService.getDatabaseTable(table);
+    }
+    getDatabaseTableSchema(table) {
+        return this.databaseManagerSignalsService.getDatabaseTableSchema(table);
+    }
+    createDatabaseTable(tableDef) {
+        return this.databaseManagerSignalsService.createDatabaseTable(tableDef);
+    }
+    updateDatabaseTableSchema(tableDef) {
+        return this.databaseManagerSignalsService.updateDatabaseTableSchema(tableDef);
+    }
+    // --- localStorage methods delegated to LocalStorageSignalsManagerService ---
+    createStore(store) {
+        this.localStorageSignalsManagerService.createStore(store);
+    }
+    setStore(store) {
+        this.localStorageSignalsManagerService.setStore(store);
+    }
+    updateStore(store) {
+        this.localStorageSignalsManagerService.updateStore(store);
+    }
+    deleteStore(store) {
+        this.localStorageSignalsManagerService.deleteStore(store);
+    }
+    getStore(storeName) {
+        return this.localStorageSignalsManagerService.store(storeName);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HTTPManagerStateSignalsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HTTPManagerStateSignalsService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HTTPManagerStateSignalsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
 class StateStorageOptions {
     constructor(store, options, model) {
         this.store = store;
@@ -8567,6 +9027,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
 class StoreStateManagerSignalsService {
     constructor() {
         this.localStorageManagerService = inject(LocalStorageSignalsManagerService);
+        this.injector = inject(Injector);
         this.state = signal(null);
         this.isRestoring = false;
         this.settings = null;
@@ -8583,6 +9044,8 @@ class StoreStateManagerSignalsService {
         });
     }
     init(options) {
+        if (this.settings !== null)
+            return;
         this.settings = options;
         const storeName = options.store ?? 'temp';
         // Create store in localStorage
@@ -8600,7 +9063,7 @@ class StoreStateManagerSignalsService {
             if (storeData && !this.isRestoring) {
                 this.state.set(storeData);
             }
-        });
+        }, { injector: this.injector });
     }
     restoreState() {
         if (!this.settings)
@@ -13772,5 +14235,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { ApiRequest, AppService, AsymmetricalEncryptionService, BatchOptions, BatchResult, CONFIG_SETTINGS_TOKEN, ChannelType, ConfigHTTPOptions, ConfigOptions, DataType, DatabaseDataDemoComponent, DatabaseManagerService, DatabaseStorage, DbService, DexieSqlService, ErrorDisplaySettings, ExecutionPlanType, GlobalStoreOptions, HTTPManagerService, HTTPManagerSignalsService, HTTPManagerStateService, HeadersService, HttpRequestManagerModule, HttpRequestServicesDemoComponent, InvalidFileInfoModel, LocalStorageDemoComponent, LocalStorageManagerService, LocalStorageOptions, LocalStorageSignalsDemoComponent, LocalStorageSignalsManagerService, LoggerService, NotificationMessage, OperationResultModel, ParsingResultModel, PathQueryService, PublicMessage, Random, RandomHSLColor, RandomHexColor, RandomNumber, RandomNumbers, RandomNumbersUnique, RandomPaletteColor, RandomSignature, RandomStr, RandomVisibleColor, RequestErrorInterceptor, RequestHeadersInterceptor, RequestManagerDemoComponent, RequestManagerStateDemoComponent, RequestOptions, RequestService, RequestSignalsService, RetryOptions, SettingOptions, SqlParseError, SqlValidationError, StateMessage, StateOperationResult, StateStorageOptions, StorageData, StorageOption, StorageType, StoreStateManagerService, StoreStateManagerSignalsService, StoreStateSignalsDemoComponent, StreamConfigModel, StreamEventMetadataModel, StreamEventModel, StreamOutputModel, StreamProgressModel, StreamType, SymmetricalEncryptionService, TableSchemaDef, UUID, UUID_STR, UploadDemoComponent, UploadValidationErrorModel, UserData, UtilsService, WSOptions, WebSocketMessageService, WithCredentialsInterceptor, calculateBatchProgress, countdown, createChannelName, delayedRetry, isErrorState, isPendingState, isSuccessState, requestPolling, requestStreaming, streamAI, streamAuto, streamEvents, streamJSON, streamNDJSON };
+export { ApiRequest, AppService, AsymmetricalEncryptionService, BatchOptions, BatchResult, CONFIG_SETTINGS_TOKEN, ChannelType, ConfigHTTPOptions, ConfigOptions, DataType, DatabaseDataDemoComponent, DatabaseManagerService, DatabaseManagerSignalsService, DatabaseStorage, DbService, DexieSqlService, ErrorDisplaySettings, ExecutionPlanType, GlobalStoreOptions, HTTPManagerService, HTTPManagerSignalsService, HTTPManagerStateService, HTTPManagerStateSignalsService, HeadersService, HttpRequestManagerModule, HttpRequestServicesDemoComponent, InvalidFileInfoModel, LocalStorageDemoComponent, LocalStorageManagerService, LocalStorageOptions, LocalStorageSignalsDemoComponent, LocalStorageSignalsManagerService, LoggerService, NotificationMessage, OperationResultModel, ParsingResultModel, PathQueryService, PublicMessage, Random, RandomHSLColor, RandomHexColor, RandomNumber, RandomNumbers, RandomNumbersUnique, RandomPaletteColor, RandomSignature, RandomStr, RandomVisibleColor, RequestErrorInterceptor, RequestHeadersInterceptor, RequestManagerDemoComponent, RequestManagerStateDemoComponent, RequestOptions, RequestService, RequestSignalsService, RetryOptions, SettingOptions, SqlParseError, SqlValidationError, StateMessage, StateOperationResult, StateStorageOptions, StorageData, StorageOption, StorageType, StoreStateManagerService, StoreStateManagerSignalsService, StoreStateSignalsDemoComponent, StreamConfigModel, StreamEventMetadataModel, StreamEventModel, StreamOutputModel, StreamProgressModel, StreamType, SymmetricalEncryptionService, TableSchemaDef, UUID, UUID_STR, UploadDemoComponent, UploadValidationErrorModel, UserData, UtilsService, WSOptions, WebSocketMessageService, WithCredentialsInterceptor, calculateBatchProgress, countdown, createChannelName, delayedRetry, isErrorState, isPendingState, isSuccessState, requestPolling, requestStreaming, streamAI, streamAuto, streamEvents, streamJSON, streamNDJSON };
 //# sourceMappingURL=http-request-manager.mjs.map