@angular-helpers/browser-web-apis 21.5.0 → 21.7.0

package/fesm2022/angular-helpers-browser-web-apis.mjs

@@ -1,9 +1,9 @@
 import * as i0 from '@angular/core';
 import { InjectionToken, inject, DestroyRef, PLATFORM_ID, Injectable, signal, computed, isSignal, effect, ElementRef, makeEnvironmentProviders } from '@angular/core';
 import { isPlatformBrowser, isPlatformServer } from '@angular/common';
-import { Observable, fromEvent, BehaviorSubject, Subject, of, map as map$1 } from 'rxjs';
-import { takeUntilDestroyed, toObservable } from '@angular/core/rxjs-interop';
-import { filter, distinctUntilChanged, map } from 'rxjs/operators';
+import { Observable, fromEvent, Subject, of, map as map$1 } from 'rxjs';
+import { toObservable, takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { filter, map, distinctUntilChanged } from 'rxjs/operators';
 import { Router } from '@angular/router';
 
 const BROWSER_API_LOGGER = new InjectionToken('BROWSER_API_LOGGER', {
@@ -779,255 +779,340 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImpor
             type: Injectable
         }] });
 
-class WebStorageService extends BrowserApiBaseService {
-    storageEvents = signal(null, ...(ngDevMode ? [{ debugName: "storageEvents" }] : /* istanbul ignore next */ []));
-    constructor() {
-        super();
-        this.setupEventListeners();
-    }
-    getApiName() {
-        return 'storage';
-    }
-    ensureSupported() {
-        super.ensureSupported();
-        if (typeof Storage === 'undefined') {
-            throw new Error('Storage API not supported in this browser');
-        }
-    }
-    setupEventListeners() {
-        if (this.isBrowserEnvironment()) {
-            fromEvent(window, 'storage')
-                .pipe(takeUntilDestroyed(this.destroyRef))
-                .subscribe((event) => {
-                const storageEvent = event;
-                const area = storageEvent.storageArea === localStorage ? 'localStorage' : 'sessionStorage';
-                this.storageEvents.set({
-                    key: storageEvent.key,
-                    newValue: storageEvent.newValue ? this.deserializeValue(storageEvent.newValue) : null,
-                    oldValue: storageEvent.oldValue ? this.deserializeValue(storageEvent.oldValue) : null,
-                    storageArea: area,
-                });
-            });
-        }
-    }
-    serializeValue(value, options) {
-        if (options?.serialize) {
-            return options.serialize(value);
-        }
-        return JSON.stringify(value);
+const SECURITY_WARN_KEY = Symbol('storage-security-warned');
+/**
+ * Implementation of `StorageNamespace` shared by `local` and `session` namespaces.
+ * Wraps every native access in try/catch so Safari private mode and sandboxed iframes
+ * (which throw `SecurityError`) degrade gracefully instead of crashing the app.
+ */
+class StorageNamespaceImpl {
+    area;
+    events;
+    logger;
+    supportedCache = null;
+    constructor(area, events, logger) {
+        this.area = area;
+        this.events = events;
+        this.logger = logger;
     }
-    deserializeValue(value, options) {
-        if (value === null)
-            return null;
-        if (options?.deserialize) {
-            return options.deserialize(value);
+    isSupported() {
+        if (this.supportedCache !== null)
+            return this.supportedCache;
+        if (typeof window === 'undefined' || typeof Storage === 'undefined') {
+            this.supportedCache = false;
+            return false;
         }
         try {
-            return JSON.parse(value);
+            const store = this.getStore();
+            const probe = `__bwa_probe_${Date.now()}__`;
+            store.setItem(probe, '1');
+            store.removeItem(probe);
+            this.supportedCache = true;
         }
         catch {
-            return value;
+            this.warnSecurityOnce();
+            this.supportedCache = false;
         }
+        return this.supportedCache;
     }
-    getKey(key, options) {
-        const prefix = options?.prefix || '';
-        return prefix ? `${prefix}:${key}` : key;
-    }
-    emitStorageChange(fullKey, newValue, oldValue, area) {
-        this.storageEvents.set({ key: fullKey, newValue, oldValue, storageArea: area });
-    }
-    // Local Storage Methods
-    setLocalStorage(key, value, options = {}) {
-        this.ensureSupported();
+    set(key, value, opts = {}) {
+        if (!this.isSupported())
+            return false;
         try {
-            const serializedValue = this.serializeValue(value, options);
-            const fullKey = this.getKey(key, options);
-            const oldRaw = localStorage.getItem(fullKey);
-            const oldValue = oldRaw !== null ? this.deserializeValue(oldRaw, options) : null;
-            localStorage.setItem(fullKey, serializedValue);
-            this.emitStorageChange(fullKey, value, oldValue, 'localStorage');
+            const fullKey = this.getKey(key, opts);
+            const oldRaw = this.getStore().getItem(fullKey);
+            const oldValue = oldRaw !== null ? this.deserializeValue(oldRaw, opts) : null;
+            const serialized = this.serializeValue(value, opts);
+            this.getStore().setItem(fullKey, serialized);
+            this.events.emit({ key: fullKey, newValue: value, oldValue, storageArea: this.area });
             return true;
         }
         catch (error) {
-            this.logError('Error setting localStorage:', error);
+            this.logger.error(`[storage:${this.area}] set("${key}") failed`, error);
             return false;
         }
     }
-    getLocalStorage(key, defaultValue = null, options = {}) {
-        this.ensureSupported();
+    get(key, defaultValue = null, opts = {}) {
+        if (!this.isSupported())
+            return defaultValue;
         try {
-            const fullKey = this.getKey(key, options);
-            const value = localStorage.getItem(fullKey);
-            return value !== null ? this.deserializeValue(value, options) : defaultValue;
+            const fullKey = this.getKey(key, opts);
+            const raw = this.getStore().getItem(fullKey);
+            return raw !== null ? this.deserializeValue(raw, opts) : defaultValue;
         }
         catch (error) {
-            this.logError('Error getting localStorage:', error);
+            this.logger.error(`[storage:${this.area}] get("${key}") failed`, error);
             return defaultValue;
         }
     }
-    removeLocalStorage(key, options = {}) {
-        this.ensureSupported();
+    remove(key, opts = {}) {
+        if (!this.isSupported())
+            return false;
         try {
-            const fullKey = this.getKey(key, options);
-            const oldRaw = localStorage.getItem(fullKey);
-            const oldValue = oldRaw !== null ? this.deserializeValue(oldRaw, options) : null;
-            localStorage.removeItem(fullKey);
-            this.emitStorageChange(fullKey, null, oldValue, 'localStorage');
+            const fullKey = this.getKey(key, opts);
+            const oldRaw = this.getStore().getItem(fullKey);
+            const oldValue = oldRaw !== null ? this.deserializeValue(oldRaw, opts) : null;
+            this.getStore().removeItem(fullKey);
+            this.events.emit({ key: fullKey, newValue: null, oldValue, storageArea: this.area });
             return true;
         }
         catch (error) {
-            this.logError('Error removing localStorage:', error);
+            this.logger.error(`[storage:${this.area}] remove("${key}") failed`, error);
             return false;
         }
     }
-    clearLocalStorage(options = {}) {
-        this.ensureSupported();
+    clear(opts = {}) {
+        if (!this.isSupported())
+            return false;
         try {
-            const prefix = options?.prefix;
+            const prefix = opts?.prefix;
+            const store = this.getStore();
             if (prefix) {
-                const keysToRemove = [];
-                for (let i = 0; i < localStorage.length; i++) {
-                    const key = localStorage.key(i);
-                    if (key && key.startsWith(`${prefix}:`)) {
-                        keysToRemove.push(key);
-                    }
+                const toRemove = [];
+                for (let i = 0; i < store.length; i++) {
+                    const k = store.key(i);
+                    if (k && k.startsWith(`${prefix}:`))
+                        toRemove.push(k);
+                }
+                for (const k of toRemove) {
+                    const oldRaw = store.getItem(k);
+                    store.removeItem(k);
+                    this.events.emit({
+                        key: k,
+                        newValue: null,
+                        oldValue: oldRaw,
+                        storageArea: this.area,
+                    });
                 }
-                keysToRemove.forEach((key) => {
-                    const oldRaw = localStorage.getItem(key);
-                    localStorage.removeItem(key);
-                    this.emitStorageChange(key, null, oldRaw, 'localStorage');
-                });
             }
             else {
-                localStorage.clear();
-                this.emitStorageChange(null, null, null, 'localStorage');
+                store.clear();
+                this.events.emit({ key: null, newValue: null, oldValue: null, storageArea: this.area });
             }
             return true;
         }
         catch (error) {
-            this.logError('Error clearing localStorage:', error);
+            this.logger.error(`[storage:${this.area}] clear() failed`, error);
             return false;
         }
     }
-    // Session Storage Methods
-    setSessionStorage(key, value, options = {}) {
-        this.ensureSupported();
+    size(opts = {}) {
+        if (!this.isSupported())
+            return 0;
         try {
-            const serializedValue = this.serializeValue(value, options);
-            const fullKey = this.getKey(key, options);
-            const oldRaw = sessionStorage.getItem(fullKey);
-            const oldValue = oldRaw !== null ? this.deserializeValue(oldRaw, options) : null;
-            sessionStorage.setItem(fullKey, serializedValue);
-            this.emitStorageChange(fullKey, value, oldValue, 'sessionStorage');
-            return true;
+            const store = this.getStore();
+            const prefix = opts?.prefix;
+            let total = 0;
+            for (let i = 0; i < store.length; i++) {
+                const k = store.key(i);
+                if (k && (!prefix || k.startsWith(`${prefix}:`))) {
+                    total += (store.getItem(k)?.length ?? 0) + k.length;
+                }
+            }
+            return total;
         }
         catch (error) {
-            this.logError('Error setting sessionStorage:', error);
-            return false;
+            this.logger.error(`[storage:${this.area}] size() failed`, error);
+            return 0;
         }
     }
-    getSessionStorage(key, defaultValue = null, options = {}) {
-        this.ensureSupported();
-        try {
-            const fullKey = this.getKey(key, options);
-            const value = sessionStorage.getItem(fullKey);
-            return value !== null ? this.deserializeValue(value, options) : defaultValue;
-        }
-        catch (error) {
-            this.logError('Error getting sessionStorage:', error);
-            return defaultValue;
+    watch(key, opts = {}) {
+        const fullKey = this.getKey(key, opts);
+        return this.events.events$.pipe(filter((event) => event.storageArea === this.area && (event.key === null || event.key === fullKey)), map((event) => event.newValue));
+    }
+    native() {
+        if (!this.isSupported()) {
+            throw new Error(`${this.area} not supported in this environment`);
         }
+        return this.getStore();
     }
-    removeSessionStorage(key, options = {}) {
-        this.ensureSupported();
+    getStore() {
+        return this.area === 'localStorage' ? window.localStorage : window.sessionStorage;
+    }
+    getKey(key, opts) {
+        const prefix = opts?.prefix ?? '';
+        return prefix ? `${prefix}:${key}` : key;
+    }
+    serializeValue(value, opts) {
+        if (opts?.serialize)
+            return opts.serialize(value);
+        return JSON.stringify(value);
+    }
+    deserializeValue(value, opts) {
+        if (opts?.deserialize)
+            return opts.deserialize(value);
         try {
-            const fullKey = this.getKey(key, options);
-            const oldRaw = sessionStorage.getItem(fullKey);
-            const oldValue = oldRaw !== null ? this.deserializeValue(oldRaw, options) : null;
-            sessionStorage.removeItem(fullKey);
-            this.emitStorageChange(fullKey, null, oldValue, 'sessionStorage');
-            return true;
+            return JSON.parse(value);
         }
-        catch (error) {
-            this.logError('Error removing sessionStorage:', error);
-            return false;
+        catch {
+            return value;
         }
     }
-    clearSessionStorage(options = {}) {
-        this.ensureSupported();
+    warnSecurityOnce() {
+        const holder = globalThis;
+        if (!holder[SECURITY_WARN_KEY])
+            holder[SECURITY_WARN_KEY] = new Set();
+        if (holder[SECURITY_WARN_KEY].has(this.area))
+            return;
+        holder[SECURITY_WARN_KEY].add(this.area);
+        this.logger.warn(`[storage:${this.area}] access denied (SecurityError). Common causes: Safari private mode, ` +
+            'sandboxed iframes, or browser storage disabled. Falling back to default values.');
+    }
+}
+
+let legacyDeprecationLogged$1 = false;
+/**
+ * Web Storage service with two namespaces (`local`, `session`) sharing one method
+ * surface. SecurityError-safe (Safari private mode, sandboxed iframes return defaults
+ * instead of throwing).
+ *
+ * Preferred usage:
+ * ```ts
+ * const storage = inject(WebStorageService);
+ * storage.local.set('user', { id: 1 });
+ * const user = storage.local.get<{ id: number }>('user');
+ * storage.local.watch<{ id: number }>('user').subscribe(console.log);
+ * ```
+ *
+ * Legacy methods (`setLocalStorage`, `getLocalStorage`, etc.) remain as deprecated
+ * wrappers for one minor cycle; removal slated for v22.
+ */
+class WebStorageService extends BrowserApiBaseService {
+    storageLogger = inject(BROWSER_API_LOGGER);
+    storageEvents = signal(null, ...(ngDevMode ? [{ debugName: "storageEvents" }] : /* istanbul ignore next */ []));
+    eventBus = {
+        emit: (event) => this.storageEvents.set(event),
+        events$: toObservable(this.storageEvents).pipe(filter((event) => event !== null), distinctUntilChanged((a, b) => a.key === b.key &&
+            a.newValue === b.newValue &&
+            a.oldValue === b.oldValue &&
+            a.storageArea === b.storageArea)),
+    };
+    /** Local storage namespace. */
+    local = new StorageNamespaceImpl('localStorage', this.eventBus, this.storageLogger);
+    /** Session storage namespace. */
+    session = new StorageNamespaceImpl('sessionStorage', this.eventBus, this.storageLogger);
+    constructor() {
+        super();
+        this.setupCrossTabListener();
+    }
+    getApiName() {
+        return 'storage';
+    }
+    ensureSupported() {
+        super.ensureSupported();
+        if (typeof Storage === 'undefined') {
+            throw new Error('Storage API not supported in this browser');
+        }
+    }
+    /** Returns true if either local or session storage is usable. */
+    isSupported() {
+        return this.local.isSupported() || this.session.isSupported();
+    }
+    /** Stream of every storage mutation observed in this tab or other tabs. */
+    getStorageEvents() {
+        return this.eventBus.events$;
+    }
+    setupCrossTabListener() {
+        if (!this.isBrowserEnvironment())
+            return;
+        fromEvent(window, 'storage')
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((event) => {
+            const area = event.storageArea === window.localStorage ? 'localStorage' : 'sessionStorage';
+            this.storageEvents.set({
+                key: event.key,
+                newValue: event.newValue ? this.safeParse(event.newValue) : null,
+                oldValue: event.oldValue ? this.safeParse(event.oldValue) : null,
+                storageArea: area,
+            });
+        });
+    }
+    safeParse(value) {
         try {
-            const prefix = options?.prefix;
-            if (prefix) {
-                const keysToRemove = [];
-                for (let i = 0; i < sessionStorage.length; i++) {
-                    const key = sessionStorage.key(i);
-                    if (key && key.startsWith(`${prefix}:`)) {
-                        keysToRemove.push(key);
-                    }
-                }
-                keysToRemove.forEach((key) => {
-                    const oldRaw = sessionStorage.getItem(key);
-                    sessionStorage.removeItem(key);
-                    this.emitStorageChange(key, null, oldRaw, 'sessionStorage');
-                });
-            }
-            else {
-                sessionStorage.clear();
-                this.emitStorageChange(null, null, null, 'sessionStorage');
-            }
-            return true;
+            return JSON.parse(value);
         }
-        catch (error) {
-            this.logError('Error clearing sessionStorage:', error);
-            return false;
+        catch {
+            return value;
         }
     }
-    // Utility Methods
+    // ---------- legacy API (deprecated) ----------
+    /** @deprecated Use `storage.local.set(key, value, opts)`. Removed in v22. */
+    setLocalStorage(key, value, options = {}) {
+        this.warnLegacyOnce();
+        return this.local.set(key, value, options);
+    }
+    /** @deprecated Use `storage.local.get(key, defaultValue, opts)`. Removed in v22. */
+    getLocalStorage(key, defaultValue = null, options = {}) {
+        this.warnLegacyOnce();
+        return this.local.get(key, defaultValue, options);
+    }
+    /** @deprecated Use `storage.local.remove(key, opts)`. Removed in v22. */
+    removeLocalStorage(key, options = {}) {
+        this.warnLegacyOnce();
+        return this.local.remove(key, options);
+    }
+    /** @deprecated Use `storage.local.clear(opts)`. Removed in v22. */
+    clearLocalStorage(options = {}) {
+        this.warnLegacyOnce();
+        return this.local.clear(options);
+    }
+    /** @deprecated Use `storage.session.set(key, value, opts)`. Removed in v22. */
+    setSessionStorage(key, value, options = {}) {
+        this.warnLegacyOnce();
+        return this.session.set(key, value, options);
+    }
+    /** @deprecated Use `storage.session.get(key, defaultValue, opts)`. Removed in v22. */
+    getSessionStorage(key, defaultValue = null, options = {}) {
+        this.warnLegacyOnce();
+        return this.session.get(key, defaultValue, options);
+    }
+    /** @deprecated Use `storage.session.remove(key, opts)`. Removed in v22. */
+    removeSessionStorage(key, options = {}) {
+        this.warnLegacyOnce();
+        return this.session.remove(key, options);
+    }
+    /** @deprecated Use `storage.session.clear(opts)`. Removed in v22. */
+    clearSessionStorage(options = {}) {
+        this.warnLegacyOnce();
+        return this.session.clear(options);
+    }
+    /** @deprecated Use `storage.local.size(opts)`. Removed in v22. */
     getLocalStorageSize(options = {}) {
-        this.ensureSupported();
-        let totalSize = 0;
-        const prefix = options?.prefix;
-        for (let i = 0; i < localStorage.length; i++) {
-            const key = localStorage.key(i);
-            if (key && (!prefix || key.startsWith(`${prefix}:`))) {
-                totalSize += (localStorage.getItem(key)?.length || 0) + key.length;
-            }
-        }
-        return totalSize;
+        this.warnLegacyOnce();
+        return this.local.size(options);
     }
+    /** @deprecated Use `storage.session.size(opts)`. Removed in v22. */
     getSessionStorageSize(options = {}) {
-        this.ensureSupported();
-        let totalSize = 0;
-        const prefix = options?.prefix;
-        for (let i = 0; i < sessionStorage.length; i++) {
-            const key = sessionStorage.key(i);
-            if (key && (!prefix || key.startsWith(`${prefix}:`))) {
-                totalSize += (sessionStorage.getItem(key)?.length || 0) + key.length;
-            }
-        }
-        return totalSize;
-    }
-    getStorageEvents() {
-        return toObservable(this.storageEvents).pipe(filter((event) => event !== null), distinctUntilChanged((prev, curr) => prev.key === curr.key &&
-            prev.newValue === curr.newValue &&
-            prev.oldValue === curr.oldValue));
+        this.warnLegacyOnce();
+        return this.session.size(options);
     }
+    /** @deprecated Use `storage.local.watch<T>(key, opts)`. Removed in v22. */
     watchLocalStorage(key, options = {}) {
-        const fullKey = this.getKey(key, options);
-        return this.getStorageEvents().pipe(filter((event) => event.storageArea === 'localStorage' && (event.key === null || event.key === fullKey)), map((event) => event.newValue));
+        this.warnLegacyOnce();
+        return this.local.watch(key, options);
     }
+    /** @deprecated Use `storage.session.watch<T>(key, opts)`. Removed in v22. */
     watchSessionStorage(key, options = {}) {
-        const fullKey = this.getKey(key, options);
-        return this.getStorageEvents().pipe(filter((event) => event.storageArea === 'sessionStorage' && (event.key === null || event.key === fullKey)), map((event) => event.newValue));
+        this.warnLegacyOnce();
+        return this.session.watch(key, options);
     }
-    // Direct access to native storage APIs
+    /** @deprecated Use `storage.local.native()`. Removed in v22. */
     getNativeLocalStorage() {
-        this.ensureSupported();
-        return localStorage;
+        this.warnLegacyOnce();
+        return this.local.native();
     }
+    /** @deprecated Use `storage.session.native()`. Removed in v22. */
     getNativeSessionStorage() {
-        this.ensureSupported();
-        return sessionStorage;
+        this.warnLegacyOnce();
+        return this.session.native();
+    }
+    warnLegacyOnce() {
+        if (legacyDeprecationLogged$1)
+            return;
+        legacyDeprecationLogged$1 = true;
+        this.storageLogger.warn('[storage] WebStorageService.{set,get,remove,clear,watch}{Local,Session}Storage are ' +
+            'deprecated. Use storage.local and storage.session namespaces. Legacy methods will be ' +
+            'removed in v22.');
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebStorageService });
@@ -1036,19 +1121,288 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImpor
             type: Injectable
         }], ctorParameters: () => [] });
 
-class WebSocketService extends BrowserApiBaseService {
-    webSocket = null;
-    statusSubject = new BehaviorSubject({
-        connected: false,
-        connecting: false,
-        reconnecting: false,
-        reconnectAttempts: 0,
-    });
-    messageSubject = new Subject();
-    reconnectAttempts = 0;
+const DEFAULT_MAX_RECONNECT_DELAY = 30_000;
+const DEFAULT_REQUEST_TIMEOUT = 30_000;
+/**
+ * Stateful WebSocket client wrapping a single connection. One instance per logical
+ * connection (do NOT share between `connect()` calls).
+ *
+ * Surfaces:
+ * - `status`: signal of the current connection state.
+ * - `messages$`: stream of every received message (parsed JSON).
+ * - `send` / `sendRaw`: outbound traffic.
+ * - `request<T>(type, data)`: round-trip with id correlation and timeout.
+ * - `close`: idempotent disposal.
+ *
+ * Reconnect uses exponential backoff with jitter, capped by `maxReconnectDelay`.
+ */
+class WebSocketClient {
+    config;
+    logger;
+    socket = null;
     reconnectTimer = null;
     heartbeatTimer = null;
-    _cleanup = this.destroyRef.onDestroy(() => this.disconnect());
+    _status;
+    _messages$ = new Subject();
+    pendingRequests = new Map();
+    disposed = false;
+    reconnectAttempts = 0;
+    constructor(config, logger, destroyRef) {
+        this.config = config;
+        this.logger = logger;
+        this._status = signal({
+            state: 'idle',
+            reconnectAttempts: 0,
+            error: null,
+        }, ...(ngDevMode ? [{ debugName: "_status" }] : /* istanbul ignore next */ []));
+        if (destroyRef) {
+            destroyRef.onDestroy(() => this.close());
+        }
+        this.openSocket();
+    }
+    get status() {
+        return this._status.asReadonly();
+    }
+    get messages$() {
+        return this._messages$.asObservable();
+    }
+    messagesByType(type) {
+        return this._messages$
+            .asObservable()
+            .pipe(filter((msg) => msg.type === type));
+    }
+    send(message) {
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+            throw new Error('WebSocket is not connected');
+        }
+        const enriched = {
+            ...message,
+            id: message.id ?? this.generateId(),
+            timestamp: message.timestamp ?? Date.now(),
+        };
+        this.socket.send(JSON.stringify(enriched));
+    }
+    sendRaw(data) {
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+            throw new Error('WebSocket is not connected');
+        }
+        this.socket.send(data);
+    }
+    /**
+     * Send a message and await a correlated response. The server MUST echo back the
+     * `correlationId` from the request as `correlationId` on the response message.
+     */
+    request(type, data, opts) {
+        const id = this.generateId();
+        const timeoutMs = opts?.timeout ?? DEFAULT_REQUEST_TIMEOUT;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`WebSocket request timeout after ${timeoutMs}ms`));
+            }, timeoutMs);
+            this.pendingRequests.set(id, {
+                resolve: resolve,
+                reject,
+                timer,
+            });
+            try {
+                this.send({ id, type, data, correlationId: id });
+            }
+            catch (error) {
+                clearTimeout(timer);
+                this.pendingRequests.delete(id);
+                reject(error instanceof Error ? error : new Error('WebSocket send failed'));
+            }
+        });
+    }
+    close() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.clearTimers();
+        if (this.socket) {
+            try {
+                this.socket.close();
+            }
+            catch {
+                // Ignore — already closing.
+            }
+            this.socket = null;
+        }
+        this.rejectAllPending(new Error('WebSocket closed'));
+        this.updateStatus({ state: 'closed', error: null });
+    }
+    /** Internal handle for tests and advanced usage. */
+    getNativeSocket() {
+        return this.socket;
+    }
+    // ---------- internals ----------
+    openSocket() {
+        if (this.disposed)
+            return;
+        this.updateStatus({ state: 'connecting', error: null });
+        try {
+            this.socket = new WebSocket(this.config.url, this.config.protocols);
+            this.attachHandlers();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'WebSocket open failed';
+            this.logger.error('[websocket] Failed to construct socket', error);
+            this.updateStatus({ state: 'closed', error: message });
+            this.scheduleReconnect();
+        }
+    }
+    attachHandlers() {
+        if (!this.socket)
+            return;
+        this.socket.onopen = () => {
+            this.reconnectAttempts = 0;
+            this.updateStatus({ state: 'open', error: null, reconnectAttempts: 0 });
+            this.startHeartbeat();
+        };
+        this.socket.onclose = (event) => {
+            this.stopHeartbeat();
+            if (this.disposed)
+                return;
+            this.updateStatus({
+                state: 'closed',
+                error: event.wasClean ? null : `closed: ${event.code} ${event.reason}`,
+            });
+            if (!event.wasClean) {
+                this.scheduleReconnect();
+            }
+        };
+        this.socket.onerror = () => {
+            this.updateStatus({ error: 'WebSocket connection error' });
+        };
+        this.socket.onmessage = (event) => {
+            this.handleIncoming(event.data);
+        };
+    }
+    handleIncoming(raw) {
+        let message;
+        try {
+            const text = typeof raw === 'string' ? raw : String(raw);
+            message = JSON.parse(text);
+        }
+        catch (error) {
+            this.logger.warn('[websocket] Failed to parse incoming message');
+            this.logger.error('[websocket] parse error', error);
+            return;
+        }
+        const correlationId = message.correlationId ?? message.id;
+        if (correlationId && this.pendingRequests.has(correlationId)) {
+            const pending = this.pendingRequests.get(correlationId);
+            clearTimeout(pending.timer);
+            this.pendingRequests.delete(correlationId);
+            pending.resolve(message.data);
+            return;
+        }
+        this._messages$.next(message);
+    }
+    scheduleReconnect() {
+        if (this.disposed)
+            return;
+        const interval = this.config.reconnectInterval ?? 0;
+        const maxAttempts = this.config.maxReconnectAttempts ?? 0;
+        if (interval <= 0 || maxAttempts <= 0)
+            return;
+        if (this.reconnectAttempts >= maxAttempts) {
+            this.updateStatus({
+                state: 'closed',
+                error: `Max reconnect attempts (${maxAttempts}) reached`,
+            });
+            return;
+        }
+        this.reconnectAttempts += 1;
+        const delay = WebSocketClient.computeBackoffDelay(this.reconnectAttempts, interval, this.config.maxReconnectDelay ?? DEFAULT_MAX_RECONNECT_DELAY);
+        this.updateStatus({
+            state: 'reconnecting',
+            reconnectAttempts: this.reconnectAttempts,
+        });
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.openSocket();
+        }, delay);
+    }
+    /**
+     * Exponential backoff with full jitter:
+     *   baseDelay = min(maxDelay, interval * 2^(attempt - 1))
+     *   delay     = random(0, baseDelay)
+     */
+    static computeBackoffDelay(attempt, interval, maxDelay) {
+        const exp = Math.min(maxDelay, interval * Math.pow(2, attempt - 1));
+        return Math.floor(Math.random() * exp);
+    }
+    startHeartbeat() {
+        const { heartbeatInterval, heartbeatMessage } = this.config;
+        if (!heartbeatInterval || heartbeatMessage === undefined)
+            return;
+        this.stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+                try {
+                    this.send({ type: 'heartbeat', data: heartbeatMessage });
+                }
+                catch (error) {
+                    this.logger.warn('[websocket] heartbeat send failed');
+                    this.logger.error('[websocket] heartbeat error', error);
+                }
+            }
+        }, heartbeatInterval);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    clearTimers() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this.stopHeartbeat();
+    }
+    rejectAllPending(reason) {
+        this.pendingRequests.forEach((entry) => {
+            clearTimeout(entry.timer);
+            entry.reject(reason);
+        });
+        this.pendingRequests.clear();
+    }
+    updateStatus(partial) {
+        this._status.update((current) => ({ ...current, ...partial }));
+    }
+    generateId() {
+        if (typeof globalThis.crypto?.randomUUID === 'function') {
+            return globalThis.crypto.randomUUID();
+        }
+        return `ws-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+    }
+}
+
+let legacyDeprecationLogged = false;
+/**
+ * Service that creates and tracks `WebSocketClient` instances.
+ *
+ * Preferred usage:
+ * ```ts
+ * const ws = inject(WebSocketService);
+ * const client = ws.createClient({ url: 'wss://...' });
+ * effect(() => console.log(client.status()));
+ * await client.request('ping', {});
+ * ```
+ *
+ * Legacy usage (`connect()` returning Observable) is preserved for one minor cycle
+ * and will be removed in v22.
+ */
+class WebSocketService extends BrowserApiBaseService {
+    wsLogger = inject(BROWSER_API_LOGGER);
+    clients = new Set();
+    _cleanup = this.destroyRef.onDestroy(() => this.disposeAll());
+    /** Legacy single-connection holder used by deprecated `connect()`/`send()` API. */
+    legacyClient = null;
     getApiName() {
         return 'websocket';
     }
@@ -1058,174 +1412,133 @@ class WebSocketService extends BrowserApiBaseService {
             throw new Error('WebSocket API not supported in this browser');
         }
     }
+    /**
+     * Create a new WebSocket client. The client owns one connection and is the recommended
+     * surface for all interactions (status signal, request/response, reconnect, etc.).
+     *
+     * The returned client is automatically disposed when the host injector is destroyed.
+     */
+    createClient(config) {
+        this.ensureSupported();
+        const client = new WebSocketClient(config, this.wsLogger, this.destroyRef);
+        this.clients.add(client);
+        return client;
+    }
+    /** Dispose every client created via `createClient()` (also called automatically on destroy). */
+    disposeAll() {
+        for (const client of this.clients) {
+            client.close();
+        }
+        this.clients.clear();
+        if (this.legacyClient) {
+            this.legacyClient.close();
+            this.legacyClient = null;
+        }
+    }
+    // ---------- legacy API (deprecated) ----------
+    /**
+     * @deprecated Use {@link createClient} which returns a `WebSocketClient` exposing a
+     * status signal, request/response, and proper reconnect. This wrapper will be removed
+     * in v22.
+     */
     connect(config) {
         this.ensureSupported();
+        this.warnLegacyOnce();
         return new Observable((observer) => {
-            this.disconnect(); // Disconnect existing connection if any
-            this.updateStatus({
-                connected: false,
-                connecting: true,
-                reconnecting: false,
-                reconnectAttempts: 0,
-            });
-            try {
-                this.webSocket = new WebSocket(config.url, config.protocols);
-                this.setupWebSocketHandlers(config);
-                observer.next(this.statusSubject.getValue());
-            }
-            catch (error) {
-                this.logError('Error creating WebSocket:', error);
-                this.updateStatus({
-                    connected: false,
-                    connecting: false,
-                    reconnecting: false,
-                    error: error instanceof Error ? error.message : 'Connection failed',
-                    reconnectAttempts: 0,
-                });
-                observer.next(this.statusSubject.getValue());
+            if (this.legacyClient) {
+                this.legacyClient.close();
             }
+            const client = new WebSocketClient(config, this.wsLogger);
+            this.legacyClient = client;
+            const sub = toObservableLike(client).subscribe({
+                next: (status) => observer.next(status),
+                error: (err) => observer.error(err),
+            });
             return () => {
-                this.disconnect();
+                sub.unsubscribe();
+                client.close();
+                if (this.legacyClient === client) {
+                    this.legacyClient = null;
+                }
             };
         });
     }
+    /** @deprecated Use {@link createClient} and call `client.close()`. */
     disconnect() {
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = null;
-        }
-        if (this.heartbeatTimer) {
-            clearInterval(this.heartbeatTimer);
-            this.heartbeatTimer = null;
-        }
-        if (this.webSocket) {
-            this.webSocket.close();
-            this.webSocket = null;
+        if (this.legacyClient) {
+            this.legacyClient.close();
+            this.legacyClient = null;
         }
-        this.updateStatus({
-            connected: false,
-            connecting: false,
-            reconnecting: false,
-            reconnectAttempts: 0,
-        });
     }
+    /** @deprecated Use the client returned by {@link createClient}. */
     send(message) {
-        if (!this.webSocket || this.webSocket.readyState !== WebSocket.OPEN) {
-            throw new Error('WebSocket is not connected');
+        if (!this.legacyClient) {
+            throw new Error('No active legacy WebSocket. Call connect() first or use createClient().');
         }
-        const messageWithTimestamp = {
-            ...message,
-            timestamp: Date.now(),
-        };
-        this.webSocket.send(JSON.stringify(messageWithTimestamp));
+        this.legacyClient.send(message);
     }
+    /** @deprecated Use the client returned by {@link createClient}. */
     sendRaw(data) {
-        if (!this.webSocket || this.webSocket.readyState !== WebSocket.OPEN) {
-            throw new Error('WebSocket is not connected');
+        if (!this.legacyClient) {
+            throw new Error('No active legacy WebSocket. Call connect() first or use createClient().');
         }
-        this.webSocket.send(data);
+        this.legacyClient.sendRaw(data);
     }
+    /** @deprecated Use `client.status` from {@link createClient}. */
     getStatus() {
-        return this.statusSubject.asObservable();
+        return new Observable((observer) => {
+            if (!this.legacyClient) {
+                observer.next({
+                    connected: false,
+                    connecting: false,
+                    reconnecting: false,
+                    reconnectAttempts: 0,
+                });
+                return () => {
+                    // No-op
+                };
+            }
+            const sub = toObservableLike(this.legacyClient).subscribe((status) => observer.next(status));
+            return () => sub.unsubscribe();
+        });
     }
+    /** @deprecated Use `client.messages$` from {@link createClient}. */
     getMessages() {
-        return this.messageSubject.asObservable();
+        if (!this.legacyClient) {
+            return new Observable(() => {
+                // No-op stream until connected.
+            });
+        }
+        return this.legacyClient.messages$;
     }
+    /** @deprecated Use `client.messagesByType()` from {@link createClient}. */
     getMessagesByType(type) {
-        return this.messageSubject
-            .asObservable()
-            .pipe(filter((msg) => msg.type === type));
-    }
-    setupWebSocketHandlers(config) {
-        if (!this.webSocket)
-            return;
-        this.webSocket.onopen = () => {
-            this.logInfo(`Connected to: ${config.url}`);
-            this.reconnectAttempts = 0;
-            this.updateStatus({
-                connected: true,
-                connecting: false,
-                reconnecting: false,
-                reconnectAttempts: 0,
-            });
-            // Start heartbeat if configured
-            if (config.heartbeatInterval && config.heartbeatMessage) {
-                this.startHeartbeat(config);
-            }
-        };
-        this.webSocket.onclose = (event) => {
-            this.logInfo(`Connection closed: ${event.code} ${event.reason}`);
-            this.updateStatus({
-                connected: false,
-                connecting: false,
-                reconnecting: false,
-                reconnectAttempts: this.reconnectAttempts,
-            });
-            // Attempt reconnection if not a clean close and reconnect is enabled
-            if (!event.wasClean && config.reconnectInterval && config.maxReconnectAttempts) {
-                this.attemptReconnect(config);
-            }
-        };
-        this.webSocket.onerror = (error) => {
-            this.logError('WebSocket error:', error);
-            this.updateStatus({
-                connected: false,
-                connecting: false,
-                reconnecting: false,
-                error: 'WebSocket connection error',
-                reconnectAttempts: this.reconnectAttempts,
+        if (!this.legacyClient) {
+            return new Observable(() => {
+                // No-op stream until connected.
             });
-        };
-        this.webSocket.onmessage = (event) => {
-            try {
-                const message = JSON.parse(event.data);
-                this.messageSubject.next(message);
-            }
-            catch (error) {
-                this.logError('Error parsing message:', error);
-            }
-        };
-    }
-    startHeartbeat(config) {
-        this.heartbeatTimer = setInterval(() => {
-            if (this.webSocket && this.webSocket.readyState === WebSocket.OPEN) {
-                this.send({
-                    type: 'heartbeat',
-                    data: config.heartbeatMessage,
-                });
-            }
-        }, config.heartbeatInterval);
-    }
-    attemptReconnect(config) {
-        if (this.reconnectAttempts >= (config.maxReconnectAttempts || 5)) {
-            this.logInfo('Max reconnect attempts reached');
-            return;
         }
-        this.reconnectAttempts++;
-        this.updateStatus({
-            connected: false,
-            connecting: false,
-            reconnecting: true,
-            reconnectAttempts: this.reconnectAttempts,
-        });
-        this.reconnectTimer = setTimeout(() => {
-            this.logInfo(`Reconnect attempt ${this.reconnectAttempts}`);
-            this.connect(config);
-        }, config.reconnectInterval || 3000);
-    }
-    updateStatus(status) {
-        const newStatus = { ...this.statusSubject.getValue(), ...status };
-        this.statusSubject.next(newStatus);
+        return this.legacyClient.messagesByType(type);
     }
-    // Direct access to native WebSocket
+    /** @deprecated Use the client returned by {@link createClient}. */
     getNativeWebSocket() {
-        return this.webSocket;
+        return this.legacyClient?.getNativeSocket() ?? null;
     }
+    /** @deprecated Use `client.status()` from {@link createClient}. */
     isConnected() {
-        return this.webSocket?.readyState === WebSocket.OPEN;
+        return this.legacyClient?.status().state === 'open';
     }
+    /** @deprecated Use the native socket via `client.getNativeSocket()`. */
     getReadyState() {
-        return this.webSocket?.readyState ?? WebSocket.CLOSED;
+        return this.legacyClient?.getNativeSocket()?.readyState ?? WebSocket.CLOSED;
+    }
+    warnLegacyOnce() {
+        if (legacyDeprecationLogged)
+            return;
+        legacyDeprecationLogged = true;
+        this.wsLogger.warn('[websocket] WebSocketService.connect() is deprecated. Use WebSocketService.createClient() ' +
+            'which returns a WebSocketClient with a status signal, request/response, and proper reconnect. ' +
+            'The legacy API will be removed in v22.');
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebSocketService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebSocketService });
@@ -1233,6 +1546,27 @@ class WebSocketService extends BrowserApiBaseService {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebSocketService, decorators: [{
             type: Injectable
         }] });
+/**
+ * Build a stream of legacy `WebSocketStatus` snapshots from a v2 client. Used to keep the
+ * deprecated `connect()` API behaving like before (Observable of legacy status).
+ */
+function toObservableLike(client) {
+    return new Observable((observer) => {
+        const emit = () => {
+            const v2 = client.status();
+            observer.next({
+                connected: v2.state === 'open',
+                connecting: v2.state === 'connecting',
+                reconnecting: v2.state === 'reconnecting',
+                error: v2.error ?? undefined,
+                reconnectAttempts: v2.reconnectAttempts,
+            });
+        };
+        emit();
+        const id = setInterval(emit, 100);
+        return () => clearInterval(id);
+    });
+}
 
 class WebWorkerService extends BrowserApiBaseService {
     workers = new Map();
@@ -2441,106 +2775,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImpor
             type: Injectable
         }] });
 
-function getIdleDetectorClass$1() {
-    return window.IdleDetector;
-}
-class IdleDetectorService extends BrowserApiBaseService {
-    getApiName() {
-        return 'idle-detector';
-    }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'IdleDetector' in window;
-    }
-    async requestPermission() {
-        if (!this.isSupported()) {
-            throw new Error('IdleDetector API not supported');
-        }
-        return getIdleDetectorClass$1().requestPermission();
-    }
-    watch(options = {}) {
-        if (!this.isSupported()) {
-            return new Observable((o) => o.error(new Error('IdleDetector API not supported')));
-        }
-        return new Observable((subscriber) => {
-            const abortController = new AbortController();
-            const detector = new (getIdleDetectorClass$1())();
-            detector.addEventListener('change', () => {
-                subscriber.next({
-                    user: detector.userState,
-                    screen: detector.screenState,
-                });
-            });
-            detector
-                .start({
-                threshold: options.threshold ?? 60_000,
-                signal: abortController.signal,
-            })
-                .catch((err) => subscriber.error(err));
-            return () => abortController.abort();
-        });
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: IdleDetectorService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: IdleDetectorService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: IdleDetectorService, decorators: [{
-            type: Injectable
-        }] });
-
-function getEyeDropperClass() {
-    return window.EyeDropper;
-}
-class EyeDropperService extends BrowserApiBaseService {
-    getApiName() {
-        return 'eye-dropper';
-    }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'EyeDropper' in window;
-    }
-    async open(signal) {
-        if (!this.isSupported()) {
-            throw new Error('EyeDropper API not supported');
-        }
-        const dropper = new (getEyeDropperClass())();
-        return dropper.open(signal ? { signal } : undefined);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: EyeDropperService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: EyeDropperService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: EyeDropperService, decorators: [{
-            type: Injectable
-        }] });
-
-function getBarcodeDetectorClass() {
-    return window.BarcodeDetector;
-}
-class BarcodeDetectorService extends BrowserApiBaseService {
-    getApiName() {
-        return 'barcode-detector';
-    }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'BarcodeDetector' in window;
-    }
-    async getSupportedFormats() {
-        if (!this.isSupported())
-            return [];
-        return getBarcodeDetectorClass().getSupportedFormats();
-    }
-    async detect(image, formats) {
-        if (!this.isSupported()) {
-            throw new Error('BarcodeDetector API not supported');
-        }
-        const detector = formats
-            ? new (getBarcodeDetectorClass())({ formats })
-            : new (getBarcodeDetectorClass())();
-        return detector.detect(image);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BarcodeDetectorService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BarcodeDetectorService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BarcodeDetectorService, decorators: [{
-            type: Injectable
-        }] });
-
 class WebAudioService extends BrowserApiBaseService {
     getApiName() {
         return 'web-audio';
@@ -2750,301 +2984,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImpor
             type: Injectable
         }] });
 
-function getBluetooth() {
-    return navigator.bluetooth;
-}
-class WebBluetoothService extends BrowserApiBaseService {
-    getApiName() {
-        return 'web-bluetooth';
-    }
-    isSupported() {
-        return this.isBrowserEnvironment() && !!getBluetooth();
-    }
-    async requestDevice(options = { acceptAllDevices: true }) {
-        if (!this.isSupported()) {
-            throw new Error('Web Bluetooth API not supported');
-        }
-        return getBluetooth().requestDevice(options);
-    }
-    async connect(device) {
-        if (!device.gatt) {
-            throw new Error('GATT server not available on this device');
-        }
-        return device.gatt.connect();
-    }
-    disconnect(device) {
-        device.gatt?.disconnect();
-    }
-    watchDisconnection(device) {
-        return new Observable((subscriber) => {
-            const handler = () => subscriber.next();
-            device.addEventListener('gattserverdisconnected', handler);
-            return () => device.removeEventListener('gattserverdisconnected', handler);
-        });
-    }
-    async readCharacteristic(server, serviceUuid, characteristicUuid) {
-        const service = await server.getPrimaryService(serviceUuid);
-        const characteristic = await service.getCharacteristic(characteristicUuid);
-        return characteristic.readValue();
-    }
-    async writeCharacteristic(server, serviceUuid, characteristicUuid, value) {
-        const service = await server.getPrimaryService(serviceUuid);
-        const characteristic = await service.getCharacteristic(characteristicUuid);
-        await characteristic.writeValue(value);
-    }
-    watchCharacteristic(server, serviceUuid, characteristicUuid) {
-        return new Observable((subscriber) => {
-            let characteristic;
-            server
-                .getPrimaryService(serviceUuid)
-                .then((service) => service.getCharacteristic(characteristicUuid))
-                .then((char) => {
-                characteristic = char;
-                const handler = (event) => {
-                    const target = event.target;
-                    if (target.value)
-                        subscriber.next(target.value);
-                };
-                characteristic.addEventListener('characteristicvaluechanged', handler);
-                return characteristic.startNotifications();
-            })
-                .catch((err) => subscriber.error(err));
-            return () => {
-                characteristic?.stopNotifications().catch(() => { });
-            };
-        });
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebBluetoothService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebBluetoothService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebBluetoothService, decorators: [{
-            type: Injectable
-        }] });
-
-function getUsb() {
-    return navigator.usb;
-}
-class WebUsbService extends BrowserApiBaseService {
-    getApiName() {
-        return 'web-usb';
-    }
-    isSupported() {
-        return this.isBrowserEnvironment() && !!getUsb();
-    }
-    async requestDevice(filters = []) {
-        if (!this.isSupported()) {
-            throw new Error('WebUSB API not supported');
-        }
-        return getUsb().requestDevice({ filters });
-    }
-    async getDevices() {
-        if (!this.isSupported())
-            return [];
-        return getUsb().getDevices();
-    }
-    async open(device) {
-        await device.open();
-    }
-    async close(device) {
-        await device.close();
-    }
-    async selectConfiguration(device, configurationValue) {
-        await device.selectConfiguration(configurationValue);
-    }
-    async claimInterface(device, interfaceNumber) {
-        await device.claimInterface(interfaceNumber);
-    }
-    async releaseInterface(device, interfaceNumber) {
-        await device.releaseInterface(interfaceNumber);
-    }
-    async transferIn(device, endpointNumber, length) {
-        return device.transferIn(endpointNumber, length);
-    }
-    async transferOut(device, endpointNumber, data) {
-        return device.transferOut(endpointNumber, data);
-    }
-    watchConnection() {
-        if (!this.isSupported()) {
-            return new Observable((o) => o.error(new Error('WebUSB API not supported')));
-        }
-        return new Observable((subscriber) => {
-            const usb = getUsb();
-            const onConnect = (e) => subscriber.next({ device: e.device, type: 'connect' });
-            const onDisconnect = (e) => subscriber.next({ device: e.device, type: 'disconnect' });
-            usb.addEventListener('connect', onConnect);
-            usb.addEventListener('disconnect', onDisconnect);
-            return () => {
-                usb.removeEventListener('connect', onConnect);
-                usb.removeEventListener('disconnect', onDisconnect);
-            };
-        });
-    }
-    getDeviceInfo(device) {
-        return {
-            vendorId: device.vendorId,
-            productId: device.productId,
-            productName: device.productName,
-            manufacturerName: device.manufacturerName,
-            serialNumber: device.serialNumber,
-            opened: device.opened,
-        };
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebUsbService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebUsbService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebUsbService, decorators: [{
-            type: Injectable
-        }] });
-
-function getNdefReaderClass() {
-    return window.NDEFReader;
-}
-class WebNfcService extends BrowserApiBaseService {
-    getApiName() {
-        return 'web-nfc';
-    }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'NDEFReader' in window;
-    }
-    scan() {
-        if (!this.isSupported()) {
-            return new Observable((o) => o.error(new Error('Web NFC API not supported')));
-        }
-        return new Observable((subscriber) => {
-            const abortController = new AbortController();
-            const reader = new (getNdefReaderClass())();
-            const onReading = (event) => {
-                const e = event;
-                subscriber.next({
-                    serialNumber: e.serialNumber,
-                    message: e.message,
-                });
-            };
-            const onError = (event) => {
-                subscriber.error(event.error ?? new Error('NFC read error'));
-            };
-            reader.addEventListener('reading', onReading);
-            reader.addEventListener('readingerror', onError);
-            reader
-                .scan({ signal: abortController.signal })
-                .catch((err) => subscriber.error(err));
-            return () => abortController.abort();
-        });
-    }
-    async write(message, options) {
-        if (!this.isSupported()) {
-            throw new Error('Web NFC API not supported');
-        }
-        const reader = new (getNdefReaderClass())();
-        await reader.write(message, options);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebNfcService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebNfcService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebNfcService, decorators: [{
-            type: Injectable
-        }] });
-
-class PaymentRequestService extends BrowserApiBaseService {
-    getApiName() {
-        return 'payment-request';
-    }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'PaymentRequest' in window;
-    }
-    async canMakePayment(methods, details) {
-        if (!this.isSupported())
-            return false;
-        const request = new PaymentRequest(methods, details);
-        return request.canMakePayment();
-    }
-    async show(methods, details, options) {
-        if (!this.isSupported()) {
-            throw new Error('Payment Request API not supported');
-        }
-        const request = new PaymentRequest(methods, details, options);
-        const response = await request.show();
-        const result = {
-            methodName: response.methodName,
-            details: response.details,
-            payerName: response.payerName ?? null,
-            payerEmail: response.payerEmail ?? null,
-            payerPhone: response.payerPhone ?? null,
-        };
-        await response.complete('success');
-        return result;
-    }
-    async abort(methods, details) {
-        if (!this.isSupported())
-            return;
-        const request = new PaymentRequest(methods, details);
-        await request.abort();
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PaymentRequestService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PaymentRequestService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PaymentRequestService, decorators: [{
-            type: Injectable
-        }] });
-
-class CredentialManagementService extends BrowserApiBaseService {
-    getApiName() {
-        return 'credential-management';
-    }
-    isSupported() {
-        return this.isBrowserEnvironment() && 'credentials' in navigator;
-    }
-    isPublicKeySupported() {
-        return this.isSupported() && 'PublicKeyCredential' in window;
-    }
-    async get(options) {
-        if (!this.isSupported()) {
-            throw new Error('Credential Management API not supported');
-        }
-        return navigator.credentials.get(options);
-    }
-    async store(credential) {
-        if (!this.isSupported()) {
-            throw new Error('Credential Management API not supported');
-        }
-        await navigator.credentials.store(credential);
-    }
-    async createPasswordCredential(data) {
-        if (!this.isSupported()) {
-            throw new Error('Credential Management API not supported');
-        }
-        return navigator.credentials.create({
-            password: data,
-        });
-    }
-    async createPublicKeyCredential(options) {
-        if (!this.isPublicKeySupported()) {
-            throw new Error('PublicKeyCredential API not supported');
-        }
-        return navigator.credentials.create({
-            publicKey: options,
-        });
-    }
-    async preventSilentAccess() {
-        if (!this.isSupported())
-            return;
-        await navigator.credentials.preventSilentAccess();
-    }
-    async isConditionalMediationAvailable() {
-        if (!this.isPublicKeySupported())
-            return false;
-        if ('isConditionalMediationAvailable' in PublicKeyCredential) {
-            return PublicKeyCredential.isConditionalMediationAvailable();
-        }
-        return false;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CredentialManagementService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CredentialManagementService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CredentialManagementService, decorators: [{
-            type: Injectable
-        }] });
-
 // Common types for browser APIs
 
 function injectPageVisibility() {
@@ -3208,42 +3147,6 @@ function injectPerformanceObserver(config) {
     };
 }
 
-function getIdleDetectorClass() {
-    return window.IdleDetector;
-}
-function injectIdleDetector(options = {}) {
-    const destroyRef = inject(DestroyRef);
-    const platformId = inject(PLATFORM_ID);
-    const defaultState = { user: 'active', screen: 'unlocked' };
-    const state = signal(defaultState, ...(ngDevMode ? [{ debugName: "state" }] : /* istanbul ignore next */ []));
-    if (isPlatformBrowser(platformId) && 'IdleDetector' in window) {
-        const abortController = new AbortController();
-        const detector = new (getIdleDetectorClass())();
-        detector.addEventListener('change', () => {
-            state.set({
-                user: detector.userState,
-                screen: detector.screenState,
-            });
-        });
-        detector
-            .start({
-            threshold: options.threshold ?? 60_000,
-            signal: abortController.signal,
-        })
-            .catch(() => {
-            /* permission denied or unsupported — keep defaults */
-        });
-        destroyRef.onDestroy(() => abortController.abort());
-    }
-    return {
-        state: state.asReadonly(),
-        userState: computed(() => state().user),
-        screenState: computed(() => state().screen),
-        isUserIdle: computed(() => state().user === 'idle'),
-        isScreenLocked: computed(() => state().screen === 'locked'),
-    };
-}
-
 function injectGamepad(index, intervalMs = 16) {
     const destroyRef = inject(DestroyRef);
     const platformId = inject(PLATFORM_ID);
@@ -3410,10 +3313,6 @@ function provideMediaRecorder() {
     return makeEnvironmentProviders([PermissionsService, MediaRecorderService]);
 }
 
-function provideIdleDetector() {
-    return makeEnvironmentProviders([PermissionsService, IdleDetectorService]);
-}
-
 function provideBattery() {
     return makeEnvironmentProviders([BatteryService]);
 }
@@ -3482,14 +3381,6 @@ function providePerformanceObserver() {
     return makeEnvironmentProviders([PerformanceObserverService]);
 }
 
-function provideEyeDropper() {
-    return makeEnvironmentProviders([EyeDropperService]);
-}
-
-function provideBarcodeDetector() {
-    return makeEnvironmentProviders([BarcodeDetectorService]);
-}
-
 function provideWebAudio() {
     return makeEnvironmentProviders([WebAudioService]);
 }
@@ -3498,26 +3389,6 @@ function provideGamepad() {
     return makeEnvironmentProviders([GamepadService]);
 }
 
-function provideWebBluetooth() {
-    return makeEnvironmentProviders([WebBluetoothService]);
-}
-
-function provideWebUsb() {
-    return makeEnvironmentProviders([WebUsbService]);
-}
-
-function provideWebNfc() {
-    return makeEnvironmentProviders([WebNfcService]);
-}
-
-function providePaymentRequest() {
-    return makeEnvironmentProviders([PaymentRequestService]);
-}
-
-function provideCredentialManagement() {
-    return makeEnvironmentProviders([CredentialManagementService]);
-}
-
 function provideMediaApis() {
     return makeEnvironmentProviders([PermissionsService, CameraService, MediaDevicesService]);
 }
@@ -3562,16 +3433,8 @@ const defaultBrowserWebApisConfig = {
     enableSpeechSynthesis: false,
     enableMutationObserver: false,
     enablePerformanceObserver: false,
-    enableIdleDetector: false,
-    enableEyeDropper: false,
-    enableBarcodeDetector: false,
     enableWebAudio: false,
     enableGamepad: false,
-    enableWebBluetooth: false,
-    enableWebUsb: false,
-    enableWebNfc: false,
-    enablePaymentRequest: false,
-    enableCredentialManagement: false,
 };
 function provideBrowserWebApis(config = {}) {
     const mergedConfig = { ...defaultBrowserWebApisConfig, ...config };
@@ -3602,16 +3465,8 @@ function provideBrowserWebApis(config = {}) {
         [mergedConfig.enableSpeechSynthesis, SpeechSynthesisService],
         [mergedConfig.enableMutationObserver, MutationObserverService],
         [mergedConfig.enablePerformanceObserver, PerformanceObserverService],
-        [mergedConfig.enableIdleDetector, IdleDetectorService],
-        [mergedConfig.enableEyeDropper, EyeDropperService],
-        [mergedConfig.enableBarcodeDetector, BarcodeDetectorService],
         [mergedConfig.enableWebAudio, WebAudioService],
         [mergedConfig.enableGamepad, GamepadService],
-        [mergedConfig.enableWebBluetooth, WebBluetoothService],
-        [mergedConfig.enableWebUsb, WebUsbService],
-        [mergedConfig.enableWebNfc, WebNfcService],
-        [mergedConfig.enablePaymentRequest, PaymentRequestService],
-        [mergedConfig.enableCredentialManagement, CredentialManagementService],
     ];
     for (const [enabled, provider] of conditionalProviders) {
         if (enabled) {
@@ -3629,4 +3484,4 @@ const version = '0.1.0';
  * Generated bundle index. Do not edit.
  */
 
-export { BROWSER_API_LOGGER, BarcodeDetectorService, BatteryService, BroadcastChannelService, BrowserApiBaseService, BrowserCapabilityService, BrowserSupportUtil, CameraService, ClipboardService, ConnectionRegistryBaseService, CredentialManagementService, EyeDropperService, FileSystemAccessService, FullscreenService, GamepadService, GeolocationService, IdleDetectorService, IntersectionObserverService, MediaDevicesService, MediaRecorderService, MutationObserverService, NetworkInformationService, NotificationService, PageVisibilityService, PaymentRequestService, PerformanceObserverService, PermissionsService, ResizeObserverService, ScreenOrientationService, ScreenWakeLockService, ServerSentEventsService, SpeechSynthesisService, VibrationService, WebAudioService, WebBluetoothService, WebNfcService, WebShareService, WebSocketService, WebStorageService, WebUsbService, WebWorkerService, permissionGuard as createPermissionGuard, defaultBrowserWebApisConfig, injectGamepad, injectIdleDetector, injectIntersectionObserver, injectMutationObserver, injectNetworkInformation, injectPageVisibility, injectPerformanceObserver, injectResizeObserver, injectScreenOrientation, permissionGuard, provideBarcodeDetector, provideBattery, provideBroadcastChannel, provideBrowserWebApis, provideCamera, provideClipboard, provideCommunicationApis, provideCredentialManagement, provideEyeDropper, provideFileSystemAccess, provideFullscreen, provideGamepad, provideGeolocation, provideIdleDetector, provideIntersectionObserver, provideLocationApis, provideMediaApis, provideMediaDevices, provideMediaRecorder, provideMutationObserver, provideNetworkInformation, provideNotifications, providePageVisibility, providePaymentRequest, providePerformanceObserver, providePermissions, provideResizeObserver, provideScreenOrientation, provideScreenWakeLock, provideServerSentEvents, provideSpeechSynthesis, provideStorageApis, provideVibration, provideWebAudio, provideWebBluetooth, provideWebNfc, provideWebShare, provideWebSocket, provideWebStorage, provideWebUsb, provideWebWorker, version };
+export { BROWSER_API_LOGGER, BatteryService, BroadcastChannelService, BrowserApiBaseService, BrowserCapabilityService, BrowserSupportUtil, CameraService, ClipboardService, ConnectionRegistryBaseService, FileSystemAccessService, FullscreenService, GamepadService, GeolocationService, IntersectionObserverService, MediaDevicesService, MediaRecorderService, MutationObserverService, NetworkInformationService, NotificationService, PageVisibilityService, PerformanceObserverService, PermissionsService, ResizeObserverService, ScreenOrientationService, ScreenWakeLockService, ServerSentEventsService, SpeechSynthesisService, VibrationService, WebAudioService, WebShareService, WebSocketClient, WebSocketService, WebStorageService, WebWorkerService, permissionGuard as createPermissionGuard, defaultBrowserWebApisConfig, injectGamepad, injectIntersectionObserver, injectMutationObserver, injectNetworkInformation, injectPageVisibility, injectPerformanceObserver, injectResizeObserver, injectScreenOrientation, permissionGuard, provideBattery, provideBroadcastChannel, provideBrowserWebApis, provideCamera, provideClipboard, provideCommunicationApis, provideFileSystemAccess, provideFullscreen, provideGamepad, provideGeolocation, provideIntersectionObserver, provideLocationApis, provideMediaApis, provideMediaDevices, provideMediaRecorder, provideMutationObserver, provideNetworkInformation, provideNotifications, providePageVisibility, providePerformanceObserver, providePermissions, provideResizeObserver, provideScreenOrientation, provideScreenWakeLock, provideServerSentEvents, provideSpeechSynthesis, provideStorageApis, provideVibration, provideWebAudio, provideWebShare, provideWebSocket, provideWebStorage, provideWebWorker, version };