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

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

@@ -2,8 +2,8 @@ import * as i0 from '@angular/core';
 import { InjectionToken, inject, DestroyRef, PLATFORM_ID, Injectable, signal, computed, isSignal, effect, ElementRef, makeEnvironmentProviders } from '@angular/core';
 import { isPlatformBrowser, isPlatformServer } from '@angular/common';
 import { Observable, fromEvent, Subject, of, map as map$1 } from 'rxjs';
-import { takeUntilDestroyed, toObservable } from '@angular/core/rxjs-interop';
-import { filter, distinctUntilChanged, map } from 'rxjs/operators';
+import { toObservable, takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { filter, map, distinctUntilChanged } from 'rxjs/operators';
 import { Router } from '@angular/router';
 
 const BROWSER_API_LOGGER = new InjectionToken('BROWSER_API_LOGGER', {
@@ -779,255 +779,340 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImpor
             type: Injectable
         }] });
 
-class WebStorageService extends BrowserApiBaseService {
-    storageEvents = signal(null, ...(ngDevMode ? [{ debugName: "storageEvents" }] : /* istanbul ignore next */ []));
-    constructor() {
-        super();
-        this.setupEventListeners();
-    }
-    getApiName() {
-        return 'storage';
-    }
-    ensureSupported() {
-        super.ensureSupported();
-        if (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;
-                const area = storageEvent.storageArea === localStorage ? 'localStorage' : 'sessionStorage';
-                this.storageEvents.set({
-                    key: storageEvent.key,
-                    newValue: storageEvent.newValue ? this.deserializeValue(storageEvent.newValue) : null,
-                    oldValue: storageEvent.oldValue ? this.deserializeValue(storageEvent.oldValue) : null,
-                    storageArea: area,
-                });
-            });
-        }
-    }
-    serializeValue(value, options) {
-        if (options?.serialize) {
-            return options.serialize(value);
-        }
-        return JSON.stringify(value);
+const SECURITY_WARN_KEY = Symbol('storage-security-warned');
+/**
+ * Implementation of `StorageNamespace` shared by `local` and `session` namespaces.
+ * Wraps every native access in try/catch so Safari private mode and sandboxed iframes
+ * (which throw `SecurityError`) degrade gracefully instead of crashing the app.
+ */
+class StorageNamespaceImpl {
+    area;
+    events;
+    logger;
+    supportedCache = null;
+    constructor(area, events, logger) {
+        this.area = area;
+        this.events = events;
+        this.logger = logger;
     }
-    deserializeValue(value, options) {
-        if (value === null)
-            return null;
-        if (options?.deserialize) {
-            return options.deserialize(value);
+    isSupported() {
+        if (this.supportedCache !== null)
+            return this.supportedCache;
+        if (typeof window === 'undefined' || typeof Storage === 'undefined') {
+            this.supportedCache = false;
+            return false;
         }
         try {
-            return JSON.parse(value);
+            const store = this.getStore();
+            const probe = `__bwa_probe_${Date.now()}__`;
+            store.setItem(probe, '1');
+            store.removeItem(probe);
+            this.supportedCache = true;
         }
         catch {
-            return value;
+            this.warnSecurityOnce();
+            this.supportedCache = false;
         }
+        return this.supportedCache;
     }
-    getKey(key, options) {
-        const prefix = options?.prefix || '';
-        return prefix ? `${prefix}:${key}` : key;
-    }
-    emitStorageChange(fullKey, newValue, oldValue, area) {
-        this.storageEvents.set({ key: fullKey, newValue, oldValue, storageArea: area });
-    }
-    // Local Storage Methods
-    setLocalStorage(key, value, options = {}) {
-        this.ensureSupported();
+    set(key, value, opts = {}) {
+        if (!this.isSupported())
+            return false;
         try {
-            const serializedValue = this.serializeValue(value, options);
-            const fullKey = this.getKey(key, options);
-            const oldRaw = localStorage.getItem(fullKey);
-            const oldValue = oldRaw !== null ? this.deserializeValue(oldRaw, options) : null;
-            localStorage.setItem(fullKey, serializedValue);
-            this.emitStorageChange(fullKey, value, oldValue, 'localStorage');
+            const fullKey = this.getKey(key, opts);
+            const oldRaw = this.getStore().getItem(fullKey);
+            const oldValue = oldRaw !== null ? this.deserializeValue(oldRaw, opts) : null;
+            const serialized = this.serializeValue(value, opts);
+            this.getStore().setItem(fullKey, serialized);
+            this.events.emit({ key: fullKey, newValue: value, oldValue, storageArea: this.area });
             return true;
         }
         catch (error) {
-            this.logError('Error setting localStorage:', error);
+            this.logger.error(`[storage:${this.area}] set("${key}") failed`, error);
             return false;
         }
     }
-    getLocalStorage(key, defaultValue = null, options = {}) {
-        this.ensureSupported();
+    get(key, defaultValue = null, opts = {}) {
+        if (!this.isSupported())
+            return defaultValue;
         try {
-            const fullKey = this.getKey(key, options);
-            const value = localStorage.getItem(fullKey);
-            return value !== null ? this.deserializeValue(value, options) : defaultValue;
+            const fullKey = this.getKey(key, opts);
+            const raw = this.getStore().getItem(fullKey);
+            return raw !== null ? this.deserializeValue(raw, opts) : defaultValue;
         }
         catch (error) {
-            this.logError('Error getting localStorage:', error);
+            this.logger.error(`[storage:${this.area}] get("${key}") failed`, error);
             return defaultValue;
         }
     }
-    removeLocalStorage(key, options = {}) {
-        this.ensureSupported();
+    remove(key, opts = {}) {
+        if (!this.isSupported())
+            return false;
         try {
-            const fullKey = this.getKey(key, options);
-            const oldRaw = localStorage.getItem(fullKey);
-            const oldValue = oldRaw !== null ? this.deserializeValue(oldRaw, options) : null;
-            localStorage.removeItem(fullKey);
-            this.emitStorageChange(fullKey, null, oldValue, 'localStorage');
+            const fullKey = this.getKey(key, opts);
+            const oldRaw = this.getStore().getItem(fullKey);
+            const oldValue = oldRaw !== null ? this.deserializeValue(oldRaw, opts) : null;
+            this.getStore().removeItem(fullKey);
+            this.events.emit({ key: fullKey, newValue: null, oldValue, storageArea: this.area });
             return true;
         }
         catch (error) {
-            this.logError('Error removing localStorage:', error);
+            this.logger.error(`[storage:${this.area}] remove("${key}") failed`, error);
             return false;
         }
     }
-    clearLocalStorage(options = {}) {
-        this.ensureSupported();
+    clear(opts = {}) {
+        if (!this.isSupported())
+            return false;
         try {
-            const prefix = options?.prefix;
+            const prefix = opts?.prefix;
+            const store = this.getStore();
             if (prefix) {
-                const keysToRemove = [];
-                for (let i = 0; i < localStorage.length; i++) {
-                    const key = localStorage.key(i);
-                    if (key && key.startsWith(`${prefix}:`)) {
-                        keysToRemove.push(key);
-                    }
+                const toRemove = [];
+                for (let i = 0; i < store.length; i++) {
+                    const k = store.key(i);
+                    if (k && k.startsWith(`${prefix}:`))
+                        toRemove.push(k);
+                }
+                for (const k of toRemove) {
+                    const oldRaw = store.getItem(k);
+                    store.removeItem(k);
+                    this.events.emit({
+                        key: k,
+                        newValue: null,
+                        oldValue: oldRaw,
+                        storageArea: this.area,
+                    });
                 }
-                keysToRemove.forEach((key) => {
-                    const oldRaw = localStorage.getItem(key);
-                    localStorage.removeItem(key);
-                    this.emitStorageChange(key, null, oldRaw, 'localStorage');
-                });
             }
             else {
-                localStorage.clear();
-                this.emitStorageChange(null, null, null, 'localStorage');
+                store.clear();
+                this.events.emit({ key: null, newValue: null, oldValue: null, storageArea: this.area });
             }
             return true;
         }
         catch (error) {
-            this.logError('Error clearing localStorage:', error);
+            this.logger.error(`[storage:${this.area}] clear() failed`, error);
             return false;
         }
     }
-    // Session Storage Methods
-    setSessionStorage(key, value, options = {}) {
-        this.ensureSupported();
+    size(opts = {}) {
+        if (!this.isSupported())
+            return 0;
         try {
-            const serializedValue = this.serializeValue(value, options);
-            const fullKey = this.getKey(key, options);
-            const oldRaw = sessionStorage.getItem(fullKey);
-            const oldValue = oldRaw !== null ? this.deserializeValue(oldRaw, options) : null;
-            sessionStorage.setItem(fullKey, serializedValue);
-            this.emitStorageChange(fullKey, value, oldValue, 'sessionStorage');
-            return true;
+            const store = this.getStore();
+            const prefix = opts?.prefix;
+            let total = 0;
+            for (let i = 0; i < store.length; i++) {
+                const k = store.key(i);
+                if (k && (!prefix || k.startsWith(`${prefix}:`))) {
+                    total += (store.getItem(k)?.length ?? 0) + k.length;
+                }
+            }
+            return total;
         }
         catch (error) {
-            this.logError('Error setting sessionStorage:', error);
-            return false;
+            this.logger.error(`[storage:${this.area}] size() failed`, error);
+            return 0;
         }
     }
-    getSessionStorage(key, defaultValue = null, options = {}) {
-        this.ensureSupported();
-        try {
-            const fullKey = this.getKey(key, options);
-            const value = sessionStorage.getItem(fullKey);
-            return value !== null ? this.deserializeValue(value, options) : defaultValue;
-        }
-        catch (error) {
-            this.logError('Error getting sessionStorage:', error);
-            return defaultValue;
+    watch(key, opts = {}) {
+        const fullKey = this.getKey(key, opts);
+        return this.events.events$.pipe(filter((event) => event.storageArea === this.area && (event.key === null || event.key === fullKey)), map((event) => event.newValue));
+    }
+    native() {
+        if (!this.isSupported()) {
+            throw new Error(`${this.area} not supported in this environment`);
         }
+        return this.getStore();
     }
-    removeSessionStorage(key, options = {}) {
-        this.ensureSupported();
+    getStore() {
+        return this.area === 'localStorage' ? window.localStorage : window.sessionStorage;
+    }
+    getKey(key, opts) {
+        const prefix = opts?.prefix ?? '';
+        return prefix ? `${prefix}:${key}` : key;
+    }
+    serializeValue(value, opts) {
+        if (opts?.serialize)
+            return opts.serialize(value);
+        return JSON.stringify(value);
+    }
+    deserializeValue(value, opts) {
+        if (opts?.deserialize)
+            return opts.deserialize(value);
         try {
-            const fullKey = this.getKey(key, options);
-            const oldRaw = sessionStorage.getItem(fullKey);
-            const oldValue = oldRaw !== null ? this.deserializeValue(oldRaw, options) : null;
-            sessionStorage.removeItem(fullKey);
-            this.emitStorageChange(fullKey, null, oldValue, 'sessionStorage');
-            return true;
+            return JSON.parse(value);
         }
-        catch (error) {
-            this.logError('Error removing sessionStorage:', error);
-            return false;
+        catch {
+            return value;
         }
     }
-    clearSessionStorage(options = {}) {
-        this.ensureSupported();
+    warnSecurityOnce() {
+        const holder = globalThis;
+        if (!holder[SECURITY_WARN_KEY])
+            holder[SECURITY_WARN_KEY] = new Set();
+        if (holder[SECURITY_WARN_KEY].has(this.area))
+            return;
+        holder[SECURITY_WARN_KEY].add(this.area);
+        this.logger.warn(`[storage:${this.area}] access denied (SecurityError). Common causes: Safari private mode, ` +
+            'sandboxed iframes, or browser storage disabled. Falling back to default values.');
+    }
+}
+
+let legacyDeprecationLogged$1 = false;
+/**
+ * Web Storage service with two namespaces (`local`, `session`) sharing one method
+ * surface. SecurityError-safe (Safari private mode, sandboxed iframes return defaults
+ * instead of throwing).
+ *
+ * Preferred usage:
+ * ```ts
+ * const storage = inject(WebStorageService);
+ * storage.local.set('user', { id: 1 });
+ * const user = storage.local.get<{ id: number }>('user');
+ * storage.local.watch<{ id: number }>('user').subscribe(console.log);
+ * ```
+ *
+ * Legacy methods (`setLocalStorage`, `getLocalStorage`, etc.) remain as deprecated
+ * wrappers for one minor cycle; removal slated for v22.
+ */
+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)),
+    };
+    /** Local storage namespace. */
+    local = new StorageNamespaceImpl('localStorage', this.eventBus, this.storageLogger);
+    /** Session storage namespace. */
+    session = new StorageNamespaceImpl('sessionStorage', this.eventBus, this.storageLogger);
+    constructor() {
+        super();
+        this.setupCrossTabListener();
+    }
+    getApiName() {
+        return 'storage';
+    }
+    ensureSupported() {
+        super.ensureSupported();
+        if (typeof Storage === 'undefined') {
+            throw new Error('Storage API not supported in this browser');
+        }
+    }
+    /** Returns true if either local or session storage is usable. */
+    isSupported() {
+        return this.local.isSupported() || this.session.isSupported();
+    }
+    /** Stream of every storage mutation observed in this tab or other tabs. */
+    getStorageEvents() {
+        return this.eventBus.events$;
+    }
+    setupCrossTabListener() {
+        if (!this.isBrowserEnvironment())
+            return;
+        fromEvent(window, 'storage')
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((event) => {
+            const area = event.storageArea === window.localStorage ? 'localStorage' : 'sessionStorage';
+            this.storageEvents.set({
+                key: event.key,
+                newValue: event.newValue ? this.safeParse(event.newValue) : null,
+                oldValue: event.oldValue ? this.safeParse(event.oldValue) : null,
+                storageArea: area,
+            });
+        });
+    }
+    safeParse(value) {
         try {
-            const prefix = options?.prefix;
-            if (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) => {
-                    const oldRaw = sessionStorage.getItem(key);
-                    sessionStorage.removeItem(key);
-                    this.emitStorageChange(key, null, oldRaw, 'sessionStorage');
-                });
-            }
-            else {
-                sessionStorage.clear();
-                this.emitStorageChange(null, null, null, 'sessionStorage');
-            }
-            return true;
+            return JSON.parse(value);
         }
-        catch (error) {
-            this.logError('Error clearing sessionStorage:', error);
-            return false;
+        catch {
+            return value;
         }
     }
-    // Utility Methods
+    // ---------- legacy API (deprecated) ----------
+    /** @deprecated Use `storage.local.set(key, value, opts)`. Removed in v22. */
+    setLocalStorage(key, value, options = {}) {
+        this.warnLegacyOnce();
+        return this.local.set(key, value, options);
+    }
+    /** @deprecated Use `storage.local.get(key, defaultValue, opts)`. Removed in v22. */
+    getLocalStorage(key, defaultValue = null, options = {}) {
+        this.warnLegacyOnce();
+        return this.local.get(key, defaultValue, options);
+    }
+    /** @deprecated Use `storage.local.remove(key, opts)`. Removed in v22. */
+    removeLocalStorage(key, options = {}) {
+        this.warnLegacyOnce();
+        return this.local.remove(key, options);
+    }
+    /** @deprecated Use `storage.local.clear(opts)`. Removed in v22. */
+    clearLocalStorage(options = {}) {
+        this.warnLegacyOnce();
+        return this.local.clear(options);
+    }
+    /** @deprecated Use `storage.session.set(key, value, opts)`. Removed in v22. */
+    setSessionStorage(key, value, options = {}) {
+        this.warnLegacyOnce();
+        return this.session.set(key, value, options);
+    }
+    /** @deprecated Use `storage.session.get(key, defaultValue, opts)`. Removed in v22. */
+    getSessionStorage(key, defaultValue = null, options = {}) {
+        this.warnLegacyOnce();
+        return this.session.get(key, defaultValue, options);
+    }
+    /** @deprecated Use `storage.session.remove(key, opts)`. Removed in v22. */
+    removeSessionStorage(key, options = {}) {
+        this.warnLegacyOnce();
+        return this.session.remove(key, options);
+    }
+    /** @deprecated Use `storage.session.clear(opts)`. Removed in v22. */
+    clearSessionStorage(options = {}) {
+        this.warnLegacyOnce();
+        return this.session.clear(options);
+    }
+    /** @deprecated Use `storage.local.size(opts)`. Removed in v22. */
     getLocalStorageSize(options = {}) {
-        this.ensureSupported();
-        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;
+        this.warnLegacyOnce();
+        return this.local.size(options);
     }
+    /** @deprecated Use `storage.session.size(opts)`. Removed in v22. */
     getSessionStorageSize(options = {}) {
-        this.ensureSupported();
-        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));
+        this.warnLegacyOnce();
+        return this.session.size(options);
     }
+    /** @deprecated Use `storage.local.watch<T>(key, opts)`. Removed in v22. */
     watchLocalStorage(key, options = {}) {
-        const fullKey = this.getKey(key, options);
-        return this.getStorageEvents().pipe(filter((event) => event.storageArea === 'localStorage' && (event.key === null || event.key === fullKey)), map((event) => event.newValue));
+        this.warnLegacyOnce();
+        return this.local.watch(key, options);
     }
+    /** @deprecated Use `storage.session.watch<T>(key, opts)`. Removed in v22. */
     watchSessionStorage(key, options = {}) {
-        const fullKey = this.getKey(key, options);
-        return this.getStorageEvents().pipe(filter((event) => event.storageArea === 'sessionStorage' && (event.key === null || event.key === fullKey)), map((event) => event.newValue));
+        this.warnLegacyOnce();
+        return this.session.watch(key, options);
     }
-    // Direct access to native storage APIs
+    /** @deprecated Use `storage.local.native()`. Removed in v22. */
     getNativeLocalStorage() {
-        this.ensureSupported();
-        return localStorage;
+        this.warnLegacyOnce();
+        return this.local.native();
     }
+    /** @deprecated Use `storage.session.native()`. Removed in v22. */
     getNativeSessionStorage() {
-        this.ensureSupported();
-        return sessionStorage;
+        this.warnLegacyOnce();
+        return this.session.native();
+    }
+    warnLegacyOnce() {
+        if (legacyDeprecationLogged$1)
+            return;
+        legacyDeprecationLogged$1 = true;
+        this.storageLogger.warn('[storage] WebStorageService.{set,get,remove,clear,watch}{Local,Session}Storage are ' +
+            'deprecated. Use storage.local and storage.session namespaces. Legacy methods will be ' +
+            'removed in v22.');
     }
     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 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-helpers/browser-web-apis",
-  "version": "21.6.0",
+  "version": "21.7.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": {

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

@@ -377,53 +377,105 @@ type ErrorCallback = (error: BrowserError) => void;
  */
 type ElementInput = Element | ElementRef<Element> | Signal<Element | ElementRef<Element> | undefined>;
 
+interface BrowserApiLogger {
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string, error?: unknown): void;
+}
+declare const BROWSER_API_LOGGER: InjectionToken<BrowserApiLogger>;
+
 interface StorageOptions {
+    /** Optional prefix used to namespace keys (e.g. `app:` -> `app:userId`). */
     prefix?: string;
     serialize?: (value: StorageValue) => string;
     deserialize?: (value: string) => StorageValue;
 }
+type StorageArea = 'localStorage' | 'sessionStorage';
 interface StorageEvent {
     key: string | null;
     newValue: StorageValue | null;
     oldValue: StorageValue | null;
-    storageArea: 'localStorage' | 'sessionStorage';
+    storageArea: StorageArea;
 }
+interface StorageNamespace {
+    readonly area: StorageArea;
+    isSupported(): boolean;
+    set<T extends StorageValue>(key: string, value: T, opts?: StorageOptions): boolean;
+    get<T extends StorageValue>(key: string, defaultValue?: T | null, opts?: StorageOptions): T | null;
+    remove(key: string, opts?: StorageOptions): boolean;
+    clear(opts?: StorageOptions): boolean;
+    size(opts?: StorageOptions): number;
+    watch<T extends StorageValue>(key: string, opts?: StorageOptions): Observable<T | null>;
+    /** Direct access to the native Storage object. Throws if unsupported. */
+    native(): Storage;
+}
+
+/**
+ * Web Storage service with two namespaces (`local`, `session`) sharing one method
+ * surface. SecurityError-safe (Safari private mode, sandboxed iframes return defaults
+ * instead of throwing).
+ *
+ * Preferred usage:
+ * ```ts
+ * const storage = inject(WebStorageService);
+ * storage.local.set('user', { id: 1 });
+ * const user = storage.local.get<{ id: number }>('user');
+ * storage.local.watch<{ id: number }>('user').subscribe(console.log);
+ * ```
+ *
+ * Legacy methods (`setLocalStorage`, `getLocalStorage`, etc.) remain as deprecated
+ * wrappers for one minor cycle; removal slated for v22.
+ */
 declare class WebStorageService extends BrowserApiBaseService {
+    private readonly storageLogger;
     private storageEvents;
+    private readonly eventBus;
+    /** Local storage namespace. */
+    readonly local: StorageNamespace;
+    /** Session storage namespace. */
+    readonly session: StorageNamespace;
     constructor();
     protected getApiName(): string;
     protected ensureSupported(): void;
-    private setupEventListeners;
-    private serializeValue;
-    private deserializeValue;
-    private getKey;
-    private emitStorageChange;
+    /** Returns true if either local or session storage is usable. */
+    isSupported(): boolean;
+    /** Stream of every storage mutation observed in this tab or other tabs. */
+    getStorageEvents(): Observable<StorageEvent>;
+    private setupCrossTabListener;
+    private safeParse;
+    /** @deprecated Use `storage.local.set(key, value, opts)`. Removed in v22. */
     setLocalStorage<T extends StorageValue>(key: string, value: T, options?: StorageOptions): boolean;
+    /** @deprecated Use `storage.local.get(key, defaultValue, opts)`. Removed in v22. */
     getLocalStorage<T extends StorageValue>(key: string, defaultValue?: T | null, options?: StorageOptions): T | null;
+    /** @deprecated Use `storage.local.remove(key, opts)`. Removed in v22. */
     removeLocalStorage(key: string, options?: StorageOptions): boolean;
+    /** @deprecated Use `storage.local.clear(opts)`. Removed in v22. */
     clearLocalStorage(options?: StorageOptions): boolean;
+    /** @deprecated Use `storage.session.set(key, value, opts)`. Removed in v22. */
     setSessionStorage<T extends StorageValue>(key: string, value: T, options?: StorageOptions): boolean;
+    /** @deprecated Use `storage.session.get(key, defaultValue, opts)`. Removed in v22. */
     getSessionStorage<T extends StorageValue>(key: string, defaultValue?: T | null, options?: StorageOptions): T | null;
+    /** @deprecated Use `storage.session.remove(key, opts)`. Removed in v22. */
     removeSessionStorage(key: string, options?: StorageOptions): boolean;
+    /** @deprecated Use `storage.session.clear(opts)`. Removed in v22. */
     clearSessionStorage(options?: StorageOptions): boolean;
+    /** @deprecated Use `storage.local.size(opts)`. Removed in v22. */
     getLocalStorageSize(options?: StorageOptions): number;
+    /** @deprecated Use `storage.session.size(opts)`. Removed in v22. */
     getSessionStorageSize(options?: StorageOptions): number;
-    getStorageEvents(): Observable<StorageEvent>;
+    /** @deprecated Use `storage.local.watch<T>(key, opts)`. Removed in v22. */
     watchLocalStorage<T extends StorageValue>(key: string, options?: StorageOptions): Observable<T | null>;
+    /** @deprecated Use `storage.session.watch<T>(key, opts)`. Removed in v22. */
     watchSessionStorage<T extends StorageValue>(key: string, options?: StorageOptions): Observable<T | null>;
+    /** @deprecated Use `storage.local.native()`. Removed in v22. */
     getNativeLocalStorage(): Storage;
+    /** @deprecated Use `storage.session.native()`. Removed in v22. */
     getNativeSessionStorage(): Storage;
+    private warnLegacyOnce;
     static ɵfac: i0.ɵɵFactoryDeclaration<WebStorageService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<WebStorageService>;
 }
 
-interface BrowserApiLogger {
-    info(message: string): void;
-    warn(message: string): void;
-    error(message: string, error?: unknown): void;
-}
-declare const BROWSER_API_LOGGER: InjectionToken<BrowserApiLogger>;
-
 /**
  * Configuration for a single WebSocket connection.
  */
@@ -1306,4 +1358,4 @@ declare function provideBrowserWebApis(config?: BrowserWebApisConfig): Environme
 declare const version = "0.1.0";
 
 export { BROWSER_API_LOGGER, BatteryService, BroadcastChannelService, BrowserApiBaseService, BrowserCapabilityService, BrowserSupportUtil, CameraService, ClipboardService, ConnectionRegistryBaseService, FileSystemAccessService, FullscreenService, GamepadService, GeolocationService, IntersectionObserverService, MediaDevicesService, MediaRecorderService, MutationObserverService, NetworkInformationService, NotificationService, PageVisibilityService, PerformanceObserverService, PermissionsService, ResizeObserverService, ScreenOrientationService, ScreenWakeLockService, ServerSentEventsService, SpeechSynthesisService, VibrationService, WebAudioService, WebShareService, WebSocketClient, WebSocketService, WebStorageService, WebWorkerService, permissionGuard as createPermissionGuard, defaultBrowserWebApisConfig, injectGamepad, injectIntersectionObserver, injectMutationObserver, injectNetworkInformation, injectPageVisibility, injectPerformanceObserver, injectResizeObserver, injectScreenOrientation, permissionGuard, provideBattery, provideBroadcastChannel, provideBrowserWebApis, provideCamera, provideClipboard, provideCommunicationApis, provideFileSystemAccess, provideFullscreen, provideGamepad, provideGeolocation, provideIntersectionObserver, provideLocationApis, provideMediaApis, provideMediaDevices, provideMediaRecorder, provideMutationObserver, provideNetworkInformation, provideNotifications, providePageVisibility, providePerformanceObserver, providePermissions, provideResizeObserver, provideScreenOrientation, provideScreenWakeLock, provideServerSentEvents, provideSpeechSynthesis, provideStorageApis, provideVibration, provideWebAudio, provideWebShare, provideWebSocket, provideWebStorage, provideWebWorker, version };
-export type { AudioAnalyserData, AudioContextState, BatteryInfo, BatteryManager, BrowserApiLogger, BrowserCapabilityId, BrowserError, BrowserPermissions, BrowserWebApisConfig, CameraCapabilities, CameraInfo, ConnectionType, EffectiveConnectionType, ElementInput, ElementSize, ErrorCallback, EventHandler, FileOpenOptions, FileSaveOptions, GamepadRef, GamepadState, GeolocationCoordinates, GeolocationError, GeolocationOptions, GeolocationPosition$1 as GeolocationPosition, 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, StorageOptions, StorageValue, VibrationPattern, VibrationPreset, VisibilityState, WakeLockStatus, WakeLockType, WebSocketClientConfig, WebSocketConfig, WebSocketMessage, WebSocketRequestOptions, WebSocketState, WebSocketStatus, WebSocketStatusV2, WorkerMessage, WorkerStatus, WorkerTask };
+export type { AudioAnalyserData, AudioContextState, BatteryInfo, BatteryManager, BrowserApiLogger, BrowserCapabilityId, BrowserError, BrowserPermissions, BrowserWebApisConfig, CameraCapabilities, CameraInfo, ConnectionType, EffectiveConnectionType, ElementInput, ElementSize, ErrorCallback, EventHandler, FileOpenOptions, FileSaveOptions, GamepadRef, GamepadState, GeolocationCoordinates, GeolocationError, GeolocationOptions, GeolocationPosition$1 as GeolocationPosition, 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, StorageValue, VibrationPattern, VibrationPreset, VisibilityState, WakeLockStatus, WakeLockType, WebSocketClientConfig, WebSocketConfig, WebSocketMessage, WebSocketRequestOptions, WebSocketState, WebSocketStatus, WebSocketStatusV2, WorkerMessage, WorkerStatus, WorkerTask };