strata-storage 1.0.0

package/dist/adapters/web/IndexedDBAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IndexedDBAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/web/IndexedDBAdapter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EACV,WAAW,EACX,mBAAmB,EACnB,YAAY,EACZ,YAAY,EACZ,QAAQ,EACR,cAAc,EACd,WAAW,EACZ,MAAM,SAAS,CAAC;AAIjB;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,WAAW;IAC/C,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAe;IACzC,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAUxC;IAEF,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,EAAE,CAAC,CAAc;gBAEb,MAAM,SAAkB,EAAE,SAAS,SAAY,EAAE,OAAO,SAAI;IAOxE;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAIrC;;OAEG;IACG,UAAU,CAAC,MAAM,CAAC,EAAE;QACxB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,GAAG,OAAO,CAAC,IAAI,CAAC;IASjB;;OAEG;YACW,YAAY;IAgC1B;;OAEG;IACG,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAiCpE;;OAEG;IACG,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IA8B1E;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBxC;;OAEG;IACG,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAwBlD;;OAEG;IACG,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IA4BxD;;OAEG;IACG,KAAK,CAAC,CAAC,GAAG,OAAO,EAAE,SAAS,EAAE,cAAc,GAAG,OAAO,CAAC,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,CAAC,CAAA;KAAE,CAAC,CAAC;IAkC9F;;OAEG;IACG,IAAI,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC;IAwDjD;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC;IAQzC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAW5B;;OAEG;IACH,OAAO,CAAC,YAAY;CAMrB"}

package/dist/adapters/web/IndexedDBAdapter.js

@@ -0,0 +1,371 @@
+/**
+ * IndexedDB Adapter - Browser IndexedDB implementation
+ * Provides large-scale persistent storage with advanced features
+ */
+import { BaseAdapter } from '@/core/BaseAdapter';
+import { createDeferred, getObjectSize } from '@/utils';
+import { StorageError, QuotaExceededError, TransactionError } from '@/utils/errors';
+/**
+ * Browser IndexedDB adapter
+ */
+export class IndexedDBAdapter extends BaseAdapter {
+    name = 'indexedDB';
+    capabilities = {
+        persistent: true,
+        synchronous: false,
+        observable: false, // No native change events
+        transactional: true,
+        queryable: true,
+        maxSize: -1, // Browser dependent, typically GBs
+        binary: true,
+        encrypted: false,
+        crossTab: false, // No built-in cross-tab sync
+    };
+    dbName;
+    storeName;
+    version;
+    db;
+    constructor(dbName = 'StrataStorage', storeName = 'storage', version = 1) {
+        super();
+        this.dbName = dbName;
+        this.storeName = storeName;
+        this.version = version;
+    }
+    /**
+     * Check if IndexedDB is available
+     */
+    async isAvailable() {
+        return typeof window !== 'undefined' && 'indexedDB' in window && window.indexedDB !== null;
+    }
+    /**
+     * Initialize the adapter
+     */
+    async initialize(config) {
+        if (config?.dbName)
+            this.dbName = config.dbName;
+        if (config?.storeName)
+            this.storeName = config.storeName;
+        if (config?.version)
+            this.version = config.version;
+        await this.openDatabase();
+        this.startTTLCleanup();
+    }
+    /**
+     * Open IndexedDB database
+     */
+    async openDatabase() {
+        if (this.db)
+            return this.db;
+        const { promise, resolve, reject } = createDeferred();
+        const request = window.indexedDB.open(this.dbName, this.version);
+        request.onerror = () => reject(new StorageError(`Failed to open IndexedDB: ${request.error}`));
+        request.onsuccess = () => {
+            this.db = request.result;
+            resolve(request.result);
+        };
+        request.onupgradeneeded = (event) => {
+            const db = event.target.result;
+            // Create object store if it doesn't exist
+            if (!db.objectStoreNames.contains(this.storeName)) {
+                const store = db.createObjectStore(this.storeName, { keyPath: 'key' });
+                // Create indexes for efficient querying
+                store.createIndex('expires', 'expires', { unique: false });
+                store.createIndex('tags', 'tags', { unique: false, multiEntry: true });
+                store.createIndex('created', 'created', { unique: false });
+                store.createIndex('updated', 'updated', { unique: false });
+            }
+        };
+        return promise;
+    }
+    /**
+     * Get a value from IndexedDB
+     */
+    async get(key) {
+        const db = await this.openDatabase();
+        const { promise, resolve, reject } = createDeferred();
+        const transaction = db.transaction([this.storeName], 'readonly');
+        const store = transaction.objectStore(this.storeName);
+        const request = store.get(key);
+        request.onsuccess = () => {
+            const result = request.result;
+            if (!result) {
+                resolve(null);
+                return;
+            }
+            // Remove the key property as it's not part of StorageValue
+            const { key: _, ...value } = result;
+            // Check TTL
+            if (this.isExpired(value)) {
+                // Don't wait for removal
+                this.remove(key).catch(console.error);
+                resolve(null);
+            }
+            else {
+                resolve(value);
+            }
+        };
+        request.onerror = () => reject(new StorageError(`Failed to get key ${key}: ${request.error}`));
+        return promise;
+    }
+    /**
+     * Set a value in IndexedDB
+     */
+    async set(key, value) {
+        const db = await this.openDatabase();
+        const oldValue = await this.get(key);
+        const { promise, resolve, reject } = createDeferred();
+        const transaction = db.transaction([this.storeName], 'readwrite');
+        const store = transaction.objectStore(this.storeName);
+        // Add key to the value for IndexedDB storage
+        const record = { key, ...value };
+        const request = store.put(record);
+        request.onsuccess = () => {
+            resolve();
+            this.emitChange(key, oldValue?.value, value.value, 'local');
+        };
+        request.onerror = () => {
+            if (this.isQuotaError(request.error)) {
+                reject(new QuotaExceededError('IndexedDB quota exceeded', { key, size: getObjectSize(value) }));
+            }
+            else {
+                reject(new StorageError(`Failed to set key ${key}: ${request.error}`));
+            }
+        };
+        return promise;
+    }
+    /**
+     * Remove a value from IndexedDB
+     */
+    async remove(key) {
+        const db = await this.openDatabase();
+        const oldValue = await this.get(key);
+        const { promise, resolve, reject } = createDeferred();
+        const transaction = db.transaction([this.storeName], 'readwrite');
+        const store = transaction.objectStore(this.storeName);
+        const request = store.delete(key);
+        request.onsuccess = () => {
+            resolve();
+            if (oldValue) {
+                this.emitChange(key, oldValue.value, undefined, 'local');
+            }
+        };
+        request.onerror = () => reject(new StorageError(`Failed to remove key ${key}: ${request.error}`));
+        return promise;
+    }
+    /**
+     * Clear IndexedDB
+     */
+    async clear(options) {
+        if (!options || (!options.pattern && !options.tags && !options.expiredOnly)) {
+            // Clear everything
+            const db = await this.openDatabase();
+            const { promise, resolve, reject } = createDeferred();
+            const transaction = db.transaction([this.storeName], 'readwrite');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.clear();
+            request.onsuccess = () => {
+                resolve();
+                this.emitChange('*', undefined, undefined, 'local');
+            };
+            request.onerror = () => reject(new StorageError(`Failed to clear store: ${request.error}`));
+            return promise;
+        }
+        // Use base implementation for filtered clear
+        await super.clear(options);
+    }
+    /**
+     * Get all keys
+     */
+    async keys(pattern) {
+        const db = await this.openDatabase();
+        const { promise, resolve, reject } = createDeferred();
+        const transaction = db.transaction([this.storeName], 'readonly');
+        const store = transaction.objectStore(this.storeName);
+        const request = store.getAllKeys();
+        request.onsuccess = async () => {
+            const allKeys = request.result;
+            // Filter expired keys
+            const validKeys = [];
+            for (const key of allKeys) {
+                const value = await this.get(key);
+                if (value) {
+                    validKeys.push(key);
+                }
+            }
+            resolve(this.filterKeys(validKeys, pattern));
+        };
+        request.onerror = () => reject(new StorageError(`Failed to get keys: ${request.error}`));
+        return promise;
+    }
+    /**
+     * Query IndexedDB with conditions
+     */
+    async query(condition) {
+        const db = await this.openDatabase();
+        const { promise, resolve, reject } = createDeferred();
+        const transaction = db.transaction([this.storeName], 'readonly');
+        const store = transaction.objectStore(this.storeName);
+        const results = [];
+        // For now, we'll do a full scan and filter
+        // In the future, we can optimize using indexes
+        const request = store.openCursor();
+        request.onsuccess = (event) => {
+            const cursor = event.target.result;
+            if (cursor) {
+                const record = cursor.value;
+                const { key, ...value } = record;
+                if (!this.isExpired(value) && this.queryEngine.matches(value.value, condition)) {
+                    results.push({ key, value: value.value });
+                }
+                cursor.continue();
+            }
+            else {
+                resolve(results);
+            }
+        };
+        request.onerror = () => reject(new StorageError(`Query failed: ${request.error}`));
+        return promise;
+    }
+    /**
+     * Get storage size
+     */
+    async size(detailed) {
+        const db = await this.openDatabase();
+        const { promise, resolve, reject } = createDeferred();
+        const transaction = db.transaction([this.storeName], 'readonly');
+        const store = transaction.objectStore(this.storeName);
+        let total = 0;
+        let count = 0;
+        let keySize = 0;
+        let valueSize = 0;
+        let metadataSize = 0;
+        const request = store.openCursor();
+        request.onsuccess = (event) => {
+            const cursor = event.target.result;
+            if (cursor) {
+                const record = cursor.value;
+                const { key, value, ...metadata } = record;
+                count++;
+                const recordKeySize = key.length * 2;
+                const recordValueSize = getObjectSize(value);
+                const recordMetadataSize = getObjectSize(metadata);
+                total += recordKeySize + recordValueSize + recordMetadataSize;
+                if (detailed) {
+                    keySize += recordKeySize;
+                    valueSize += recordValueSize;
+                    metadataSize += recordMetadataSize;
+                }
+                cursor.continue();
+            }
+            else {
+                const result = { total, count };
+                if (detailed) {
+                    result.detailed = {
+                        keys: keySize,
+                        values: valueSize,
+                        metadata: metadataSize,
+                    };
+                }
+                resolve(result);
+            }
+        };
+        request.onerror = () => reject(new StorageError(`Failed to calculate size: ${request.error}`));
+        return promise;
+    }
+    /**
+     * Begin a transaction
+     */
+    async transaction() {
+        const db = await this.openDatabase();
+        const txn = db.transaction([this.storeName], 'readwrite');
+        const store = txn.objectStore(this.storeName);
+        return new IndexedDBTransaction(store, txn);
+    }
+    /**
+     * Close the adapter
+     */
+    async close() {
+        if (this.db) {
+            this.db.close();
+            this.db = undefined;
+        }
+        if (super.close) {
+            await super.close();
+        }
+    }
+    /**
+     * Check if error is quota exceeded
+     */
+    isQuotaError(error) {
+        if (error instanceof Error || error instanceof DOMException) {
+            return error.name === 'QuotaExceededError' || error.message.toLowerCase().includes('quota');
+        }
+        return false;
+    }
+}
+/**
+ * IndexedDB transaction implementation
+ */
+class IndexedDBTransaction {
+    store;
+    txn;
+    committed = false;
+    aborted = false;
+    constructor(store, txn) {
+        this.store = store;
+        this.txn = txn;
+    }
+    async get(key) {
+        if (this.aborted)
+            throw new TransactionError('Transaction already aborted');
+        const { promise, resolve, reject } = createDeferred();
+        const request = this.store.get(key);
+        request.onsuccess = () => {
+            const result = request.result;
+            resolve(result ? result.value : null);
+        };
+        request.onerror = () => reject(new StorageError(`Transaction get failed: ${request.error}`));
+        return promise;
+    }
+    async set(key, value) {
+        if (this.aborted)
+            throw new TransactionError('Transaction already aborted');
+        const { promise, resolve, reject } = createDeferred();
+        const now = Date.now();
+        const record = {
+            key,
+            value,
+            created: now,
+            updated: now,
+        };
+        const request = this.store.put(record);
+        request.onsuccess = () => resolve();
+        request.onerror = () => reject(new StorageError(`Transaction set failed: ${request.error}`));
+        return promise;
+    }
+    async remove(key) {
+        if (this.aborted)
+            throw new TransactionError('Transaction already aborted');
+        const { promise, resolve, reject } = createDeferred();
+        const request = this.store.delete(key);
+        request.onsuccess = () => resolve();
+        request.onerror = () => reject(new StorageError(`Transaction remove failed: ${request.error}`));
+        return promise;
+    }
+    async commit() {
+        if (this.aborted)
+            throw new TransactionError('Cannot commit aborted transaction');
+        if (this.committed)
+            throw new TransactionError('Transaction already committed');
+        this.committed = true;
+        // IndexedDB auto-commits when transaction completes
+    }
+    async rollback() {
+        if (this.committed)
+            throw new TransactionError('Cannot rollback committed transaction');
+        if (this.aborted)
+            return;
+        this.aborted = true;
+        this.txn.abort();
+    }
+}

package/dist/adapters/web/LocalStorageAdapter.d.ts

@@ -0,0 +1,63 @@
+/**
+ * LocalStorage Adapter - Browser localStorage implementation
+ * Provides persistent storage with 5-10MB limit
+ */
+import { BaseAdapter } from '@/core/BaseAdapter';
+import type { StorageType, StorageCapabilities, StorageValue, ClearOptions, SizeInfo, SubscriptionCallback, UnsubscribeFunction } from '@/types';
+/**
+ * Browser localStorage adapter
+ */
+export declare class LocalStorageAdapter extends BaseAdapter {
+    readonly name: StorageType;
+    readonly capabilities: StorageCapabilities;
+    protected prefix: string;
+    protected listeners: Map<SubscriptionCallback, (event: StorageEvent) => void>;
+    constructor(prefix?: string);
+    /**
+     * Check if localStorage is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Initialize the adapter
+     */
+    initialize(config?: {
+        prefix?: string;
+    }): Promise<void>;
+    /**
+     * Get a value from localStorage
+     */
+    get<T = unknown>(key: string): Promise<StorageValue<T> | null>;
+    /**
+     * Set a value in localStorage
+     */
+    set<T = unknown>(key: string, value: StorageValue<T>): Promise<void>;
+    /**
+     * Remove a value from localStorage
+     */
+    remove(key: string): Promise<void>;
+    /**
+     * Clear localStorage
+     */
+    clear(options?: ClearOptions): Promise<void>;
+    /**
+     * Get all keys
+     */
+    keys(pattern?: string | RegExp): Promise<string[]>;
+    /**
+     * Get storage size
+     */
+    size(detailed?: boolean): Promise<SizeInfo>;
+    /**
+     * Subscribe to storage changes
+     */
+    subscribe(callback: SubscriptionCallback): UnsubscribeFunction;
+    /**
+     * Close the adapter
+     */
+    close(): Promise<void>;
+    /**
+     * Check if error is quota exceeded
+     */
+    protected isQuotaError(error: unknown): boolean;
+}
+//# sourceMappingURL=LocalStorageAdapter.d.ts.map

package/dist/adapters/web/LocalStorageAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalStorageAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/web/LocalStorageAdapter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EACV,WAAW,EACX,mBAAmB,EACnB,YAAY,EACZ,YAAY,EACZ,QAAQ,EACR,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,SAAS,CAAC;AAIjB;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,WAAW;IAClD,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAkB;IAC5C,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAUxC;IAEF,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,SAAS,EAAE,GAAG,CAAC,oBAAoB,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC,CAAa;gBAE9E,MAAM,SAAY;IAK9B;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAgBrC;;OAEG;IACG,UAAU,CAAC,MAAM,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAO7D;;OAEG;IACG,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAoBpE;;OAEG;IACG,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAqB1E;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASxC;;OAEG;IACG,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBlD;;OAEG;IACG,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAmBxD;;OAEG;IACG,IAAI,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC;IAoCjD;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,oBAAoB,GAAG,mBAAmB;IAkC9D;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAY5B;;OAEG;IACH,SAAS,CAAC,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;CAUhD"}

package/dist/adapters/web/LocalStorageAdapter.js

@@ -0,0 +1,238 @@
+/**
+ * LocalStorage Adapter - Browser localStorage implementation
+ * Provides persistent storage with 5-10MB limit
+ */
+import { BaseAdapter } from '@/core/BaseAdapter';
+import { serialize, deserialize, getObjectSize } from '@/utils';
+import { QuotaExceededError, SerializationError } from '@/utils/errors';
+/**
+ * Browser localStorage adapter
+ */
+export class LocalStorageAdapter extends BaseAdapter {
+    name = 'localStorage';
+    capabilities = {
+        persistent: true,
+        synchronous: false, // We use async for consistency
+        observable: true, // Via storage events
+        transactional: false,
+        queryable: true,
+        maxSize: 10 * 1024 * 1024, // Typically 5-10MB
+        binary: false, // Only strings
+        encrypted: false,
+        crossTab: true, // Storage events work across tabs
+    };
+    prefix;
+    listeners = new Map();
+    constructor(prefix = 'strata:') {
+        super();
+        this.prefix = prefix;
+    }
+    /**
+     * Check if localStorage is available
+     */
+    async isAvailable() {
+        try {
+            if (typeof window === 'undefined' || !window.localStorage) {
+                return false;
+            }
+            // Test if we can actually use it
+            const testKey = `${this.prefix}__test__`;
+            window.localStorage.setItem(testKey, 'test');
+            window.localStorage.removeItem(testKey);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Initialize the adapter
+     */
+    async initialize(config) {
+        if (config?.prefix) {
+            this.prefix = config.prefix;
+        }
+        this.startTTLCleanup();
+    }
+    /**
+     * Get a value from localStorage
+     */
+    async get(key) {
+        try {
+            const item = window.localStorage.getItem(this.prefix + key);
+            if (!item)
+                return null;
+            const value = deserialize(item);
+            // Check TTL
+            if (this.isExpired(value)) {
+                await this.remove(key);
+                return null;
+            }
+            return value;
+        }
+        catch (error) {
+            console.error(`Failed to get key ${key} from localStorage:`, error);
+            return null;
+        }
+    }
+    /**
+     * Set a value in localStorage
+     */
+    async set(key, value) {
+        const fullKey = this.prefix + key;
+        const oldValue = await this.get(key);
+        try {
+            const serialized = serialize(value);
+            window.localStorage.setItem(fullKey, serialized);
+        }
+        catch (error) {
+            if (this.isQuotaError(error)) {
+                throw new QuotaExceededError('LocalStorage quota exceeded', {
+                    key,
+                    size: getObjectSize(value),
+                });
+            }
+            throw new SerializationError(`Failed to store key ${key} in localStorage`, error);
+        }
+        // Emit change event (storage events don't fire in same window)
+        this.emitChange(key, oldValue?.value, value.value, 'local');
+    }
+    /**
+     * Remove a value from localStorage
+     */
+    async remove(key) {
+        const oldValue = await this.get(key);
+        window.localStorage.removeItem(this.prefix + key);
+        if (oldValue) {
+            this.emitChange(key, oldValue.value, undefined, 'local');
+        }
+    }
+    /**
+     * Clear localStorage
+     */
+    async clear(options) {
+        if (!options || (!options.pattern && !options.tags && !options.expiredOnly)) {
+            // Clear all with our prefix
+            const keysToRemove = [];
+            for (let i = 0; i < window.localStorage.length; i++) {
+                const key = window.localStorage.key(i);
+                if (key?.startsWith(this.prefix)) {
+                    keysToRemove.push(key);
+                }
+            }
+            keysToRemove.forEach((key) => window.localStorage.removeItem(key));
+            this.emitChange('*', undefined, undefined, 'local');
+            return;
+        }
+        // Use base implementation for filtered clear
+        await super.clear(options);
+    }
+    /**
+     * Get all keys
+     */
+    async keys(pattern) {
+        const keys = [];
+        for (let i = 0; i < window.localStorage.length; i++) {
+            const fullKey = window.localStorage.key(i);
+            if (fullKey?.startsWith(this.prefix)) {
+                const key = fullKey.substring(this.prefix.length);
+                // Check if not expired
+                const value = await this.get(key);
+                if (value) {
+                    keys.push(key);
+                }
+            }
+        }
+        return this.filterKeys(keys, pattern);
+    }
+    /**
+     * Get storage size
+     */
+    async size(detailed) {
+        let total = 0;
+        let count = 0;
+        let keySize = 0;
+        let valueSize = 0;
+        for (let i = 0; i < window.localStorage.length; i++) {
+            const fullKey = window.localStorage.key(i);
+            if (fullKey?.startsWith(this.prefix)) {
+                const item = window.localStorage.getItem(fullKey);
+                if (item) {
+                    count++;
+                    const itemSize = (fullKey.length + item.length) * 2; // UTF-16
+                    total += itemSize;
+                    if (detailed) {
+                        keySize += fullKey.length * 2;
+                        valueSize += item.length * 2;
+                    }
+                }
+            }
+        }
+        const result = { total, count };
+        if (detailed) {
+            result.detailed = {
+                keys: keySize,
+                values: valueSize,
+                metadata: 0, // Metadata is included in values for localStorage
+            };
+        }
+        return result;
+    }
+    /**
+     * Subscribe to storage changes
+     */
+    subscribe(callback) {
+        const listener = (event) => {
+            // Only process events from other windows/tabs
+            if (event.storageArea !== window.localStorage)
+                return;
+            // Check if the key belongs to us
+            if (!event.key || !event.key.startsWith(this.prefix))
+                return;
+            const key = event.key.substring(this.prefix.length);
+            const oldValue = event.oldValue ? deserialize(event.oldValue) : null;
+            const newValue = event.newValue ? deserialize(event.newValue) : null;
+            callback({
+                key,
+                oldValue: oldValue?.value ?? undefined,
+                newValue: newValue?.value ?? undefined,
+                source: 'remote',
+                storage: this.name,
+                timestamp: Date.now(),
+            });
+        };
+        window.addEventListener('storage', listener);
+        this.listeners.set(callback, listener);
+        return () => {
+            const storedListener = this.listeners.get(callback);
+            if (storedListener) {
+                window.removeEventListener('storage', storedListener);
+                this.listeners.delete(callback);
+            }
+        };
+    }
+    /**
+     * Close the adapter
+     */
+    async close() {
+        // Remove all storage event listeners
+        this.listeners.forEach((listener) => {
+            window.removeEventListener('storage', listener);
+        });
+        this.listeners.clear();
+        if (super.close) {
+            await super.close();
+        }
+    }
+    /**
+     * Check if error is quota exceeded
+     */
+    isQuotaError(error) {
+        if (error instanceof Error) {
+            return (error.name === 'QuotaExceededError' ||
+                error.name === 'NS_ERROR_DOM_QUOTA_REACHED' ||
+                error.message.toLowerCase().includes('quota'));
+        }
+        return false;
+    }
+}