@angular-helpers/browser-web-apis 21.0.2 → 21.1.0

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

@@ -1,7 +1,10 @@
 import * as i0 from '@angular/core';
-import { Injectable, inject, DestroyRef, PLATFORM_ID } from '@angular/core';
+import { Injectable, inject, DestroyRef, PLATFORM_ID, signal, makeEnvironmentProviders } from '@angular/core';
 import { isPlatformBrowser, isPlatformServer } from '@angular/common';
-import { Observable } from 'rxjs';
+import { Observable, fromEvent, Subject } from 'rxjs';
+import { takeUntilDestroyed, toObservable } from '@angular/core/rxjs-interop';
+import { filter, distinctUntilChanged, map } from 'rxjs/operators';
+import { Router } from '@angular/router';
 
 class PermissionsService {
     async query(descriptor) {
@@ -67,6 +70,16 @@ class BrowserApiBaseService {
             return false;
         }
     }
+    /**
+     * Create an error with proper cause chaining
+     */
+    createError(message, cause) {
+        const error = new Error(message);
+        if (cause !== undefined) {
+            error.cause = cause;
+        }
+        return error;
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BrowserApiBaseService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BrowserApiBaseService });
 }
@@ -76,11 +89,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImpor
 
 class CameraService extends BrowserApiBaseService {
     currentStream = null;
-    createError(message, cause) {
-        const error = new Error(message);
-        error.cause = cause;
-        return error;
-    }
     getApiName() {
         return 'camera';
     }
@@ -103,8 +111,8 @@ class CameraService extends BrowserApiBaseService {
                 video: {
                     width: { ideal: 1280 },
                     height: { ideal: 720 },
-                    facingMode: 'user'
-                }
+                    facingMode: 'user',
+                },
             };
             this.currentStream = await navigator.mediaDevices.getUserMedia(streamConstraints);
             return this.currentStream;
@@ -140,14 +148,14 @@ class CameraService extends BrowserApiBaseService {
     async switchCamera(deviceId, constraints = {
         video: {
             width: { ideal: 1280 },
-            height: { ideal: 720 }
-        }
+            height: { ideal: 720 },
+        },
     }) {
         this.stopCamera();
         const finalConstraints = {
             video: constraints.video && typeof constraints.video === 'object'
                 ? { ...constraints.video, deviceId: { exact: deviceId } }
-                : { deviceId: { exact: deviceId } }
+                : { deviceId: { exact: deviceId } },
         };
         return this.startCamera(finalConstraints);
     }
@@ -155,7 +163,7 @@ class CameraService extends BrowserApiBaseService {
         this.ensureCameraSupport();
         try {
             const stream = await navigator.mediaDevices.getUserMedia({
-                video: { deviceId: { exact: deviceId } }
+                video: { deviceId: { exact: deviceId } },
             });
             const videoTrack = stream.getVideoTracks()[0];
             const capabilities = videoTrack.getCapabilities();
@@ -178,7 +186,7 @@ class CameraService extends BrowserApiBaseService {
         this.ensureCameraSupport();
         try {
             const devices = await navigator.mediaDevices.enumerateDevices();
-            return devices.filter(device => device.kind === 'videoinput');
+            return devices.filter((device) => device.kind === 'videoinput');
         }
         catch (error) {
             console.error('[CameraService] Error enumerating video devices:', error);
@@ -243,11 +251,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImpor
         }] });
 
 class MediaDevicesService extends BrowserApiBaseService {
-    createError(message, cause) {
-        const error = new Error(message);
-        error.cause = cause;
-        return error;
-    }
     getApiName() {
         return 'media-devices';
     }
@@ -272,7 +275,7 @@ class MediaDevicesService extends BrowserApiBaseService {
         try {
             const defaultConstraints = {
                 video: true,
-                audio: true
+                audio: true,
             };
             const finalConstraints = constraints || defaultConstraints;
             return await navigator.mediaDevices.getUserMedia(finalConstraints);
@@ -290,7 +293,7 @@ class MediaDevicesService extends BrowserApiBaseService {
         try {
             const defaultConstraints = {
                 video: true,
-                audio: false
+                audio: false,
             };
             const finalConstraints = constraints || defaultConstraints;
             return await navigator.mediaDevices.getDisplayMedia(finalConstraints);
@@ -332,7 +335,7 @@ class MediaDevicesService extends BrowserApiBaseService {
     }
     async getDevicesByKind(kind) {
         const devices = await this.getDevices();
-        return devices.filter(device => device.kind === kind);
+        return devices.filter((device) => device.kind === kind);
     }
     handleMediaError(error) {
         let message;
@@ -378,12 +381,23 @@ class NotificationService extends BrowserApiBaseService {
     getApiName() {
         return 'notifications';
     }
+    get permission() {
+        return Notification.permission;
+    }
+    isSupported() {
+        return 'Notification' in window;
+    }
+    async requestNotificationPermission() {
+        if (!this.isSupported()) {
+            throw new Error('Notification API not supported in this browser');
+        }
+        return Notification.requestPermission();
+    }
     async showNotification(title, options) {
-        if (!('Notification' in window)) {
+        if (!this.isSupported()) {
             throw new Error('Notification API not supported in this browser');
         }
-        const permissionStatus = await this.permissionsService.query({ name: 'notifications' });
-        if (permissionStatus.state !== 'granted') {
+        if (Notification.permission !== 'granted') {
             throw new Error('Notification permission required. Please grant notification access and try again.');
         }
         try {
@@ -410,7 +424,7 @@ class ClipboardService extends BrowserApiBaseService {
             throw new Error('Clipboard API not supported in this browser');
         }
         const permissionStatus = await this.permissionsService.query({
-            name: `clipboard-${action}`
+            name: `clipboard-${action}`,
         });
         if (permissionStatus.state !== 'granted') {
             throw new Error(`Clipboard ${action} permission required. Please grant clipboard access and try again.`);
@@ -465,7 +479,7 @@ const BROWSER_CAPABILITIES = [
     { id: 'webStorage', label: 'Web Storage', requiresSecureContext: false },
     { id: 'webShare', label: 'Web Share', requiresSecureContext: true },
     { id: 'battery', label: 'Battery API', requiresSecureContext: false },
-    { id: 'webSocket', label: 'WebSocket API', requiresSecureContext: false }
+    { id: 'webSocket', label: 'WebSocket API', requiresSecureContext: false },
 ];
 class BrowserCapabilityService {
     getCapabilities() {
@@ -509,7 +523,7 @@ class BrowserCapabilityService {
             label: capability.label,
             supported: this.isSupported(capability.id),
             secureContext,
-            requiresSecureContext: capability.requiresSecureContext
+            requiresSecureContext: capability.requiresSecureContext,
         }));
     }
     async getPermissionState(permission) {
@@ -532,6 +546,752 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImpor
             args: [{ providedIn: 'root' }]
         }] });
 
+class BatteryService extends BrowserApiBaseService {
+    batteryManager = null;
+    getApiName() {
+        return 'battery';
+    }
+    ensureBatterySupport() {
+        const nav = navigator;
+        if (!('getBattery' in nav)) {
+            throw new Error('Battery API not supported in this browser');
+        }
+    }
+    async initialize() {
+        this.ensureBatterySupport();
+        try {
+            const nav = navigator;
+            this.batteryManager = await nav.getBattery();
+            const batteryInfo = this.getBatteryInfo();
+            this.setupEventListeners();
+            return batteryInfo;
+        }
+        catch (error) {
+            console.error('[BatteryService] Error initializing battery API:', error);
+            throw this.createError('Failed to initialize battery API', error);
+        }
+    }
+    getBatteryInfo() {
+        if (!this.batteryManager) {
+            throw new Error('Battery service not initialized. Call initialize() first.');
+        }
+        return {
+            charging: this.batteryManager.charging,
+            chargingTime: this.batteryManager.chargingTime,
+            dischargingTime: this.batteryManager.dischargingTime,
+            level: this.batteryManager.level,
+        };
+    }
+    watchBatteryInfo() {
+        if (!this.batteryManager) {
+            throw new Error('Battery service not initialized. Call initialize() first.');
+        }
+        return new Observable((observer) => {
+            const updateBatteryInfo = () => {
+                observer.next(this.getBatteryInfo());
+            };
+            // Listen to all battery events
+            this.batteryManager.addEventListener('chargingchange', updateBatteryInfo);
+            this.batteryManager.addEventListener('levelchange', updateBatteryInfo);
+            this.batteryManager.addEventListener('chargingtimechange', updateBatteryInfo);
+            this.batteryManager.addEventListener('dischargingtimechange', updateBatteryInfo);
+            // Send initial value
+            updateBatteryInfo();
+            return () => {
+                // Cleanup event listeners
+                this.batteryManager.removeEventListener('chargingchange', updateBatteryInfo);
+                this.batteryManager.removeEventListener('levelchange', updateBatteryInfo);
+                this.batteryManager.removeEventListener('chargingtimechange', updateBatteryInfo);
+                this.batteryManager.removeEventListener('dischargingtimechange', updateBatteryInfo);
+            };
+        });
+    }
+    setupEventListeners() {
+        if (!this.batteryManager)
+            return;
+        this.batteryManager.addEventListener('chargingchange', () => {
+            console.log('[BatteryService] Charging status changed:', this.batteryManager.charging);
+        });
+        this.batteryManager.addEventListener('levelchange', () => {
+            console.log('[BatteryService] Battery level changed:', this.batteryManager.level);
+        });
+    }
+    // Direct access to native battery API
+    getNativeBatteryManager() {
+        if (!this.batteryManager) {
+            throw new Error('Battery service not initialized. Call initialize() first.');
+        }
+        return this.batteryManager;
+    }
+    isCharging() {
+        return this.getBatteryInfo().charging;
+    }
+    getLevel() {
+        return this.getBatteryInfo().level;
+    }
+    getChargingTime() {
+        return this.getBatteryInfo().chargingTime;
+    }
+    getDischargingTime() {
+        return this.getBatteryInfo().dischargingTime;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BatteryService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BatteryService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BatteryService, decorators: [{
+            type: Injectable
+        }] });
+
+class WebShareService extends BrowserApiBaseService {
+    getApiName() {
+        return 'web-share';
+    }
+    ensureWebShareSupport() {
+        if (!('share' in navigator)) {
+            throw new Error('Web Share API not supported in this browser');
+        }
+    }
+    async share(data) {
+        this.ensureWebShareSupport();
+        try {
+            await navigator.share(data);
+            return { shared: true };
+        }
+        catch (error) {
+            console.error('[WebShareService] Error sharing:', error);
+            const errorMessage = error instanceof Error ? error.message : 'Share failed';
+            return { shared: false, error: errorMessage };
+        }
+    }
+    canShare() {
+        return 'share' in navigator;
+    }
+    canShareFiles() {
+        if (!('share' in navigator))
+            return false;
+        // Check if the browser supports file sharing
+        const testFiles = [new File([''], 'test.txt', { type: 'text/plain' })];
+        return navigator.canShare?.({ files: testFiles }) ?? false;
+    }
+    // Direct access to native share API
+    getNativeShare() {
+        this.ensureWebShareSupport();
+        return navigator.share;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebShareService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebShareService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebShareService, decorators: [{
+            type: Injectable
+        }] });
+
+class WebStorageService extends BrowserApiBaseService {
+    storageEvents = signal(null, ...(ngDevMode ? [{ debugName: "storageEvents" }] : /* istanbul ignore next */ []));
+    destroyRef = inject(DestroyRef);
+    constructor() {
+        super();
+        this.setupEventListeners();
+    }
+    getApiName() {
+        return 'storage';
+    }
+    ensureStorageSupport() {
+        if (!this.isBrowserEnvironment() || 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;
+                if (storageEvent.key && storageEvent.newValue !== null) {
+                    this.storageEvents.set({
+                        key: storageEvent.key,
+                        newValue: this.deserializeValue(storageEvent.newValue),
+                        oldValue: storageEvent.oldValue ? this.deserializeValue(storageEvent.oldValue) : null,
+                        storageArea: storageEvent.storageArea === localStorage ? 'localStorage' : 'sessionStorage',
+                    });
+                }
+            });
+        }
+    }
+    serializeValue(value, options) {
+        if (options?.serialize) {
+            return options.serialize(value);
+        }
+        return JSON.stringify(value);
+    }
+    deserializeValue(value, options) {
+        if (value === null)
+            return null;
+        if (options?.deserialize) {
+            return options.deserialize(value);
+        }
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return value;
+        }
+    }
+    getKey(key, options) {
+        const prefix = options?.prefix || '';
+        return prefix ? `${prefix}:${key}` : key;
+    }
+    // Local Storage Methods
+    setLocalStorage(key, value, options = {}) {
+        this.ensureStorageSupport();
+        try {
+            const serializedValue = this.serializeValue(value, options);
+            const fullKey = this.getKey(key, options);
+            localStorage.setItem(fullKey, serializedValue);
+            return true;
+        }
+        catch (error) {
+            console.error('[WebStorageService] Error setting localStorage:', error);
+            return false;
+        }
+    }
+    getLocalStorage(key, defaultValue = null, options = {}) {
+        this.ensureStorageSupport();
+        try {
+            const fullKey = this.getKey(key, options);
+            const value = localStorage.getItem(fullKey);
+            return value !== null ? this.deserializeValue(value, options) : defaultValue;
+        }
+        catch (error) {
+            console.error('[WebStorageService] Error getting localStorage:', error);
+            return defaultValue;
+        }
+    }
+    removeLocalStorage(key, options = {}) {
+        this.ensureStorageSupport();
+        try {
+            const fullKey = this.getKey(key, options);
+            localStorage.removeItem(fullKey);
+            return true;
+        }
+        catch (error) {
+            console.error('[WebStorageService] Error removing localStorage:', error);
+            return false;
+        }
+    }
+    clearLocalStorage(options = {}) {
+        this.ensureStorageSupport();
+        try {
+            const prefix = options?.prefix;
+            if (prefix) {
+                // Only remove keys with the specified prefix
+                const keysToRemove = [];
+                for (let i = 0; i < localStorage.length; i++) {
+                    const key = localStorage.key(i);
+                    if (key && key.startsWith(`${prefix}:`)) {
+                        keysToRemove.push(key);
+                    }
+                }
+                keysToRemove.forEach((key) => localStorage.removeItem(key));
+            }
+            else {
+                localStorage.clear();
+            }
+            return true;
+        }
+        catch (error) {
+            console.error('[WebStorageService] Error clearing localStorage:', error);
+            return false;
+        }
+    }
+    // Session Storage Methods
+    setSessionStorage(key, value, options = {}) {
+        this.ensureStorageSupport();
+        try {
+            const serializedValue = this.serializeValue(value, options);
+            const fullKey = this.getKey(key, options);
+            sessionStorage.setItem(fullKey, serializedValue);
+            return true;
+        }
+        catch (error) {
+            console.error('[WebStorageService] Error setting sessionStorage:', error);
+            return false;
+        }
+    }
+    getSessionStorage(key, defaultValue = null, options = {}) {
+        this.ensureStorageSupport();
+        try {
+            const fullKey = this.getKey(key, options);
+            const value = sessionStorage.getItem(fullKey);
+            return value !== null ? this.deserializeValue(value, options) : defaultValue;
+        }
+        catch (error) {
+            console.error('[WebStorageService] Error getting sessionStorage:', error);
+            return defaultValue;
+        }
+    }
+    removeSessionStorage(key, options = {}) {
+        this.ensureStorageSupport();
+        try {
+            const fullKey = this.getKey(key, options);
+            sessionStorage.removeItem(fullKey);
+            return true;
+        }
+        catch (error) {
+            console.error('[WebStorageService] Error removing sessionStorage:', error);
+            return false;
+        }
+    }
+    clearSessionStorage(options = {}) {
+        this.ensureStorageSupport();
+        try {
+            const prefix = options?.prefix;
+            if (prefix) {
+                // Only remove keys with the specified 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) => sessionStorage.removeItem(key));
+            }
+            else {
+                sessionStorage.clear();
+            }
+            return true;
+        }
+        catch (error) {
+            console.error('[WebStorageService] Error clearing sessionStorage:', error);
+            return false;
+        }
+    }
+    // Utility Methods
+    getLocalStorageSize(options = {}) {
+        this.ensureStorageSupport();
+        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;
+    }
+    getSessionStorageSize(options = {}) {
+        this.ensureStorageSupport();
+        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));
+    }
+    watchLocalStorage(key, options = {}) {
+        return this.getStorageEvents().pipe(map((event) => {
+            const fullKey = this.getKey(key, options);
+            if (event.key === fullKey && event.storageArea === 'localStorage') {
+                return event.newValue;
+            }
+            return this.getLocalStorage(key, null, options);
+        }));
+    }
+    watchSessionStorage(key, options = {}) {
+        return this.getStorageEvents().pipe(map((event) => {
+            const fullKey = this.getKey(key, options);
+            if (event.key === fullKey && event.storageArea === 'sessionStorage') {
+                return event.newValue;
+            }
+            return this.getSessionStorage(key, null, options);
+        }));
+    }
+    // Direct access to native storage APIs
+    getNativeLocalStorage() {
+        this.ensureStorageSupport();
+        return localStorage;
+    }
+    getNativeSessionStorage() {
+        this.ensureStorageSupport();
+        return sessionStorage;
+    }
+    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 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebStorageService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class WebSocketService extends BrowserApiBaseService {
+    webSocket = null;
+    statusSubject = new Subject();
+    messageSubject = new Subject();
+    reconnectAttempts = 0;
+    reconnectTimer = null;
+    heartbeatTimer = null;
+    getApiName() {
+        return 'websocket';
+    }
+    ensureWebSocketSupport() {
+        if (typeof WebSocket === 'undefined') {
+            throw new Error('WebSocket API not supported in this browser');
+        }
+    }
+    connect(config) {
+        this.ensureWebSocketSupport();
+        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.getCurrentStatus());
+            }
+            catch (error) {
+                console.error('[WebSocketService] 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.getCurrentStatus());
+            }
+            return () => {
+                this.disconnect();
+            };
+        });
+    }
+    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,
+        });
+    }
+    send(message) {
+        if (!this.webSocket || this.webSocket.readyState !== WebSocket.OPEN) {
+            throw new Error('WebSocket is not connected');
+        }
+        const messageWithTimestamp = {
+            ...message,
+            timestamp: Date.now(),
+        };
+        this.webSocket.send(JSON.stringify(messageWithTimestamp));
+    }
+    sendRaw(data) {
+        if (!this.webSocket || this.webSocket.readyState !== WebSocket.OPEN) {
+            throw new Error('WebSocket is not connected');
+        }
+        this.webSocket.send(data);
+    }
+    getStatus() {
+        return this.statusSubject.asObservable();
+    }
+    getMessages() {
+        return this.messageSubject
+            .asObservable()
+            .pipe(filter((msg) => true));
+    }
+    setupWebSocketHandlers(config) {
+        if (!this.webSocket)
+            return;
+        this.webSocket.onopen = () => {
+            console.log('[WebSocketService] 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) => {
+            console.log('[WebSocketService] 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) => {
+            console.error('[WebSocketService] WebSocket error:', error);
+            this.updateStatus({
+                connected: false,
+                connecting: false,
+                reconnecting: false,
+                error: 'WebSocket connection error',
+                reconnectAttempts: this.reconnectAttempts,
+            });
+        };
+        this.webSocket.onmessage = (event) => {
+            try {
+                const message = JSON.parse(event.data);
+                this.messageSubject.next(message);
+            }
+            catch (error) {
+                console.error('[WebSocketService] 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)) {
+            console.log('[WebSocketService] Max reconnect attempts reached');
+            return;
+        }
+        this.reconnectAttempts++;
+        this.updateStatus({
+            connected: false,
+            connecting: false,
+            reconnecting: true,
+            reconnectAttempts: this.reconnectAttempts,
+        });
+        this.reconnectTimer = setTimeout(() => {
+            console.log(`[WebSocketService] Reconnect attempt ${this.reconnectAttempts}`);
+            this.connect(config);
+        }, config.reconnectInterval || 3000);
+    }
+    updateStatus(status) {
+        const currentStatus = this.getCurrentStatus();
+        const newStatus = { ...currentStatus, ...status };
+        this.statusSubject.next(newStatus);
+    }
+    getCurrentStatus() {
+        return {
+            connected: this.webSocket?.readyState === WebSocket.OPEN,
+            connecting: false,
+            reconnecting: false,
+            reconnectAttempts: this.reconnectAttempts,
+        };
+    }
+    // Direct access to native WebSocket
+    getNativeWebSocket() {
+        return this.webSocket;
+    }
+    isConnected() {
+        return this.webSocket?.readyState === WebSocket.OPEN;
+    }
+    getReadyState() {
+        return this.webSocket?.readyState ?? WebSocket.CLOSED;
+    }
+    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 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebSocketService, decorators: [{
+            type: Injectable
+        }] });
+
+class WebWorkerService extends BrowserApiBaseService {
+    destroyRef = inject(DestroyRef);
+    workers = new Map();
+    workerStatuses = new Map();
+    workerMessages = new Map();
+    currentWorkerStatuses = new Map();
+    getApiName() {
+        return 'webworker';
+    }
+    ensureWorkerSupport() {
+        if (typeof Worker === 'undefined') {
+            throw new Error('Web Workers not supported in this browser');
+        }
+    }
+    createWorker(name, scriptUrl) {
+        this.ensureWorkerSupport();
+        return new Observable((observer) => {
+            if (this.workers.has(name)) {
+                observer.next(this.currentWorkerStatuses.get(name));
+                return () => {
+                    // No-op: workers are managed explicitly via terminateWorker/terminateAllWorkers
+                };
+            }
+            try {
+                const worker = new Worker(scriptUrl);
+                this.workers.set(name, worker);
+                this.setupWorker(name, worker);
+                const status = {
+                    initialized: true,
+                    running: true,
+                    messageCount: 0,
+                };
+                this.currentWorkerStatuses.set(name, status);
+                this.updateWorkerStatus(name, status);
+                observer.next(status);
+            }
+            catch (error) {
+                console.error(`[WebWorkerService] Failed to create worker ${name}:`, error);
+                const status = {
+                    initialized: false,
+                    running: false,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                    messageCount: 0,
+                };
+                this.currentWorkerStatuses.set(name, status);
+                this.updateWorkerStatus(name, status);
+                observer.next(status);
+            }
+            return () => {
+                // No-op: workers are managed explicitly via terminateWorker/terminateAllWorkers
+            };
+        });
+    }
+    terminateWorker(name) {
+        const worker = this.workers.get(name);
+        if (worker) {
+            worker.terminate();
+            this.workers.delete(name);
+            this.workerStatuses.delete(name);
+            this.workerMessages.delete(name);
+            this.currentWorkerStatuses.delete(name);
+        }
+    }
+    terminateAllWorkers() {
+        this.workers.forEach((_, name) => {
+            this.terminateWorker(name);
+        });
+    }
+    postMessage(workerName, task) {
+        const worker = this.workers.get(workerName);
+        if (!worker) {
+            console.error(`[WebWorkerService] Worker ${workerName} not found`);
+            return;
+        }
+        try {
+            const message = { ...task, timestamp: Date.now() };
+            if (task.transferable) {
+                worker.postMessage(message, task.transferable);
+            }
+            else {
+                worker.postMessage(message);
+            }
+            const currentStatus = this.currentWorkerStatuses.get(workerName);
+            if (currentStatus) {
+                currentStatus.messageCount++;
+                this.updateWorkerStatus(workerName, currentStatus);
+            }
+        }
+        catch (error) {
+            console.error(`[WebWorkerService] Failed to post message to worker ${workerName}:`, error);
+        }
+    }
+    getMessages(workerName) {
+        if (!this.workerMessages.has(workerName)) {
+            this.workerMessages.set(workerName, new Subject());
+        }
+        return this.workerMessages.get(workerName).asObservable();
+    }
+    getStatus(workerName) {
+        if (!this.workerStatuses.has(workerName)) {
+            this.workerStatuses.set(workerName, new Subject());
+        }
+        return this.workerStatuses.get(workerName).asObservable();
+    }
+    getCurrentStatus(workerName) {
+        return this.currentWorkerStatuses.get(workerName);
+    }
+    getAllStatuses() {
+        return new Map(this.currentWorkerStatuses);
+    }
+    isWorkerRunning(workerName) {
+        const status = this.currentWorkerStatuses.get(workerName);
+        return status?.running ?? false;
+    }
+    setupWorker(name, worker) {
+        worker.onmessage = (event) => {
+            const message = {
+                id: event.data.id || `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                type: event.data.type || 'message',
+                data: event.data.data,
+                timestamp: event.data.timestamp || Date.now(),
+            };
+            if (!this.workerMessages.has(name)) {
+                this.workerMessages.set(name, new Subject());
+            }
+            this.workerMessages.get(name).next(message);
+        };
+        worker.onerror = (error) => {
+            console.error(`[WebWorkerService] Worker ${name} error:`, error);
+            const status = {
+                initialized: true,
+                running: false,
+                error: error instanceof Error ? error.message : 'Worker error',
+                messageCount: this.currentWorkerStatuses.get(name)?.messageCount ?? 0,
+            };
+            this.currentWorkerStatuses.set(name, status);
+            this.updateWorkerStatus(name, status);
+        };
+        // Auto-cleanup when service is destroyed
+        this.destroyRef.onDestroy(() => {
+            this.terminateWorker(name);
+        });
+    }
+    updateWorkerStatus(name, status) {
+        if (!this.workerStatuses.has(name)) {
+            this.workerStatuses.set(name, new Subject());
+        }
+        this.workerStatuses.get(name).next(status);
+    }
+    // Direct access to native Worker API
+    getNativeWorker(name) {
+        return this.workers.get(name);
+    }
+    getAllWorkers() {
+        return new Map(this.workers);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebWorkerService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebWorkerService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebWorkerService, decorators: [{
+            type: Injectable
+        }] });
+
+// Common types for browser APIs
+
 class BrowserSupportUtil {
     static isSupported(feature) {
         if (typeof window === 'undefined' || typeof navigator === 'undefined') {
@@ -570,9 +1330,9 @@ class BrowserSupportUtil {
             'clipboard',
             'clipboard-read',
             'clipboard-write',
-            'persistent-storage'
+            'persistent-storage',
         ];
-        return features.filter(feature => !this.isSupported(feature));
+        return features.filter((feature) => !this.isSupported(feature));
     }
     static isSecureContext() {
         return typeof window !== 'undefined' ? window.isSecureContext : false;
@@ -595,7 +1355,7 @@ class BrowserSupportUtil {
             isChrome: /chrome/.test(userAgent) && !/edge/.test(userAgent),
             isFirefox: /firefox/.test(userAgent),
             isSafari: /safari/.test(userAgent) && !/chrome/.test(userAgent),
-            isEdge: /edge/.test(userAgent) || /edg/.test(userAgent)
+            isEdge: /edge/.test(userAgent) || /edg/.test(userAgent),
         };
     }
     static getBrowserName(userAgent) {
@@ -615,26 +1375,22 @@ class BrowserSupportUtil {
     }
 }
 
-class PermissionGuard {
-    permissionsService;
-    router;
-    constructor(permissionsService, router) {
-        this.permissionsService = permissionsService;
-        this.router = router;
-    }
-    canActivate(route) {
-        const permission = route.data?.['permission'];
+/**
+ * Functional guard that checks if the user has the required permission.
+ * Usage in routes: { canActivate: [permissionGuard('camera')] }
+ */
+const permissionGuard = (permission) => {
+    return async (_route) => {
+        const permissionsService = inject(PermissionsService);
+        const router = inject(Router);
         if (!permission) {
-            return Promise.resolve(true);
+            return true;
         }
-        return this.checkPermission(permission);
-    }
-    async checkPermission(permission) {
         try {
-            const status = await this.permissionsService.query({ name: permission });
+            const status = await permissionsService.query({ name: permission });
             if (status.state !== 'granted') {
-                this.router.navigate(['/permission-denied'], {
-                    queryParams: { permission }
+                router.navigate(['/permission-denied'], {
+                    queryParams: { permission },
                 });
                 return false;
             }
@@ -642,18 +1398,99 @@ class PermissionGuard {
         }
         catch (error) {
             console.error('Permission guard error:', error);
-            this.router.navigate(['/permission-denied'], {
-                queryParams: { permission }
+            router.navigate(['/permission-denied'], {
+                queryParams: { permission },
             });
             return false;
         }
+    };
+};
+
+const defaultBrowserWebApisConfig = {
+    enableCamera: true,
+    enableGeolocation: true,
+    enableNotifications: true,
+    enableClipboard: true,
+    enableBattery: false,
+    enableMediaDevices: true,
+    enableWebShare: false,
+    enableWebStorage: false,
+    enableWebSocket: false,
+    enableWebWorker: false,
+};
+function provideBrowserWebApis(config = {}) {
+    const mergedConfig = { ...defaultBrowserWebApisConfig, ...config };
+    const providers = [PermissionsService];
+    const conditionalProviders = [
+        [mergedConfig.enableCamera, CameraService],
+        [mergedConfig.enableGeolocation, GeolocationService],
+        [mergedConfig.enableNotifications, NotificationService],
+        [mergedConfig.enableClipboard, ClipboardService],
+        [mergedConfig.enableMediaDevices, MediaDevicesService],
+        [mergedConfig.enableBattery, BatteryService],
+        [mergedConfig.enableWebShare, WebShareService],
+        [mergedConfig.enableWebStorage, WebStorageService],
+        [mergedConfig.enableWebSocket, WebSocketService],
+        [mergedConfig.enableWebWorker, WebWorkerService],
+    ];
+    for (const [enabled, provider] of conditionalProviders) {
+        if (enabled) {
+            providers.push(provider);
+        }
     }
+    return makeEnvironmentProviders(providers);
 }
-function createPermissionGuard(permission) {
-    return {
-        canActivate: [PermissionGuard],
-        data: { permission }
-    };
+// Feature-specific providers for tree-shaking
+function provideCamera() {
+    return makeEnvironmentProviders([PermissionsService, CameraService]);
+}
+function provideGeolocation() {
+    return makeEnvironmentProviders([PermissionsService, GeolocationService]);
+}
+function provideNotifications() {
+    return makeEnvironmentProviders([PermissionsService, NotificationService]);
+}
+function provideClipboard() {
+    return makeEnvironmentProviders([PermissionsService, ClipboardService]);
+}
+function provideMediaDevices() {
+    return makeEnvironmentProviders([PermissionsService, MediaDevicesService]);
+}
+function provideBattery() {
+    return makeEnvironmentProviders([BatteryService]);
+}
+function provideWebShare() {
+    return makeEnvironmentProviders([WebShareService]);
+}
+function provideWebStorage() {
+    return makeEnvironmentProviders([WebStorageService]);
+}
+function provideWebSocket() {
+    return makeEnvironmentProviders([WebSocketService]);
+}
+function provideWebWorker() {
+    return makeEnvironmentProviders([WebWorkerService]);
+}
+function providePermissions() {
+    return makeEnvironmentProviders([PermissionsService]);
+}
+// Combined providers for common use cases
+function provideMediaApis() {
+    return makeEnvironmentProviders([PermissionsService, CameraService, MediaDevicesService]);
+}
+function provideLocationApis() {
+    return makeEnvironmentProviders([PermissionsService, GeolocationService]);
+}
+function provideStorageApis() {
+    return makeEnvironmentProviders([PermissionsService, ClipboardService, WebStorageService]);
+}
+function provideCommunicationApis() {
+    return makeEnvironmentProviders([
+        PermissionsService,
+        NotificationService,
+        WebShareService,
+        WebSocketService,
+    ]);
 }
 
 // Browser Web APIs Services
@@ -664,5 +1501,4 @@ const version = '0.1.0';
  * Generated bundle index. Do not edit.
  */
 
-export { BrowserCapabilityService, BrowserSupportUtil, CameraService, ClipboardService, GeolocationService, MediaDevicesService, NotificationService, PermissionGuard, PermissionsService, createPermissionGuard, version };
-//# sourceMappingURL=angular-helpers-browser-web-apis.mjs.map
+export { BatteryService, BrowserApiBaseService, BrowserCapabilityService, BrowserSupportUtil, CameraService, ClipboardService, GeolocationService, MediaDevicesService, NotificationService, PermissionsService, WebShareService, WebSocketService, WebStorageService, WebWorkerService, permissionGuard as createPermissionGuard, defaultBrowserWebApisConfig, permissionGuard, provideBattery, provideBrowserWebApis, provideCamera, provideClipboard, provideCommunicationApis, provideGeolocation, provideLocationApis, provideMediaApis, provideMediaDevices, provideNotifications, providePermissions, provideStorageApis, provideWebShare, provideWebSocket, provideWebStorage, provideWebWorker, version };