strata-storage 1.0.0

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

@@ -0,0 +1,69 @@
+/**
+ * Memory Adapter - In-memory storage implementation
+ * Provides fast, non-persistent storage using Map
+ */
+import { BaseAdapter } from '@/core/BaseAdapter';
+import type { StorageType, StorageCapabilities, StorageValue, ClearOptions, QueryCondition } from '@/types';
+/**
+ * In-memory storage adapter using Map
+ */
+export declare class MemoryAdapter extends BaseAdapter {
+    readonly name: StorageType;
+    readonly capabilities: StorageCapabilities;
+    private storage;
+    private maxSize?;
+    private currentSize;
+    /**
+     * Check if adapter is available (always true for memory)
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Initialize the adapter
+     */
+    initialize(config?: {
+        maxSize?: number;
+    }): Promise<void>;
+    /**
+     * Get a value from memory
+     */
+    get<T = unknown>(key: string): Promise<StorageValue<T> | null>;
+    /**
+     * Set a value in memory
+     */
+    set<T = unknown>(key: string, value: StorageValue<T>): Promise<void>;
+    /**
+     * Remove a value from memory
+     */
+    remove(key: string): Promise<void>;
+    /**
+     * Clear memory storage
+     */
+    clear(options?: ClearOptions): Promise<void>;
+    /**
+     * Check if key exists
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Get all keys
+     */
+    keys(pattern?: string | RegExp): Promise<string[]>;
+    /**
+     * Query implementation for memory adapter
+     */
+    query<T = unknown>(condition: QueryCondition): Promise<Array<{
+        key: string;
+        value: T;
+    }>>;
+    /**
+     * Get current memory usage
+     */
+    getMemoryUsage(): {
+        used: number;
+        limit?: number;
+    };
+    /**
+     * Close the adapter
+     */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=MemoryAdapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/web/MemoryAdapter.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,cAAc,EACf,MAAM,SAAS,CAAC;AAGjB;;GAEG;AACH,qBAAa,aAAc,SAAQ,WAAW;IAC5C,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAY;IACtC,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAUxC;IAEF,OAAO,CAAC,OAAO,CAAwC;IACvD,OAAO,CAAC,OAAO,CAAC,CAAS;IACzB,OAAO,CAAC,WAAW,CAAK;IAExB;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAIrC;;OAEG;IACG,UAAU,CAAC,MAAM,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAK9D;;OAEG;IACG,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAepE;;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;IAWxC;;OAEG;IACG,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAalD;;OAEG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAKxC;;OAEG;IACG,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAkBxD;;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;IAe9F;;OAEG;IACH,cAAc,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE;IAOlD;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAO7B"}

package/dist/adapters/web/MemoryAdapter.js

@@ -0,0 +1,165 @@
+/**
+ * Memory Adapter - In-memory storage implementation
+ * Provides fast, non-persistent storage using Map
+ */
+import { BaseAdapter } from '@/core/BaseAdapter';
+import { deepClone } from '@/utils';
+/**
+ * In-memory storage adapter using Map
+ */
+export class MemoryAdapter extends BaseAdapter {
+    name = 'memory';
+    capabilities = {
+        persistent: false,
+        synchronous: false, // We use async for consistency
+        observable: true,
+        transactional: false,
+        queryable: true,
+        maxSize: -1, // No hard limit, but configurable
+        binary: true,
+        encrypted: false, // Encryption handled by feature layer
+        crossTab: false, // Memory is per-instance
+    };
+    storage = new Map();
+    maxSize;
+    currentSize = 0;
+    /**
+     * Check if adapter is available (always true for memory)
+     */
+    async isAvailable() {
+        return true;
+    }
+    /**
+     * Initialize the adapter
+     */
+    async initialize(config) {
+        this.maxSize = config?.maxSize;
+        this.startTTLCleanup();
+    }
+    /**
+     * Get a value from memory
+     */
+    async get(key) {
+        const value = this.storage.get(key);
+        if (!value)
+            return null;
+        // Check TTL
+        if (this.isExpired(value)) {
+            await this.remove(key);
+            return null;
+        }
+        // Return a deep clone to prevent external modifications
+        return deepClone(value);
+    }
+    /**
+     * Set a value in memory
+     */
+    async set(key, value) {
+        const oldValue = this.storage.get(key);
+        const newSize = this.calculateSize(value);
+        // Check size limit if configured
+        if (this.maxSize && this.maxSize > 0) {
+            const oldSize = oldValue ? this.calculateSize(oldValue) : 0;
+            const projectedSize = this.currentSize - oldSize + newSize;
+            if (projectedSize > this.maxSize) {
+                throw new Error(`Memory storage size limit exceeded. Limit: ${this.maxSize}, Projected: ${projectedSize}`);
+            }
+        }
+        // Store a deep clone to prevent external modifications
+        const clonedValue = deepClone(value);
+        this.storage.set(key, clonedValue);
+        // Update size tracking
+        if (oldValue) {
+            this.currentSize -= this.calculateSize(oldValue);
+        }
+        this.currentSize += newSize;
+        // Emit change event
+        this.emitChange(key, oldValue?.value, value.value, 'local');
+    }
+    /**
+     * Remove a value from memory
+     */
+    async remove(key) {
+        const value = this.storage.get(key);
+        if (!value)
+            return;
+        this.storage.delete(key);
+        this.currentSize -= this.calculateSize(value);
+        // Emit change event
+        this.emitChange(key, value.value, undefined, 'local');
+    }
+    /**
+     * Clear memory storage
+     */
+    async clear(options) {
+        if (!options || (!options.pattern && !options.tags && !options.expiredOnly)) {
+            // Clear everything
+            this.storage.clear();
+            this.currentSize = 0;
+            this.emitChange('*', undefined, undefined, 'local');
+            return;
+        }
+        // Use base implementation for filtered clear
+        await super.clear(options);
+    }
+    /**
+     * Check if key exists
+     */
+    async has(key) {
+        const value = this.storage.get(key);
+        return value !== undefined && !this.isExpired(value);
+    }
+    /**
+     * Get all keys
+     */
+    async keys(pattern) {
+        const allKeys = Array.from(this.storage.keys());
+        // Remove expired entries
+        const validKeys = [];
+        for (const key of allKeys) {
+            const value = this.storage.get(key);
+            if (value && !this.isExpired(value)) {
+                validKeys.push(key);
+            }
+            else if (value) {
+                // Clean up expired entry
+                await this.remove(key);
+            }
+        }
+        return this.filterKeys(validKeys, pattern);
+    }
+    /**
+     * Query implementation for memory adapter
+     */
+    async query(condition) {
+        const results = [];
+        for (const [key, item] of this.storage.entries()) {
+            if (!this.isExpired(item) && this.queryEngine.matches(item.value, condition)) {
+                results.push({
+                    key,
+                    value: deepClone(item.value),
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Get current memory usage
+     */
+    getMemoryUsage() {
+        return {
+            used: this.currentSize,
+            limit: this.maxSize,
+        };
+    }
+    /**
+     * Close the adapter
+     */
+    async close() {
+        if (super.close) {
+            await super.close();
+        }
+        this.storage.clear();
+        this.currentSize = 0;
+    }
+}

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

@@ -0,0 +1,53 @@
+/**
+ * SessionStorage Adapter - Browser sessionStorage implementation
+ * Provides session-scoped storage with 5-10MB limit
+ */
+import { LocalStorageAdapter } from './LocalStorageAdapter';
+import type { StorageType, StorageCapabilities } from '@/types';
+/**
+ * Browser sessionStorage adapter
+ * Extends LocalStorageAdapter as the API is identical
+ */
+export declare class SessionStorageAdapter extends LocalStorageAdapter {
+    readonly name: StorageType;
+    readonly capabilities: StorageCapabilities;
+    constructor(prefix?: string);
+    /**
+     * Check if sessionStorage is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Override all methods to use sessionStorage instead of localStorage
+     */
+    protected getStorage(): Storage;
+    /**
+     * Get a value from sessionStorage
+     */
+    get<T = unknown>(key: string): Promise<import('@/types').StorageValue<T> | null>;
+    /**
+     * Set a value in sessionStorage
+     */
+    set<T = unknown>(key: string, value: import('@/types').StorageValue<T>): Promise<void>;
+    /**
+     * Remove a value from sessionStorage
+     */
+    remove(key: string): Promise<void>;
+    /**
+     * Clear sessionStorage
+     */
+    clear(options?: import('@/types').ClearOptions): Promise<void>;
+    /**
+     * Get all keys
+     */
+    keys(pattern?: string | RegExp): Promise<string[]>;
+    /**
+     * Get storage size
+     */
+    size(detailed?: boolean): Promise<import('@/types').SizeInfo>;
+    /**
+     * Subscribe to storage changes
+     * Note: sessionStorage doesn't fire storage events in the same tab
+     */
+    subscribe(_callback: import('@/types').SubscriptionCallback): import('@/types').UnsubscribeFunction;
+}
+//# sourceMappingURL=SessionStorageAdapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SessionStorageAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/web/SessionStorageAdapter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEhE;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,mBAAmB;IAC5D,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAoB;IAC9C,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAUxC;gBAEU,MAAM,SAAoB;IAItC;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAgBrC;;OAEG;IACH,SAAS,CAAC,UAAU,IAAI,OAAO;IAI/B;;OAEG;IACG,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAoBtF;;OAEG;IACG,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB5F;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASxC;;OAEG;IACG,KAAK,CAAC,OAAO,CAAC,EAAE,OAAO,SAAS,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBpE;;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,OAAO,SAAS,EAAE,QAAQ,CAAC;IAoCnE;;;OAGG;IACH,SAAS,CACP,SAAS,EAAE,OAAO,SAAS,EAAE,oBAAoB,GAChD,OAAO,SAAS,EAAE,mBAAmB;CAKzC"}

package/dist/adapters/web/SessionStorageAdapter.js

@@ -0,0 +1,180 @@
+/**
+ * SessionStorage Adapter - Browser sessionStorage implementation
+ * Provides session-scoped storage with 5-10MB limit
+ */
+import { LocalStorageAdapter } from './LocalStorageAdapter';
+/**
+ * Browser sessionStorage adapter
+ * Extends LocalStorageAdapter as the API is identical
+ */
+export class SessionStorageAdapter extends LocalStorageAdapter {
+    name = 'sessionStorage';
+    capabilities = {
+        persistent: false, // Only for session
+        synchronous: false,
+        observable: true,
+        transactional: false,
+        queryable: true,
+        maxSize: 10 * 1024 * 1024, // Typically 5-10MB
+        binary: false,
+        encrypted: false,
+        crossTab: false, // Session storage is per-tab
+    };
+    constructor(prefix = 'strata:session:') {
+        super(prefix);
+    }
+    /**
+     * Check if sessionStorage is available
+     */
+    async isAvailable() {
+        try {
+            if (typeof window === 'undefined' || !window.sessionStorage) {
+                return false;
+            }
+            // Test if we can actually use it
+            const testKey = `${this.prefix}__test__`;
+            window.sessionStorage.setItem(testKey, 'test');
+            window.sessionStorage.removeItem(testKey);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Override all methods to use sessionStorage instead of localStorage
+     */
+    getStorage() {
+        return window.sessionStorage;
+    }
+    /**
+     * Get a value from sessionStorage
+     */
+    async get(key) {
+        try {
+            const item = window.sessionStorage.getItem(this.prefix + key);
+            if (!item)
+                return null;
+            const value = JSON.parse(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 sessionStorage:`, error);
+            return null;
+        }
+    }
+    /**
+     * Set a value in sessionStorage
+     */
+    async set(key, value) {
+        const fullKey = this.prefix + key;
+        const oldValue = await this.get(key);
+        try {
+            const serialized = JSON.stringify(value);
+            window.sessionStorage.setItem(fullKey, serialized);
+        }
+        catch (error) {
+            if (this.isQuotaError(error)) {
+                throw new Error(`SessionStorage quota exceeded for key ${key}`);
+            }
+            throw new Error(`Failed to store key ${key} in sessionStorage: ${error}`);
+        }
+        // Emit change event
+        this.emitChange(key, oldValue?.value, value.value, 'local');
+    }
+    /**
+     * Remove a value from sessionStorage
+     */
+    async remove(key) {
+        const oldValue = await this.get(key);
+        window.sessionStorage.removeItem(this.prefix + key);
+        if (oldValue) {
+            this.emitChange(key, oldValue.value, undefined, 'local');
+        }
+    }
+    /**
+     * Clear sessionStorage
+     */
+    async clear(options) {
+        if (!options || (!options.pattern && !options.tags && !options.expiredOnly)) {
+            // Clear all with our prefix
+            const keysToRemove = [];
+            for (let i = 0; i < window.sessionStorage.length; i++) {
+                const key = window.sessionStorage.key(i);
+                if (key?.startsWith(this.prefix)) {
+                    keysToRemove.push(key);
+                }
+            }
+            keysToRemove.forEach((key) => window.sessionStorage.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.sessionStorage.length; i++) {
+            const fullKey = window.sessionStorage.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.sessionStorage.length; i++) {
+            const fullKey = window.sessionStorage.key(i);
+            if (fullKey?.startsWith(this.prefix)) {
+                const item = window.sessionStorage.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,
+            };
+        }
+        return result;
+    }
+    /**
+     * Subscribe to storage changes
+     * Note: sessionStorage doesn't fire storage events in the same tab
+     */
+    subscribe(_callback) {
+        // For sessionStorage, we only get local changes, not cross-tab
+        // So we'll just return a no-op unsubscribe function
+        return () => { };
+    }
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Web storage adapters
+ */
+export { MemoryAdapter } from './MemoryAdapter';
+export { LocalStorageAdapter } from './LocalStorageAdapter';
+export { SessionStorageAdapter } from './SessionStorageAdapter';
+export { IndexedDBAdapter } from './IndexedDBAdapter';
+export { CookieAdapter } from './CookieAdapter';
+export { CacheAdapter } from './CacheAdapter';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/web/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/adapters/web/index.js

@@ -0,0 +1,9 @@
+/**
+ * Web storage adapters
+ */
+export { MemoryAdapter } from './MemoryAdapter';
+export { LocalStorageAdapter } from './LocalStorageAdapter';
+export { SessionStorageAdapter } from './SessionStorageAdapter';
+export { IndexedDBAdapter } from './IndexedDBAdapter';
+export { CookieAdapter } from './CookieAdapter';
+export { CacheAdapter } from './CacheAdapter';

package/dist/core/AdapterRegistry.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Registry for managing storage adapters
+ */
+import type { StorageAdapter, StorageType } from '@/types';
+/**
+ * Adapter registry for managing storage adapters
+ */
+export declare class AdapterRegistry {
+    private adapters;
+    private initialized;
+    /**
+     * Register a storage adapter
+     */
+    register(adapter: StorageAdapter): void;
+    /**
+     * Get a storage adapter by name
+     */
+    get(name: StorageType): StorageAdapter | undefined;
+    /**
+     * Get an adapter and ensure it's initialized
+     */
+    getInitialized(name: StorageType, config?: unknown): Promise<StorageAdapter>;
+    /**
+     * Check if an adapter is registered
+     */
+    has(name: StorageType): boolean;
+    /**
+     * Get all registered adapter names
+     */
+    getNames(): StorageType[];
+    /**
+     * Get all registered adapters
+     */
+    getAll(): StorageAdapter[];
+    /**
+     * Get available adapters for current platform
+     */
+    getAvailable(): Promise<StorageAdapter[]>;
+    /**
+     * Unregister an adapter
+     */
+    unregister(name: StorageType): boolean;
+    /**
+     * Clear all adapters
+     */
+    clear(): void;
+    /**
+     * Close all adapters
+     */
+    closeAll(): Promise<void>;
+}
+//# sourceMappingURL=AdapterRegistry.d.ts.map

package/dist/core/AdapterRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdapterRegistry.d.ts","sourceRoot":"","sources":["../../src/core/AdapterRegistry.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3D;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAA+C;IAC/D,OAAO,CAAC,WAAW,CAA+B;IAElD;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAIvC;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,WAAW,GAAG,cAAc,GAAG,SAAS;IAIlD;;OAEG;IACG,cAAc,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,cAAc,CAAC;IAwBlF;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO;IAI/B;;OAEG;IACH,QAAQ,IAAI,WAAW,EAAE;IAIzB;;OAEG;IACH,MAAM,IAAI,cAAc,EAAE;IAI1B;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;IAY/C;;OAEG;IACH,UAAU,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO;IAKtC;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAYhC"}

package/dist/core/AdapterRegistry.js

@@ -0,0 +1,102 @@
+/**
+ * Registry for managing storage adapters
+ */
+import { AdapterNotAvailableError } from '@/utils/errors';
+/**
+ * Adapter registry for managing storage adapters
+ */
+export class AdapterRegistry {
+    adapters = new Map();
+    initialized = new Set();
+    /**
+     * Register a storage adapter
+     */
+    register(adapter) {
+        this.adapters.set(adapter.name, adapter);
+    }
+    /**
+     * Get a storage adapter by name
+     */
+    get(name) {
+        return this.adapters.get(name);
+    }
+    /**
+     * Get an adapter and ensure it's initialized
+     */
+    async getInitialized(name, config) {
+        const adapter = this.get(name);
+        if (!adapter) {
+            throw new AdapterNotAvailableError(name);
+        }
+        // Check if adapter is available on current platform
+        const isAvailable = await adapter.isAvailable();
+        if (!isAvailable) {
+            throw new AdapterNotAvailableError(name, {
+                reason: 'Not available on current platform',
+            });
+        }
+        // Initialize if not already done
+        if (!this.initialized.has(name)) {
+            await adapter.initialize(config);
+            this.initialized.add(name);
+        }
+        return adapter;
+    }
+    /**
+     * Check if an adapter is registered
+     */
+    has(name) {
+        return this.adapters.has(name);
+    }
+    /**
+     * Get all registered adapter names
+     */
+    getNames() {
+        return Array.from(this.adapters.keys());
+    }
+    /**
+     * Get all registered adapters
+     */
+    getAll() {
+        return Array.from(this.adapters.values());
+    }
+    /**
+     * Get available adapters for current platform
+     */
+    async getAvailable() {
+        const available = [];
+        for (const adapter of this.adapters.values()) {
+            if (await adapter.isAvailable()) {
+                available.push(adapter);
+            }
+        }
+        return available;
+    }
+    /**
+     * Unregister an adapter
+     */
+    unregister(name) {
+        this.initialized.delete(name);
+        return this.adapters.delete(name);
+    }
+    /**
+     * Clear all adapters
+     */
+    clear() {
+        this.adapters.clear();
+        this.initialized.clear();
+    }
+    /**
+     * Close all adapters
+     */
+    async closeAll() {
+        const promises = [];
+        for (const [name, adapter] of this.adapters) {
+            if (this.initialized.has(name) && adapter.close) {
+                promises.push(adapter.close());
+            }
+        }
+        await Promise.all(promises);
+        this.initialized.clear();
+    }
+}