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

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

@@ -1,7 +1,7 @@
 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 { Observable, fromEvent, Subject, of, map as map$1 } from 'rxjs';
 import { takeUntilDestroyed, toObservable } from '@angular/core/rxjs-interop';
 import { filter, distinctUntilChanged, map } from 'rxjs/operators';
 import { Router } from '@angular/router';
@@ -1036,196 +1036,424 @@ 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());
-    getApiName() {
-        return 'websocket';
-    }
-    ensureSupported() {
-        super.ensureSupported();
-        if (typeof WebSocket === 'undefined') {
-            throw new Error('WebSocket API not supported in this browser');
+    _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();
     }
-    connect(config) {
-        this.ensureSupported();
-        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());
-            }
-            return () => {
-                this.disconnect();
-            };
-        });
+    get status() {
+        return this._status.asReadonly();
     }
-    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;
-        }
-        this.updateStatus({
-            connected: false,
-            connecting: false,
-            reconnecting: false,
-            reconnectAttempts: 0,
-        });
+    get messages$() {
+        return this._messages$.asObservable();
+    }
+    messagesByType(type) {
+        return this._messages$
+            .asObservable()
+            .pipe(filter((msg) => msg.type === type));
     }
     send(message) {
-        if (!this.webSocket || this.webSocket.readyState !== WebSocket.OPEN) {
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
             throw new Error('WebSocket is not connected');
         }
-        const messageWithTimestamp = {
+        const enriched = {
             ...message,
-            timestamp: Date.now(),
+            id: message.id ?? this.generateId(),
+            timestamp: message.timestamp ?? Date.now(),
         };
-        this.webSocket.send(JSON.stringify(messageWithTimestamp));
+        this.socket.send(JSON.stringify(enriched));
     }
     sendRaw(data) {
-        if (!this.webSocket || this.webSocket.readyState !== WebSocket.OPEN) {
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
             throw new Error('WebSocket is not connected');
         }
-        this.webSocket.send(data);
+        this.socket.send(data);
     }
-    getStatus() {
-        return this.statusSubject.asObservable();
+    /**
+     * 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'));
+            }
+        });
     }
-    getMessages() {
-        return this.messageSubject.asObservable();
+    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 });
     }
-    getMessagesByType(type) {
-        return this.messageSubject
-            .asObservable()
-            .pipe(filter((msg) => msg.type === type));
+    /** 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();
+        }
     }
-    setupWebSocketHandlers(config) {
-        if (!this.webSocket)
+    attachHandlers() {
+        if (!this.socket)
             return;
-        this.webSocket.onopen = () => {
-            this.logInfo(`Connected to: ${config.url}`);
+        this.socket.onopen = () => {
             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.updateStatus({ state: 'open', error: null, reconnectAttempts: 0 });
+            this.startHeartbeat();
         };
-        this.webSocket.onclose = (event) => {
-            this.logInfo(`Connection closed: ${event.code} ${event.reason}`);
+        this.socket.onclose = (event) => {
+            this.stopHeartbeat();
+            if (this.disposed)
+                return;
             this.updateStatus({
-                connected: false,
-                connecting: false,
-                reconnecting: false,
-                reconnectAttempts: this.reconnectAttempts,
+                state: 'closed',
+                error: event.wasClean ? null : `closed: ${event.code} ${event.reason}`,
             });
-            // Attempt reconnection if not a clean close and reconnect is enabled
-            if (!event.wasClean && config.reconnectInterval && config.maxReconnectAttempts) {
-                this.attemptReconnect(config);
+            if (!event.wasClean) {
+                this.scheduleReconnect();
             }
         };
-        this.webSocket.onerror = (error) => {
-            this.logError('WebSocket error:', error);
-            this.updateStatus({
-                connected: false,
-                connecting: false,
-                reconnecting: false,
-                error: 'WebSocket connection error',
-                reconnectAttempts: this.reconnectAttempts,
-            });
+        this.socket.onerror = () => {
+            this.updateStatus({ error: 'WebSocket connection error' });
         };
-        this.webSocket.onmessage = (event) => {
-            try {
-                const message = JSON.parse(event.data);
-                this.messageSubject.next(message);
-            }
-            catch (error) {
-                this.logError('Error parsing message:', error);
-            }
+        this.socket.onmessage = (event) => {
+            this.handleIncoming(event.data);
         };
     }
-    startHeartbeat(config) {
-        this.heartbeatTimer = setInterval(() => {
-            if (this.webSocket && this.webSocket.readyState === WebSocket.OPEN) {
-                this.send({
-                    type: 'heartbeat',
-                    data: config.heartbeatMessage,
-                });
-            }
-        }, config.heartbeatInterval);
+    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);
     }
-    attemptReconnect(config) {
-        if (this.reconnectAttempts >= (config.maxReconnectAttempts || 5)) {
-            this.logInfo('Max reconnect attempts reached');
+    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++;
+        this.reconnectAttempts += 1;
+        const delay = WebSocketClient.computeBackoffDelay(this.reconnectAttempts, interval, this.config.maxReconnectDelay ?? DEFAULT_MAX_RECONNECT_DELAY);
         this.updateStatus({
-            connected: false,
-            connecting: false,
-            reconnecting: true,
+            state: 'reconnecting',
             reconnectAttempts: this.reconnectAttempts,
         });
         this.reconnectTimer = setTimeout(() => {
-            this.logInfo(`Reconnect attempt ${this.reconnectAttempts}`);
-            this.connect(config);
-        }, config.reconnectInterval || 3000);
+            this.reconnectTimer = null;
+            this.openSocket();
+        }, delay);
     }
-    updateStatus(status) {
-        const newStatus = { ...this.statusSubject.getValue(), ...status };
-        this.statusSubject.next(newStatus);
+    /**
+     * 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';
+    }
+    ensureSupported() {
+        super.ensureSupported();
+        if (typeof WebSocket === 'undefined') {
+            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) => {
+            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 () => {
+                sub.unsubscribe();
+                client.close();
+                if (this.legacyClient === client) {
+                    this.legacyClient = null;
+                }
+            };
+        });
+    }
+    /** @deprecated Use {@link createClient} and call `client.close()`. */
+    disconnect() {
+        if (this.legacyClient) {
+            this.legacyClient.close();
+            this.legacyClient = null;
+        }
+    }
+    /** @deprecated Use the client returned by {@link createClient}. */
+    send(message) {
+        if (!this.legacyClient) {
+            throw new Error('No active legacy WebSocket. Call connect() first or use createClient().');
+        }
+        this.legacyClient.send(message);
+    }
+    /** @deprecated Use the client returned by {@link createClient}. */
+    sendRaw(data) {
+        if (!this.legacyClient) {
+            throw new Error('No active legacy WebSocket. Call connect() first or use createClient().');
+        }
+        this.legacyClient.sendRaw(data);
+    }
+    /** @deprecated Use `client.status` from {@link createClient}. */
+    getStatus() {
+        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();
+        });
     }
-    // Direct access to native WebSocket
+    /** @deprecated Use `client.messages$` from {@link createClient}. */
+    getMessages() {
+        if (!this.legacyClient) {
+            return new Observable(() => {
+                // No-op stream until connected.
+            });
+        }
+        return this.legacyClient.messages$;
+    }
+    /** @deprecated Use `client.messagesByType()` from {@link createClient}. */
+    getMessagesByType(type) {
+        if (!this.legacyClient) {
+            return new Observable(() => {
+                // No-op stream until connected.
+            });
+        }
+        return this.legacyClient.messagesByType(type);
+    }
+    /** @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 +1461,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 +2690,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 +2899,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 +3062,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 +3228,6 @@ function provideMediaRecorder() {
     return makeEnvironmentProviders([PermissionsService, MediaRecorderService]);
 }
 
-function provideIdleDetector() {
-    return makeEnvironmentProviders([PermissionsService, IdleDetectorService]);
-}
-
 function provideBattery() {
     return makeEnvironmentProviders([BatteryService]);
 }
@@ -3482,14 +3296,6 @@ function providePerformanceObserver() {
     return makeEnvironmentProviders([PerformanceObserverService]);
 }
 
-function provideEyeDropper() {
-    return makeEnvironmentProviders([EyeDropperService]);
-}
-
-function provideBarcodeDetector() {
-    return makeEnvironmentProviders([BarcodeDetectorService]);
-}
-
 function provideWebAudio() {
     return makeEnvironmentProviders([WebAudioService]);
 }
@@ -3498,26 +3304,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 +3348,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 +3380,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 +3399,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 };