@buoy-gg/shared-ui 7.0.41 → 7.0.42

package/lib/module/utils/persistentStorage.js

@@ -1,603 +1 @@
-"use strict";
-
-/**
- * Persistent Storage for React Buoy DevTools
- *
- * This module provides a storage abstraction that persists independently of AsyncStorage.
- * When expo-file-system is available, it uses file-based storage that survives
- * AsyncStorage.clear() calls (e.g., during logout flows).
- *
- * Fallback hierarchy:
- * 1. FileSystem (expo-file-system) - persistent, survives AsyncStorage.clear()
- * 2. AsyncStorage - standard React Native storage
- * 3. Memory - in-memory fallback when nothing else works
- */
-
-import { devToolsStorageKeys } from "../storage/devToolsStorageKeys.js";
-
-// Web globals type declarations (for cross-platform compatibility)
-// These allow TypeScript to compile in React Native where window/localStorage don't exist
-
-// Types
-
-// Storage backend state
-
-let storageBackend = null;
-let initPromise = null;
-let initWarningShown = false;
-
-// Cached modules
-let FileSystem = null;
-let AsyncStorage = null;
-
-// Memory fallback
-const memoryStore = new Map();
-
-// Check if we're in a web environment with localStorage
-function isWebEnvironment() {
-  return typeof window !== "undefined" && window?.localStorage !== undefined;
-}
-
-// Constants
-const STORAGE_DIR_NAME = "react-buoy";
-const HEALTH_CHECK_FILE_NAME = ".health-check";
-function getStorageDir() {
-  if (!FileSystem?.documentDirectory) return null;
-  return `${FileSystem.documentDirectory}${STORAGE_DIR_NAME}/`;
-}
-
-// Android's expo-file-system resolves write paths as URIs and decodes %2F back
-// to /, which turns slashed keys into non-existent subdirectories. Escape /
-// before encodeURIComponent so the filename stays flat. JSON-Pointer-style
-// escape is collision-free: ~ -> ~0, then / -> ~1. Decode reverses ~1 -> /
-// before ~0 -> ~ so a key containing the literal "~1" round-trips correctly.
-function encodeKeyForFs(key) {
-  return encodeURIComponent(key.replace(/~/g, "~0").replace(/\//g, "~1"));
-}
-function decodeKeyFromFs(encoded) {
-  return decodeURIComponent(encoded).replace(/~1/g, "/").replace(/~0/g, "~");
-}
-function getFilePath(key) {
-  const dir = getStorageDir();
-  if (!dir) return null;
-  return `${dir}${encodeKeyForFs(key)}.json`;
-}
-
-/**
- * Try to load expo-file-system
- *
- * Note: We try the legacy import first (expo-file-system/legacy) for v19+ compatibility,
- * then fall back to the main import for older versions.
- */
-function loadFileSystem() {
-  if (FileSystem) return FileSystem;
-
-  // Try legacy import first (v19+ moved legacy functions here)
-  try {
-    const mod = require("expo-file-system/legacy");
-    FileSystem = mod?.default || mod;
-    if (FileSystem && FileSystem.documentDirectory) {
-      return FileSystem;
-    }
-    FileSystem = null;
-  } catch {
-    // Not available, try main import
-  }
-
-  // Fall back to main import (older versions or if legacy path doesn't exist)
-  try {
-    const mod = require("expo-file-system");
-    FileSystem = mod?.default || mod;
-    if (FileSystem && FileSystem.documentDirectory) {
-      return FileSystem;
-    }
-    FileSystem = null;
-  } catch {
-    // Not installed or not available
-  }
-  return null;
-}
-
-/**
- * Try to load AsyncStorage
- */
-function loadAsyncStorage() {
-  if (AsyncStorage) return AsyncStorage;
-  try {
-    const mod = require("@react-native-async-storage/async-storage");
-    AsyncStorage = mod?.default || mod;
-    if (AsyncStorage && typeof AsyncStorage.getItem === "function") {
-      return AsyncStorage;
-    }
-    AsyncStorage = null;
-  } catch {
-    // Not installed or not available
-  }
-  return null;
-}
-
-/**
- * Test if FileSystem works with CRUD operations
- */
-async function testFileSystem() {
-  const fs = loadFileSystem();
-  if (!fs || !fs.documentDirectory) {
-    return false;
-  }
-  const storageDir = getStorageDir();
-  if (!storageDir) return false;
-  const healthCheckFile = `${storageDir}${HEALTH_CHECK_FILE_NAME}`;
-  try {
-    // Ensure directory exists
-    const dirInfo = await fs.getInfoAsync(storageDir);
-    if (!dirInfo.exists) {
-      await fs.makeDirectoryAsync(storageDir, {
-        intermediates: true
-      });
-    }
-
-    // Test write
-    const testData = `health-check-${Date.now()}`;
-    await fs.writeAsStringAsync(healthCheckFile, testData);
-
-    // Test read
-    const readBack = await fs.readAsStringAsync(healthCheckFile);
-    if (readBack !== testData) {
-      return false;
-    }
-
-    // Test delete
-    await fs.deleteAsync(healthCheckFile, {
-      idempotent: true
-    });
-    return true;
-  } catch (error) {
-    console.warn("[React Buoy] FileSystem health check failed:", error);
-    return false;
-  }
-}
-
-/**
- * Migrate existing AsyncStorage keys to FileSystem
- */
-async function migrateFromAsyncStorage() {
-  const asyncStorage = loadAsyncStorage();
-  if (!asyncStorage) return;
-  try {
-    const allKeys = await asyncStorage.getAllKeys();
-    const buoyKeys = allKeys.filter(k => k.startsWith(devToolsStorageKeys.base));
-    if (buoyKeys.length === 0) {
-      return; // Nothing to migrate
-    }
-    const pairs = await asyncStorage.multiGet(buoyKeys);
-    let migratedCount = 0;
-    for (const [fullKey, value] of pairs) {
-      if (value !== null) {
-        // Store in file system (key already has the prefix)
-        await fileSystemStorage.setItem(fullKey, value);
-        migratedCount++;
-      }
-    }
-
-    // Migration complete - count is ${migratedCount} items
-    void migratedCount;
-
-    // Optionally: clean up old AsyncStorage keys after successful migration
-    // await asyncStorage.multiRemove(buoyKeys);
-  } catch (error) {
-    console.warn("[React Buoy] Migration failed:", error);
-    // Continue anyway - not critical
-  }
-}
-
-// File system storage implementation
-const fileSystemStorage = {
-  async getItem(key) {
-    const fs = loadFileSystem();
-    if (!fs) return null;
-    const filePath = getFilePath(key);
-    if (!filePath) return null;
-    try {
-      // Check if file exists before reading (best practice from Expo docs)
-      const fileInfo = await fs.getInfoAsync(filePath);
-      if (!fileInfo.exists) {
-        return null;
-      }
-      const content = await fs.readAsStringAsync(filePath);
-      return content;
-    } catch {
-      return null; // File doesn't exist or read failed
-    }
-  },
-  async setItem(key, value) {
-    const fs = loadFileSystem();
-    if (!fs) return;
-    const storageDir = getStorageDir();
-    const filePath = getFilePath(key);
-    if (!storageDir || !filePath) return;
-    try {
-      // Ensure directory exists
-      const dirInfo = await fs.getInfoAsync(storageDir);
-      if (!dirInfo.exists) {
-        await fs.makeDirectoryAsync(storageDir, {
-          intermediates: true
-        });
-      }
-      await fs.writeAsStringAsync(filePath, value);
-    } catch (error) {
-      console.warn("[React Buoy] FileSystem write failed:", error);
-    }
-  },
-  async removeItem(key) {
-    const fs = loadFileSystem();
-    if (!fs) return;
-    const filePath = getFilePath(key);
-    if (!filePath) return;
-    try {
-      await fs.deleteAsync(filePath, {
-        idempotent: true
-      });
-    } catch {
-      // Ignore if doesn't exist
-    }
-  },
-  async getAllKeys() {
-    const fs = loadFileSystem();
-    if (!fs) return [];
-    const storageDir = getStorageDir();
-    if (!storageDir) return [];
-    try {
-      const dirInfo = await fs.getInfoAsync(storageDir);
-      if (!dirInfo.exists) return [];
-      const files = await fs.readDirectoryAsync(storageDir);
-      return files.filter(f => f.endsWith(".json")).map(f => decodeKeyFromFs(f.replace(".json", "")));
-    } catch {
-      return [];
-    }
-  },
-  async multiGet(keys) {
-    const results = [];
-    for (const key of keys) {
-      const value = await this.getItem(key);
-      results.push([key, value]);
-    }
-    return results;
-  },
-  async multiRemove(keys) {
-    for (const key of keys) {
-      await this.removeItem(key);
-    }
-  },
-  async clear() {
-    const fs = loadFileSystem();
-    if (!fs) return;
-    const storageDir = getStorageDir();
-    if (!storageDir) return;
-    try {
-      await fs.deleteAsync(storageDir, {
-        idempotent: true
-      });
-    } catch {
-      // Ignore
-    }
-  }
-};
-
-// AsyncStorage adapter
-const asyncStorageAdapter = {
-  async getItem(key) {
-    const storage = loadAsyncStorage();
-    if (!storage) return memoryStore.get(key) ?? null;
-    try {
-      return await storage.getItem(key);
-    } catch {
-      return memoryStore.get(key) ?? null;
-    }
-  },
-  async setItem(key, value) {
-    const storage = loadAsyncStorage();
-    if (!storage) {
-      memoryStore.set(key, value);
-      return;
-    }
-    try {
-      await storage.setItem(key, value);
-    } catch {
-      memoryStore.set(key, value);
-    }
-  },
-  async removeItem(key) {
-    const storage = loadAsyncStorage();
-    memoryStore.delete(key);
-    if (!storage) return;
-    try {
-      await storage.removeItem(key);
-    } catch {
-      // Ignore
-    }
-  },
-  async getAllKeys() {
-    const storage = loadAsyncStorage();
-    if (!storage) return Array.from(memoryStore.keys());
-    try {
-      const keys = await storage.getAllKeys();
-      return keys.filter(k => k.startsWith(devToolsStorageKeys.base));
-    } catch {
-      return Array.from(memoryStore.keys());
-    }
-  },
-  async multiGet(keys) {
-    const storage = loadAsyncStorage();
-    if (!storage) {
-      return keys.map(k => [k, memoryStore.get(k) ?? null]);
-    }
-    try {
-      const results = await storage.multiGet(keys);
-      return results;
-    } catch {
-      return keys.map(k => [k, memoryStore.get(k) ?? null]);
-    }
-  },
-  async multiRemove(keys) {
-    keys.forEach(k => memoryStore.delete(k));
-    const storage = loadAsyncStorage();
-    if (!storage) return;
-    try {
-      await storage.multiRemove(keys);
-    } catch {
-      // Ignore
-    }
-  },
-  async clear() {
-    memoryStore.clear();
-    const storage = loadAsyncStorage();
-    if (!storage) return;
-    try {
-      const allKeys = await storage.getAllKeys();
-      const buoyKeys = allKeys.filter(k => k.startsWith(devToolsStorageKeys.base));
-      if (buoyKeys.length > 0) {
-        await storage.multiRemove(buoyKeys);
-      }
-    } catch {
-      // Ignore
-    }
-  }
-};
-
-// localStorage adapter (for web environments)
-const localStorageAdapter = {
-  async getItem(key) {
-    if (!isWebEnvironment()) return memoryStore.get(key) ?? null;
-    try {
-      return window.localStorage.getItem(key);
-    } catch {
-      return memoryStore.get(key) ?? null;
-    }
-  },
-  async setItem(key, value) {
-    if (!isWebEnvironment()) {
-      memoryStore.set(key, value);
-      return;
-    }
-    try {
-      window.localStorage.setItem(key, value);
-    } catch {
-      memoryStore.set(key, value);
-    }
-  },
-  async removeItem(key) {
-    memoryStore.delete(key);
-    if (!isWebEnvironment()) return;
-    try {
-      window.localStorage.removeItem(key);
-    } catch {
-      // Ignore
-    }
-  },
-  async getAllKeys() {
-    if (!isWebEnvironment()) return Array.from(memoryStore.keys());
-    try {
-      const keys = [];
-      const storage = window.localStorage;
-      for (let i = 0; i < storage.length; i++) {
-        const key = storage.key(i);
-        if (key && key.startsWith(devToolsStorageKeys.base)) {
-          keys.push(key);
-        }
-      }
-      return keys;
-    } catch {
-      return Array.from(memoryStore.keys());
-    }
-  },
-  async multiGet(keys) {
-    const results = [];
-    for (const key of keys) {
-      const value = await this.getItem(key);
-      results.push([key, value]);
-    }
-    return results;
-  },
-  async multiRemove(keys) {
-    for (const key of keys) {
-      await this.removeItem(key);
-    }
-  },
-  async clear() {
-    memoryStore.clear();
-    if (!isWebEnvironment()) return;
-    try {
-      const keys = await this.getAllKeys();
-      const storage = window.localStorage;
-      for (const key of keys) {
-        storage.removeItem(key);
-      }
-    } catch {
-      // Ignore
-    }
-  }
-};
-
-// Memory-only storage
-const memoryStorage = {
-  async getItem(key) {
-    return memoryStore.get(key) ?? null;
-  },
-  async setItem(key, value) {
-    memoryStore.set(key, value);
-  },
-  async removeItem(key) {
-    memoryStore.delete(key);
-  },
-  async getAllKeys() {
-    return Array.from(memoryStore.keys());
-  },
-  async multiGet(keys) {
-    return keys.map(k => [k, memoryStore.get(k) ?? null]);
-  },
-  async multiRemove(keys) {
-    keys.forEach(k => memoryStore.delete(k));
-  },
-  async clear() {
-    memoryStore.clear();
-  }
-};
-
-/**
- * Initialize storage - determines which backend to use
- *
- * Fallback hierarchy:
- * 1. FileSystem (expo-file-system) - persistent, survives AsyncStorage.clear()
- * 2. AsyncStorage - standard React Native storage
- * 3. localStorage - web browser storage
- * 4. Memory - in-memory fallback when nothing else works
- */
-async function initStorage() {
-  // Only run once
-  if (storageBackend !== null) return;
-
-  // Test FileSystem first (React Native with expo-file-system)
-  const fileSystemWorks = await testFileSystem();
-  if (fileSystemWorks) {
-    // Check if we need to migrate from AsyncStorage
-    const existingFiles = await fileSystemStorage.getAllKeys();
-    if (existingFiles.length === 0) {
-      // Empty file storage - check for AsyncStorage data to migrate
-      await migrateFromAsyncStorage();
-    }
-    storageBackend = "filesystem";
-  } else if (isWebEnvironment()) {
-    // Prefer localStorage on web (marketing site, RN-web, Electron renderer)
-    // BEFORE AsyncStorage. Hosts often alias AsyncStorage to a demo/remote
-    // shim that must not own buoy prefs — and must not trip the "fallback"
-    // warning on every page load.
-    storageBackend = "localstorage";
-  } else {
-    // Try AsyncStorage (React Native)
-    const asyncStorage = loadAsyncStorage();
-    if (asyncStorage) {
-      storageBackend = "asyncstorage";
-      if (!initWarningShown) {
-        initWarningShown = true;
-        console.warn("[React Buoy] Using AsyncStorage fallback. " + "Settings may be lost if AsyncStorage is cleared. " + "Install expo-file-system for persistent storage.");
-      }
-    } else {
-      storageBackend = "memory";
-      if (!initWarningShown) {
-        initWarningShown = true;
-        console.warn("[React Buoy] Using in-memory storage. " + "Settings will be lost on app restart.");
-      }
-    }
-  }
-}
-
-/**
- * Ensure init runs before any storage operation
- */
-function ensureInit() {
-  if (!initPromise) {
-    initPromise = initStorage();
-  }
-  return initPromise;
-}
-
-/**
- * Get the current storage implementation based on detected backend
- */
-function getStorage() {
-  switch (storageBackend) {
-    case "filesystem":
-      return fileSystemStorage;
-    case "asyncstorage":
-      return asyncStorageAdapter;
-    case "localstorage":
-      return localStorageAdapter;
-    case "memory":
-    default:
-      return memoryStorage;
-  }
-}
-
-/**
- * Persistent storage for React Buoy DevTools
- *
- * Uses FileSystem when available (survives AsyncStorage.clear()),
- * falls back to AsyncStorage, then localStorage (web), then memory.
- *
- * Same API as AsyncStorage for easy migration.
- */
-export const persistentStorage = {
-  async getItem(key) {
-    await ensureInit();
-    return getStorage().getItem(key);
-  },
-  async setItem(key, value) {
-    await ensureInit();
-    return getStorage().setItem(key, value);
-  },
-  async removeItem(key) {
-    await ensureInit();
-    return getStorage().removeItem(key);
-  },
-  async getAllKeys() {
-    await ensureInit();
-    return getStorage().getAllKeys();
-  },
-  async multiGet(keys) {
-    await ensureInit();
-    return getStorage().multiGet(keys);
-  },
-  async multiRemove(keys) {
-    await ensureInit();
-    return getStorage().multiRemove(keys);
-  },
-  async clear() {
-    await ensureInit();
-    return getStorage().clear();
-  }
-};
-
-/**
- * Check if persistent storage (FileSystem) is being used
- */
-export async function isUsingPersistentStorage() {
-  await ensureInit();
-  return storageBackend === "filesystem";
-}
-
-/**
- * Get the current storage backend type
- */
-export async function getStorageBackendType() {
-  await ensureInit();
-  return storageBackend ?? "memory";
-}
-
-/**
- * Force re-initialization of storage (useful for testing)
- */
-export function resetStorageInit() {
-  storageBackend = null;
-  initPromise = null;
-  initWarningShown = false;
-}
+"use strict";import{devToolsStorageKeys as h}from"../storage/devToolsStorageKeys.js";let i=null;let I=null;let w=false;let o=null;let y=null;const n=new Map;function m(){return typeof window!=="undefined"&&window?.localStorage!==void 0}const v="react-buoy";const K=".health-check";function d(){if(!o?.documentDirectory)return null;return`${o.documentDirectory}${v}/`}function R(t){return encodeURIComponent(t.replace(/~/g,"~0").replace(/\//g,"~1"))}function D(t){return decodeURIComponent(t).replace(/~1/g,"/").replace(/~0/g,"~")}function A(t){const e=d();if(!e)return null;return`${e}${R(t)}.json`}function g(){if(o)return o;try{const t=require("expo-file-system/legacy");o=t?.default||t;if(o&&o.documentDirectory){return o}o=null}catch{}try{const t=require("expo-file-system");o=t?.default||t;if(o&&o.documentDirectory){return o}o=null}catch{}return null}function l(){if(y)return y;try{const t=require("@react-native-async-storage/async-storage");y=t?.default||t;if(y&&typeof y.getItem==="function"){return y}y=null}catch{}return null}async function F(){const t=g();if(!t||!t.documentDirectory){return false}const e=d();if(!e)return false;const r=`${e}${K}`;try{const a=await t.getInfoAsync(e);if(!a.exists){await t.makeDirectoryAsync(e,{intermediates:true})}const s=`health-check-${Date.now()}`;await t.writeAsStringAsync(r,s);const c=await t.readAsStringAsync(r);if(c!==s){return false}await t.deleteAsync(r,{idempotent:true});return true}catch(a){console.warn("[React Buoy] FileSystem health check failed:",a);return false}}async function x(){const t=l();if(!t)return;try{const e=await t.getAllKeys();const r=e.filter(c=>c.startsWith(h.base));if(r.length===0){return}const a=await t.multiGet(r);let s=0;for(const[c,p]of a){if(p!==null){await S.setItem(c,p);s++}}void s}catch(e){console.warn("[React Buoy] Migration failed:",e)}}const S={async getItem(t){const e=g();if(!e)return null;const r=A(t);if(!r)return null;try{const a=await e.getInfoAsync(r);if(!a.exists){return null}const s=await e.readAsStringAsync(r);return s}catch{return null}},async setItem(t,e){const r=g();if(!r)return;const a=d();const s=A(t);if(!a||!s)return;try{const c=await r.getInfoAsync(a);if(!c.exists){await r.makeDirectoryAsync(a,{intermediates:true})}await r.writeAsStringAsync(s,e)}catch(c){console.warn("[React Buoy] FileSystem write failed:",c)}},async removeItem(t){const e=g();if(!e)return;const r=A(t);if(!r)return;try{await e.deleteAsync(r,{idempotent:true})}catch{}},async getAllKeys(){const t=g();if(!t)return[];const e=d();if(!e)return[];try{const r=await t.getInfoAsync(e);if(!r.exists)return[];const a=await t.readDirectoryAsync(e);return a.filter(s=>s.endsWith(".json")).map(s=>D(s.replace(".json","")))}catch{return[]}},async multiGet(t){const e=[];for(const r of t){const a=await this.getItem(r);e.push([r,a])}return e},async multiRemove(t){for(const e of t){await this.removeItem(e)}},async clear(){const t=g();if(!t)return;const e=d();if(!e)return;try{await t.deleteAsync(e,{idempotent:true})}catch{}}};const b={async getItem(t){const e=l();if(!e)return n.get(t)??null;try{return await e.getItem(t)}catch{return n.get(t)??null}},async setItem(t,e){const r=l();if(!r){n.set(t,e);return}try{await r.setItem(t,e)}catch{n.set(t,e)}},async removeItem(t){const e=l();n.delete(t);if(!e)return;try{await e.removeItem(t)}catch{}},async getAllKeys(){const t=l();if(!t)return Array.from(n.keys());try{const e=await t.getAllKeys();return e.filter(r=>r.startsWith(h.base))}catch{return Array.from(n.keys())}},async multiGet(t){const e=l();if(!e){return t.map(r=>[r,n.get(r)??null])}try{const r=await e.multiGet(t);return r}catch{return t.map(r=>[r,n.get(r)??null])}},async multiRemove(t){t.forEach(r=>n.delete(r));const e=l();if(!e)return;try{await e.multiRemove(t)}catch{}},async clear(){n.clear();const t=l();if(!t)return;try{const e=await t.getAllKeys();const r=e.filter(a=>a.startsWith(h.base));if(r.length>0){await t.multiRemove(r)}}catch{}}};const k={async getItem(t){if(!m())return n.get(t)??null;try{return window.localStorage.getItem(t)}catch{return n.get(t)??null}},async setItem(t,e){if(!m()){n.set(t,e);return}try{window.localStorage.setItem(t,e)}catch{n.set(t,e)}},async removeItem(t){n.delete(t);if(!m())return;try{window.localStorage.removeItem(t)}catch{}},async getAllKeys(){if(!m())return Array.from(n.keys());try{const t=[];const e=window.localStorage;for(let r=0;r<e.length;r++){const a=e.key(r);if(a&&a.startsWith(h.base)){t.push(a)}}return t}catch{return Array.from(n.keys())}},async multiGet(t){const e=[];for(const r of t){const a=await this.getItem(r);e.push([r,a])}return e},async multiRemove(t){for(const e of t){await this.removeItem(e)}},async clear(){n.clear();if(!m())return;try{const t=await this.getAllKeys();const e=window.localStorage;for(const r of t){e.removeItem(r)}}catch{}}};const E={async getItem(t){return n.get(t)??null},async setItem(t,e){n.set(t,e)},async removeItem(t){n.delete(t)},async getAllKeys(){return Array.from(n.keys())},async multiGet(t){return t.map(e=>[e,n.get(e)??null])},async multiRemove(t){t.forEach(e=>n.delete(e))},async clear(){n.clear()}};async function G(){if(i!==null)return;const t=await F();if(t){const e=await S.getAllKeys();if(e.length===0){await x()}i="filesystem"}else if(m()){i="localstorage"}else{const e=l();if(e){i="asyncstorage";if(!w){w=true;console.warn("[React Buoy] Using AsyncStorage fallback. Settings may be lost if AsyncStorage is cleared. Install expo-file-system for persistent storage.")}}else{i="memory";if(!w){w=true;console.warn("[React Buoy] Using in-memory storage. Settings will be lost on app restart.")}}}}function u(){if(!I){I=G()}return I}function f(){switch(i){case"filesystem":return S;case"asyncstorage":return b;case"localstorage":return k;case"memory":default:return E}}export const persistentStorage={async getItem(t){await u();return f().getItem(t)},async setItem(t,e){await u();return f().setItem(t,e)},async removeItem(t){await u();return f().removeItem(t)},async getAllKeys(){await u();return f().getAllKeys()},async multiGet(t){await u();return f().multiGet(t)},async multiRemove(t){await u();return f().multiRemove(t)},async clear(){await u();return f().clear()}};export async function isUsingPersistentStorage(){await u();return i==="filesystem"}export async function getStorageBackendType(){await u();return i??"memory"}export function resetStorageInit(){i=null;I=null;w=false}

package/lib/module/utils/persistentStorage.web.js

@@ -1,72 +1 @@
-"use strict";
-
-import { devToolsStorageKeys } from "../storage/devToolsStorageKeys.js";
-// Retain writes if storage is blocked or full. Null entries mask failed removals.
-const pending = new Map();
-function storage() {
-  try {
-    return typeof window === "undefined" ? null : window.localStorage;
-  } catch {
-    return null;
-  }
-}
-export const persistentStorage = {
-  async getItem(key) {
-    if (pending.has(key)) return pending.get(key) ?? null;
-    try {
-      return storage()?.getItem(key) ?? null;
-    } catch {
-      return null;
-    }
-  },
-  async setItem(key, value) {
-    pending.set(key, value);
-    try {
-      const backend = storage();
-      if (backend) {
-        backend.setItem(key, value);
-        pending.delete(key);
-      }
-    } catch {/* Keep the value for this session. */}
-  },
-  async removeItem(key) {
-    pending.set(key, null);
-    try {
-      const backend = storage();
-      if (backend) {
-        backend.removeItem(key);
-        pending.delete(key);
-      }
-    } catch {/* Keep the removal for this session. */}
-  },
-  async getAllKeys() {
-    const keys = new Set();
-    try {
-      const backend = storage();
-      if (backend) for (let i = 0; i < backend.length; i++) {
-        const key = backend.key(i);
-        if (key?.startsWith(devToolsStorageKeys.base)) keys.add(key);
-      }
-    } catch {/* Pending entries remain available. */}
-    for (const [key, value] of pending) {
-      if (!key.startsWith(devToolsStorageKeys.base)) continue;
-      if (value === null) keys.delete(key);else keys.add(key);
-    }
-    return [...keys];
-  },
-  async multiGet(keys) {
-    return Promise.all(keys.map(async key => [key, await persistentStorage.getItem(key)]));
-  },
-  async multiRemove(keys) {
-    await Promise.all(keys.map(key => persistentStorage.removeItem(key)));
-  },
-  async clear() {
-    await persistentStorage.multiRemove(await persistentStorage.getAllKeys());
-  }
-};
-export async function isUsingPersistentStorage() {
-  return storage() !== null;
-}
-export async function getStorageBackendType() {
-  return storage() ? "localstorage" : "memory";
-}
+"use strict";import{devToolsStorageKeys as o}from"../storage/devToolsStorageKeys.js";const a=new Map;function r(){try{return typeof window==="undefined"?null:window.localStorage}catch{return null}}export const persistentStorage={async getItem(t){if(a.has(t))return a.get(t)??null;try{return r()?.getItem(t)??null}catch{return null}},async setItem(t,e){a.set(t,e);try{const n=r();if(n){n.setItem(t,e);a.delete(t)}}catch{}},async removeItem(t){a.set(t,null);try{const e=r();if(e){e.removeItem(t);a.delete(t)}}catch{}},async getAllKeys(){const t=new Set;try{const e=r();if(e)for(let n=0;n<e.length;n++){const s=e.key(n);if(s?.startsWith(o.base))t.add(s)}}catch{}for(const[e,n]of a){if(!e.startsWith(o.base))continue;if(n===null)t.delete(e);else t.add(e)}return[...t]},async multiGet(t){return Promise.all(t.map(async e=>[e,await persistentStorage.getItem(e)]))},async multiRemove(t){await Promise.all(t.map(e=>persistentStorage.removeItem(e)))},async clear(){await persistentStorage.multiRemove(await persistentStorage.getAllKeys())}};export async function isUsingPersistentStorage(){return r()!==null}export async function getStorageBackendType(){return r()?"localstorage":"memory"}

package/lib/module/utils/realNow.js

@@ -0,0 +1 @@
+"use strict";export function realNow(){const o=globalThis.__buoyRealNow;return typeof o==="function"?o():Date.now()}