@buoy-gg/storage 1.7.7 → 2.1.1

package/lib/commonjs/storage/stores/storageEventStore.js

@@ -0,0 +1,243 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.subscribeToStorageEvents = exports.storageEventStore = exports.stopStorageCapture = exports.startStorageCapture = exports.resumeStorageCapture = exports.pauseStorageCapture = exports.onStorageEvent = exports.isStorageCapturing = exports.getStorageEvents = exports.clearStorageEvents = void 0;
+var _AsyncStorageListener = require("../utils/AsyncStorageListener");
+var _MMKVListener = require("../utils/MMKVListener");
+/**
+ * Storage Event Store
+ *
+ * Centralized store that aggregates storage events from AsyncStorage and MMKV
+ * into a single event stream. This provides a single source of truth for all
+ * storage operations, eliminating duplicate subscriptions across components.
+ *
+ * @example
+ * ```typescript
+ * import { storageEventStore } from '@buoy-gg/storage';
+ *
+ * // Subscribe to storage events
+ * const unsubscribe = storageEventStore.subscribe((events) => {
+ *   console.log('Storage events:', events);
+ * });
+ *
+ * // Start capturing (must be called once)
+ * await storageEventStore.startCapturing();
+ *
+ * // Later, clean up
+ * unsubscribe();
+ * ```
+ */
+
+/**
+ * Unified storage event type combining AsyncStorage and MMKV events
+ */
+
+/**
+ * Listener callback type for storage events
+ */
+
+/**
+ * Listener callback for individual new events
+ */
+
+const MAX_EVENTS = 500;
+class StorageEventStore {
+  events = [];
+  listeners = new Set();
+  eventCallbacks = new Set();
+  isCapturing = false;
+
+  // Unsubscribe functions
+  asyncStorageUnsubscribe = null;
+  mmkvUnsubscribe = null;
+
+  /**
+   * Start capturing storage events from both AsyncStorage and MMKV
+   */
+  async startCapturing() {
+    if (this.isCapturing) {
+      return;
+    }
+
+    // Start AsyncStorage listening if not already active
+    if (!(0, _AsyncStorageListener.isListening)()) {
+      await (0, _AsyncStorageListener.startListening)();
+    }
+
+    // Subscribe to AsyncStorage events
+    this.asyncStorageUnsubscribe = (0, _AsyncStorageListener.addListener)(event => {
+      const storageEvent = {
+        ...event,
+        storageType: "async"
+      };
+      this.addEvent(storageEvent);
+    });
+
+    // Subscribe to MMKV events
+    this.mmkvUnsubscribe = (0, _MMKVListener.addMMKVListener)(event => {
+      const storageEvent = {
+        ...event,
+        storageType: "mmkv"
+      };
+      this.addEvent(storageEvent);
+    });
+    this.isCapturing = true;
+  }
+
+  /**
+   * Stop capturing storage events
+   */
+  stopCapturing() {
+    if (!this.isCapturing) {
+      return;
+    }
+
+    // Unsubscribe from AsyncStorage
+    if (this.asyncStorageUnsubscribe) {
+      this.asyncStorageUnsubscribe();
+      this.asyncStorageUnsubscribe = null;
+    }
+
+    // Unsubscribe from MMKV
+    if (this.mmkvUnsubscribe) {
+      this.mmkvUnsubscribe();
+      this.mmkvUnsubscribe = null;
+    }
+    this.isCapturing = false;
+  }
+
+  /**
+   * Pause event capture (used during time-travel operations)
+   */
+  pauseCapture() {
+    (0, _AsyncStorageListener.pauseCapture)();
+    // MMKV listener doesn't have pause, but it's less common for time-travel
+  }
+
+  /**
+   * Resume event capture after pausing
+   */
+  resumeCapture() {
+    (0, _AsyncStorageListener.resumeCapture)();
+  }
+
+  /**
+   * Add an event to the store
+   */
+  addEvent(event) {
+    // Add to beginning (newest first)
+    this.events = [event, ...this.events].slice(0, MAX_EVENTS);
+
+    // Notify event callbacks (for individual events)
+    this.eventCallbacks.forEach(callback => {
+      try {
+        callback(event);
+      } catch {
+        // Ignore callback errors
+      }
+    });
+
+    // Notify listeners (for full event list)
+    this.notifyListeners();
+  }
+
+  /**
+   * Subscribe to all storage events (receives full event array on each change)
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+
+    // Immediately call with current events
+    listener(this.events);
+
+    // Return unsubscribe function
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  /**
+   * Subscribe to new events only (receives individual events as they occur)
+   */
+  onEvent(callback) {
+    this.eventCallbacks.add(callback);
+    return () => {
+      this.eventCallbacks.delete(callback);
+    };
+  }
+
+  /**
+   * Notify all listeners of changes
+   */
+  notifyListeners() {
+    const events = this.events;
+    this.listeners.forEach(listener => {
+      try {
+        listener(events);
+      } catch {
+        // Ignore listener errors
+      }
+    });
+  }
+
+  /**
+   * Get all events
+   */
+  getEvents() {
+    return this.events;
+  }
+
+  /**
+   * Get events filtered by storage type
+   */
+  getEventsByType(storageType) {
+    return this.events.filter(event => event.storageType === storageType);
+  }
+
+  /**
+   * Get event count
+   */
+  getEventCount() {
+    return this.events.length;
+  }
+
+  /**
+   * Clear all events
+   */
+  clearEvents() {
+    this.events = [];
+    this.notifyListeners();
+  }
+
+  /**
+   * Check if currently capturing events
+   */
+  get capturing() {
+    return this.isCapturing;
+  }
+}
+
+// Singleton instance
+const storageEventStore = exports.storageEventStore = new StorageEventStore();
+
+// Convenience exports
+const startStorageCapture = () => storageEventStore.startCapturing();
+exports.startStorageCapture = startStorageCapture;
+const stopStorageCapture = () => storageEventStore.stopCapturing();
+exports.stopStorageCapture = stopStorageCapture;
+const pauseStorageCapture = () => storageEventStore.pauseCapture();
+exports.pauseStorageCapture = pauseStorageCapture;
+const resumeStorageCapture = () => storageEventStore.resumeCapture();
+exports.resumeStorageCapture = resumeStorageCapture;
+const subscribeToStorageEvents = listener => storageEventStore.subscribe(listener);
+exports.subscribeToStorageEvents = subscribeToStorageEvents;
+const onStorageEvent = callback => storageEventStore.onEvent(callback);
+exports.onStorageEvent = onStorageEvent;
+const getStorageEvents = () => storageEventStore.getEvents();
+exports.getStorageEvents = getStorageEvents;
+const clearStorageEvents = () => storageEventStore.clearEvents();
+exports.clearStorageEvents = clearStorageEvents;
+const isStorageCapturing = () => storageEventStore.capturing;
+exports.isStorageCapturing = isStorageCapturing;

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.stopListening = exports.startListening = exports.removeAllListeners = exports.isListening = exports.getListenerCount = exports.default = exports.addListener = void 0;
+exports.stopListening = exports.startListening = exports.resumeCapture = exports.removeAllListeners = exports.pauseCapture = exports.isPaused = exports.isListening = exports.getListenerCount = exports.default = exports.addListener = void 0;
 var _asyncStorage = _interopRequireDefault(require("@react-native-async-storage/async-storage"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // AsyncStorage method signatures - matching the actual AsyncStorage API
@@ -40,6 +40,7 @@ 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
@@ -153,9 +154,14 @@ class AsyncStorageListener {
    *
    * @param event - The AsyncStorage event to emit
    *
-   * @performance Skips processing when no listeners are registered
+   * @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;
@@ -198,16 +204,25 @@ class AsyncStorageListener {
 
     // Swizzle setItem
     const swizzled_setItem = async (key, value) => {
-      // Only emit event if key is not ignored
+      // 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.default.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
+            value,
+            prevValue
           }
         });
+        return result;
       }
       return this.originalSetItem ? this.originalSetItem(key, value) : Promise.resolve();
     };
@@ -221,19 +236,24 @@ class AsyncStorageListener {
     // Swizzle removeItem
     if (_asyncStorage.default) {
       _asyncStorage.default.removeItem = async key => {
-        // Intercepted removeItem
-
-        // Only emit event if key is not ignored
+        // 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.default.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
+              key,
+              prevValue
             }
           });
-        } else {
-          // Ignoring removeItem for ignored key
+          return result;
         }
         return this.originalRemoveItem ? this.originalRemoveItem(key) : Promise.resolve();
       };
@@ -242,20 +262,25 @@ class AsyncStorageListener {
     // Swizzle mergeItem
     if (_asyncStorage.default) {
       _asyncStorage.default.mergeItem = async (key, value) => {
-        // Intercepted mergeItem operation
-
-        // Only emit event if key is not ignored
+        // 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.default.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
+              value,
+              prevValue
             }
           });
-        } else {
-          // Ignoring mergeItem for ignored key
+          return result;
         }
         return this.originalMergeItem ? this.originalMergeItem(key, value) : Promise.resolve();
       };
@@ -264,32 +289,64 @@ class AsyncStorageListener {
     // Swizzle clear
     if (_asyncStorage.default) {
       _asyncStorage.default.clear = async () => {
-        // Intercepted clear operation
+        // Capture all key-value pairs before clearing
+        let prevPairs = [];
+        try {
+          const allKeys = await _asyncStorage.default.getAllKeys();
+          // Filter out ignored keys
+          const keysToCapture = allKeys.filter(key => !this.shouldIgnoreKey(key));
+          if (keysToCapture.length > 0) {
+            const keyValuePairs = await _asyncStorage.default.multiGet(keysToCapture);
+            prevPairs = keyValuePairs;
+          }
+        } 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()
+          timestamp: new Date(),
+          data: {
+            prevPairs
+          }
         });
-        return this.originalClear ? this.originalClear() : Promise.resolve();
+        return result;
       };
     }
 
     // Swizzle multiSet
     if (_asyncStorage.default) {
       _asyncStorage.default.multiSet = async keyValuePairs => {
-        // Intercepted multiSet operation with multiple pairs
-
         // Filter out ignored keys
         const filteredPairs = keyValuePairs.filter(([key]) => !this.shouldIgnoreKey(key));
         if (filteredPairs.length > 0) {
+          // Capture previous values for all keys being set
+          const keysToSet = filteredPairs.map(([key]) => key);
+          let prevPairs = [];
+          try {
+            const existingValues = await _asyncStorage.default.multiGet(keysToSet);
+            prevPairs = existingValues;
+          } catch {
+            // Failed to capture previous values
+          }
+
+          // Execute the operation
+          const result = this.originalMultiSet ? await this.originalMultiSet(keyValuePairs) : undefined;
+
+          // Emit event with previous values
           this.emit({
             action: "multiSet",
             timestamp: new Date(),
             data: {
-              pairs: filteredPairs
+              pairs: filteredPairs,
+              prevPairs
             }
           });
-        } else {
-          // All keys in multiSet are ignored
+          return result;
         }
         return this.originalMultiSet ? this.originalMultiSet(keyValuePairs) : Promise.resolve();
       };
@@ -298,20 +355,31 @@ class AsyncStorageListener {
     // Swizzle multiRemove
     if (_asyncStorage.default) {
       _asyncStorage.default.multiRemove = async keys => {
-        // Intercepted multiRemove operation with multiple keys
-
         // Filter out ignored keys
         const filteredKeys = keys.filter(key => !this.shouldIgnoreKey(key));
         if (filteredKeys.length > 0) {
+          // Capture previous values for all keys being removed
+          let prevPairs = [];
+          try {
+            const existingValues = await _asyncStorage.default.multiGet(filteredKeys);
+            prevPairs = existingValues;
+          } catch {
+            // Failed to capture previous values
+          }
+
+          // Execute the operation
+          const result = this.originalMultiRemove ? await this.originalMultiRemove(keys) : undefined;
+
+          // Emit event with previous values
           this.emit({
             action: "multiRemove",
             timestamp: new Date(),
             data: {
-              keys: filteredKeys
+              keys: filteredKeys,
+              prevPairs
             }
           });
-        } else {
-          // All keys in multiRemove are ignored
+          return result;
         }
         return this.originalMultiRemove ? this.originalMultiRemove(keys) : Promise.resolve();
       };
@@ -320,20 +388,32 @@ class AsyncStorageListener {
     // Swizzle multiMerge if available
     if (this.originalMultiMerge && _asyncStorage.default) {
       _asyncStorage.default.multiMerge = async keyValuePairs => {
-        // Intercepted multiMerge operation with multiple pairs
-
         // Filter out ignored keys
         const filteredPairs = keyValuePairs.filter(([key]) => !this.shouldIgnoreKey(key));
         if (filteredPairs.length > 0) {
+          // Capture previous values for all keys being merged
+          const keysToMerge = filteredPairs.map(([key]) => key);
+          let prevPairs = [];
+          try {
+            const existingValues = await _asyncStorage.default.multiGet(keysToMerge);
+            prevPairs = existingValues;
+          } catch {
+            // Failed to capture previous values
+          }
+
+          // Execute the operation
+          const result = this.originalMultiMerge ? await this.originalMultiMerge(keyValuePairs) : undefined;
+
+          // Emit event with previous values
           this.emit({
             action: "multiMerge",
             timestamp: new Date(),
             data: {
-              pairs: filteredPairs
+              pairs: filteredPairs,
+              prevPairs
             }
           });
-        } else {
-          // All keys in multiMerge are ignored
+          return result;
         }
         return this.originalMultiMerge ? this.originalMultiMerge(keyValuePairs) : Promise.resolve();
       };
@@ -439,6 +519,32 @@ class AsyncStorageListener {
   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;
+  }
 }
 
 /**
@@ -493,6 +599,29 @@ const isListening = () => asyncStorageListener.isActive;
 exports.isListening = isListening;
 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.
+ */
+exports.getListenerCount = getListenerCount;
+const pauseCapture = () => asyncStorageListener.pause();
+
+/**
+ * Resume event emission after pausing
+ */
+exports.pauseCapture = pauseCapture;
+const resumeCapture = () => asyncStorageListener.resume();
+
+/**
+ * Check if event emission is currently paused
+ *
+ * @returns True if paused, false otherwise
+ */
+exports.resumeCapture = resumeCapture;
+const isPaused = () => asyncStorageListener.paused;
+
 /**
  * Export the singleton instance for advanced usage
  *
@@ -506,5 +635,5 @@ const getListenerCount = () => asyncStorageListener.listenerCount;
  * }
  * ```
  */
-exports.getListenerCount = getListenerCount;
+exports.isPaused = isPaused;
 var _default = exports.default = asyncStorageListener;

package/lib/commonjs/storage/utils/index.js

@@ -27,6 +27,12 @@ Object.defineProperty(exports, "asyncStorageListener", {
     return _AsyncStorageListener.default;
   }
 });
+Object.defineProperty(exports, "canUndo", {
+  enumerable: true,
+  get: function () {
+    return _storageTimeTravelUtils.canUndo;
+  }
+});
 Object.defineProperty(exports, "clearAllAppStorage", {
   enumerable: true,
   get: function () {
@@ -105,12 +111,24 @@ Object.defineProperty(exports, "isMMKVListening", {
     return _MMKVListener.isMMKVListening;
   }
 });
+Object.defineProperty(exports, "isPaused", {
+  enumerable: true,
+  get: function () {
+    return _AsyncStorageListener.isPaused;
+  }
+});
 Object.defineProperty(exports, "isTypeMatch", {
   enumerable: true,
   get: function () {
     return _mmkvTypeDetection.isTypeMatch;
   }
 });
+Object.defineProperty(exports, "jumpToState", {
+  enumerable: true,
+  get: function () {
+    return _storageTimeTravelUtils.jumpToState;
+  }
+});
 Object.defineProperty(exports, "mmkvInstanceRegistry", {
   enumerable: true,
   get: function () {
@@ -123,6 +141,12 @@ Object.defineProperty(exports, "mmkvListener", {
     return _MMKVListener.mmkvListener;
   }
 });
+Object.defineProperty(exports, "pauseCapture", {
+  enumerable: true,
+  get: function () {
+    return _AsyncStorageListener.pauseCapture;
+  }
+});
 Object.defineProperty(exports, "registerMMKVInstance", {
   enumerable: true,
   get: function () {
@@ -153,6 +177,12 @@ Object.defineProperty(exports, "removeMMKVInstance", {
     return _MMKVListener.removeMMKVInstance;
   }
 });
+Object.defineProperty(exports, "resumeCapture", {
+  enumerable: true,
+  get: function () {
+    return _AsyncStorageListener.resumeCapture;
+  }
+});
 Object.defineProperty(exports, "startListening", {
   enumerable: true,
   get: function () {
@@ -165,6 +195,12 @@ Object.defineProperty(exports, "stopListening", {
     return _AsyncStorageListener.stopListening;
   }
 });
+Object.defineProperty(exports, "undoOperation", {
+  enumerable: true,
+  get: function () {
+    return _storageTimeTravelUtils.undoOperation;
+  }
+});
 Object.defineProperty(exports, "unregisterMMKVInstance", {
   enumerable: true,
   get: function () {
@@ -174,6 +210,7 @@ Object.defineProperty(exports, "unregisterMMKVInstance", {
 var _clearAllStorage = require("./clearAllStorage");
 var _mmkvAvailability = require("./mmkvAvailability");
 var _AsyncStorageListener = _interopRequireWildcard(require("./AsyncStorageListener"));
+var _storageTimeTravelUtils = require("./storageTimeTravelUtils");
 var _MMKVInstanceRegistry = require("./MMKVInstanceRegistry");
 var _MMKVListener = require("./MMKVListener");
 var _mmkvTypeDetection = require("./mmkvTypeDetection");