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

package/README.es.md

@@ -8,12 +8,13 @@ Paquete de servicios Angular para acceder de forma estructurada y segura a Brows
 
 ## Caracteristicas
 
-- Seguridad integrada con prevencion de ReDoS usando Web Workers
 - Acceso unificado a APIs del navegador mediante servicios tipados
-- Arquitectura tree-shakable
-- Configuracion modular para habilitar solo lo necesario
+- **Tree-shaking real** — cada `provideX()` vive en su propio modulo e importa solo lo que necesita
+- `provideBrowserWebApis()` para configuracion rapida cuando el tamano del bundle no es critico
 - APIs reactivas con signals y observables
-- Integracion segura con el ciclo de vida usando `destroyRef`
+- Integracion segura con el ciclo de vida via `DestroyRef` (cleanup automatico)
+- Logging y manejo de errores centralizado en `BrowserApiBaseService`
+- Validacion de contexto seguro y deteccion de soporte del navegador incorporados
 
 ## Servicios disponibles
 
@@ -29,6 +30,8 @@ Paquete de servicios Angular para acceder de forma estructurada y segura a Brows
 
 - `IntersectionObserverService` - Detectar cuando elementos entran/salen del viewport
 - `ResizeObserverService` - Observar cambios de tamano de elementos
+- `MutationObserverService` - Observar mutaciones en el DOM
+- `PerformanceObserverService` - Monitorear entradas de rendimiento (LCP, CLS, etc.)
 
 ### APIs de sistema
 
@@ -39,6 +42,9 @@ Paquete de servicios Angular para acceder de forma estructurada y segura a Brows
 - `FullscreenService` - Alternar modo pantalla completa para elementos
 - `VibrationService` - Activar patrones de retroalimentacion tactil
 - `SpeechSynthesisService` - Texto a voz con seleccion de voz
+- `IdleDetectorService` - Detectar estado idle del usuario y bloqueo de pantalla
+- `GamepadService` - Polling de entrada de controladores de juego
+- `WebAudioService` - Contexto de audio, osciladores y analizadores
 
 ### APIs de red
 
@@ -75,6 +81,8 @@ npm install @angular-helpers/browser-web-apis
 
 ## Configuracion rapida
 
+### Todo en uno (sin preocupacion por el bundle)
+
 ```typescript
 import { provideBrowserWebApis } from '@angular-helpers/browser-web-apis';
 
@@ -89,6 +97,62 @@ bootstrapApplication(AppComponent, {
 });
 ```
 
+### Configuracion granular (recomendada para produccion)
+
+Cada `provideX()` vive en su propio modulo e importa solo su servicio. Los bundlers (webpack, Rollup, Vite) eliminan todo lo que no uses.
+
+```typescript
+import {
+  provideCamera,
+  provideGeolocation,
+  provideWebStorage,
+} from '@angular-helpers/browser-web-apis';
+
+bootstrapApplication(AppComponent, {
+  providers: [
+    provideCamera(), // → solo CameraService + PermissionsService
+    provideGeolocation(), // → solo GeolocationService + PermissionsService
+    provideWebStorage(), // → solo WebStorageService
+  ],
+});
+```
+
+Cada servicio tiene su propio `provideX()`:
+
+| Funcion                         | Servicios incluidos                         |
+| ------------------------------- | ------------------------------------------- |
+| `provideCamera()`               | `PermissionsService`, `CameraService`       |
+| `provideGeolocation()`          | `PermissionsService`, `GeolocationService`  |
+| `provideNotifications()`        | `PermissionsService`, `NotificationService` |
+| `provideClipboard()`            | `PermissionsService`, `ClipboardService`    |
+| `provideMediaDevices()`         | `PermissionsService`, `MediaDevicesService` |
+| `provideWebStorage()`           | `WebStorageService`                         |
+| `provideWebSocket()`            | `WebSocketService`                          |
+| `provideWebWorker()`            | `WebWorkerService`                          |
+| `provideBattery()`              | `BatteryService`                            |
+| `provideIntersectionObserver()` | `IntersectionObserverService`               |
+| `provideResizeObserver()`       | `ResizeObserverService`                     |
+| `provideMutationObserver()`     | `MutationObserverService`                   |
+| `providePerformanceObserver()`  | `PerformanceObserverService`                |
+| `providePageVisibility()`       | `PageVisibilityService`                     |
+| `provideNetworkInformation()`   | `NetworkInformationService`                 |
+| …y 22 mas                       | Ver `src/providers/`                        |
+
+### Providers combinados
+
+Funciones de conveniencia que agrupan servicios relacionados:
+
+```typescript
+import { provideMediaApis, provideStorageApis } from '@angular-helpers/browser-web-apis';
+
+bootstrapApplication(AppComponent, {
+  providers: [
+    provideMediaApis(), // Camera + MediaDevices + Permissions
+    provideStorageApis(), // Clipboard + WebStorage + Permissions
+  ],
+});
+```
+
 ## Uso por servicio
 
 ### CameraService

package/README.md

@@ -8,12 +8,13 @@ Angular services package for a structured and secure access layer over browser W
 
 ## Features
 
-- Integrated security with ReDoS prevention using Web Workers
 - Unified browser API access through strongly typed services
-- Tree-shakable architecture
-- Modular provider setup to enable only what you need
-- Reactive APIs with signals and observables
-- Lifecycle-safe integration with `destroyRef`
+- **True tree-shaking** — individual `provideX()` functions import only their own service
+- All-in-one `provideBrowserWebApis()` for quick setup when bundle size is not a concern
+- Reactive APIs using signals and observables
+- Lifecycle-safe integration with `DestroyRef` (automatic cleanup)
+- Centralized logging and error handling via `BrowserApiBaseService`
+- Secure context validation and browser support detection built in
 
 ## Available Services
 
@@ -96,6 +97,8 @@ npm install @angular-helpers/browser-web-apis
 
 ## Quick Setup
 
+### All-in-one (zero bundle budget concern)
+
 ```typescript
 import { provideBrowserWebApis } from '@angular-helpers/browser-web-apis';
 
@@ -110,6 +113,62 @@ bootstrapApplication(AppComponent, {
 });
 ```
 
+### Granular setup (recommended for production)
+
+Each `provideX()` lives in its own module and imports only the service it needs. Bundlers (webpack, Rollup, Vite) will tree-shake anything you don't include.
+
+```typescript
+import {
+  provideCamera,
+  provideGeolocation,
+  provideWebStorage,
+} from '@angular-helpers/browser-web-apis';
+
+bootstrapApplication(AppComponent, {
+  providers: [
+    provideCamera(), // → only CameraService + PermissionsService
+    provideGeolocation(), // → only GeolocationService + PermissionsService
+    provideWebStorage(), // → only WebStorageService
+  ],
+});
+```
+
+Every service has a matching `provideX()` function:
+
+| Function                        | Services included                           |
+| ------------------------------- | ------------------------------------------- |
+| `provideCamera()`               | `PermissionsService`, `CameraService`       |
+| `provideGeolocation()`          | `PermissionsService`, `GeolocationService`  |
+| `provideNotifications()`        | `PermissionsService`, `NotificationService` |
+| `provideClipboard()`            | `PermissionsService`, `ClipboardService`    |
+| `provideMediaDevices()`         | `PermissionsService`, `MediaDevicesService` |
+| `provideWebStorage()`           | `WebStorageService`                         |
+| `provideWebSocket()`            | `WebSocketService`                          |
+| `provideWebWorker()`            | `WebWorkerService`                          |
+| `provideBattery()`              | `BatteryService`                            |
+| `provideIntersectionObserver()` | `IntersectionObserverService`               |
+| `provideResizeObserver()`       | `ResizeObserverService`                     |
+| `provideMutationObserver()`     | `MutationObserverService`                   |
+| `providePerformanceObserver()`  | `PerformanceObserverService`                |
+| `providePageVisibility()`       | `PageVisibilityService`                     |
+| `provideNetworkInformation()`   | `NetworkInformationService`                 |
+| …and 22 more                    | See `src/providers/`                        |
+
+### Combo providers
+
+Convenience functions that bundle related services:
+
+```typescript
+import { provideMediaApis, provideStorageApis } from '@angular-helpers/browser-web-apis';
+
+bootstrapApplication(AppComponent, {
+  providers: [
+    provideMediaApis(), // Camera + MediaDevices + Permissions
+    provideStorageApis(), // Clipboard + WebStorage + Permissions
+  ],
+});
+```
+
 ## Usage by Service
 
 ### CameraService

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

@@ -0,0 +1,478 @@
+import * as i0 from '@angular/core';
+import { Injectable, inject, DestroyRef, PLATFORM_ID, signal, computed, makeEnvironmentProviders } from '@angular/core';
+import { Observable } from 'rxjs';
+import { BrowserApiBaseService, PermissionsService } from '@angular-helpers/browser-web-apis';
+import { isPlatformBrowser } from '@angular/common';
+
+function getIdleDetectorClass$1() {
+    return window.IdleDetector;
+}
+class IdleDetectorService extends BrowserApiBaseService {
+    getApiName() {
+        return 'idle-detector';
+    }
+    isSupported() {
+        return this.isBrowserEnvironment() && 'IdleDetector' in window;
+    }
+    async requestPermission() {
+        if (!this.isSupported()) {
+            throw new Error('IdleDetector API not supported');
+        }
+        return getIdleDetectorClass$1().requestPermission();
+    }
+    watch(options = {}) {
+        if (!this.isSupported()) {
+            return new Observable((o) => o.error(new Error('IdleDetector API not supported')));
+        }
+        return new Observable((subscriber) => {
+            const abortController = new AbortController();
+            const detector = new (getIdleDetectorClass$1())();
+            detector.addEventListener('change', () => {
+                subscriber.next({
+                    user: detector.userState,
+                    screen: detector.screenState,
+                });
+            });
+            detector
+                .start({
+                threshold: options.threshold ?? 60_000,
+                signal: abortController.signal,
+            })
+                .catch((err) => subscriber.error(err));
+            return () => abortController.abort();
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: IdleDetectorService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: IdleDetectorService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: IdleDetectorService, decorators: [{
+            type: Injectable
+        }] });
+
+function getEyeDropperClass() {
+    return window.EyeDropper;
+}
+class EyeDropperService extends BrowserApiBaseService {
+    getApiName() {
+        return 'eye-dropper';
+    }
+    isSupported() {
+        return this.isBrowserEnvironment() && 'EyeDropper' in window;
+    }
+    async open() {
+        if (!this.isSupported()) {
+            throw new Error('EyeDropper API not supported');
+        }
+        const eyeDropper = new (getEyeDropperClass())();
+        return eyeDropper.open();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: EyeDropperService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: EyeDropperService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: EyeDropperService, decorators: [{
+            type: Injectable
+        }] });
+
+function getBarcodeDetectorClass() {
+    return window.BarcodeDetector;
+}
+class BarcodeDetectorService extends BrowserApiBaseService {
+    getApiName() {
+        return 'barcode-detector';
+    }
+    isSupported() {
+        return this.isBrowserEnvironment() && 'BarcodeDetector' in window;
+    }
+    async getSupportedFormats() {
+        if (!this.isSupported()) {
+            return [];
+        }
+        return getBarcodeDetectorClass().getSupportedFormats();
+    }
+    async detect(source, formats) {
+        if (!this.isSupported()) {
+            throw new Error('BarcodeDetector API not supported');
+        }
+        const detector = new (getBarcodeDetectorClass())(formats ? { formats } : undefined);
+        return detector.detect(source);
+    }
+    detectStream(video, options = {}) {
+        return new Observable((subscriber) => {
+            if (!this.isSupported()) {
+                subscriber.error(new Error('BarcodeDetector API not supported'));
+                return () => { };
+            }
+            const detector = new (getBarcodeDetectorClass())(options.formats ? { formats: options.formats } : undefined);
+            let rafId = null;
+            let isActive = true;
+            const detect = async () => {
+                if (!isActive)
+                    return;
+                try {
+                    const barcodes = await detector.detect(video);
+                    if (barcodes.length > 0) {
+                        subscriber.next(barcodes);
+                    }
+                    rafId = requestAnimationFrame(detect);
+                }
+                catch (error) {
+                    subscriber.error(error);
+                }
+            };
+            rafId = requestAnimationFrame(detect);
+            return () => {
+                isActive = false;
+                if (rafId !== null) {
+                    cancelAnimationFrame(rafId);
+                }
+            };
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BarcodeDetectorService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BarcodeDetectorService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BarcodeDetectorService, decorators: [{
+            type: Injectable
+        }] });
+
+function getBluetoothApi() {
+    return navigator.bluetooth;
+}
+class WebBluetoothService extends BrowserApiBaseService {
+    getApiName() {
+        return 'web-bluetooth';
+    }
+    isSupported() {
+        return this.isBrowserEnvironment() && 'bluetooth' in navigator;
+    }
+    async requestDevice(options) {
+        if (!this.isSupported()) {
+            throw new Error('Web Bluetooth API not supported');
+        }
+        const device = await getBluetoothApi().requestDevice(options ?? {});
+        return device;
+    }
+    async getConnectedDevices() {
+        // Note: Web Bluetooth does not expose an API to list all connected devices
+        // Devices must be paired/connected per session
+        return [];
+    }
+    watchConnectionChanges() {
+        return new Observable((subscriber) => {
+            // Web Bluetooth doesn't have a global connection event
+            // This would need to be implemented per-device via gattserverdisconnected
+            subscriber.complete();
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebBluetoothService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebBluetoothService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebBluetoothService, decorators: [{
+            type: Injectable
+        }] });
+
+function getUsb() {
+    return navigator.usb;
+}
+class WebUsbService extends BrowserApiBaseService {
+    getApiName() {
+        return 'web-usb';
+    }
+    isSupported() {
+        return this.isBrowserEnvironment() && 'usb' in navigator;
+    }
+    async requestDevice(filters) {
+        if (!this.isSupported()) {
+            throw new Error('WebUSB API not supported');
+        }
+        const device = await getUsb().requestDevice({ filters });
+        return device;
+    }
+    async getDevices() {
+        if (!this.isSupported()) {
+            return [];
+        }
+        return getUsb().getDevices();
+    }
+    watchDeviceChanges() {
+        if (!this.isSupported()) {
+            return new Observable((o) => o.error(new Error('WebUSB API not supported')));
+        }
+        return new Observable((subscriber) => {
+            const usb = getUsb();
+            const onConnect = (e) => subscriber.next({ device: e.device, type: 'connect' });
+            const onDisconnect = (e) => subscriber.next({ device: e.device, type: 'disconnect' });
+            usb.addEventListener('connect', onConnect);
+            usb.addEventListener('disconnect', onDisconnect);
+            return () => {
+                usb.removeEventListener('connect', onConnect);
+                usb.removeEventListener('disconnect', onDisconnect);
+            };
+        });
+    }
+    getDeviceInfo(device) {
+        return {
+            vendorId: device.vendorId,
+            productId: device.productId,
+            productName: device.productName,
+            manufacturerName: device.manufacturerName,
+            serialNumber: device.serialNumber,
+            opened: device.opened,
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebUsbService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebUsbService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebUsbService, decorators: [{
+            type: Injectable
+        }] });
+
+function getNdefReaderClass() {
+    return window.NDEFReader;
+}
+class WebNfcService extends BrowserApiBaseService {
+    getApiName() {
+        return 'web-nfc';
+    }
+    isSupported() {
+        return this.isBrowserEnvironment() && 'NDEFReader' in window;
+    }
+    scan() {
+        if (!this.isSupported()) {
+            return new Observable((o) => o.error(new Error('Web NFC API not supported')));
+        }
+        return new Observable((subscriber) => {
+            const abortController = new AbortController();
+            const reader = new (getNdefReaderClass())();
+            const onReading = (event) => {
+                const e = event;
+                subscriber.next({
+                    serialNumber: e.serialNumber,
+                    message: e.message,
+                });
+            };
+            const onError = (event) => {
+                subscriber.error(event.error ?? new Error('NFC read error'));
+            };
+            reader.addEventListener('reading', onReading);
+            reader.addEventListener('readingerror', onError);
+            reader
+                .scan({ signal: abortController.signal })
+                .catch((err) => subscriber.error(err));
+            return () => abortController.abort();
+        });
+    }
+    async write(message, options) {
+        if (!this.isSupported()) {
+            throw new Error('Web NFC API not supported');
+        }
+        const reader = new (getNdefReaderClass())();
+        await reader.write(message, options);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebNfcService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebNfcService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: WebNfcService, decorators: [{
+            type: Injectable
+        }] });
+
+class PaymentRequestService extends BrowserApiBaseService {
+    getApiName() {
+        return 'payment-request';
+    }
+    isSupported() {
+        return this.isBrowserEnvironment() && 'PaymentRequest' in window;
+    }
+    async canMakePayment(methods, details) {
+        if (!this.isSupported())
+            return false;
+        const request = new PaymentRequest(methods, details);
+        return request.canMakePayment();
+    }
+    async show(methods, details, options) {
+        if (!this.isSupported()) {
+            throw new Error('Payment Request API not supported');
+        }
+        const request = new PaymentRequest(methods, details, options);
+        const response = await request.show();
+        const result = {
+            methodName: response.methodName,
+            details: response.details,
+            payerName: response.payerName ?? null,
+            payerEmail: response.payerEmail ?? null,
+            payerPhone: response.payerPhone ?? null,
+        };
+        await response.complete('success');
+        return result;
+    }
+    async abort(methods, details) {
+        if (!this.isSupported())
+            return;
+        const request = new PaymentRequest(methods, details);
+        await request.abort();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PaymentRequestService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PaymentRequestService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PaymentRequestService, decorators: [{
+            type: Injectable
+        }] });
+
+class CredentialManagementService extends BrowserApiBaseService {
+    getApiName() {
+        return 'credential-management';
+    }
+    isSupported() {
+        return this.isBrowserEnvironment() && 'credentials' in navigator;
+    }
+    isPublicKeySupported() {
+        return this.isSupported() && 'PublicKeyCredential' in window;
+    }
+    async get(options) {
+        if (!this.isSupported()) {
+            throw new Error('Credential Management API not supported');
+        }
+        return navigator.credentials.get(options);
+    }
+    async store(credential) {
+        if (!this.isSupported()) {
+            throw new Error('Credential Management API not supported');
+        }
+        await navigator.credentials.store(credential);
+    }
+    async createPasswordCredential(data) {
+        if (!this.isSupported()) {
+            throw new Error('Credential Management API not supported');
+        }
+        return navigator.credentials.create({
+            password: data,
+        });
+    }
+    async createPublicKeyCredential(options) {
+        if (!this.isPublicKeySupported()) {
+            throw new Error('PublicKeyCredential API not supported');
+        }
+        return navigator.credentials.create({
+            publicKey: options,
+        });
+    }
+    async preventSilentAccess() {
+        if (!this.isSupported())
+            return;
+        await navigator.credentials.preventSilentAccess();
+    }
+    async isConditionalMediationAvailable() {
+        if (!this.isPublicKeySupported())
+            return false;
+        if ('isConditionalMediationAvailable' in PublicKeyCredential) {
+            return PublicKeyCredential.isConditionalMediationAvailable();
+        }
+        return false;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CredentialManagementService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CredentialManagementService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CredentialManagementService, decorators: [{
+            type: Injectable
+        }] });
+
+function getIdleDetectorClass() {
+    return window.IdleDetector;
+}
+function injectIdleDetector(options = {}) {
+    const destroyRef = inject(DestroyRef);
+    const platformId = inject(PLATFORM_ID);
+    const defaultState = { user: 'active', screen: 'unlocked' };
+    const state = signal(defaultState, ...(ngDevMode ? [{ debugName: "state" }] : /* istanbul ignore next */ []));
+    if (isPlatformBrowser(platformId) && 'IdleDetector' in window) {
+        const abortController = new AbortController();
+        const detector = new (getIdleDetectorClass())();
+        detector.addEventListener('change', () => {
+            state.set({
+                user: detector.userState,
+                screen: detector.screenState,
+            });
+        });
+        detector
+            .start({
+            threshold: options.threshold ?? 60_000,
+            signal: abortController.signal,
+        })
+            .catch(() => {
+            /* permission denied or unsupported — keep defaults */
+        });
+        destroyRef.onDestroy(() => abortController.abort());
+    }
+    return {
+        state: state.asReadonly(),
+        userState: computed(() => state().user),
+        screenState: computed(() => state().screen),
+        isUserIdle: computed(() => state().user === 'idle'),
+        isScreenLocked: computed(() => state().screen === 'locked'),
+    };
+}
+
+function provideIdleDetector() {
+    return makeEnvironmentProviders([PermissionsService, IdleDetectorService]);
+}
+function provideEyeDropper() {
+    return makeEnvironmentProviders([EyeDropperService]);
+}
+function provideBarcodeDetector() {
+    return makeEnvironmentProviders([BarcodeDetectorService]);
+}
+function provideWebBluetooth() {
+    return makeEnvironmentProviders([WebBluetoothService]);
+}
+function provideWebUsb() {
+    return makeEnvironmentProviders([WebUsbService]);
+}
+function provideWebNfc() {
+    return makeEnvironmentProviders([WebNfcService]);
+}
+function providePaymentRequest() {
+    return makeEnvironmentProviders([PaymentRequestService]);
+}
+function provideCredentialManagement() {
+    return makeEnvironmentProviders([CredentialManagementService]);
+}
+const defaultExperimentalWebApisConfig = {
+    enableIdleDetector: false,
+    enableEyeDropper: false,
+    enableBarcodeDetector: false,
+    enableWebBluetooth: false,
+    enableWebUsb: false,
+    enableWebNfc: false,
+    enablePaymentRequest: false,
+    enableCredentialManagement: false,
+};
+function provideExperimentalWebApis(config = {}) {
+    const mergedConfig = { ...defaultExperimentalWebApisConfig, ...config };
+    const providers = [];
+    const conditionalProviders = [
+        [mergedConfig.enableIdleDetector, IdleDetectorService],
+        [mergedConfig.enableEyeDropper, EyeDropperService],
+        [mergedConfig.enableBarcodeDetector, BarcodeDetectorService],
+        [mergedConfig.enableWebBluetooth, WebBluetoothService],
+        [mergedConfig.enableWebUsb, WebUsbService],
+        [mergedConfig.enableWebNfc, WebNfcService],
+        [mergedConfig.enablePaymentRequest, PaymentRequestService],
+        [mergedConfig.enableCredentialManagement, CredentialManagementService],
+    ];
+    for (const [enabled, provider] of conditionalProviders) {
+        if (enabled) {
+            providers.push(provider);
+        }
+    }
+    return makeEnvironmentProviders(providers);
+}
+
+// Secondary entry point: @angular-helpers/browser-web-apis/experimental
+// Experimental Chromium-only APIs that require specific browser support
+// --- Services ---
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BarcodeDetectorService, CredentialManagementService, EyeDropperService, IdleDetectorService, PaymentRequestService, WebBluetoothService, WebNfcService, WebUsbService, defaultExperimentalWebApisConfig, injectIdleDetector, provideBarcodeDetector, provideCredentialManagement, provideExperimentalWebApis, provideEyeDropper, provideIdleDetector, providePaymentRequest, provideWebBluetooth, provideWebNfc, provideWebUsb };