@buoy-gg/storage 3.0.1 → 4.0.1

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

@@ -7,6 +7,8 @@ exports.subscribeToStorageEvents = exports.storageEventStore = exports.onStorage
 var _sharedUi = require("@buoy-gg/shared-ui");
 var _AsyncStorageListener = require("../utils/AsyncStorageListener");
 var _MMKVListener = require("../utils/MMKVListener");
+var _MMKVInstanceRegistry = require("../utils/MMKVInstanceRegistry");
+var _mmkvTypeDetection = require("../utils/mmkvTypeDetection");
 /**
  * Storage Event Store
  *
@@ -53,6 +55,7 @@ class StorageEventStore extends _sharedUi.BaseEventStore {
   // Unsubscribe functions for raw listeners
   asyncStorageUnsubscribe = null;
   mmkvUnsubscribe = null;
+  hasScannedInitialState = false;
   constructor() {
     super({
       storeName: "storage",
@@ -60,6 +63,84 @@ class StorageEventStore extends _sharedUi.BaseEventStore {
     });
   }
 
+  /**
+   * Scan all registered MMKV instances and AsyncStorage for existing keys,
+   * creating synthetic events so that getEvents() includes the current state
+   * (not just changes made after capture started). Only runs once per store
+   * lifetime to avoid duplicates.
+   */
+  async scanExistingState() {
+    if (this.hasScannedInitialState) return;
+    this.hasScannedInitialState = true;
+    const now = new Date();
+
+    // ── MMKV: synchronous scan ──
+    const instances = _MMKVInstanceRegistry.mmkvInstanceRegistry.getAll();
+    for (const {
+      id: instanceId,
+      instance
+    } of instances) {
+      try {
+        const keys = instance.getAllKeys();
+        for (const key of keys) {
+          const {
+            value,
+            type: valueType
+          } = (0, _mmkvTypeDetection.detectMMKVType)(instance, key);
+          const actionMap = {
+            string: "set.string",
+            number: "set.number",
+            boolean: "set.boolean",
+            buffer: "set.buffer"
+          };
+          const action = actionMap[valueType] ?? "set.string";
+          this.addEvent({
+            action,
+            timestamp: now,
+            instanceId,
+            data: {
+              key,
+              value,
+              valueType
+            },
+            storageType: "mmkv",
+            id: nextStorageEventId()
+          });
+        }
+      } catch {
+        // Instance may not be accessible — skip silently
+      }
+    }
+
+    // ── AsyncStorage: async scan ──
+    try {
+      const {
+        asyncStorage,
+        readMany
+      } = require("../utils/asyncStorageCompat");
+      if (asyncStorage) {
+        const allKeys = await asyncStorage.getAllKeys();
+        if (allKeys.length > 0) {
+          const pairs = await readMany(allKeys);
+          for (const [key, rawValue] of pairs) {
+            this.addEvent({
+              action: "setItem",
+              timestamp: now,
+              data: {
+                key,
+                value: rawValue ?? undefined
+              },
+              storageType: "async",
+              id: nextStorageEventId()
+            });
+          }
+        }
+      }
+    } catch {
+      // AsyncStorage not available — skip silently
+    }
+  }
+
   /**
    * Start capturing storage events from both AsyncStorage and MMKV
    */
@@ -92,6 +173,9 @@ class StorageEventStore extends _sharedUi.BaseEventStore {
         this.addEvent(storageEvent);
       });
     }
+
+    // Scan existing keys so getEvents() includes pre-existing state
+    await this.scanExistingState();
   }
 
   /**

package/lib/commonjs/storage/sync/storageSyncAdapter.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.storageSyncAdapter = void 0;
+var _asyncStorage = _interopRequireDefault(require("@react-native-async-storage/async-storage"));
+var _asyncStorageCompat = require("../utils/asyncStorageCompat");
+var _storageEventStore = require("../stores/storageEventStore");
+var _clearAllStorage = require("../utils/clearAllStorage");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Sync adapter for the storage tool, consumed by @buoy-gg/external-sync's
+ * `useExternalSync` (structurally matches its ToolSyncAdapter interface so
+ * this package doesn't need a dependency on it).
+ *
+ * Subscribing starts the underlying capture lifecycle (including the initial
+ * key scan), so storage events are only recorded while a dashboard is
+ * watching.
+ *
+ * The `async.*` actions mirror the AsyncStorage API so the desktop dashboard
+ * can proxy its browse/edit mode against the device's real storage.
+ */
+const storageSyncAdapter = exports.storageSyncAdapter = {
+  version: 1,
+  getSnapshot: () => _storageEventStore.storageEventStore.getEvents(),
+  subscribe: onChange => _storageEventStore.storageEventStore.subscribeToEvents(onChange),
+  actions: {
+    clearEvents: () => {
+      _storageEventStore.storageEventStore.clearEvents();
+    },
+    /** Clears all app storage keys, preserving dev tools settings. */
+    clearAppStorage: () => (0, _clearAllStorage.clearAllAppStorage)(),
+    // ── Remote AsyncStorage proxy (desktop browse/edit mode) ──
+    // Single-item methods share the same signature across async-storage v2/v3;
+    // batch methods go through the compat helpers (which translate to v3's
+    // getMany/setMany/removeMany) and keep the v2 tuple/pairs shape on the wire.
+    "async.getAllKeys": () => _asyncStorage.default.getAllKeys(),
+    "async.multiGet": params => (0, _asyncStorageCompat.readMany)(params.keys),
+    "async.getItem": params => _asyncStorage.default.getItem(params.key),
+    "async.setItem": params => {
+      const {
+        key,
+        value
+      } = params;
+      return _asyncStorage.default.setItem(key, value);
+    },
+    "async.removeItem": params => _asyncStorage.default.removeItem(params.key),
+    "async.multiRemove": params => (0, _asyncStorageCompat.removeMany)(params.keys),
+    "async.multiSet": params => (0, _asyncStorageCompat.writeMany)(params.pairs),
+    "async.clear": () => _asyncStorage.default.clear()
+  }
+};

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

@@ -4,10 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 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 }; }
+var _asyncStorageCompat = require("./asyncStorageCompat");
 // AsyncStorage method signatures - matching the actual AsyncStorage API
 
+// v3-only batch methods (replace multiSet/multiRemove)
+
 // Event types for AsyncStorage operations
 
 /**
@@ -18,6 +19,12 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
  * 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
@@ -58,9 +65,13 @@ class AsyncStorageListener {
   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
@@ -99,19 +110,27 @@ class AsyncStorageListener {
     }
 
     // Check if methods are already swizzled by checking the function name
-    if (_asyncStorage.default.setItem.name === "swizzled_setItem") {
+    if (_asyncStorageCompat.asyncStorage.setItem.name === "swizzled_setItem") {
       // Don't store swizzled methods as originals
       return false;
     }
 
-    // Store original methods (these should be the real AsyncStorage methods)
-    this.originalSetItem = _asyncStorage.default.setItem.bind(_asyncStorage.default);
-    this.originalRemoveItem = _asyncStorage.default.removeItem.bind(_asyncStorage.default);
-    this.originalMergeItem = _asyncStorage.default.mergeItem.bind(_asyncStorage.default);
-    this.originalClear = _asyncStorage.default.clear.bind(_asyncStorage.default);
-    this.originalMultiSet = _asyncStorage.default.multiSet.bind(_asyncStorage.default);
-    this.originalMultiRemove = _asyncStorage.default.multiRemove.bind(_asyncStorage.default);
-    this.originalMultiMerge = _asyncStorage.default.multiMerge ? _asyncStorage.default.multiMerge.bind(_asyncStorage.default) : null;
+    // Store original methods (these should be the real AsyncStorage methods).
+    // Single-item + clear are identical across v2/v3.
+    this.originalSetItem = _asyncStorageCompat.asyncStorage.setItem.bind(_asyncStorageCompat.asyncStorage);
+    this.originalRemoveItem = _asyncStorageCompat.asyncStorage.removeItem.bind(_asyncStorageCompat.asyncStorage);
+    this.originalClear = _asyncStorageCompat.asyncStorage.clear.bind(_asyncStorageCompat.asyncStorage);
+    if (_asyncStorageCompat.asyncStorageCaps.hasLegacyMultiApi) {
+      // v2: multiSet/multiRemove + merge API
+      this.originalMultiSet = _asyncStorageCompat.asyncStorage.multiSet.bind(_asyncStorageCompat.asyncStorage);
+      this.originalMultiRemove = _asyncStorageCompat.asyncStorage.multiRemove.bind(_asyncStorageCompat.asyncStorage);
+      this.originalMergeItem = _asyncStorageCompat.asyncStorage.mergeItem.bind(_asyncStorageCompat.asyncStorage);
+      this.originalMultiMerge = _asyncStorageCompat.asyncStorage.multiMerge ? _asyncStorageCompat.asyncStorage.multiMerge.bind(_asyncStorageCompat.asyncStorage) : null;
+    } else {
+      // v3: setMany/removeMany; merge API was removed (nothing to capture)
+      this.originalSetMany = _asyncStorageCompat.asyncStorage.setMany.bind(_asyncStorageCompat.asyncStorage);
+      this.originalRemoveMany = _asyncStorageCompat.asyncStorage.removeMany.bind(_asyncStorageCompat.asyncStorage);
+    }
 
     // Original methods stored successfully
     this.isInitialized = true;
@@ -125,27 +144,35 @@ class AsyncStorageListener {
    * AsyncStorage methods that were saved during initialization.
    */
   restoreOriginalMethods() {
-    if (!_asyncStorage.default || !this.originalSetItem) {
+    if (!_asyncStorageCompat.asyncStorage || !this.originalSetItem) {
       return;
     }
-    _asyncStorage.default.setItem = this.originalSetItem;
+    _asyncStorageCompat.asyncStorage.setItem = this.originalSetItem;
     if (this.originalRemoveItem) {
-      _asyncStorage.default.removeItem = this.originalRemoveItem;
-    }
-    if (this.originalMergeItem) {
-      _asyncStorage.default.mergeItem = this.originalMergeItem;
+      _asyncStorageCompat.asyncStorage.removeItem = this.originalRemoveItem;
     }
     if (this.originalClear) {
-      _asyncStorage.default.clear = this.originalClear;
+      _asyncStorageCompat.asyncStorage.clear = this.originalClear;
+    }
+    // v2 batch + merge
+    if (this.originalMergeItem) {
+      _asyncStorageCompat.asyncStorage.mergeItem = this.originalMergeItem;
     }
     if (this.originalMultiSet) {
-      _asyncStorage.default.multiSet = this.originalMultiSet;
+      _asyncStorageCompat.asyncStorage.multiSet = this.originalMultiSet;
     }
     if (this.originalMultiRemove) {
-      _asyncStorage.default.multiRemove = this.originalMultiRemove;
+      _asyncStorageCompat.asyncStorage.multiRemove = this.originalMultiRemove;
     }
     if (this.originalMultiMerge) {
-      _asyncStorage.default.multiMerge = this.originalMultiMerge;
+      _asyncStorageCompat.asyncStorage.multiMerge = this.originalMultiMerge;
+    }
+    // v3 batch
+    if (this.originalSetMany) {
+      _asyncStorageCompat.asyncStorage.setMany = this.originalSetMany;
+    }
+    if (this.originalRemoveMany) {
+      _asyncStorageCompat.asyncStorage.removeMany = this.originalRemoveMany;
     }
   }
 
@@ -175,6 +202,77 @@ class AsyncStorageListener {
     });
   }
 
+  /**
+   * 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 (0, _asyncStorageCompat.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 (0, _asyncStorageCompat.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
    *
@@ -196,7 +294,7 @@ class AsyncStorageListener {
     }
 
     // Check if methods are already swizzled (this can happen if initialize was called twice somehow)
-    if (_asyncStorage.default && _asyncStorage.default.setItem.name === "swizzled_setItem") {
+    if (_asyncStorageCompat.asyncStorage && _asyncStorageCompat.asyncStorage.setItem.name === "swizzled_setItem") {
       this.restoreOriginalMethods();
     }
 
@@ -207,7 +305,7 @@ class AsyncStorageListener {
       // 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;
+        const prevValue = this.originalSetItem ? await _asyncStorageCompat.asyncStorage.getItem(key) : null;
 
         // Execute the operation
         const result = this.originalSetItem ? await this.originalSetItem(key, value) : undefined;
@@ -229,17 +327,17 @@ class AsyncStorageListener {
     Object.defineProperty(swizzled_setItem, "name", {
       value: "swizzled_setItem"
     });
-    if (_asyncStorage.default) {
-      _asyncStorage.default.setItem = swizzled_setItem;
+    if (_asyncStorageCompat.asyncStorage) {
+      _asyncStorageCompat.asyncStorage.setItem = swizzled_setItem;
     }
 
     // Swizzle removeItem
-    if (_asyncStorage.default) {
-      _asyncStorage.default.removeItem = async key => {
+    if (_asyncStorageCompat.asyncStorage) {
+      _asyncStorageCompat.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.default.getItem(key) : null;
+          const prevValue = this.originalRemoveItem ? await _asyncStorageCompat.asyncStorage.getItem(key) : null;
 
           // Execute the operation
           const result = this.originalRemoveItem ? await this.originalRemoveItem(key) : undefined;
@@ -259,13 +357,13 @@ class AsyncStorageListener {
       };
     }
 
-    // Swizzle mergeItem
-    if (_asyncStorage.default) {
-      _asyncStorage.default.mergeItem = async (key, value) => {
+    // Swizzle mergeItem (v2 only — v3 removed the merge API)
+    if (_asyncStorageCompat.asyncStorageCaps.hasMergeApi && _asyncStorageCompat.asyncStorage) {
+      _asyncStorageCompat.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.default.getItem(key) : null;
+          const prevValue = this.originalMergeItem ? await _asyncStorageCompat.asyncStorage.getItem(key) : null;
 
           // Execute the operation
           const result = this.originalMergeItem ? await this.originalMergeItem(key, value) : undefined;
@@ -287,17 +385,16 @@ class AsyncStorageListener {
     }
 
     // Swizzle clear
-    if (_asyncStorage.default) {
-      _asyncStorage.default.clear = async () => {
+    if (_asyncStorageCompat.asyncStorage) {
+      _asyncStorageCompat.asyncStorage.clear = async () => {
         // Capture all key-value pairs before clearing
         let prevPairs = [];
         try {
-          const allKeys = await _asyncStorage.default.getAllKeys();
+          const allKeys = await _asyncStorageCompat.asyncStorage.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;
+            prevPairs = await (0, _asyncStorageCompat.readMany)(keysToCapture);
           }
         } catch {
           // Failed to capture previous state
@@ -318,105 +415,18 @@ class AsyncStorageListener {
       };
     }
 
-    // Swizzle multiSet
-    if (_asyncStorage.default) {
-      _asyncStorage.default.multiSet = async keyValuePairs => {
-        // 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,
-              prevPairs
-            }
-          });
-          return result;
-        }
-        return this.originalMultiSet ? this.originalMultiSet(keyValuePairs) : Promise.resolve();
-      };
-    }
-
-    // Swizzle multiRemove
-    if (_asyncStorage.default) {
-      _asyncStorage.default.multiRemove = async 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,
-              prevPairs
-            }
-          });
-          return result;
-        }
-        return this.originalMultiRemove ? this.originalMultiRemove(keys) : Promise.resolve();
-      };
-    }
-
-    // Swizzle multiMerge if available
-    if (this.originalMultiMerge && _asyncStorage.default) {
-      _asyncStorage.default.multiMerge = async keyValuePairs => {
-        // 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,
-              prevPairs
-            }
-          });
-          return result;
-        }
-        return this.originalMultiMerge ? this.originalMultiMerge(keyValuePairs) : Promise.resolve();
-      };
+    // Swizzle the batch methods for whichever API the installed version exposes.
+    if (_asyncStorageCompat.asyncStorageCaps.hasLegacyMultiApi && _asyncStorageCompat.asyncStorage) {
+      // ── v2: multiSet / multiRemove / multiMerge ──
+      _asyncStorageCompat.asyncStorage.multiSet = keyValuePairs => this.handleBatchSet(keyValuePairs, () => this.originalMultiSet ? this.originalMultiSet(keyValuePairs) : Promise.resolve());
+      _asyncStorageCompat.asyncStorage.multiRemove = keys => this.handleBatchRemove(keys, () => this.originalMultiRemove ? this.originalMultiRemove(keys) : Promise.resolve());
+      if (this.originalMultiMerge) {
+        _asyncStorageCompat.asyncStorage.multiMerge = keyValuePairs => this.handleBatchSet(keyValuePairs, () => this.originalMultiMerge ? this.originalMultiMerge(keyValuePairs) : Promise.resolve(), "multiMerge");
+      }
+    } else if (_asyncStorageCompat.asyncStorage) {
+      // ── v3: setMany / removeMany (normalized back to multiSet/multiRemove events) ──
+      _asyncStorageCompat.asyncStorage.setMany = entries => this.handleBatchSet(Object.entries(entries), () => this.originalSetMany ? this.originalSetMany(entries) : Promise.resolve());
+      _asyncStorageCompat.asyncStorage.removeMany = keys => this.handleBatchRemove(keys, () => this.originalRemoveMany ? this.originalRemoveMany(keys) : Promise.resolve());
     }
     this.isListening = true;
     // Started listening successfully
@@ -432,34 +442,12 @@ class AsyncStorageListener {
     if (!this.isListening) {
       return;
     }
-    if (!_asyncStorage.default) {
+    if (!_asyncStorageCompat.asyncStorage) {
       return;
     }
 
     // Stopping listener and restoring original methods
-
-    // Restore original methods
-    if (this.originalSetItem) {
-      _asyncStorage.default.setItem = this.originalSetItem;
-    }
-    if (this.originalRemoveItem) {
-      _asyncStorage.default.removeItem = this.originalRemoveItem;
-    }
-    if (this.originalMergeItem) {
-      _asyncStorage.default.mergeItem = this.originalMergeItem;
-    }
-    if (this.originalClear) {
-      _asyncStorage.default.clear = this.originalClear;
-    }
-    if (this.originalMultiSet) {
-      _asyncStorage.default.multiSet = this.originalMultiSet;
-    }
-    if (this.originalMultiRemove) {
-      _asyncStorage.default.multiRemove = this.originalMultiRemove;
-    }
-    if (this.originalMultiMerge) {
-      _asyncStorage.default.multiMerge = this.originalMultiMerge;
-    }
+    this.restoreOriginalMethods();
     this.isListening = false;
     // Stopped listening successfully
   }