react-achievements 3.3.0 → 3.4.0

package/dist/index.js

@@ -8,10 +8,18 @@ import 'react-toastify/dist/ReactToastify.css';
 const isDate = (value) => {
     return value instanceof Date;
 };
+// Type guard to detect async storage
+function isAsyncStorage(storage) {
+    // Check if methods return Promises
+    const testResult = storage.getMetrics();
+    return testResult && typeof testResult.then === 'function';
+}
 var StorageType;
 (function (StorageType) {
     StorageType["Local"] = "local";
     StorageType["Memory"] = "memory";
+    StorageType["IndexedDB"] = "indexeddb";
+    StorageType["RestAPI"] = "restapi"; // Asynchronous REST API storage
 })(StorageType || (StorageType = {}));
 
 /**
@@ -70,13 +78,15 @@ class ConfigurationError extends AchievementError {
     }
 }
 /**
- * Error thrown when sync operations fail (for async storage backends)
+ * Error thrown when network sync operations fail
  */
 class SyncError extends AchievementError {
-    constructor(message, originalError) {
-        super(message, 'SYNC_ERROR', true, 'Check your network connection and backend server status. The operation will be retried automatically.');
-        this.originalError = originalError;
+    constructor(message, details) {
+        super(message, 'SYNC_ERROR', true, // recoverable (can retry)
+        'Check your network connection and try again. If the problem persists, achievements will sync when connection is restored.');
         this.name = 'SyncError';
+        this.statusCode = details === null || details === void 0 ? void 0 : details.statusCode;
+        this.timeout = details === null || details === void 0 ? void 0 : details.timeout;
     }
 }
 /**
@@ -216,6 +226,641 @@ class MemoryStorage {
     }
 }
 
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+class AsyncStorageAdapter {
+    constructor(asyncStorage, options) {
+        this.pendingWrites = [];
+        this.asyncStorage = asyncStorage;
+        this.onError = options === null || options === void 0 ? void 0 : options.onError;
+        this.cache = {
+            metrics: {},
+            unlocked: [],
+            loaded: false
+        };
+        // Eagerly load data from async storage (non-blocking)
+        this.initializeCache();
+    }
+    /**
+     * Initialize cache by loading from async storage
+     * This happens in the background during construction
+     */
+    initializeCache() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const [metrics, unlocked] = yield Promise.all([
+                    this.asyncStorage.getMetrics(),
+                    this.asyncStorage.getUnlockedAchievements()
+                ]);
+                this.cache.metrics = metrics;
+                this.cache.unlocked = unlocked;
+                this.cache.loaded = true;
+            }
+            catch (error) {
+                // Handle initialization errors
+                console.error('Failed to initialize async storage:', error);
+                if (this.onError) {
+                    const storageError = error instanceof AchievementError
+                        ? error
+                        : new StorageError('Failed to initialize storage', error);
+                    this.onError(storageError);
+                }
+                // Set to empty state on error
+                this.cache.loaded = true; // Mark as loaded even on error to prevent blocking
+            }
+        });
+    }
+    /**
+     * Wait for cache to be loaded (used internally)
+     * Returns immediately if already loaded, otherwise waits
+     */
+    ensureCacheLoaded() {
+        return __awaiter(this, void 0, void 0, function* () {
+            while (!this.cache.loaded) {
+                yield new Promise(resolve => setTimeout(resolve, 10));
+            }
+        });
+    }
+    /**
+     * SYNC READ: Returns cached metrics immediately
+     * Cache is loaded eagerly during construction
+     */
+    getMetrics() {
+        return this.cache.metrics;
+    }
+    /**
+     * SYNC WRITE: Updates cache immediately, writes to storage in background
+     * Uses optimistic updates - assumes write will succeed
+     */
+    setMetrics(metrics) {
+        // Update cache immediately (optimistic update)
+        this.cache.metrics = metrics;
+        // Write to async storage in background
+        const writePromise = this.asyncStorage.setMetrics(metrics).catch(error => {
+            console.error('Failed to write metrics to async storage:', error);
+            if (this.onError) {
+                const storageError = error instanceof AchievementError
+                    ? error
+                    : new StorageError('Failed to write metrics', error);
+                this.onError(storageError);
+            }
+        });
+        // Track pending write for cleanup/testing
+        this.pendingWrites.push(writePromise);
+    }
+    /**
+     * SYNC READ: Returns cached unlocked achievements immediately
+     */
+    getUnlockedAchievements() {
+        return this.cache.unlocked;
+    }
+    /**
+     * SYNC WRITE: Updates cache immediately, writes to storage in background
+     */
+    setUnlockedAchievements(achievements) {
+        // Update cache immediately (optimistic update)
+        this.cache.unlocked = achievements;
+        // Write to async storage in background
+        const writePromise = this.asyncStorage.setUnlockedAchievements(achievements).catch(error => {
+            console.error('Failed to write unlocked achievements to async storage:', error);
+            if (this.onError) {
+                const storageError = error instanceof AchievementError
+                    ? error
+                    : new StorageError('Failed to write achievements', error);
+                this.onError(storageError);
+            }
+        });
+        // Track pending write
+        this.pendingWrites.push(writePromise);
+    }
+    /**
+     * SYNC CLEAR: Clears cache immediately, clears storage in background
+     */
+    clear() {
+        // Clear cache immediately
+        this.cache.metrics = {};
+        this.cache.unlocked = [];
+        // Clear async storage in background
+        const clearPromise = this.asyncStorage.clear().catch(error => {
+            console.error('Failed to clear async storage:', error);
+            if (this.onError) {
+                const storageError = error instanceof AchievementError
+                    ? error
+                    : new StorageError('Failed to clear storage', error);
+                this.onError(storageError);
+            }
+        });
+        // Track pending write
+        this.pendingWrites.push(clearPromise);
+    }
+    /**
+     * Wait for all pending writes to complete (useful for testing/cleanup)
+     * NOT part of AchievementStorage interface - utility method
+     */
+    flush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all(this.pendingWrites);
+            this.pendingWrites = [];
+        });
+    }
+}
+
+class IndexedDBStorage {
+    constructor(dbName = 'react-achievements') {
+        this.storeName = 'achievements';
+        this.db = null;
+        this.dbName = dbName;
+        this.initPromise = this.initDB();
+    }
+    /**
+     * Initialize IndexedDB database and object store
+     */
+    initDB() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const request = indexedDB.open(this.dbName, 1);
+                request.onerror = () => {
+                    reject(new StorageError('Failed to open IndexedDB'));
+                };
+                request.onsuccess = () => {
+                    this.db = request.result;
+                    resolve();
+                };
+                request.onupgradeneeded = (event) => {
+                    const db = event.target.result;
+                    // Create object store if it doesn't exist
+                    if (!db.objectStoreNames.contains(this.storeName)) {
+                        db.createObjectStore(this.storeName);
+                    }
+                };
+            });
+        });
+    }
+    /**
+     * Generic get operation from IndexedDB
+     */
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.initPromise;
+            if (!this.db)
+                throw new StorageError('Database not initialized');
+            return new Promise((resolve, reject) => {
+                const transaction = this.db.transaction([this.storeName], 'readonly');
+                const store = transaction.objectStore(this.storeName);
+                const request = store.get(key);
+                request.onsuccess = () => {
+                    resolve(request.result || null);
+                };
+                request.onerror = () => {
+                    reject(new StorageError(`Failed to read from IndexedDB: ${key}`));
+                };
+            });
+        });
+    }
+    /**
+     * Generic set operation to IndexedDB
+     */
+    set(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.initPromise;
+            if (!this.db)
+                throw new StorageError('Database not initialized');
+            return new Promise((resolve, reject) => {
+                const transaction = this.db.transaction([this.storeName], 'readwrite');
+                const store = transaction.objectStore(this.storeName);
+                const request = store.put(value, key);
+                request.onsuccess = () => {
+                    resolve();
+                };
+                request.onerror = () => {
+                    reject(new StorageError(`Failed to write to IndexedDB: ${key}`));
+                };
+            });
+        });
+    }
+    /**
+     * Delete operation from IndexedDB
+     */
+    delete(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.initPromise;
+            if (!this.db)
+                throw new StorageError('Database not initialized');
+            return new Promise((resolve, reject) => {
+                const transaction = this.db.transaction([this.storeName], 'readwrite');
+                const store = transaction.objectStore(this.storeName);
+                const request = store.delete(key);
+                request.onsuccess = () => {
+                    resolve();
+                };
+                request.onerror = () => {
+                    reject(new StorageError(`Failed to delete from IndexedDB: ${key}`));
+                };
+            });
+        });
+    }
+    getMetrics() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const metrics = yield this.get('metrics');
+            return metrics || {};
+        });
+    }
+    setMetrics(metrics) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.set('metrics', metrics);
+        });
+    }
+    getUnlockedAchievements() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const unlocked = yield this.get('unlocked');
+            return unlocked || [];
+        });
+    }
+    setUnlockedAchievements(achievements) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.set('unlocked', achievements);
+        });
+    }
+    clear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all([
+                this.delete('metrics'),
+                this.delete('unlocked')
+            ]);
+        });
+    }
+}
+
+class RestApiStorage {
+    constructor(config) {
+        this.config = Object.assign({ timeout: 10000, headers: {} }, config);
+    }
+    /**
+     * Generic fetch wrapper with timeout and error handling
+     */
+    fetchWithTimeout(url, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+            try {
+                const response = yield fetch(url, Object.assign(Object.assign({}, options), { headers: Object.assign(Object.assign({ 'Content-Type': 'application/json' }, this.config.headers), options.headers), signal: controller.signal }));
+                clearTimeout(timeoutId);
+                if (!response.ok) {
+                    throw new SyncError(`HTTP ${response.status}: ${response.statusText}`, { statusCode: response.status });
+                }
+                return response;
+            }
+            catch (error) {
+                clearTimeout(timeoutId);
+                if (error instanceof Error && error.name === 'AbortError') {
+                    throw new SyncError('Request timeout', { timeout: this.config.timeout });
+                }
+                throw error;
+            }
+        });
+    }
+    getMetrics() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const url = `${this.config.baseUrl}/users/${this.config.userId}/achievements/metrics`;
+                const response = yield this.fetchWithTimeout(url, { method: 'GET' });
+                const data = yield response.json();
+                return data.metrics || {};
+            }
+            catch (error) {
+                // Re-throw SyncError and other AchievementErrors (but not StorageError)
+                // Multiple checks for Jest compatibility
+                const err = error;
+                if (((_a = err === null || err === void 0 ? void 0 : err.constructor) === null || _a === void 0 ? void 0 : _a.name) === 'SyncError' || (err === null || err === void 0 ? void 0 : err.name) === 'SyncError') {
+                    throw error;
+                }
+                // Also check instanceof for normal cases
+                if (error instanceof AchievementError && !(error instanceof StorageError)) {
+                    throw error;
+                }
+                throw new StorageError('Failed to fetch metrics from API', error);
+            }
+        });
+    }
+    setMetrics(metrics) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const url = `${this.config.baseUrl}/users/${this.config.userId}/achievements/metrics`;
+                yield this.fetchWithTimeout(url, {
+                    method: 'PUT',
+                    body: JSON.stringify({ metrics })
+                });
+            }
+            catch (error) {
+                const err = error;
+                if (((_a = err === null || err === void 0 ? void 0 : err.constructor) === null || _a === void 0 ? void 0 : _a.name) === 'SyncError' || (err === null || err === void 0 ? void 0 : err.name) === 'SyncError')
+                    throw error;
+                if (error instanceof AchievementError && !(error instanceof StorageError))
+                    throw error;
+                throw new StorageError('Failed to save metrics to API', error);
+            }
+        });
+    }
+    getUnlockedAchievements() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const url = `${this.config.baseUrl}/users/${this.config.userId}/achievements/unlocked`;
+                const response = yield this.fetchWithTimeout(url, { method: 'GET' });
+                const data = yield response.json();
+                return data.unlocked || [];
+            }
+            catch (error) {
+                const err = error;
+                if (((_a = err === null || err === void 0 ? void 0 : err.constructor) === null || _a === void 0 ? void 0 : _a.name) === 'SyncError' || (err === null || err === void 0 ? void 0 : err.name) === 'SyncError')
+                    throw error;
+                if (error instanceof AchievementError && !(error instanceof StorageError))
+                    throw error;
+                throw new StorageError('Failed to fetch unlocked achievements from API', error);
+            }
+        });
+    }
+    setUnlockedAchievements(achievements) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const url = `${this.config.baseUrl}/users/${this.config.userId}/achievements/unlocked`;
+                yield this.fetchWithTimeout(url, {
+                    method: 'PUT',
+                    body: JSON.stringify({ unlocked: achievements })
+                });
+            }
+            catch (error) {
+                const err = error;
+                if (((_a = err === null || err === void 0 ? void 0 : err.constructor) === null || _a === void 0 ? void 0 : _a.name) === 'SyncError' || (err === null || err === void 0 ? void 0 : err.name) === 'SyncError')
+                    throw error;
+                if (error instanceof AchievementError && !(error instanceof StorageError))
+                    throw error;
+                throw new StorageError('Failed to save unlocked achievements to API', error);
+            }
+        });
+    }
+    clear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const url = `${this.config.baseUrl}/users/${this.config.userId}/achievements`;
+                yield this.fetchWithTimeout(url, { method: 'DELETE' });
+            }
+            catch (error) {
+                const err = error;
+                if (((_a = err === null || err === void 0 ? void 0 : err.constructor) === null || _a === void 0 ? void 0 : _a.name) === 'SyncError' || (err === null || err === void 0 ? void 0 : err.name) === 'SyncError')
+                    throw error;
+                if (error instanceof AchievementError && !(error instanceof StorageError))
+                    throw error;
+                throw new StorageError('Failed to clear achievements via API', error);
+            }
+        });
+    }
+}
+
+class OfflineQueueStorage {
+    constructor(innerStorage) {
+        this.queue = [];
+        this.isOnline = typeof navigator !== 'undefined' ? navigator.onLine : true;
+        this.isSyncing = false;
+        this.queueStorageKey = 'achievements_offline_queue';
+        this.handleOnline = () => {
+            this.isOnline = true;
+            console.log('[OfflineQueue] Back online, processing queue...');
+            this.processQueue();
+        };
+        this.handleOffline = () => {
+            this.isOnline = false;
+            console.log('[OfflineQueue] Offline mode activated');
+        };
+        this.innerStorage = innerStorage;
+        // Load queued operations from localStorage
+        this.loadQueue();
+        // Listen for online/offline events (only in browser environment)
+        if (typeof window !== 'undefined') {
+            window.addEventListener('online', this.handleOnline);
+            window.addEventListener('offline', this.handleOffline);
+        }
+        // Process queue if already online
+        if (this.isOnline) {
+            this.processQueue();
+        }
+    }
+    loadQueue() {
+        try {
+            if (typeof localStorage !== 'undefined') {
+                const queueData = localStorage.getItem(this.queueStorageKey);
+                if (queueData) {
+                    this.queue = JSON.parse(queueData);
+                }
+            }
+        }
+        catch (error) {
+            console.error('Failed to load offline queue:', error);
+            this.queue = [];
+        }
+    }
+    saveQueue() {
+        try {
+            if (typeof localStorage !== 'undefined') {
+                localStorage.setItem(this.queueStorageKey, JSON.stringify(this.queue));
+            }
+        }
+        catch (error) {
+            console.error('Failed to save offline queue:', error);
+        }
+    }
+    processQueue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isSyncing || this.queue.length === 0 || !this.isOnline) {
+                return;
+            }
+            this.isSyncing = true;
+            try {
+                // Process operations in order
+                while (this.queue.length > 0 && this.isOnline) {
+                    const operation = this.queue[0];
+                    try {
+                        switch (operation.type) {
+                            case 'setMetrics':
+                                yield this.innerStorage.setMetrics(operation.data);
+                                break;
+                            case 'setUnlockedAchievements':
+                                yield this.innerStorage.setUnlockedAchievements(operation.data);
+                                break;
+                            case 'clear':
+                                yield this.innerStorage.clear();
+                                break;
+                        }
+                        // Operation succeeded, remove from queue
+                        this.queue.shift();
+                        this.saveQueue();
+                    }
+                    catch (error) {
+                        console.error('Failed to sync queued operation:', error);
+                        // Stop processing on error, will retry later
+                        break;
+                    }
+                }
+            }
+            finally {
+                this.isSyncing = false;
+            }
+        });
+    }
+    queueOperation(type, data) {
+        const operation = {
+            id: `${Date.now()}_${Math.random()}`,
+            type,
+            data,
+            timestamp: Date.now()
+        };
+        this.queue.push(operation);
+        this.saveQueue();
+        // Try to process queue if online
+        if (this.isOnline) {
+            this.processQueue();
+        }
+    }
+    getMetrics() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Reads always try to hit the server first
+            try {
+                return yield this.innerStorage.getMetrics();
+            }
+            catch (error) {
+                if (!this.isOnline) {
+                    throw new StorageError('Cannot read metrics while offline');
+                }
+                throw error;
+            }
+        });
+    }
+    setMetrics(metrics) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isOnline) {
+                try {
+                    yield this.innerStorage.setMetrics(metrics);
+                    return;
+                }
+                catch (error) {
+                    // Failed while online, queue it
+                    console.warn('Failed to set metrics, queuing for later:', error);
+                }
+            }
+            // Queue operation if offline or if online operation failed
+            this.queueOperation('setMetrics', metrics);
+        });
+    }
+    getUnlockedAchievements() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Reads always try to hit the server first
+            try {
+                return yield this.innerStorage.getUnlockedAchievements();
+            }
+            catch (error) {
+                if (!this.isOnline) {
+                    throw new StorageError('Cannot read achievements while offline');
+                }
+                throw error;
+            }
+        });
+    }
+    setUnlockedAchievements(achievements) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isOnline) {
+                try {
+                    yield this.innerStorage.setUnlockedAchievements(achievements);
+                    return;
+                }
+                catch (error) {
+                    // Failed while online, queue it
+                    console.warn('Failed to set unlocked achievements, queuing for later:', error);
+                }
+            }
+            // Queue operation if offline or if online operation failed
+            this.queueOperation('setUnlockedAchievements', achievements);
+        });
+    }
+    clear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isOnline) {
+                try {
+                    yield this.innerStorage.clear();
+                    // Also clear the queue
+                    this.queue = [];
+                    this.saveQueue();
+                    return;
+                }
+                catch (error) {
+                    console.warn('Failed to clear, queuing for later:', error);
+                }
+            }
+            // Queue operation if offline or if online operation failed
+            this.queueOperation('clear');
+        });
+    }
+    /**
+     * Manually trigger queue processing (useful for testing)
+     */
+    sync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.processQueue();
+        });
+    }
+    /**
+     * Get current queue status (useful for debugging)
+     */
+    getQueueStatus() {
+        return {
+            pending: this.queue.length,
+            operations: [...this.queue]
+        };
+    }
+    /**
+     * Cleanup listeners (call on unmount)
+     */
+    destroy() {
+        if (typeof window !== 'undefined') {
+            window.removeEventListener('online', this.handleOnline);
+            window.removeEventListener('offline', this.handleOffline);
+        }
+    }
+}
+
 const getPositionStyles = (position) => {
     const base = {
         position: 'fixed',
@@ -655,7 +1300,7 @@ function preserveMetrics(current, imported) {
 }
 
 const AchievementContext = createContext(undefined);
-const AchievementProvider = ({ achievements: achievementsConfig, storage = StorageType.Local, children, icons = {}, onError, }) => {
+const AchievementProvider = ({ achievements: achievementsConfig, storage = StorageType.Local, children, icons = {}, onError, restApiConfig, }) => {
     // Normalize the configuration to the complex format
     const achievements = normalizeAchievements(achievementsConfig);
     const [achievementState, setAchievementState] = useState({
@@ -671,19 +1316,41 @@ const AchievementProvider = ({ achievements: achievementsConfig, storage = Stora
     const [currentAchievement, setCurrentAchievement] = useState(null);
     if (!storageRef.current) {
         if (typeof storage === 'string') {
-            if (storage === StorageType.Local) {
-                storageRef.current = new LocalStorage('achievements');
+            // StorageType enum
+            switch (storage) {
+                case StorageType.Local:
+                    storageRef.current = new LocalStorage('achievements');
+                    break;
+                case StorageType.Memory:
+                    storageRef.current = new MemoryStorage();
+                    break;
+                case StorageType.IndexedDB:
+                    // Wrap async storage with adapter
+                    const indexedDB = new IndexedDBStorage('react-achievements');
+                    storageRef.current = new AsyncStorageAdapter(indexedDB, { onError });
+                    break;
+                case StorageType.RestAPI:
+                    if (!restApiConfig) {
+                        throw new ConfigurationError('restApiConfig is required when using StorageType.RestAPI');
+                    }
+                    // Wrap async storage with adapter
+                    const restApi = new RestApiStorage(restApiConfig);
+                    storageRef.current = new AsyncStorageAdapter(restApi, { onError });
+                    break;
+                default:
+                    throw new ConfigurationError(`Unsupported storage type: ${storage}`);
             }
-            else if (storage === StorageType.Memory) {
-                storageRef.current = new MemoryStorage();
+        }
+        else {
+            // Custom storage instance
+            // Check if it's async storage and wrap with adapter
+            if (isAsyncStorage(storage)) {
+                storageRef.current = new AsyncStorageAdapter(storage, { onError });
             }
             else {
-                throw new Error(`Unsupported storage type: ${storage}`);
+                storageRef.current = storage;
             }
         }
-        else {
-            storageRef.current = storage;
-        }
     }
     const storageImpl = storageRef.current;
     const getNotifiedAchievementsKey = () => {
@@ -1344,5 +2011,5 @@ class AchievementBuilder {
     }
 }
 
-export { AchievementBuilder, AchievementContext, AchievementError, AchievementProvider, BadgesButton, BadgesModal, ConfettiWrapper, ConfigurationError, ImportValidationError, LocalStorage, MemoryStorage, StorageError, StorageQuotaError, StorageType, SyncError, createConfigHash, defaultAchievementIcons, defaultStyles, exportAchievementData, importAchievementData, isAchievementError, isRecoverableError, isSimpleConfig, normalizeAchievements, useAchievements, useSimpleAchievements };
+export { AchievementBuilder, AchievementContext, AchievementError, AchievementProvider, AsyncStorageAdapter, BadgesButton, BadgesModal, ConfettiWrapper, ConfigurationError, ImportValidationError, IndexedDBStorage, LocalStorage, MemoryStorage, OfflineQueueStorage, RestApiStorage, StorageError, StorageQuotaError, StorageType, SyncError, createConfigHash, defaultAchievementIcons, defaultStyles, exportAchievementData, importAchievementData, isAchievementError, isAsyncStorage, isRecoverableError, isSimpleConfig, normalizeAchievements, useAchievements, useSimpleAchievements };
 //# sourceMappingURL=index.js.map