strata-storage/dist/plugin/web.js

Zero-dependency universal storage plugin providing a unified API for all storage operations across web, Android, and iOS platforms

/**
 * Strata Storage Web Implementation
 * Web platform implementation of the Capacitor plugin
 */
import { LocalStorageAdapter } from "../adapters/web/LocalStorageAdapter.js";
import { IndexedDBAdapter } from "../adapters/web/IndexedDBAdapter.js";
import { CacheAdapter } from "../adapters/web/CacheAdapter.js";
import { NotSupportedError } from "../utils/errors.js";
export class StrataStorageWeb {
    adapters = new Map();
    initialized = false;
    async initializeAdapters() {
        if (this.initialized)
            return;
        this.adapters.set('preferences', new LocalStorageAdapter('strata_prefs_'));
        this.adapters.set('secure', new IndexedDBAdapter('strata-secure'));
        this.adapters.set('sqlite', new IndexedDBAdapter('strata-db'));
        this.adapters.set('filesystem', new CacheAdapter('strata-files'));
        await Promise.all(Array.from(this.adapters.values()).map((adapter) => adapter.initialize()));
        this.initialized = true;
    }
    getAdapter(storageType) {
        const adapter = this.adapters.get(storageType);
        if (!adapter) {
            throw new NotSupportedError(`Storage type '${storageType}'`, 'web plugin', {
                availableTypes: Array.from(this.adapters.keys()),
                suggestion: this.getSuggestion(storageType),
            });
        }
        return adapter;
    }
    async isAvailable(options) {
        await this.initializeAdapters();
        const adapter = this.adapters.get(options.storage);
        if (!adapter) {
            return { available: false };
        }
        const available = await adapter.isAvailable();
        return { available };
    }
    async get(options) {
        await this.initializeAdapters();
        const adapter = this.getAdapter(options.storage || 'preferences');
        const value = await adapter.get(options.key);
        return { value };
    }
    async set(options) {
        await this.initializeAdapters();
        const adapter = this.getAdapter(options.storage || 'preferences');
        await adapter.set(options.key, options.value);
    }
    async remove(options) {
        await this.initializeAdapters();
        const adapter = this.getAdapter(options.storage || 'preferences');
        await adapter.remove(options.key);
    }
    async clear(options) {
        await this.initializeAdapters();
        const adapter = this.getAdapter(options.storage || 'preferences');
        await adapter.clear();
    }
    async keys(options) {
        await this.initializeAdapters();
        const adapter = this.getAdapter(options.storage || 'preferences');
        const keys = await adapter.keys();
        return { keys };
    }
    async size(options) {
        await this.initializeAdapters();
        const adapter = this.getAdapter(options.storage || 'preferences');
        const sizeInfo = await adapter.size();
        return { total: sizeInfo.total, count: sizeInfo.count };
    }
    /**
     * Get suggestion for web alternative based on native storage type
     */
    getSuggestion(storageType) {
        const suggestions = {
            preferences: 'Use localStorage adapter for persistent key-value storage.',
            secure: 'Use indexedDB adapter with encryption enabled for secure storage.',
            sqlite: 'Use indexedDB adapter for database-like storage.',
            filesystem: 'Use Cache API adapter or indexedDB for file storage.',
        };
        return (suggestions[storageType] ||
            'Use one of the web adapters: localStorage, sessionStorage, indexedDB, cookies, or cache.');
    }
}