@buoy-gg/storage 7.0.40 → 7.0.42

package/lib/module/storage/utils/AsyncStorageListener.js

@@ -1,679 +1 @@
-"use strict";
-
-import { asyncStorage as AsyncStorage, asyncStorageCaps, readMany } from "./asyncStorageCompat";
-
-// AsyncStorage method signatures - matching the actual AsyncStorage API
-
-// v3-only batch methods (replace multiSet/multiRemove)
-
-/**
- * The pristine (un-swizzled) AsyncStorage methods, stashed on globalThis under a
- * cross-realm Symbol.
- *
- * Why this exists: the listener below is a module-scope singleton. Metro Fast
- * Refresh re-evaluates the module and builds a NEW instance whose `original*`
- * fields are all null — but `AsyncStorage.setItem` still points at the OLD
- * instance's `swizzled_setItem`. Without a stash, `initialize()` sees the
- * existing swizzle, has no way to recover the real methods, and bails; the
- * listener then never attaches, so storage events stop for the rest of the
- * session (writes still work, they just go unrecorded). Keeping the originals
- * off the instance lets a fresh instance re-attach cleanly.
- */
-
-const ORIGINALS_KEY = Symbol.for("@buoy-gg/storage.asyncStorageOriginals");
-function readStashedOriginals() {
-  return globalThis[ORIGINALS_KEY] ?? null;
-}
-function stashOriginals(originals) {
-  globalThis[ORIGINALS_KEY] = originals;
-}
-
-// Event types for AsyncStorage operations
-
-/**
- * Singleton class for intercepting and monitoring AsyncStorage operations
- *
- * This class uses method swizzling to intercept all AsyncStorage operations
- * (setItem, removeItem, mergeItem, clear, multiSet, multiRemove, multiMerge)
- * and emits events to registered listeners. It maintains the original functionality
- * while providing observability for debugging and development tools.
- *
- * Supports both async-storage v2 (multiGet/multiSet/multiRemove/mergeItem) and
- * v3 (getMany/setMany/removeMany, no merge). On v3 the renamed batch methods are
- * swizzled and normalized back to the same v2-shaped events, so the rest of the
- * tool — event store, time-travel, desktop sync — is version-agnostic. v3 dropped
- * the merge API entirely, so no merge events can occur there.
- *
- * @example
- * ```typescript
- * // Start listening to all AsyncStorage operations
- * startListening();
- *
- * // Add a listener for storage events
- * const unsubscribe = addListener((event) => {
- *   console.log(`${event.action}:`, event.data);
- * });
- *
- * // Clean up
- * unsubscribe();
- * stopListening();
- * ```
- *
- * @performance Uses method interception rather than polling for zero-overhead when inactive
- * @performance Includes key filtering to prevent dev tools from triggering self-events
- */
-class AsyncStorageListener {
-  listeners = [];
-  isListening = false;
-  isInitialized = false;
-  isPaused = false;
-
-  // Keys to ignore for dev tools to prevent self-triggering
-  // Only ignore specific keys that would cause infinite loops in the storage browser
-  ignoredKeys = new Set(["@react_buoy_storage_event_filters",
-  // Storage events filter settings
-  "@react_buoy_storage_key_filters",
-  // Storage browser key filters
-  "@react_buoy_storage_is_monitoring",
-  // Storage monitoring toggle
-  "REACT_QUERY_OFFLINE_CACHE" // React Query cache
-  ]);
-
-  // Store original methods
-  originalSetItem = null;
-  originalRemoveItem = null;
-  originalMergeItem = null;
-  originalClear = null;
-  // v2 batch originals
-  originalMultiSet = null;
-  originalMultiRemove = null;
-  originalMultiMerge = null;
-  // v3 batch originals
-  originalSetMany = null;
-  originalRemoveMany = null;
-
-  /**
-   * Determines if a storage key should be ignored to prevent infinite loops
-   *
-   * Dev tools often store their own state in AsyncStorage, which would trigger
-   * events and cause infinite loops or unnecessary noise.
-   *
-   * @param key - The storage key to check
-   * @returns True if the key should be ignored, false otherwise
-   */
-  shouldIgnoreKey(key) {
-    // Check exact matches
-    if (this.ignoredKeys.has(key)) return true;
-
-    // Check prefix matches
-    for (const ignoredKey of this.ignoredKeys) {
-      if (key.startsWith(ignoredKey)) return true;
-    }
-    return false;
-  }
-
-  /**
-   * Copy a set of pristine methods onto this instance's `original*` fields.
-   *
-   * Used both when capturing them for the first time and when adopting the
-   * global stash after a Fast Refresh, so `restoreOriginalMethods()` and the
-   * swizzles always have real methods to call through to.
-   */
-  adoptOriginals(originals) {
-    this.originalSetItem = originals.setItem;
-    this.originalRemoveItem = originals.removeItem;
-    this.originalClear = originals.clear;
-    this.originalMergeItem = originals.mergeItem;
-    this.originalMultiSet = originals.multiSet;
-    this.originalMultiRemove = originals.multiRemove;
-    this.originalMultiMerge = originals.multiMerge;
-    this.originalSetMany = originals.setMany;
-    this.originalRemoveMany = originals.removeMany;
-  }
-
-  /**
-   * Initialize the listener by loading AsyncStorage and storing original methods
-   *
-   * This method performs safety checks to ensure we don't double-initialize
-   * and verifies that AsyncStorage methods haven't already been swizzled.
-   *
-   * @returns Promise<boolean> - True if initialization succeeded, false otherwise
-   *
-   * @throws Will log errors if AsyncStorage is already swizzled by another instance
-   */
-  async initialize() {
-    if (this.isInitialized) {
-      // Already initialized - skipping
-      return true;
-    }
-
-    // Already swizzled — by a previous instance of this class that Fast Refresh
-    // replaced, or by a duplicate copy of the package. Adopt the stashed
-    // originals so this instance can restore + re-swizzle. Bailing here is what
-    // used to kill storage events until a full app reload.
-    if (AsyncStorage.setItem.name === "swizzled_setItem") {
-      const stashed = readStashedOriginals();
-      if (!stashed) {
-        // Swizzled by something we didn't install and whose originals we never
-        // captured — taking the current methods as "originals" would bake the
-        // foreign swizzle in permanently, so stay out of the way.
-        return false;
-      }
-      this.adoptOriginals(stashed);
-      this.isInitialized = true;
-      return true;
-    }
-
-    // Store original methods (these should be the real AsyncStorage methods).
-    // Single-item + clear are identical across v2/v3.
-    const originals = {
-      setItem: AsyncStorage.setItem.bind(AsyncStorage),
-      removeItem: AsyncStorage.removeItem.bind(AsyncStorage),
-      clear: AsyncStorage.clear.bind(AsyncStorage),
-      mergeItem: null,
-      multiSet: null,
-      multiRemove: null,
-      multiMerge: null,
-      setMany: null,
-      removeMany: null
-    };
-    if (asyncStorageCaps.hasLegacyMultiApi) {
-      // v2: multiSet/multiRemove + merge API
-      originals.multiSet = AsyncStorage.multiSet.bind(AsyncStorage);
-      originals.multiRemove = AsyncStorage.multiRemove.bind(AsyncStorage);
-      originals.mergeItem = AsyncStorage.mergeItem.bind(AsyncStorage);
-      originals.multiMerge = AsyncStorage.multiMerge ? AsyncStorage.multiMerge.bind(AsyncStorage) : null;
-    } else {
-      // v3: setMany/removeMany; merge API was removed (nothing to capture)
-      originals.setMany = AsyncStorage.setMany.bind(AsyncStorage);
-      originals.removeMany = AsyncStorage.removeMany.bind(AsyncStorage);
-    }
-
-    // Keep them reachable across a module re-evaluation, then adopt.
-    stashOriginals(originals);
-    this.adoptOriginals(originals);
-
-    // Original methods stored successfully
-    this.isInitialized = true;
-    return true;
-  }
-
-  /**
-   * Restore original AsyncStorage methods to their unmodified state
-   *
-   * This method undoes the method swizzling by restoring the original
-   * AsyncStorage methods that were saved during initialization.
-   */
-  restoreOriginalMethods() {
-    if (!AsyncStorage || !this.originalSetItem) {
-      return;
-    }
-    AsyncStorage.setItem = this.originalSetItem;
-    if (this.originalRemoveItem) {
-      AsyncStorage.removeItem = this.originalRemoveItem;
-    }
-    if (this.originalClear) {
-      AsyncStorage.clear = this.originalClear;
-    }
-    // v2 batch + merge
-    if (this.originalMergeItem) {
-      AsyncStorage.mergeItem = this.originalMergeItem;
-    }
-    if (this.originalMultiSet) {
-      AsyncStorage.multiSet = this.originalMultiSet;
-    }
-    if (this.originalMultiRemove) {
-      AsyncStorage.multiRemove = this.originalMultiRemove;
-    }
-    if (this.originalMultiMerge) {
-      AsyncStorage.multiMerge = this.originalMultiMerge;
-    }
-    // v3 batch
-    if (this.originalSetMany) {
-      AsyncStorage.setMany = this.originalSetMany;
-    }
-    if (this.originalRemoveMany) {
-      AsyncStorage.removeMany = this.originalRemoveMany;
-    }
-  }
-
-  /**
-   * Emit an AsyncStorage event to all registered listeners
-   *
-   * @param event - The AsyncStorage event to emit
-   *
-   * @performance Skips processing when no listeners are registered or when paused
-   */
-  emit(event) {
-    // Skip emitting if paused (used during time-travel operations)
-    if (this.isPaused) {
-      return;
-    }
-
-    // Skip emitting if there are no listeners
-    if (this.listeners.length === 0) {
-      return;
-    }
-    this.listeners.forEach(listener => {
-      try {
-        listener(event);
-      } catch (error) {
-        // Error in event listener - continuing with others
-      }
-    });
-  }
-
-  /**
-   * Shared core for batch writes (v2 multiSet/multiMerge, v3 setMany).
-   *
-   * Captures previous values for the affected keys, runs the original native
-   * operation, and emits a normalized event. `action` distinguishes a plain set
-   * from a merge so time-travel can replay them differently.
-   */
-  async handleBatchSet(pairs, runOriginal, action = "multiSet") {
-    // Filter out ignored keys
-    const filteredPairs = pairs.filter(([key]) => !this.shouldIgnoreKey(key));
-    if (filteredPairs.length === 0) {
-      return runOriginal();
-    }
-
-    // Capture previous values for all keys being written
-    const keysToSet = filteredPairs.map(([key]) => key);
-    let prevPairs = [];
-    try {
-      prevPairs = await readMany(keysToSet);
-    } catch {
-      // Failed to capture previous values
-    }
-
-    // Execute the operation
-    const result = await runOriginal();
-
-    // Emit event with previous values
-    this.emit({
-      action,
-      timestamp: new Date(),
-      data: {
-        pairs: filteredPairs,
-        prevPairs
-      }
-    });
-    return result;
-  }
-
-  /**
-   * Shared core for batch removals (v2 multiRemove, v3 removeMany).
-   */
-  async handleBatchRemove(keys, runOriginal) {
-    // Filter out ignored keys
-    const filteredKeys = keys.filter(key => !this.shouldIgnoreKey(key));
-    if (filteredKeys.length === 0) {
-      return runOriginal();
-    }
-
-    // Capture previous values for all keys being removed
-    let prevPairs = [];
-    try {
-      prevPairs = await readMany(filteredKeys);
-    } catch {
-      // Failed to capture previous values
-    }
-
-    // Execute the operation
-    const result = await runOriginal();
-
-    // Emit event with previous values
-    this.emit({
-      action: "multiRemove",
-      timestamp: new Date(),
-      data: {
-        keys: filteredKeys,
-        prevPairs
-      }
-    });
-    return result;
-  }
-
-  /**
-   * Start intercepting AsyncStorage operations by swizzling methods
-   *
-   * This method replaces all AsyncStorage methods with wrapped versions
-   * that emit events while preserving the original functionality.
-   *
-   * @throws Will log errors if initialization fails or methods are already swizzled
-   *
-   * @performance Uses method swizzling for minimal runtime overhead
-   * @performance Includes safety checks to prevent double-initialization
-   */
-  async startListening() {
-    if (this.isListening) {
-      return;
-    }
-    const initialized = await this.initialize();
-    if (!initialized) {
-      return;
-    }
-
-    // Check if methods are already swizzled (this can happen if initialize was called twice somehow)
-    if (AsyncStorage && AsyncStorage.setItem.name === "swizzled_setItem") {
-      this.restoreOriginalMethods();
-    }
-
-    // Starting to listen for AsyncStorage operations
-
-    // Swizzle setItem
-    const swizzled_setItem = async (key, value) => {
-      // Only capture and emit if key is not ignored
-      if (!this.shouldIgnoreKey(key)) {
-        // Capture previous value before the operation
-        const prevValue = this.originalSetItem ? await AsyncStorage.getItem(key) : null;
-
-        // Execute the operation
-        const result = this.originalSetItem ? await this.originalSetItem(key, value) : undefined;
-
-        // Emit event with previous value
-        this.emit({
-          action: "setItem",
-          timestamp: new Date(),
-          data: {
-            key,
-            value,
-            prevValue
-          }
-        });
-        return result;
-      }
-      return this.originalSetItem ? this.originalSetItem(key, value) : Promise.resolve();
-    };
-    Object.defineProperty(swizzled_setItem, "name", {
-      value: "swizzled_setItem"
-    });
-    if (AsyncStorage) {
-      AsyncStorage.setItem = swizzled_setItem;
-    }
-
-    // Swizzle removeItem
-    if (AsyncStorage) {
-      AsyncStorage.removeItem = async key => {
-        // Only capture and emit if key is not ignored
-        if (!this.shouldIgnoreKey(key)) {
-          // Capture previous value before the operation
-          const prevValue = this.originalRemoveItem ? await AsyncStorage.getItem(key) : null;
-
-          // Execute the operation
-          const result = this.originalRemoveItem ? await this.originalRemoveItem(key) : undefined;
-
-          // Emit event with previous value
-          this.emit({
-            action: "removeItem",
-            timestamp: new Date(),
-            data: {
-              key,
-              prevValue
-            }
-          });
-          return result;
-        }
-        return this.originalRemoveItem ? this.originalRemoveItem(key) : Promise.resolve();
-      };
-    }
-
-    // Swizzle mergeItem (v2 only — v3 removed the merge API)
-    if (asyncStorageCaps.hasMergeApi && AsyncStorage) {
-      AsyncStorage.mergeItem = async (key, value) => {
-        // Only capture and emit if key is not ignored
-        if (!this.shouldIgnoreKey(key)) {
-          // Capture previous value before the operation
-          const prevValue = this.originalMergeItem ? await AsyncStorage.getItem(key) : null;
-
-          // Execute the operation
-          const result = this.originalMergeItem ? await this.originalMergeItem(key, value) : undefined;
-
-          // Emit event with previous value
-          this.emit({
-            action: "mergeItem",
-            timestamp: new Date(),
-            data: {
-              key,
-              value,
-              prevValue
-            }
-          });
-          return result;
-        }
-        return this.originalMergeItem ? this.originalMergeItem(key, value) : Promise.resolve();
-      };
-    }
-
-    // Swizzle clear
-    if (AsyncStorage) {
-      AsyncStorage.clear = async () => {
-        // Capture all key-value pairs before clearing
-        let prevPairs = [];
-        try {
-          const allKeys = await AsyncStorage.getAllKeys();
-          // Filter out ignored keys
-          const keysToCapture = allKeys.filter(key => !this.shouldIgnoreKey(key));
-          if (keysToCapture.length > 0) {
-            prevPairs = await readMany(keysToCapture);
-          }
-        } catch {
-          // Failed to capture previous state
-        }
-
-        // Execute the operation
-        const result = this.originalClear ? await this.originalClear() : undefined;
-
-        // Emit event with previous pairs
-        this.emit({
-          action: "clear",
-          timestamp: new Date(),
-          data: {
-            prevPairs
-          }
-        });
-        return result;
-      };
-    }
-
-    // Swizzle the batch methods for whichever API the installed version exposes.
-    if (asyncStorageCaps.hasLegacyMultiApi && AsyncStorage) {
-      // ── v2: multiSet / multiRemove / multiMerge ──
-      AsyncStorage.multiSet = keyValuePairs => this.handleBatchSet(keyValuePairs, () => this.originalMultiSet ? this.originalMultiSet(keyValuePairs) : Promise.resolve());
-      AsyncStorage.multiRemove = keys => this.handleBatchRemove(keys, () => this.originalMultiRemove ? this.originalMultiRemove(keys) : Promise.resolve());
-      if (this.originalMultiMerge) {
-        AsyncStorage.multiMerge = keyValuePairs => this.handleBatchSet(keyValuePairs, () => this.originalMultiMerge ? this.originalMultiMerge(keyValuePairs) : Promise.resolve(), "multiMerge");
-      }
-    } else if (AsyncStorage) {
-      // ── v3: setMany / removeMany (normalized back to multiSet/multiRemove events) ──
-      AsyncStorage.setMany = entries => this.handleBatchSet(Object.entries(entries), () => this.originalSetMany ? this.originalSetMany(entries) : Promise.resolve());
-      AsyncStorage.removeMany = keys => this.handleBatchRemove(keys, () => this.originalRemoveMany ? this.originalRemoveMany(keys) : Promise.resolve());
-    }
-    this.isListening = true;
-    // Started listening successfully
-  }
-
-  /**
-   * Stop listening and restore original AsyncStorage methods
-   *
-   * This method undoes all method swizzling and restores AsyncStorage
-   * to its original state.
-   */
-  stopListening() {
-    if (!this.isListening) {
-      return;
-    }
-    if (!AsyncStorage) {
-      return;
-    }
-
-    // Stopping listener and restoring original methods
-    this.restoreOriginalMethods();
-    this.isListening = false;
-    // Stopped listening successfully
-  }
-
-  /**
-   * Add a listener for AsyncStorage events
-   *
-   * @param listener - Callback function to handle AsyncStorage events
-   * @returns Unsubscribe function to remove the listener
-   *
-   * @example
-   * ```typescript
-   * const unsubscribe = asyncStorageListener.addListener((event) => {
-   *   console.log('Storage operation:', event.action, event.data);
-   * });
-   *
-   * // Later, remove the listener
-   * unsubscribe();
-   * ```
-   */
-  addListener(listener) {
-    this.listeners.push(listener);
-
-    // Return unsubscribe function
-    return () => {
-      const index = this.listeners.indexOf(listener);
-      if (index > -1) {
-        this.listeners.splice(index, 1);
-      }
-    };
-  }
-
-  /**
-   * Remove all registered event listeners
-   *
-   * Clears the internal listeners array, stopping all event notifications.
-   */
-  removeAllListeners() {
-    this.listeners = [];
-    // Removed all listeners
-  }
-
-  /**
-   * Check if the listener is currently active and intercepting operations
-   *
-   * @returns True if currently listening to AsyncStorage operations
-   */
-  get isActive() {
-    return this.isListening;
-  }
-
-  /**
-   * Get the number of currently registered event listeners
-   *
-   * @returns Number of active listeners
-   */
-  get listenerCount() {
-    return this.listeners.length;
-  }
-
-  /**
-   * Pause event emission (used during time-travel operations)
-   *
-   * When paused, storage operations still execute but events are not emitted.
-   * This prevents circular event triggering during replay/jump operations.
-   */
-  pause() {
-    this.isPaused = true;
-  }
-
-  /**
-   * Resume event emission after pausing
-   */
-  resume() {
-    this.isPaused = false;
-  }
-
-  /**
-   * Check if event emission is currently paused
-   *
-   * @returns True if paused, false otherwise
-   */
-  get paused() {
-    return this.isPaused;
-  }
-}
-
-/**
- * Singleton instance of AsyncStorageListener
- *
- * This ensures only one listener instance exists across the entire application,
- * preventing conflicts and duplicate event handling.
- */
-const asyncStorageListener = new AsyncStorageListener();
-
-/**
- * Start listening to AsyncStorage operations
- *
- * @returns Promise that resolves when listening starts successfully
- */
-export const startListening = () => asyncStorageListener.startListening();
-
-/**
- * Stop listening to AsyncStorage operations
- */
-export const stopListening = () => asyncStorageListener.stopListening();
-
-/**
- * Add an event listener for AsyncStorage operations
- *
- * @param listener - Callback function to handle events
- * @returns Unsubscribe function to remove the listener
- */
-export const addListener = listener => asyncStorageListener.addListener(listener);
-
-/**
- * Remove all registered event listeners
- */
-export const removeAllListeners = () => asyncStorageListener.removeAllListeners();
-
-/**
- * Check if currently listening to AsyncStorage operations
- *
- * @returns True if actively intercepting AsyncStorage methods
- */
-export const isListening = () => asyncStorageListener.isActive;
-
-/**
- * Get the current number of registered event listeners
- *
- * @returns Number of active listeners
- */
-export const getListenerCount = () => asyncStorageListener.listenerCount;
-
-/**
- * Pause event emission (used during time-travel operations)
- *
- * When paused, storage operations still execute but events are not emitted.
- * This prevents circular event triggering during replay/jump operations.
- */
-export const pauseCapture = () => asyncStorageListener.pause();
-
-/**
- * Resume event emission after pausing
- */
-export const resumeCapture = () => asyncStorageListener.resume();
-
-/**
- * Check if event emission is currently paused
- *
- * @returns True if paused, false otherwise
- */
-export const isPaused = () => asyncStorageListener.paused;
-
-/**
- * Export the singleton instance for advanced usage
- *
- * @example
- * ```typescript
- * import asyncStorageListener from './AsyncStorageListener';
- *
- * // Access advanced methods directly
- * if (asyncStorageListener.isActive) {
- *   console.log(`${asyncStorageListener.listenerCount} listeners active`);
- * }
- * ```
- */
-export default asyncStorageListener;
+"use strict";import{asyncStorage as e,asyncStorageCaps as u,readMany as h}from"./asyncStorageCompat";const c=Symbol.for("@buoy-gg/storage.asyncStorageOriginals");function d(){return globalThis[c]??null}function M(o){globalThis[c]=o}class I{listeners=[];isListening=false;isInitialized=false;isPaused=false;ignoredKeys=new Set(["@react_buoy_storage_event_filters","@react_buoy_storage_key_filters","@react_buoy_storage_is_monitoring","REACT_QUERY_OFFLINE_CACHE"]);originalSetItem=null;originalRemoveItem=null;originalMergeItem=null;originalClear=null;originalMultiSet=null;originalMultiRemove=null;originalMultiMerge=null;originalSetMany=null;originalRemoveMany=null;shouldIgnoreKey(i){if(this.ignoredKeys.has(i))return true;for(const s of this.ignoredKeys){if(i.startsWith(s))return true}return false}adoptOriginals(i){this.originalSetItem=i.setItem;this.originalRemoveItem=i.removeItem;this.originalClear=i.clear;this.originalMergeItem=i.mergeItem;this.originalMultiSet=i.multiSet;this.originalMultiRemove=i.multiRemove;this.originalMultiMerge=i.multiMerge;this.originalSetMany=i.setMany;this.originalRemoveMany=i.removeMany}async initialize(){if(this.isInitialized){return true}if(e.setItem.name==="swizzled_setItem"){const s=d();if(!s){return false}this.adoptOriginals(s);this.isInitialized=true;return true}const i={setItem:e.setItem.bind(e),removeItem:e.removeItem.bind(e),clear:e.clear.bind(e),mergeItem:null,multiSet:null,multiRemove:null,multiMerge:null,setMany:null,removeMany:null};if(u.hasLegacyMultiApi){i.multiSet=e.multiSet.bind(e);i.multiRemove=e.multiRemove.bind(e);i.mergeItem=e.mergeItem.bind(e);i.multiMerge=e.multiMerge?e.multiMerge.bind(e):null}else{i.setMany=e.setMany.bind(e);i.removeMany=e.removeMany.bind(e)}M(i);this.adoptOriginals(i);this.isInitialized=true;return true}restoreOriginalMethods(){if(!e||!this.originalSetItem){return}e.setItem=this.originalSetItem;if(this.originalRemoveItem){e.removeItem=this.originalRemoveItem}if(this.originalClear){e.clear=this.originalClear}if(this.originalMergeItem){e.mergeItem=this.originalMergeItem}if(this.originalMultiSet){e.multiSet=this.originalMultiSet}if(this.originalMultiRemove){e.multiRemove=this.originalMultiRemove}if(this.originalMultiMerge){e.multiMerge=this.originalMultiMerge}if(this.originalSetMany){e.setMany=this.originalSetMany}if(this.originalRemoveMany){e.removeMany=this.originalRemoveMany}}emit(i){if(this.isPaused){return}if(this.listeners.length===0){return}this.listeners.forEach(s=>{try{s(i)}catch(t){}})}async handleBatchSet(i,s,t="multiSet"){const r=i.filter(([g])=>!this.shouldIgnoreKey(g));if(r.length===0){return s()}const n=r.map(([g])=>g);let a=[];try{a=await h(n)}catch{}const m=await s();this.emit({action:t,timestamp:new Date,data:{pairs:r,prevPairs:a}});return m}async handleBatchRemove(i,s){const t=i.filter(a=>!this.shouldIgnoreKey(a));if(t.length===0){return s()}let r=[];try{r=await h(t)}catch{}const n=await s();this.emit({action:"multiRemove",timestamp:new Date,data:{keys:t,prevPairs:r}});return n}async startListening(){if(this.isListening){return}const i=await this.initialize();if(!i){return}if(e&&e.setItem.name==="swizzled_setItem"){this.restoreOriginalMethods()}const s=async(t,r)=>{if(!this.shouldIgnoreKey(t)){const n=this.originalSetItem?await e.getItem(t):null;const a=this.originalSetItem?await this.originalSetItem(t,r):void 0;this.emit({action:"setItem",timestamp:new Date,data:{key:t,value:r,prevValue:n}});return a}return this.originalSetItem?this.originalSetItem(t,r):Promise.resolve()};Object.defineProperty(s,"name",{value:"swizzled_setItem"});if(e){e.setItem=s}if(e){e.removeItem=async t=>{if(!this.shouldIgnoreKey(t)){const r=this.originalRemoveItem?await e.getItem(t):null;const n=this.originalRemoveItem?await this.originalRemoveItem(t):void 0;this.emit({action:"removeItem",timestamp:new Date,data:{key:t,prevValue:r}});return n}return this.originalRemoveItem?this.originalRemoveItem(t):Promise.resolve()}}if(u.hasMergeApi&&e){e.mergeItem=async(t,r)=>{if(!this.shouldIgnoreKey(t)){const n=this.originalMergeItem?await e.getItem(t):null;const a=this.originalMergeItem?await this.originalMergeItem(t,r):void 0;this.emit({action:"mergeItem",timestamp:new Date,data:{key:t,value:r,prevValue:n}});return a}return this.originalMergeItem?this.originalMergeItem(t,r):Promise.resolve()}}if(e){e.clear=async()=>{let t=[];try{const n=await e.getAllKeys();const a=n.filter(m=>!this.shouldIgnoreKey(m));if(a.length>0){t=await h(a)}}catch{}const r=this.originalClear?await this.originalClear():void 0;this.emit({action:"clear",timestamp:new Date,data:{prevPairs:t}});return r}}if(u.hasLegacyMultiApi&&e){e.multiSet=t=>this.handleBatchSet(t,()=>this.originalMultiSet?this.originalMultiSet(t):Promise.resolve());e.multiRemove=t=>this.handleBatchRemove(t,()=>this.originalMultiRemove?this.originalMultiRemove(t):Promise.resolve());if(this.originalMultiMerge){e.multiMerge=t=>this.handleBatchSet(t,()=>this.originalMultiMerge?this.originalMultiMerge(t):Promise.resolve(),"multiMerge")}}else if(e){e.setMany=t=>this.handleBatchSet(Object.entries(t),()=>this.originalSetMany?this.originalSetMany(t):Promise.resolve());e.removeMany=t=>this.handleBatchRemove(t,()=>this.originalRemoveMany?this.originalRemoveMany(t):Promise.resolve())}this.isListening=true}stopListening(){if(!this.isListening){return}if(!e){return}this.restoreOriginalMethods();this.isListening=false}addListener(i){this.listeners.push(i);return()=>{const s=this.listeners.indexOf(i);if(s>-1){this.listeners.splice(s,1)}}}removeAllListeners(){this.listeners=[]}get isActive(){return this.isListening}get listenerCount(){return this.listeners.length}pause(){this.isPaused=true}resume(){this.isPaused=false}get paused(){return this.isPaused}}const l=new I;export const startListening=()=>l.startListening();export const stopListening=()=>l.stopListening();export const addListener=o=>l.addListener(o);export const removeAllListeners=()=>l.removeAllListeners();export const isListening=()=>l.isActive;export const getListenerCount=()=>l.listenerCount;export const pauseCapture=()=>l.pause();export const resumeCapture=()=>l.resume();export const isPaused=()=>l.paused;export default l;

package/lib/module/storage/utils/AsyncStorageListener.web.js

@@ -0,0 +1 @@
+"use strict";import{subscribeToBrowserStorage as f}from"@buoy-gg/shared-ui/utils";const t=new Set;let r;let n=false;const p=new Set(["@react_buoy_storage_event_filters","@react_buoy_storage_key_filters","@react_buoy_storage_is_monitoring","REACT_QUERY_OFFLINE_CACHE"]);const u=e=>[...p].some(i=>e.startsWith(i));export async function startListening(){if(r||typeof window==="undefined")return;r=f(e=>{if(n||e.area!=="localStorage"||e.key!==void 0&&u(e.key))return;const{area:i,action:a,...s}=e;if(s.prevPairs)s.prevPairs=s.prevPairs.filter(([o])=>!u(o));const c={action:a,data:s,timestamp:new Date};for(const o of[...t]){try{o(c)}catch{}}})}export function stopListening(){r?.();r=void 0}export function addListener(e){t.add(e);return()=>{t.delete(e)}}export function removeAllListeners(){t.clear()}export function isListening(){return!!r}export function getListenerCount(){return t.size}export function pauseCapture(){n=true}export function resumeCapture(){n=false}export function isPaused(){return n}const d={startListening,stopListening,addListener,removeAllListeners,pause:pauseCapture,resume:resumeCapture,get isActive(){return isListening()},get listenerCount(){return t.size},get paused(){return n}};export default d;