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

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

@@ -0,0 +1,1504 @@
+import * as i0 from '@angular/core';
+import { Injectable, inject, DestroyRef, PLATFORM_ID, signal, makeEnvironmentProviders } from '@angular/core';
+import { isPlatformBrowser, isPlatformServer } from '@angular/common';
+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) {
+        if (!this.isSupported()) {
+            throw new Error('Permissions API not supported');
+        }
+        try {
+            return await navigator.permissions.query(descriptor);
+        }
+        catch (error) {
+            console.error('Error querying permission:', error);
+            throw error;
+        }
+    }
+    isSupported() {
+        return typeof navigator !== 'undefined' && 'permissions' in navigator;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PermissionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PermissionsService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PermissionsService, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * Base class for all Browser Web API services
+ * Provides common functionality for:
+ * - Support checking
+ * - Permission management
+ * - Error handling
+ * - Lifecycle management with destroyRef
+ * - Logging
+ */
+class BrowserApiBaseService {
+    permissionsService = inject(PermissionsService);
+    destroyRef = inject(DestroyRef);
+    platformId = inject(PLATFORM_ID);
+    /**
+     * Check if running in browser environment using Angular's platform detection
+     */
+    isBrowserEnvironment() {
+        return isPlatformBrowser(this.platformId);
+    }
+    /**
+     * Check if running in server environment using Angular's platform detection
+     */
+    isServerEnvironment() {
+        return isPlatformServer(this.platformId);
+    }
+    /**
+     * Request a permission
+     */
+    async requestPermission(permission) {
+        if (this.isServerEnvironment()) {
+            throw new Error(`${this.getApiName()} API not available in server environment`);
+        }
+        try {
+            const status = await this.permissionsService.query({ name: permission });
+            return status.state === 'granted';
+        }
+        catch (error) {
+            console.error(`[${this.getApiName()}] Error requesting permission for ${permission}:`, error);
+            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 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BrowserApiBaseService, decorators: [{
+            type: Injectable
+        }] });
+
+class CameraService extends BrowserApiBaseService {
+    currentStream = null;
+    getApiName() {
+        return 'camera';
+    }
+    ensureCameraSupport() {
+        if (!('mediaDevices' in navigator) || !('getUserMedia' in navigator.mediaDevices)) {
+            throw new Error('Camera API not supported in this browser');
+        }
+    }
+    async startCamera(constraints) {
+        this.ensureCameraSupport();
+        if (this.currentStream) {
+            this.stopCamera();
+        }
+        const permissionStatus = await this.permissionsService.query({ name: 'camera' });
+        if (permissionStatus.state !== 'granted') {
+            throw new Error('Camera permission required. Please grant camera access and try again.');
+        }
+        try {
+            const streamConstraints = constraints || {
+                video: {
+                    width: { ideal: 1280 },
+                    height: { ideal: 720 },
+                    facingMode: 'user',
+                },
+            };
+            this.currentStream = await navigator.mediaDevices.getUserMedia(streamConstraints);
+            return this.currentStream;
+        }
+        catch (error) {
+            console.error('[CameraService] Error starting camera:', error);
+            if (error instanceof Error && error.name === 'NotAllowedError') {
+                throw this.createError('Camera permission denied by user. Please allow camera access in your browser settings and refresh the page.', error);
+            }
+            else if (error instanceof Error && error.name === 'NotFoundError') {
+                throw this.createError('No camera device found. Please connect a camera and try again.', error);
+            }
+            else if (error instanceof Error && error.name === 'NotReadableError') {
+                throw this.createError('Camera is already in use by another application. Please close other applications using the camera and try again.', error);
+            }
+            else if (error instanceof Error && error.name === 'OverconstrainedError') {
+                throw this.createError('Camera constraints cannot be satisfied. Try with different camera settings.', error);
+            }
+            else {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+                throw this.createError(`Camera error: ${errorMessage}`, error);
+            }
+        }
+    }
+    stopCamera() {
+        if (this.currentStream) {
+            this.currentStream.getTracks().forEach((track) => {
+                track.stop();
+            });
+            this.currentStream = null;
+        }
+    }
+    async switchCamera(deviceId, constraints = {
+        video: {
+            width: { ideal: 1280 },
+            height: { ideal: 720 },
+        },
+    }) {
+        this.stopCamera();
+        const finalConstraints = {
+            video: constraints.video && typeof constraints.video === 'object'
+                ? { ...constraints.video, deviceId: { exact: deviceId } }
+                : { deviceId: { exact: deviceId } },
+        };
+        return this.startCamera(finalConstraints);
+    }
+    async getCameraCapabilities(deviceId) {
+        this.ensureCameraSupport();
+        try {
+            const stream = await navigator.mediaDevices.getUserMedia({
+                video: { deviceId: { exact: deviceId } },
+            });
+            const videoTrack = stream.getVideoTracks()[0];
+            const capabilities = videoTrack.getCapabilities();
+            // Clean up the stream
+            stream.getTracks().forEach((track) => track.stop());
+            return capabilities || null;
+        }
+        catch (error) {
+            console.error('[CameraService] Error getting camera capabilities:', error);
+            return null;
+        }
+    }
+    getCurrentStream() {
+        return this.currentStream;
+    }
+    isStreaming() {
+        return this.currentStream !== null;
+    }
+    async getVideoInputDevices() {
+        this.ensureCameraSupport();
+        try {
+            const devices = await navigator.mediaDevices.enumerateDevices();
+            return devices.filter((device) => device.kind === 'videoinput');
+        }
+        catch (error) {
+            console.error('[CameraService] Error enumerating video devices:', error);
+            throw this.createError('Failed to enumerate video devices', error);
+        }
+    }
+    // Direct access to native camera API
+    getNativeMediaDevices() {
+        this.ensureCameraSupport();
+        return navigator.mediaDevices;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CameraService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CameraService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CameraService, decorators: [{
+            type: Injectable
+        }] });
+
+class GeolocationService extends BrowserApiBaseService {
+    getApiName() {
+        return 'geolocation';
+    }
+    ensureGeolocationSupport() {
+        if (!('geolocation' in navigator)) {
+            throw new Error('Geolocation API not supported in this browser');
+        }
+    }
+    getCurrentPosition(options) {
+        this.ensureGeolocationSupport();
+        return new Promise((resolve, reject) => {
+            navigator.geolocation.getCurrentPosition((position) => resolve(position), (error) => {
+                console.error('[GeolocationService] Error getting position:', error);
+                reject(error);
+            }, options);
+        });
+    }
+    watchPosition(options) {
+        this.ensureGeolocationSupport();
+        return new Observable((observer) => {
+            const watchId = navigator.geolocation.watchPosition((position) => observer.next(position), (error) => {
+                console.error('[GeolocationService] Error watching position:', error);
+                observer.error(error);
+            }, options);
+            return () => {
+                navigator.geolocation.clearWatch(watchId);
+            };
+        });
+    }
+    clearWatch(watchId) {
+        navigator.geolocation.clearWatch(watchId);
+    }
+    // Direct access to native geolocation API
+    getNativeGeolocation() {
+        this.ensureGeolocationSupport();
+        return navigator.geolocation;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: GeolocationService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: GeolocationService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: GeolocationService, decorators: [{
+            type: Injectable
+        }] });
+
+class MediaDevicesService extends BrowserApiBaseService {
+    getApiName() {
+        return 'media-devices';
+    }
+    ensureMediaDevicesSupport() {
+        if (!('mediaDevices' in navigator)) {
+            throw new Error('MediaDevices API not supported in this browser');
+        }
+    }
+    async getDevices() {
+        this.ensureMediaDevicesSupport();
+        try {
+            const devices = await navigator.mediaDevices.enumerateDevices();
+            return devices;
+        }
+        catch (error) {
+            console.error('[MediaDevicesService] Error enumerating devices:', error);
+            throw this.createError('Failed to enumerate media devices', error);
+        }
+    }
+    async getUserMedia(constraints) {
+        this.ensureMediaDevicesSupport();
+        try {
+            const defaultConstraints = {
+                video: true,
+                audio: true,
+            };
+            const finalConstraints = constraints || defaultConstraints;
+            return await navigator.mediaDevices.getUserMedia(finalConstraints);
+        }
+        catch (error) {
+            console.error('[MediaDevicesService] Error getting user media:', error);
+            throw this.handleMediaError(error);
+        }
+    }
+    async getDisplayMedia(constraints) {
+        this.ensureMediaDevicesSupport();
+        if (!('getDisplayMedia' in navigator.mediaDevices)) {
+            throw new Error('Display media API not supported in this browser');
+        }
+        try {
+            const defaultConstraints = {
+                video: true,
+                audio: false,
+            };
+            const finalConstraints = constraints || defaultConstraints;
+            return await navigator.mediaDevices.getDisplayMedia(finalConstraints);
+        }
+        catch (error) {
+            console.error('[MediaDevicesService] Error getting display media:', error);
+            throw this.createError('Failed to get display media', error);
+        }
+    }
+    watchDeviceChanges() {
+        this.ensureMediaDevicesSupport();
+        return new Observable((observer) => {
+            const handleDeviceChange = async () => {
+                try {
+                    const devices = await navigator.mediaDevices.enumerateDevices();
+                    observer.next(devices);
+                }
+                catch (error) {
+                    console.error('[MediaDevicesService] Error handling device change:', error);
+                }
+            };
+            // Listen for device changes
+            navigator.mediaDevices.addEventListener('devicechange', handleDeviceChange);
+            // Get initial devices
+            handleDeviceChange();
+            return () => {
+                navigator.mediaDevices.removeEventListener('devicechange', handleDeviceChange);
+            };
+        });
+    }
+    getVideoInputDevices() {
+        return this.getDevicesByKind('videoinput');
+    }
+    getAudioInputDevices() {
+        return this.getDevicesByKind('audioinput');
+    }
+    getAudioOutputDevices() {
+        return this.getDevicesByKind('audiooutput');
+    }
+    async getDevicesByKind(kind) {
+        const devices = await this.getDevices();
+        return devices.filter((device) => device.kind === kind);
+    }
+    handleMediaError(error) {
+        let message;
+        if (error instanceof Error) {
+            switch (error.name) {
+                case 'NotAllowedError':
+                    message = 'Permission denied by user';
+                    break;
+                case 'NotFoundError':
+                    message = 'No media device found';
+                    break;
+                case 'NotReadableError':
+                    message = 'Media device is already in use';
+                    break;
+                case 'OverconstrainedError':
+                    message = 'Media constraints cannot be satisfied';
+                    break;
+                case 'TypeError':
+                    message = 'Invalid media constraints provided';
+                    break;
+                default:
+                    message = `Media error: ${error.message}`;
+            }
+        }
+        else {
+            message = 'Unknown media error occurred';
+        }
+        return this.createError(message, error);
+    }
+    // Direct access to native media devices API
+    getNativeMediaDevices() {
+        this.ensureMediaDevicesSupport();
+        return navigator.mediaDevices;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: MediaDevicesService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: MediaDevicesService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: MediaDevicesService, decorators: [{
+            type: Injectable
+        }] });
+
+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 (!this.isSupported()) {
+            throw new Error('Notification API not supported in this browser');
+        }
+        if (Notification.permission !== 'granted') {
+            throw new Error('Notification permission required. Please grant notification access and try again.');
+        }
+        try {
+            return new Notification(title, options);
+        }
+        catch (error) {
+            console.error('[NotificationService] Error showing notification:', error);
+            throw error;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: NotificationService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: NotificationService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: NotificationService, decorators: [{
+            type: Injectable
+        }] });
+
+class ClipboardService extends BrowserApiBaseService {
+    getApiName() {
+        return 'clipboard';
+    }
+    async ensureClipboardPermission(action) {
+        if (!('clipboard' in navigator)) {
+            throw new Error('Clipboard API not supported in this browser');
+        }
+        const permissionStatus = await this.permissionsService.query({
+            name: `clipboard-${action}`,
+        });
+        if (permissionStatus.state !== 'granted') {
+            throw new Error(`Clipboard ${action} permission required. Please grant clipboard access and try again.`);
+        }
+    }
+    async writeText(text) {
+        await this.ensureClipboardPermission('write');
+        try {
+            await navigator.clipboard.writeText(text);
+        }
+        catch (error) {
+            console.error('[ClipboardService] Error writing to clipboard:', error);
+            throw error;
+        }
+    }
+    async readText() {
+        await this.ensureClipboardPermission('read');
+        try {
+            return await navigator.clipboard.readText();
+        }
+        catch (error) {
+            console.error('[ClipboardService] Error reading from clipboard:', error);
+            throw error;
+        }
+    }
+    async writeTextSecure(text) {
+        await this.ensureClipboardPermission('write');
+        try {
+            await navigator.clipboard.writeText(text);
+        }
+        catch (error) {
+            console.error('[ClipboardService] Error writing to clipboard:', error);
+            throw error;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: ClipboardService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: ClipboardService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: ClipboardService, decorators: [{
+            type: Injectable
+        }] });
+
+const BROWSER_CAPABILITIES = [
+    { id: 'permissions', label: 'Permissions API', requiresSecureContext: false },
+    { id: 'geolocation', label: 'Geolocation API', requiresSecureContext: true },
+    { id: 'clipboard', label: 'Clipboard API', requiresSecureContext: true },
+    { id: 'notification', label: 'Notification API', requiresSecureContext: true },
+    { id: 'mediaDevices', label: 'MediaDevices API', requiresSecureContext: true },
+    { id: 'camera', label: 'Camera API', requiresSecureContext: true },
+    { id: 'webWorker', label: 'Web Worker API', requiresSecureContext: false },
+    { id: 'regexSecurity', label: 'Regex Security', requiresSecureContext: false },
+    { 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 },
+];
+class BrowserCapabilityService {
+    getCapabilities() {
+        return BROWSER_CAPABILITIES;
+    }
+    isSecureContext() {
+        return typeof window !== 'undefined' && window.isSecureContext;
+    }
+    isSupported(capability) {
+        switch (capability) {
+            case 'permissions':
+                return typeof navigator !== 'undefined' && 'permissions' in navigator;
+            case 'geolocation':
+                return typeof navigator !== 'undefined' && 'geolocation' in navigator;
+            case 'clipboard':
+                return typeof navigator !== 'undefined' && 'clipboard' in navigator;
+            case 'notification':
+                return typeof window !== 'undefined' && 'Notification' in window;
+            case 'mediaDevices':
+            case 'camera':
+                return typeof navigator !== 'undefined' && 'mediaDevices' in navigator;
+            case 'webWorker':
+            case 'regexSecurity':
+                return typeof Worker !== 'undefined';
+            case 'webStorage':
+                return typeof Storage !== 'undefined';
+            case 'webShare':
+                return typeof navigator !== 'undefined' && 'share' in navigator;
+            case 'battery':
+                return typeof navigator !== 'undefined' && 'getBattery' in navigator;
+            case 'webSocket':
+                return typeof WebSocket !== 'undefined';
+            default:
+                return false;
+        }
+    }
+    getAllStatuses() {
+        const secureContext = this.isSecureContext();
+        return this.getCapabilities().map((capability) => ({
+            id: capability.id,
+            label: capability.label,
+            supported: this.isSupported(capability.id),
+            secureContext,
+            requiresSecureContext: capability.requiresSecureContext,
+        }));
+    }
+    async getPermissionState(permission) {
+        if (typeof navigator === 'undefined' || !('permissions' in navigator)) {
+            return 'unknown';
+        }
+        try {
+            const status = await navigator.permissions.query({ name: permission });
+            return status.state;
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BrowserCapabilityService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BrowserCapabilityService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BrowserCapabilityService, decorators: [{
+            type: Injectable,
+            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') {
+            return false;
+        }
+        switch (feature) {
+            case 'permissions':
+                return 'permissions' in navigator;
+            case 'camera':
+                return 'mediaDevices' in navigator && 'getUserMedia' in navigator.mediaDevices;
+            case 'microphone':
+                return 'mediaDevices' in navigator && 'getUserMedia' in navigator.mediaDevices;
+            case 'geolocation':
+                return 'geolocation' in navigator;
+            case 'notifications':
+                return 'Notification' in window;
+            case 'clipboard':
+                return 'clipboard' in navigator;
+            case 'clipboard-read':
+                return 'clipboard' in navigator && 'readText' in navigator.clipboard;
+            case 'clipboard-write':
+                return 'clipboard' in navigator && 'writeText' in navigator.clipboard;
+            case 'persistent-storage':
+                return 'storage' in navigator && 'persist' in navigator.storage;
+            default:
+                return false;
+        }
+    }
+    static getUnsupportedFeatures() {
+        const features = [
+            'permissions',
+            'camera',
+            'microphone',
+            'geolocation',
+            'notifications',
+            'clipboard',
+            'clipboard-read',
+            'clipboard-write',
+            'persistent-storage',
+        ];
+        return features.filter((feature) => !this.isSupported(feature));
+    }
+    static isSecureContext() {
+        return typeof window !== 'undefined' ? window.isSecureContext : false;
+    }
+    static getUserAgent() {
+        return typeof navigator !== 'undefined' ? navigator.userAgent : '';
+    }
+    static isMobile() {
+        const userAgent = this.getUserAgent().toLowerCase();
+        return /android|webos|iphone|ipad|ipod|blackberry|iemobile|opera mini/i.test(userAgent);
+    }
+    static isDesktop() {
+        return !this.isMobile();
+    }
+    static getBrowserInfo() {
+        const userAgent = this.getUserAgent();
+        return {
+            name: this.getBrowserName(userAgent),
+            version: this.getBrowserVersion(userAgent),
+            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),
+        };
+    }
+    static getBrowserName(userAgent) {
+        if (/chrome/.test(userAgent) && !/edge/.test(userAgent))
+            return 'Chrome';
+        if (/firefox/.test(userAgent))
+            return 'Firefox';
+        if (/safari/.test(userAgent) && !/chrome/.test(userAgent))
+            return 'Safari';
+        if (/edge/.test(userAgent) || /edg/.test(userAgent))
+            return 'Edge';
+        return 'Unknown';
+    }
+    static getBrowserVersion(userAgent) {
+        const match = userAgent.match(/(chrome|firefox|safari|edge|edg)\/(\d+)/i);
+        return match ? match[2] : 'Unknown';
+    }
+}
+
+/**
+ * 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 true;
+        }
+        try {
+            const status = await permissionsService.query({ name: permission });
+            if (status.state !== 'granted') {
+                router.navigate(['/permission-denied'], {
+                    queryParams: { permission },
+                });
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            console.error('Permission guard error:', error);
+            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);
+}
+// 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
+// Version
+const version = '0.1.0';
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+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 };