@angular-helpers/browser-web-apis 21.10.0 → 21.12.0

package/README.es.md

@@ -45,6 +45,9 @@ Paquete de servicios Angular para acceder de forma estructurada y segura a Brows
 - `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
+- `WebLocksService` - Coordinacion de locks entre pestanas
+- `StorageManagerService` - Cuotas y persistencia de almacenamiento
+- `CompressionService` - Streams de compresion gzip/deflate
 
 ### APIs de red
 
@@ -706,6 +709,88 @@ export class MyComponent {
 }
 ```
 
+### injectClipboard
+
+```typescript
+import { injectClipboard } from '@angular-helpers/browser-web-apis';
+
+@Component({...})
+export class MyComponent {
+  readonly cb = injectClipboard();
+
+  // cb.text()        → string | null (ultimo texto copiado)
+  // cb.error()       → string | null
+  // cb.busy()        → boolean
+  // cb.isSupported() → boolean
+
+  async copy(text: string) {
+    await this.cb.writeText(text);
+  }
+}
+```
+
+### injectGeolocation
+
+```typescript
+import { injectGeolocation } from '@angular-helpers/browser-web-apis';
+
+@Component({...})
+export class MyComponent {
+  readonly geo = injectGeolocation({ watch: true });
+
+  // geo.position()    → GeolocationPosition | null
+  // geo.error()       → GeolocationPositionError | null
+  // geo.watching()    → boolean
+  // geo.isSupported() → boolean
+
+  stopWatching() {
+    this.geo.stop();
+  }
+}
+```
+
+### injectBattery
+
+```typescript
+import { injectBattery } from '@angular-helpers/browser-web-apis';
+
+@Component({...})
+export class MyComponent {
+  readonly battery = injectBattery();
+
+  // battery.info()        → BatteryInfo | null (nivel, carga, tiempos)
+  // battery.error()       → string | null
+  // battery.isSupported() → boolean
+
+  async refresh() {
+    await this.battery.refresh();
+  }
+}
+```
+
+### injectWakeLock
+
+```typescript
+import { injectWakeLock } from '@angular-helpers/browser-web-apis';
+
+@Component({...})
+export class MyComponent {
+  readonly wakeLock = injectWakeLock();
+
+  // wakeLock.active()      → boolean
+  // wakeLock.error()       → string | null
+  // wakeLock.isSupported() → boolean
+
+  async toggle() {
+    if (this.wakeLock.active()) {
+      await this.wakeLock.release();
+    } else {
+      await this.wakeLock.request();
+    }
+  }
+}
+```
+
 ### Tipo ElementInput
 
 Tanto `injectResizeObserver` como `injectIntersectionObserver` aceptan el tipo `ElementInput`:

package/README.md

@@ -45,6 +45,9 @@ Angular services package for a structured and secure access layer over browser W
 - `IdleDetectorService` - Detect user idle state and screen lock
 - `GamepadService` - Game controller input polling
 - `WebAudioService` - Audio context, oscillators, and analysers
+- `WebLocksService` - Cross-tab resource locking coordination
+- `StorageManagerService` - Storage quotas and persistence
+- `CompressionService` - Gzip/deflate compression streams
 
 ### Network APIs
 
@@ -101,13 +104,21 @@ npm install @angular-helpers/browser-web-apis
 
 ```typescript
 import { provideBrowserWebApis } from '@angular-helpers/browser-web-apis';
+import {
+  CameraService,
+  GeolocationService,
+  NotificationService,
+} from '@angular-helpers/browser-web-apis';
 
 bootstrapApplication(AppComponent, {
   providers: [
     provideBrowserWebApis({
-      enableCamera: true,
-      enableGeolocation: true,
-      enableNotifications: true,
+      services: [
+        CameraService,
+        GeolocationService,
+        NotificationService,
+        // Add more services as needed
+      ],
     }),
   ],
 });
@@ -152,6 +163,9 @@ Every service has a matching `provideX()` function:
 | `providePerformanceObserver()`  | `PerformanceObserverService`                |
 | `providePageVisibility()`       | `PageVisibilityService`                     |
 | `provideNetworkInformation()`   | `NetworkInformationService`                 |
+| `provideWebLocks()`             | `WebLocksService`                           |
+| `provideStorageManager()`       | `StorageManagerService`                     |
+| `provideCompression()`          | `CompressionService`                        |
 | …and 22 more                    | See `src/providers/`                        |
 
 ### Combo providers
@@ -755,6 +769,88 @@ export class MyComponent {
 }
 ```
 
+### injectClipboard
+
+```typescript
+import { injectClipboard } from '@angular-helpers/browser-web-apis';
+
+@Component({...})
+export class MyComponent {
+  readonly cb = injectClipboard();
+
+  // cb.text()        → string | null (last copied text)
+  // cb.error()       → string | null
+  // cb.busy()        → boolean
+  // cb.isSupported() → boolean
+
+  async copy(text: string) {
+    await this.cb.writeText(text);
+  }
+}
+```
+
+### injectGeolocation
+
+```typescript
+import { injectGeolocation } from '@angular-helpers/browser-web-apis';
+
+@Component({...})
+export class MyComponent {
+  readonly geo = injectGeolocation({ watch: true });
+
+  // geo.position()  → GeolocationPosition | null
+  // geo.error()     → GeolocationPositionError | null
+  // geo.watching()  → boolean
+  // geo.isSupported() → boolean
+
+  stopWatching() {
+    this.geo.stop();
+  }
+}
+```
+
+### injectBattery
+
+```typescript
+import { injectBattery } from '@angular-helpers/browser-web-apis';
+
+@Component({...})
+export class MyComponent {
+  readonly battery = injectBattery();
+
+  // battery.info()        → BatteryInfo | null (level, charging, times)
+  // battery.error()       → string | null
+  // battery.isSupported() → boolean
+
+  async refresh() {
+    await this.battery.refresh();
+  }
+}
+```
+
+### injectWakeLock
+
+```typescript
+import { injectWakeLock } from '@angular-helpers/browser-web-apis';
+
+@Component({...})
+export class MyComponent {
+  readonly wakeLock = injectWakeLock();
+
+  // wakeLock.active()      → boolean
+  // wakeLock.error()       → string | null
+  // wakeLock.isSupported() → boolean
+
+  async toggle() {
+    if (this.wakeLock.active()) {
+      await this.wakeLock.release();
+    } else {
+      await this.wakeLock.request();
+    }
+  }
+}
+```
+
 ### ElementInput type
 
 Both `injectResizeObserver` and `injectIntersectionObserver` accept the `ElementInput` type:

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

@@ -1,22 +1,66 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, Injectable, inject, DestroyRef, PLATFORM_ID, signal, computed, isSignal, effect, ElementRef, makeEnvironmentProviders } from '@angular/core';
+import { InjectionToken, isDevMode, inject, Injectable, DestroyRef, PLATFORM_ID, signal, computed, isSignal, effect, ElementRef, makeEnvironmentProviders } from '@angular/core';
 import { isPlatformBrowser, isPlatformServer } from '@angular/common';
 import { Observable, fromEvent, Subject, of, map as map$1 } from 'rxjs';
 import { toObservable, takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { filter, map, distinctUntilChanged } from 'rxjs/operators';
 import { Router } from '@angular/router';
 
+const LEVEL_RANK = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+    silent: 100,
+};
+/**
+ * Global log level for `BROWSER_API_LOGGER`. Defaults to `'debug'` in dev mode and
+ * `'warn'` in production. Override via `provideBrowserApiLogLevel('silent')` etc.
+ */
+const BROWSER_API_LOG_LEVEL = new InjectionToken('BROWSER_API_LOG_LEVEL', {
+    providedIn: 'root',
+    factory: () => (isDevMode() ? 'debug' : 'warn'),
+});
 const BROWSER_API_LOGGER = new InjectionToken('BROWSER_API_LOGGER', {
     providedIn: 'root',
-    factory: () => ({
-        // oxlint-disable-next-line no-console
-        info: (message) => console.info(message),
-        // oxlint-disable-next-line no-console
-        warn: (message) => console.warn(message),
-        // oxlint-disable-next-line no-console
-        error: (message, error) => console.error(message, error),
-    }),
+    factory: () => {
+        const level = inject(BROWSER_API_LOG_LEVEL);
+        return createLevelGatedLogger(level);
+    },
 });
+function createLevelGatedLogger(level) {
+    const min = LEVEL_RANK[level];
+    return {
+        debug: (message) => {
+            if (LEVEL_RANK.debug < min)
+                return;
+            // oxlint-disable-next-line no-console
+            console.debug(message);
+        },
+        info: (message) => {
+            if (LEVEL_RANK.info < min)
+                return;
+            // oxlint-disable-next-line no-console
+            console.info(message);
+        },
+        warn: (message) => {
+            if (LEVEL_RANK.warn < min)
+                return;
+            // oxlint-disable-next-line no-console
+            console.warn(message);
+        },
+        error: (message, error) => {
+            if (LEVEL_RANK.error < min)
+                return;
+            // oxlint-disable-next-line no-console
+            console.error(message, error);
+        },
+    };
+}
+/** Log level helper provider. Overrides the default `BROWSER_API_LOG_LEVEL`. */
+function provideBrowserApiLogLevel(level) {
+    return { provide: BROWSER_API_LOG_LEVEL, useValue: level };
+}
 
 const BROWSER_CAPABILITIES = [
     { id: 'permissions', label: 'Permissions API', requiresSecureContext: false },
@@ -267,6 +311,9 @@ class BrowserApiBaseService {
     logInfo(message) {
         this.logger.info(`[${this.getApiName()}] ${message}`);
     }
+    logDebug(message) {
+        this.logger.debug?.(`[${this.getApiName()}] ${message}`);
+    }
     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 });
 }
@@ -1004,19 +1051,22 @@ let legacyDeprecationLogged$1 = false;
 class WebStorageService extends BrowserApiBaseService {
     storageLogger = inject(BROWSER_API_LOGGER);
     storageEvents = signal(null, ...(ngDevMode ? [{ debugName: "storageEvents" }] : /* istanbul ignore next */ []));
-    eventBus = {
-        emit: (event) => this.storageEvents.set(event),
-        events$: toObservable(this.storageEvents).pipe(filter((event) => event !== null), distinctUntilChanged((a, b) => a.key === b.key &&
-            a.newValue === b.newValue &&
-            a.oldValue === b.oldValue &&
-            a.storageArea === b.storageArea)),
-    };
+    eventBus;
     /** Local storage namespace. */
-    local = new StorageNamespaceImpl('localStorage', this.eventBus, this.storageLogger);
+    local;
     /** Session storage namespace. */
-    session = new StorageNamespaceImpl('sessionStorage', this.eventBus, this.storageLogger);
+    session;
     constructor() {
         super();
+        this.eventBus = {
+            emit: (event) => this.storageEvents.set(event),
+            events$: toObservable(this.storageEvents).pipe(filter((event) => event !== null), distinctUntilChanged((a, b) => a.key === b.key &&
+                a.newValue === b.newValue &&
+                a.oldValue === b.oldValue &&
+                a.storageArea === b.storageArea)),
+        };
+        this.local = new StorageNamespaceImpl('localStorage', this.eventBus, this.storageLogger);
+        this.session = new StorageNamespaceImpl('sessionStorage', this.eventBus, this.storageLogger);
         this.setupCrossTabListener();
     }
     getApiName() {
@@ -1660,6 +1710,8 @@ class WebWorkerService extends BrowserApiBaseService {
         this.entries.delete(name);
     }
     terminateAllWorkers() {
+        // Snapshot keys before mutating the map inside terminateWorker.
+        // oxlint-disable-next-line unicorn/no-useless-spread
         for (const name of [...this.entries.keys()]) {
             this.terminateWorker(name);
         }
@@ -2069,17 +2121,17 @@ class BroadcastChannelService extends ConnectionRegistryBaseService {
             if (!channel) {
                 channel = new BroadcastChannel(name);
                 this.connections.set(name, channel);
+                // Register cleanup once per channel, not per subscription.
+                this.destroyRef.onDestroy(() => this.close(name));
             }
             const handler = (event) => observer.next(event.data);
             const errorHandler = () => observer.error(new Error(`BroadcastChannel "${name}" error`));
             channel.addEventListener('message', handler);
             channel.addEventListener('messageerror', errorHandler);
-            const cleanup = () => {
+            return () => {
                 channel.removeEventListener('message', handler);
                 channel.removeEventListener('messageerror', errorHandler);
             };
-            this.destroyRef.onDestroy(() => this.close(name));
-            return cleanup;
         });
     }
     post(name, data) {
@@ -2088,6 +2140,7 @@ class BroadcastChannelService extends ConnectionRegistryBaseService {
         if (!channel) {
             channel = new BroadcastChannel(name);
             this.connections.set(name, channel);
+            // Register cleanup once per channel creation.
             this.destroyRef.onDestroy(() => this.close(name));
         }
         channel.postMessage(data);
@@ -2178,6 +2231,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImpor
 
 class ScreenWakeLockService extends BrowserApiBaseService {
     sentinel = null;
+    releaseRegistered = false;
     getApiName() {
         return 'screen-wake-lock';
     }
@@ -2199,7 +2253,11 @@ class ScreenWakeLockService extends BrowserApiBaseService {
             this.sentinel.addEventListener('release', () => {
                 this.sentinel = null;
             });
-            this.destroyRef.onDestroy(() => this.release());
+            // Register the destroy cleanup only once across multiple request() calls.
+            if (!this.releaseRegistered) {
+                this.releaseRegistered = true;
+                this.destroyRef.onDestroy(() => this.release());
+            }
             return { active: true, type, released: false };
         }
         catch (error) {
@@ -2236,9 +2294,7 @@ class ScreenWakeLockService extends BrowserApiBaseService {
             };
             document.addEventListener('visibilitychange', handleVisibilityChange);
             emit();
-            const cleanup = () => document.removeEventListener('visibilitychange', handleVisibilityChange);
-            this.destroyRef.onDestroy(cleanup);
-            return cleanup;
+            return () => document.removeEventListener('visibilitychange', handleVisibilityChange);
         });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: ScreenWakeLockService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
@@ -2398,12 +2454,10 @@ class FullscreenService extends BrowserApiBaseService {
             document.addEventListener('fullscreenchange', handler);
             document.addEventListener('webkitfullscreenchange', handler);
             observer.next(this.isFullscreen);
-            const cleanup = () => {
+            return () => {
                 document.removeEventListener('fullscreenchange', handler);
                 document.removeEventListener('webkitfullscreenchange', handler);
             };
-            this.destroyRef.onDestroy(cleanup);
-            return cleanup;
         });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: FullscreenService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
@@ -2639,11 +2693,9 @@ class ServerSentEventsService extends ConnectionRegistryBaseService {
                     source.addEventListener(type, messageHandler);
                 }
             }
-            const cleanup = () => {
+            return () => {
                 this.disconnect(url);
             };
-            this.destroyRef.onDestroy(cleanup);
-            return cleanup;
         });
     }
     disconnect(url) {
@@ -2746,9 +2798,7 @@ class SpeechSynthesisService extends BrowserApiBaseService {
             const emit = () => observer.next(speechSynthesis.getVoices());
             speechSynthesis.addEventListener('voiceschanged', emit);
             emit();
-            const cleanup = () => speechSynthesis.removeEventListener('voiceschanged', emit);
-            this.destroyRef.onDestroy(cleanup);
-            return cleanup;
+            return () => speechSynthesis.removeEventListener('voiceschanged', emit);
         });
     }
     speak(text, options = {}) {
@@ -2777,12 +2827,19 @@ class SpeechSynthesisService extends BrowserApiBaseService {
             };
             observer.next('speaking');
             speechSynthesis.speak(utterance);
-            const cleanup = () => {
+            let completed = false;
+            const origOnEnd = utterance.onend;
+            utterance.onend = (ev) => {
+                completed = true;
+                origOnEnd?.call(utterance, ev);
+            };
+            return () => {
                 speechSynthesis.cancel();
-                observer.next('idle');
+                // Only emit idle if the Observable hasn't already completed via onend/onerror.
+                if (!completed) {
+                    observer.next('idle');
+                }
             };
-            this.destroyRef.onDestroy(cleanup);
-            return cleanup;
         });
     }
     pause() {
@@ -2894,6 +2951,7 @@ class WebAudioService extends BrowserApiBaseService {
         return 'web-audio';
     }
     context = null;
+    destroyRegistered = false;
     getCapabilityId() {
         return 'webAudio';
     }
@@ -2903,7 +2961,10 @@ class WebAudioService extends BrowserApiBaseService {
         }
         if (!this.context || this.context.state === 'closed') {
             this.context = new AudioContext();
-            this.destroyRef.onDestroy(() => this.close());
+            if (!this.destroyRegistered) {
+                this.destroyRegistered = true;
+                this.destroyRef.onDestroy(() => this.close());
+            }
         }
         return this.context;
     }
@@ -3098,6 +3159,121 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImpor
             type: Injectable
         }] });
 
+class EyeDropperService extends BrowserApiBaseService {
+    getApiName() {
+        return 'eye-dropper';
+    }
+    getCapabilityId() {
+        return 'eyeDropper';
+    }
+    /** Override to also assert secure context (required by the spec). */
+    isSupported() {
+        return (super.isSupported() &&
+            typeof window !== 'undefined' &&
+            'EyeDropper' in window &&
+            window.isSecureContext);
+    }
+    ensureSupported() {
+        super.ensureSupported();
+        if (!window.isSecureContext) {
+            throw new Error('EyeDropper API requires a secure context (HTTPS)');
+        }
+    }
+    /**
+     * Opens the system eye dropper tool and returns the selected color.
+     *
+     * @param options Optional configuration including an AbortSignal to cancel the dropper.
+     * @returns A promise that resolves with the selected color in sRGB Hex format (e.g., "#000000").
+     * @throws DOMException if the user cancels the selection (AbortError).
+     */
+    async open(options) {
+        this.ensureSupported();
+        const EyeDropperClass = window.EyeDropper;
+        if (!EyeDropperClass) {
+            throw new Error('EyeDropper is not supported in this browser.');
+        }
+        const eyeDropper = new EyeDropperClass();
+        return eyeDropper.open(options);
+    }
+    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
+        }] });
+
+class IdleDetectorService extends BrowserApiBaseService {
+    getApiName() {
+        return 'idle-detector';
+    }
+    getCapabilityId() {
+        return 'idleDetector';
+    }
+    isSupported() {
+        return (super.isSupported() &&
+            typeof window !== 'undefined' &&
+            'IdleDetector' in window &&
+            window.isSecureContext);
+    }
+    ensureSupported() {
+        super.ensureSupported();
+        if (!window.isSecureContext) {
+            throw new Error('IdleDetector API requires a secure context (HTTPS)');
+        }
+    }
+    async requestPermission() {
+        this.ensureSupported();
+        const IdleDetectorClass = window.IdleDetector;
+        return IdleDetectorClass.requestPermission();
+    }
+    /**
+     * Starts tracking idle state. Emits the current state and subsequent changes.
+     * Note: You must call requestPermission() and be granted access before starting.
+     *
+     * @param options Configuration for the idle detector, including the threshold (minimum 60000ms).
+     * @returns An Observable of the IdleState.
+     */
+    watch(options) {
+        return new Observable((observer) => {
+            this.ensureSupported();
+            const IdleDetectorClass = window.IdleDetector;
+            const detector = new IdleDetectorClass();
+            const emit = () => {
+                observer.next({
+                    userState: detector.userState,
+                    screenState: detector.screenState,
+                });
+            };
+            detector.addEventListener('change', emit);
+            // We use a custom AbortController if one wasn't provided,
+            // so we can abort the detector when the observable is unsubscribed.
+            const abortController = new AbortController();
+            const signal = options.signal || abortController.signal;
+            const combinedOptions = { ...options, signal };
+            // Stop tracking if an external signal aborts
+            if (options.signal) {
+                options.signal.addEventListener('abort', () => {
+                    observer.complete();
+                }, { once: true });
+            }
+            detector.start(combinedOptions).catch((err) => {
+                observer.error(err);
+            });
+            return () => {
+                detector.removeEventListener('change', emit);
+                if (!signal.aborted) {
+                    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
+        }] });
+
 /**
  * Service wrapping `navigator.locks` (Web Locks API). Coordinates exclusive or
  * shared access to a named resource across tabs and workers.
@@ -3285,6 +3461,35 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImpor
             type: Injectable
         }] });
 
+/**
+ * When set to `true`, suppresses the one-time runtime warning that experimental
+ * services emit on first use. Default is `false` (warnings emitted).
+ */
+const BROWSER_API_EXPERIMENTAL_SILENT = new InjectionToken('BROWSER_API_EXPERIMENTAL_SILENT', {
+    providedIn: 'root',
+    factory: () => false,
+});
+const warned = new Set();
+/**
+ * Emit a one-time runtime warning explaining that the API is experimental and
+ * subject to breaking changes. No-op after the first call for a given key, or if
+ * the consumer has provided `BROWSER_API_EXPERIMENTAL_SILENT` as `true`.
+ */
+function warnExperimental(key, context) {
+    if (context.silent)
+        return;
+    if (warned.has(key))
+        return;
+    warned.add(key);
+    context.logger.warn(`[browser-web-apis:experimental] "${key}" is part of the experimental surface ` +
+        'and may change without a major bump. Provide BROWSER_API_EXPERIMENTAL_SILENT=true ' +
+        'to suppress this warning.');
+}
+/** Test-only: reset the in-memory dedup set. */
+function resetExperimentalWarnings() {
+    warned.clear();
+}
+
 // Common types for browser APIs
 
 function injectPageVisibility() {
@@ -3662,6 +3867,9 @@ function injectWakeLock() {
     let sentinel = null;
     let disposed = false;
     const onRelease = () => {
+        if (sentinel) {
+            sentinel.removeEventListener('release', onRelease);
+        }
         if (!disposed)
             active.set(false);
         sentinel = null;
@@ -3701,8 +3909,11 @@ function injectWakeLock() {
     };
     destroyRef.onDestroy(() => {
         disposed = true;
-        if (sentinel && !sentinel.released) {
-            void sentinel.release();
+        if (sentinel) {
+            sentinel.removeEventListener('release', onRelease);
+            if (!sentinel.released) {
+                void sentinel.release();
+            }
         }
         sentinel = null;
     });
@@ -3715,6 +3926,153 @@ function injectWakeLock() {
     };
 }
 
+function injectEyeDropper() {
+    const platformId = inject(PLATFORM_ID);
+    const isBrowser = isPlatformBrowser(platformId);
+    const hasDropper = isBrowser && typeof window !== 'undefined' && 'EyeDropper' in window;
+    const supported = signal(hasDropper && window.isSecureContext, ...(ngDevMode ? [{ debugName: "supported" }] : /* istanbul ignore next */ []));
+    const color = signal(null, ...(ngDevMode ? [{ debugName: "color" }] : /* istanbul ignore next */ []));
+    const error = signal(null, ...(ngDevMode ? [{ debugName: "error" }] : /* istanbul ignore next */ []));
+    const isOpening = signal(false, ...(ngDevMode ? [{ debugName: "isOpening" }] : /* istanbul ignore next */ []));
+    const open = async (options) => {
+        if (!supported()) {
+            error.set(new Error('EyeDropper API is not supported in this environment'));
+            return null;
+        }
+        const EyeDropperClass = window.EyeDropper;
+        const dropper = new EyeDropperClass();
+        isOpening.set(true);
+        error.set(null);
+        try {
+            const result = await dropper.open(options);
+            color.set(result.sRGBHex);
+            return result;
+        }
+        catch (e) {
+            if (e instanceof DOMException && e.name === 'AbortError') {
+                // User canceled, not an error
+                return null;
+            }
+            const err = e instanceof Error ? e : new Error(String(e));
+            error.set(err);
+            return null;
+        }
+        finally {
+            isOpening.set(false);
+        }
+    };
+    return {
+        isSupported: supported.asReadonly(),
+        color: color.asReadonly(),
+        error: error.asReadonly(),
+        isOpening: isOpening.asReadonly(),
+        open,
+    };
+}
+
+function injectIdleDetector() {
+    const platformId = inject(PLATFORM_ID);
+    const destroyRef = inject(DestroyRef);
+    const isBrowser = isPlatformBrowser(platformId);
+    const hasDetector = isBrowser && typeof window !== 'undefined' && 'IdleDetector' in window;
+    const supported = signal(hasDetector && window.isSecureContext, ...(ngDevMode ? [{ debugName: "supported" }] : /* istanbul ignore next */ []));
+    const state = signal(null, ...(ngDevMode ? [{ debugName: "state" }] : /* istanbul ignore next */ []));
+    const error = signal(null, ...(ngDevMode ? [{ debugName: "error" }] : /* istanbul ignore next */ []));
+    const isTracking = signal(false, ...(ngDevMode ? [{ debugName: "isTracking" }] : /* istanbul ignore next */ []));
+    let detector = null;
+    let abortController = null;
+    let disposed = false;
+    const onStateChange = () => {
+        if (disposed || !detector)
+            return;
+        state.set({
+            userState: detector.userState,
+            screenState: detector.screenState,
+        });
+    };
+    const stop = () => {
+        if (detector) {
+            detector.removeEventListener('change', onStateChange);
+        }
+        if (abortController) {
+            abortController.abort();
+            abortController = null;
+        }
+        detector = null;
+        if (!disposed) {
+            isTracking.set(false);
+        }
+    };
+    destroyRef.onDestroy(() => {
+        disposed = true;
+        stop();
+    });
+    const requestPermission = async () => {
+        if (!supported())
+            return 'denied';
+        const IdleDetectorClass = window.IdleDetector;
+        return IdleDetectorClass.requestPermission();
+    };
+    const start = async (options) => {
+        if (!supported() || disposed) {
+            error.set(new Error('IdleDetector API is not supported in this environment'));
+            return;
+        }
+        stop();
+        error.set(null);
+        const IdleDetectorClass = window.IdleDetector;
+        detector = new IdleDetectorClass();
+        abortController = new AbortController();
+        const combinedSignal = options.signal
+            ? abortSignalAny([options.signal, abortController.signal])
+            : abortController.signal;
+        detector.addEventListener('change', onStateChange);
+        try {
+            await detector.start({ ...options, signal: combinedSignal });
+            if (!disposed) {
+                isTracking.set(true);
+                // Initial state emit
+                onStateChange();
+            }
+        }
+        catch (e) {
+            stop();
+            if (!disposed) {
+                if (e instanceof DOMException && e.name === 'AbortError') {
+                    // Expected when stopped manually
+                    return;
+                }
+                error.set(e instanceof Error ? e : new Error(String(e)));
+            }
+        }
+    };
+    // Helper to combine abort signals since AbortSignal.any is relatively new
+    function abortSignalAny(signals) {
+        if (typeof AbortSignal !== 'undefined' && 'any' in AbortSignal) {
+            return AbortSignal.any(signals);
+        }
+        const controller = new AbortController();
+        for (const s of signals) {
+            if (s.aborted) {
+                controller.abort(s.reason);
+                return controller.signal;
+            }
+            s.addEventListener('abort', () => controller.abort(s.reason), { once: true });
+        }
+        return controller.signal;
+    }
+    return {
+        isSupported: supported.asReadonly(),
+        state: state.asReadonly(),
+        error: error.asReadonly(),
+        isTracking: isTracking.asReadonly(),
+        isIdle: computed(() => state()?.userState === 'idle'),
+        start,
+        stop,
+        requestPermission,
+    };
+}
+
 class BrowserSupportUtil {
     static isSupported(feature) {
         if (typeof window === 'undefined' || typeof navigator === 'undefined') {
@@ -3820,6 +4178,7 @@ const permissionGuard = (permission) => {
             return true;
         }
         catch (error) {
+            // oxlint-disable-next-line no-console -- guard errors must surface to DevTools; no injectable logger here
             console.error('Permission guard error:', error);
             router.navigate(['/permission-denied'], {
                 queryParams: { permission },
@@ -3953,6 +4312,14 @@ function provideCompression() {
     return makeEnvironmentProviders([CompressionService]);
 }
 
+function provideEyeDropper() {
+    return makeEnvironmentProviders([EyeDropperService, PermissionsService]);
+}
+
+function provideIdleDetector() {
+    return makeEnvironmentProviders([IdleDetectorService, PermissionsService]);
+}
+
 function provideMediaApis() {
     return makeEnvironmentProviders([PermissionsService, CameraService, MediaDevicesService]);
 }
@@ -3999,10 +4366,36 @@ const defaultBrowserWebApisConfig = {
     enablePerformanceObserver: false,
     enableWebAudio: false,
     enableGamepad: false,
+    enableEyeDropper: false,
+    enableIdleDetector: false,
 };
+let legacyFlagsDeprecationLogged = false;
 function provideBrowserWebApis(config = {}) {
-    const mergedConfig = { ...defaultBrowserWebApisConfig, ...config };
+    const { services, ...flagConfig } = config;
+    // Composition-first path: only `services` provided, no flags.
+    if (services && Object.keys(flagConfig).length === 0) {
+        return makeEnvironmentProviders([
+            PermissionsService,
+            ...services.flatMap((env) => env.ɵproviders ?? []),
+        ]);
+    }
+    // Legacy flag-bag path. Log deprecation once if any enableX is set.
+    if (Object.keys(flagConfig).length > 0 && !legacyFlagsDeprecationLogged) {
+        legacyFlagsDeprecationLogged = true;
+        // oxlint-disable-next-line no-console
+        console.warn('[browser-web-apis] provideBrowserWebApis(enableX flags) is deprecated. ' +
+            'Pass `{ services: [provideCamera(), ...] }` instead. The flag-bag form will be ' +
+            'removed in v22.');
+    }
+    const mergedConfig = { ...defaultBrowserWebApisConfig, ...flagConfig };
     const providers = [PermissionsService];
+    if (services) {
+        for (const env of services) {
+            const inner = env.ɵproviders;
+            if (inner)
+                providers.push(...inner);
+        }
+    }
     const conditionalProviders = [
         [mergedConfig.enableCamera, CameraService],
         [mergedConfig.enableGeolocation, GeolocationService],
@@ -4031,6 +4424,8 @@ function provideBrowserWebApis(config = {}) {
         [mergedConfig.enablePerformanceObserver, PerformanceObserverService],
         [mergedConfig.enableWebAudio, WebAudioService],
         [mergedConfig.enableGamepad, GamepadService],
+        [mergedConfig.enableEyeDropper, EyeDropperService],
+        [mergedConfig.enableIdleDetector, IdleDetectorService],
     ];
     for (const [enabled, provider] of conditionalProviders) {
         if (enabled) {
@@ -4048,4 +4443,4 @@ const version = '0.1.0';
  * Generated bundle index. Do not edit.
  */
 
-export { BROWSER_API_LOGGER, BatteryService, BroadcastChannelService, BrowserApiBaseService, BrowserCapabilityService, BrowserSupportUtil, CameraService, ClipboardService, CompressionService, ConnectionRegistryBaseService, FileSystemAccessService, FullscreenService, GamepadService, GeolocationService, IntersectionObserverService, MediaDevicesService, MediaRecorderService, MutationObserverService, NetworkInformationService, NotificationService, PageVisibilityService, PerformanceObserverService, PermissionsService, ResizeObserverService, ScreenOrientationService, ScreenWakeLockService, ServerSentEventsService, SpeechSynthesisService, StorageManagerService, VibrationService, WebAudioService, WebLocksService, WebShareService, WebSocketClient, WebSocketService, WebStorageService, WebWorkerService, permissionGuard as createPermissionGuard, defaultBrowserWebApisConfig, injectBattery, injectClipboard, injectGamepad, injectGeolocation, injectIntersectionObserver, injectMutationObserver, injectNetworkInformation, injectPageVisibility, injectPerformanceObserver, injectResizeObserver, injectScreenOrientation, injectWakeLock, permissionGuard, provideBattery, provideBroadcastChannel, provideBrowserWebApis, provideCamera, provideClipboard, provideCommunicationApis, provideCompression, provideFileSystemAccess, provideFullscreen, provideGamepad, provideGeolocation, provideIntersectionObserver, provideLocationApis, provideMediaApis, provideMediaDevices, provideMediaRecorder, provideMutationObserver, provideNetworkInformation, provideNotifications, providePageVisibility, providePerformanceObserver, providePermissions, provideResizeObserver, provideScreenOrientation, provideScreenWakeLock, provideServerSentEvents, provideSpeechSynthesis, provideStorageApis, provideStorageManager, provideVibration, provideWebAudio, provideWebLocks, provideWebShare, provideWebSocket, provideWebStorage, provideWebWorker, version };
+export { BROWSER_API_EXPERIMENTAL_SILENT, BROWSER_API_LOGGER, BROWSER_API_LOG_LEVEL, BatteryService, BroadcastChannelService, BrowserApiBaseService, BrowserCapabilityService, BrowserSupportUtil, CameraService, ClipboardService, CompressionService, ConnectionRegistryBaseService, EyeDropperService, FileSystemAccessService, FullscreenService, GamepadService, GeolocationService, IdleDetectorService, IntersectionObserverService, MediaDevicesService, MediaRecorderService, MutationObserverService, NetworkInformationService, NotificationService, PageVisibilityService, PerformanceObserverService, PermissionsService, ResizeObserverService, ScreenOrientationService, ScreenWakeLockService, ServerSentEventsService, SpeechSynthesisService, StorageManagerService, VibrationService, WebAudioService, WebLocksService, WebShareService, WebSocketClient, WebSocketService, WebStorageService, WebWorkerService, permissionGuard as createPermissionGuard, defaultBrowserWebApisConfig, injectBattery, injectClipboard, injectEyeDropper, injectGamepad, injectGeolocation, injectIdleDetector, injectIntersectionObserver, injectMutationObserver, injectNetworkInformation, injectPageVisibility, injectPerformanceObserver, injectResizeObserver, injectScreenOrientation, injectWakeLock, permissionGuard, provideBattery, provideBroadcastChannel, provideBrowserApiLogLevel, provideBrowserWebApis, provideCamera, provideClipboard, provideCommunicationApis, provideCompression, provideEyeDropper, provideFileSystemAccess, provideFullscreen, provideGamepad, provideGeolocation, provideIdleDetector, provideIntersectionObserver, provideLocationApis, provideMediaApis, provideMediaDevices, provideMediaRecorder, provideMutationObserver, provideNetworkInformation, provideNotifications, providePageVisibility, providePerformanceObserver, providePermissions, provideResizeObserver, provideScreenOrientation, provideScreenWakeLock, provideServerSentEvents, provideSpeechSynthesis, provideStorageApis, provideStorageManager, provideVibration, provideWebAudio, provideWebLocks, provideWebShare, provideWebSocket, provideWebStorage, provideWebWorker, version, warnExperimental };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-helpers/browser-web-apis",
-  "version": "21.10.0",
+  "version": "21.12.0",
   "description": "Sistema de servicios Angular para acceso formalizado a Browser Web APIs (cámara, permisos, geolocalización, etc.)",
   "homepage": "https://gaspar1992.github.io/angular-helpers/docs/browser-web-apis",
   "repository": {
@@ -49,6 +49,7 @@
       "default": "./fesm2022/angular-helpers-browser-web-apis-experimental.mjs"
     }
   },
+  "type": "module",
   "dependencies": {
     "tslib": "^2.3.0"
   }

package/types/angular-helpers-browser-web-apis.d.ts

@@ -230,6 +230,7 @@ declare abstract class BrowserApiBaseService {
     protected logError(message: string, error?: unknown): void;
     protected logWarn(message: string): void;
     protected logInfo(message: string): void;
+    protected logDebug(message: string): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<BrowserApiBaseService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BrowserApiBaseService>;
 }
@@ -392,12 +393,24 @@ type ErrorCallback = (error: BrowserError) => void;
  */
 type ElementInput = Element | ElementRef<Element> | Signal<Element | ElementRef<Element> | undefined>;
 
+type BrowserApiLogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
 interface BrowserApiLogger {
+    debug?(message: string): void;
     info(message: string): void;
     warn(message: string): void;
     error(message: string, error?: unknown): void;
 }
+/**
+ * Global log level for `BROWSER_API_LOGGER`. Defaults to `'debug'` in dev mode and
+ * `'warn'` in production. Override via `provideBrowserApiLogLevel('silent')` etc.
+ */
+declare const BROWSER_API_LOG_LEVEL: InjectionToken<BrowserApiLogLevel>;
 declare const BROWSER_API_LOGGER: InjectionToken<BrowserApiLogger>;
+/** Log level helper provider. Overrides the default `BROWSER_API_LOG_LEVEL`. */
+declare function provideBrowserApiLogLevel(level: BrowserApiLogLevel): {
+    provide: InjectionToken<BrowserApiLogLevel>;
+    useValue: BrowserApiLogLevel;
+};
 
 interface StorageOptions {
     /** Optional prefix used to namespace keys (e.g. `app:` -> `app:userId`). */
@@ -877,6 +890,7 @@ interface WakeLockStatus {
 }
 declare class ScreenWakeLockService extends BrowserApiBaseService {
     private sentinel;
+    private releaseRegistered;
     protected getApiName(): string;
     protected getCapabilityId(): BrowserCapabilityId;
     get isActive(): boolean;
@@ -1105,6 +1119,7 @@ interface AudioAnalyserData {
 declare class WebAudioService extends BrowserApiBaseService {
     protected getApiName(): string;
     private context;
+    private destroyRegistered;
     protected getCapabilityId(): BrowserCapabilityId;
     getContext(): AudioContext;
     resume(): Promise<void>;
@@ -1146,6 +1161,59 @@ declare class GamepadService extends BrowserApiBaseService {
     static ɵprov: i0.ɵɵInjectableDeclaration<GamepadService>;
 }
 
+interface EyeDropperResult {
+    sRGBHex: string;
+}
+declare class EyeDropperService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    protected getCapabilityId(): BrowserCapabilityId;
+    /** Override to also assert secure context (required by the spec). */
+    isSupported(): boolean;
+    protected ensureSupported(): void;
+    /**
+     * Opens the system eye dropper tool and returns the selected color.
+     *
+     * @param options Optional configuration including an AbortSignal to cancel the dropper.
+     * @returns A promise that resolves with the selected color in sRGB Hex format (e.g., "#000000").
+     * @throws DOMException if the user cancels the selection (AbortError).
+     */
+    open(options?: {
+        signal?: AbortSignal;
+    }): Promise<EyeDropperResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EyeDropperService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EyeDropperService>;
+}
+
+type UserIdleState = 'active' | 'idle';
+type ScreenIdleState = 'locked' | 'unlocked';
+interface IdleState {
+    userState: UserIdleState | null;
+    screenState: ScreenIdleState | null;
+}
+interface IdleDetectorOptions {
+    /** The minimum number of milliseconds of inactivity before the user is considered idle. Must be at least 60000. */
+    threshold: number;
+    /** An AbortSignal to abort the idle detection. */
+    signal?: AbortSignal;
+}
+declare class IdleDetectorService extends BrowserApiBaseService {
+    protected getApiName(): string;
+    protected getCapabilityId(): BrowserCapabilityId;
+    isSupported(): boolean;
+    protected ensureSupported(): void;
+    requestPermission(): Promise<PermissionState>;
+    /**
+     * Starts tracking idle state. Emits the current state and subsequent changes.
+     * Note: You must call requestPermission() and be granted access before starting.
+     *
+     * @param options Configuration for the idle detector, including the threshold (minimum 60000ms).
+     * @returns An Observable of the IdleState.
+     */
+    watch(options: IdleDetectorOptions): Observable<IdleState>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IdleDetectorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IdleDetectorService>;
+}
+
 interface LockOptionsLike {
     mode?: 'exclusive' | 'shared';
     ifAvailable?: boolean;
@@ -1242,6 +1310,24 @@ declare class CompressionService extends BrowserApiBaseService {
     static ɵprov: i0.ɵɵInjectableDeclaration<CompressionService>;
 }
 
+/**
+ * When set to `true`, suppresses the one-time runtime warning that experimental
+ * services emit on first use. Default is `false` (warnings emitted).
+ */
+declare const BROWSER_API_EXPERIMENTAL_SILENT: InjectionToken<boolean>;
+interface ExperimentalWarnContext {
+    silent: boolean;
+    logger: {
+        warn: (message: string) => void;
+    };
+}
+/**
+ * Emit a one-time runtime warning explaining that the API is experimental and
+ * subject to breaking changes. No-op after the first call for a given key, or if
+ * the consumer has provided `BROWSER_API_EXPERIMENTAL_SILENT` as `true`.
+ */
+declare function warnExperimental(key: string, context: ExperimentalWarnContext): void;
+
 interface MediaDevice {
     deviceId: string;
     groupId: string;
@@ -1455,6 +1541,29 @@ interface WakeLockRef {
 }
 declare function injectWakeLock(): WakeLockRef;
 
+interface EyeDropperRef {
+    readonly isSupported: Signal<boolean>;
+    readonly color: Signal<string | null>;
+    readonly error: Signal<Error | null>;
+    readonly isOpening: Signal<boolean>;
+    open(options?: {
+        signal?: AbortSignal;
+    }): Promise<EyeDropperResult | null>;
+}
+declare function injectEyeDropper(): EyeDropperRef;
+
+interface IdleDetectorRef {
+    readonly isSupported: Signal<boolean>;
+    readonly state: Signal<IdleState | null>;
+    readonly error: Signal<Error | null>;
+    readonly isTracking: Signal<boolean>;
+    readonly isIdle: Signal<boolean>;
+    start(options: IdleDetectorOptions): Promise<void>;
+    stop(): void;
+    requestPermission(): Promise<PermissionState>;
+}
+declare function injectIdleDetector(): IdleDetectorRef;
+
 declare class BrowserSupportUtil {
     static isSupported(feature: string): boolean;
     static getUnsupportedFeatures(): string[];
@@ -1542,12 +1651,29 @@ declare function provideStorageManager(): EnvironmentProviders;
 
 declare function provideCompression(): EnvironmentProviders;
 
+declare function provideEyeDropper(): EnvironmentProviders;
+
+declare function provideIdleDetector(): EnvironmentProviders;
+
 declare function provideMediaApis(): EnvironmentProviders;
 declare function provideLocationApis(): EnvironmentProviders;
 declare function provideStorageApis(): EnvironmentProviders;
 declare function provideCommunicationApis(): EnvironmentProviders;
 
-interface BrowserWebApisConfig {
+/**
+ * Composition-first config: pass an array of `provide*()` calls and we merge them
+ * into a single `EnvironmentProviders`. Preferred over the `enableX` flag bag.
+ *
+ * ```ts
+ * provideBrowserWebApis({
+ *   services: [provideCamera(), provideClipboard(), provideMediaApis()],
+ * })
+ * ```
+ */
+interface BrowserWebApisCompositionConfig {
+    services?: EnvironmentProviders[];
+}
+interface BrowserWebApisConfig extends BrowserWebApisCompositionConfig {
     enableCamera?: boolean;
     enableGeolocation?: boolean;
     enableNotifications?: boolean;
@@ -1575,11 +1701,13 @@ interface BrowserWebApisConfig {
     enablePerformanceObserver?: boolean;
     enableWebAudio?: boolean;
     enableGamepad?: boolean;
+    enableEyeDropper?: boolean;
+    enableIdleDetector?: boolean;
 }
 declare const defaultBrowserWebApisConfig: BrowserWebApisConfig;
 declare function provideBrowserWebApis(config?: BrowserWebApisConfig): EnvironmentProviders;
 
 declare const version = "0.1.0";
 
-export { BROWSER_API_LOGGER, BatteryService, BroadcastChannelService, BrowserApiBaseService, BrowserCapabilityService, BrowserSupportUtil, CameraService, ClipboardService, CompressionService, ConnectionRegistryBaseService, FileSystemAccessService, FullscreenService, GamepadService, GeolocationService, IntersectionObserverService, MediaDevicesService, MediaRecorderService, MutationObserverService, NetworkInformationService, NotificationService, PageVisibilityService, PerformanceObserverService, PermissionsService, ResizeObserverService, ScreenOrientationService, ScreenWakeLockService, ServerSentEventsService, SpeechSynthesisService, StorageManagerService, VibrationService, WebAudioService, WebLocksService, WebShareService, WebSocketClient, WebSocketService, WebStorageService, WebWorkerService, permissionGuard as createPermissionGuard, defaultBrowserWebApisConfig, injectBattery, injectClipboard, injectGamepad, injectGeolocation, injectIntersectionObserver, injectMutationObserver, injectNetworkInformation, injectPageVisibility, injectPerformanceObserver, injectResizeObserver, injectScreenOrientation, injectWakeLock, permissionGuard, provideBattery, provideBroadcastChannel, provideBrowserWebApis, provideCamera, provideClipboard, provideCommunicationApis, provideCompression, provideFileSystemAccess, provideFullscreen, provideGamepad, provideGeolocation, provideIntersectionObserver, provideLocationApis, provideMediaApis, provideMediaDevices, provideMediaRecorder, provideMutationObserver, provideNetworkInformation, provideNotifications, providePageVisibility, providePerformanceObserver, providePermissions, provideResizeObserver, provideScreenOrientation, provideScreenWakeLock, provideServerSentEvents, provideSpeechSynthesis, provideStorageApis, provideStorageManager, provideVibration, provideWebAudio, provideWebLocks, provideWebShare, provideWebSocket, provideWebStorage, provideWebWorker, version };
-export type { AudioAnalyserData, AudioContextState, BatteryInfo, BatteryManager, BatteryRef, BrowserApiLogger, BrowserCapabilityId, BrowserError, BrowserPermissions, BrowserWebApisConfig, CameraCapabilities, CameraInfo, ClipboardRef, CompressionFormat, ConnectionType, EffectiveConnectionType, ElementInput, ElementSize, ErrorCallback, EventHandler, FileOpenOptions, FileSaveOptions, GamepadRef, GamepadState, GeolocationCoordinates, GeolocationError, GeolocationOptions, GeolocationPosition$1 as GeolocationPosition, GeolocationRef, GeolocationWatchOptions, IntersectionObserverOptions, IntersectionRef, MediaDevice, MediaDeviceKind, MediaDevicesInfo, MediaStreamConstraints$1 as MediaStreamConstraints, MediaTrackConstraints$1 as MediaTrackConstraints, MutationObserverOptions, MutationRef, NetworkInformation, NetworkInformationRef, OrientationInfo, OrientationLockType, OrientationType, PageVisibilityRef, PerformanceEntryType, PerformanceObserverConfig, PerformanceObserverRef, PermissionNameExt, PermissionRequest, RecordingOptions, RecordingResult, RecordingState, ResizeObserverOptions, ResizeRef, SSEConfig, SSEConnectionState, SSEMessage, ScreenOrientationRef, SpeechOptions, SpeechState, StorageEvent, StorageNamespace, StorageOptions, StorageQuotaEstimate, StorageValue, VibrationPattern, VibrationPreset, VisibilityState, WakeLockRef, WakeLockStatus, WakeLockType, WebSocketClientConfig, WebSocketConfig, WebSocketMessage, WebSocketRequestOptions, WebSocketState, WebSocketStatus, WebSocketStatusV2, WorkerMessage, WorkerRequestOptions, WorkerStatus, WorkerTask };
+export { BROWSER_API_EXPERIMENTAL_SILENT, BROWSER_API_LOGGER, BROWSER_API_LOG_LEVEL, BatteryService, BroadcastChannelService, BrowserApiBaseService, BrowserCapabilityService, BrowserSupportUtil, CameraService, ClipboardService, CompressionService, ConnectionRegistryBaseService, EyeDropperService, FileSystemAccessService, FullscreenService, GamepadService, GeolocationService, IdleDetectorService, IntersectionObserverService, MediaDevicesService, MediaRecorderService, MutationObserverService, NetworkInformationService, NotificationService, PageVisibilityService, PerformanceObserverService, PermissionsService, ResizeObserverService, ScreenOrientationService, ScreenWakeLockService, ServerSentEventsService, SpeechSynthesisService, StorageManagerService, VibrationService, WebAudioService, WebLocksService, WebShareService, WebSocketClient, WebSocketService, WebStorageService, WebWorkerService, permissionGuard as createPermissionGuard, defaultBrowserWebApisConfig, injectBattery, injectClipboard, injectEyeDropper, injectGamepad, injectGeolocation, injectIdleDetector, injectIntersectionObserver, injectMutationObserver, injectNetworkInformation, injectPageVisibility, injectPerformanceObserver, injectResizeObserver, injectScreenOrientation, injectWakeLock, permissionGuard, provideBattery, provideBroadcastChannel, provideBrowserApiLogLevel, provideBrowserWebApis, provideCamera, provideClipboard, provideCommunicationApis, provideCompression, provideEyeDropper, provideFileSystemAccess, provideFullscreen, provideGamepad, provideGeolocation, provideIdleDetector, provideIntersectionObserver, provideLocationApis, provideMediaApis, provideMediaDevices, provideMediaRecorder, provideMutationObserver, provideNetworkInformation, provideNotifications, providePageVisibility, providePerformanceObserver, providePermissions, provideResizeObserver, provideScreenOrientation, provideScreenWakeLock, provideServerSentEvents, provideSpeechSynthesis, provideStorageApis, provideStorageManager, provideVibration, provideWebAudio, provideWebLocks, provideWebShare, provideWebSocket, provideWebStorage, provideWebWorker, version, warnExperimental };
+export type { AudioAnalyserData, AudioContextState, BatteryInfo, BatteryManager, BatteryRef, BrowserApiLogLevel, BrowserApiLogger, BrowserCapabilityId, BrowserError, BrowserPermissions, BrowserWebApisCompositionConfig, BrowserWebApisConfig, CameraCapabilities, CameraInfo, ClipboardRef, CompressionFormat, ConnectionType, EffectiveConnectionType, ElementInput, ElementSize, ErrorCallback, EventHandler, ExperimentalWarnContext, EyeDropperRef, EyeDropperResult, FileOpenOptions, FileSaveOptions, GamepadRef, GamepadState, GeolocationCoordinates, GeolocationError, GeolocationOptions, GeolocationPosition$1 as GeolocationPosition, GeolocationRef, GeolocationWatchOptions, IdleDetectorOptions, IdleDetectorRef, IdleState, IntersectionObserverOptions, IntersectionRef, MediaDevice, MediaDeviceKind, MediaDevicesInfo, MediaStreamConstraints$1 as MediaStreamConstraints, MediaTrackConstraints$1 as MediaTrackConstraints, MutationObserverOptions, MutationRef, NetworkInformation, NetworkInformationRef, OrientationInfo, OrientationLockType, OrientationType, PageVisibilityRef, PerformanceEntryType, PerformanceObserverConfig, PerformanceObserverRef, PermissionNameExt, PermissionRequest, RecordingOptions, RecordingResult, RecordingState, ResizeObserverOptions, ResizeRef, SSEConfig, SSEConnectionState, SSEMessage, ScreenIdleState, ScreenOrientationRef, SpeechOptions, SpeechState, StorageEvent, StorageNamespace, StorageOptions, StorageQuotaEstimate, StorageValue, UserIdleState, VibrationPattern, VibrationPreset, VisibilityState, WakeLockRef, WakeLockStatus, WakeLockType, WebSocketClientConfig, WebSocketConfig, WebSocketMessage, WebSocketRequestOptions, WebSocketState, WebSocketStatus, WebSocketStatusV2, WorkerMessage, WorkerRequestOptions, WorkerStatus, WorkerTask };