@buoy-gg/storage 7.0.3 → 7.0.5

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

@@ -126,6 +126,20 @@ class MMKVListener {
     // The native listener (addOnValueChangedListener) is sufficient for monitoring writes
 
     let nativeListenerUnsubscribe;
+
+    // Seed the shadow copy so the FIRST observed write already knows what it
+    // replaced. Without this, every key's first event would claim the key never
+    // existed even when it was carried over from a previous launch.
+    const lastKnownValues = new Map();
+    try {
+      for (const key of instance.getAllKeys() ?? []) {
+        if (this.shouldIgnoreKey(key)) continue;
+        lastKnownValues.set(key, detectMMKVType(instance, key).value);
+      }
+    } catch {
+      // Key scan unavailable — prevValue is simply absent until each key is
+      // written once, which is strictly better than reporting a wrong value.
+    }
     if (typeof instance.addOnValueChangedListener === "function") {
       try {
         nativeListenerUnsubscribe = instance.addOnValueChangedListener(key => {
@@ -138,9 +152,15 @@ class MMKVListener {
             type
           } = detectMMKVType(instance, key);
 
+          // Read the shadow copy BEFORE overwriting it — this is the value the
+          // write replaced. `undefined` means the key did not exist.
+          const prevValue = lastKnownValues.get(key);
+
           // Determine action: if value is undefined/unknown, it was deleted
           const isDelete = type === "unknown" || value === undefined;
           if (isDelete) {
+            lastKnownValues.delete(key);
+
             // Key was deleted
             const event = {
               action: "delete",
@@ -148,11 +168,14 @@ class MMKVListener {
               instanceId,
               data: {
                 key,
+                prevValue,
                 success: true
               }
             };
             this.emit(event);
           } else {
+            lastKnownValues.set(key, value);
+
             // Key was set/updated
             const action = type === "string" ? "set.string" : type === "number" ? "set.number" : type === "boolean" ? "set.boolean" : type === "buffer" ? "set.buffer" : "set.string"; // fallback
 
@@ -163,6 +186,7 @@ class MMKVListener {
               data: {
                 key,
                 value,
+                prevValue,
                 valueType: type,
                 success: true
               }
@@ -181,7 +205,8 @@ class MMKVListener {
       instanceId,
       originalMethods: {},
       // Not used in v4
-      nativeListenerUnsubscribe
+      nativeListenerUnsubscribe,
+      lastKnownValues
     });
   }
 
@@ -201,9 +226,20 @@ class MMKVListener {
       nativeListenerUnsubscribe
     } = tracked;
 
-    // Remove native listener
-    if (nativeListenerUnsubscribe) {
-      nativeListenerUnsubscribe();
+    // Remove native listener. The return of addOnValueChangedListener varies by
+    // implementation: a bare unsubscribe function, or a Listener object with a
+    // `.remove()` method (react-native-mmkv v4 and the desktop RemoteMMKV
+    // back-end). Handle both, and never let teardown throw — this runs during
+    // React unmount, where an exception escapes every error boundary and blanks
+    // the whole app.
+    try {
+      if (typeof nativeListenerUnsubscribe === "function") {
+        nativeListenerUnsubscribe();
+      } else if (typeof nativeListenerUnsubscribe?.remove === "function") {
+        nativeListenerUnsubscribe.remove();
+      }
+    } catch {
+      /* listener already gone / back-end offline — nothing to clean up */
     }
 
     // Remove from tracking

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

@@ -49,12 +49,14 @@
 class SecureStoreRegistry {
   module = null;
   keys = new Map();
+  listeners = new Set();
 
   /**
    * Register the SecureStore module and the keys to expose. Callable multiple
    * times — keys accumulate, the latest module wins.
    */
   register(module, descriptors) {
+    const before = this.signature();
     this.module = module;
     for (const d of descriptors) {
       const entry = typeof d === "string" ? {
@@ -71,11 +73,41 @@ class SecureStoreRegistry {
       };
       this.keys.set(entry.key, entry);
     }
+    // Only announce a real change. The desktop dashboard re-registers the same
+    // key set on every device snapshot, and subscribers re-read the keychain on
+    // notify — signature-comparing keeps that from turning into a read storm.
+    if (this.signature() !== before) this.notify();
   }
 
   /** Remove a key from the registry (does not delete the stored value). */
   unregister(key) {
-    this.keys.delete(key);
+    if (this.keys.delete(key)) this.notify();
+  }
+
+  /**
+   * Subscribe to registry changes (keys registered/unregistered). Lets the
+   * browser pick up keys that register after the tool is already open.
+   * Returns an unsubscribe function.
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  /** Content signature of the registered entries (module identity excluded). */
+  signature() {
+    return JSON.stringify(Array.from(this.keys.values()));
+  }
+  notify() {
+    this.listeners.forEach(listener => {
+      try {
+        listener();
+      } catch {
+        // Listener errors are not ours
+      }
+    });
   }
 
   /** The registered SecureStore module, or null if none registered yet. */
@@ -102,6 +134,25 @@ class SecureStoreRegistry {
     if (!this.module || !entry) return;
     await this.module.deleteItemAsync(key, entry.options);
   }
+
+  /**
+   * Write a stored value via the registered module, using the options the key
+   * was registered with — writing with different `keychainService` options than
+   * the value was created with silently creates a SECOND entry the app can't
+   * read, so the registered options are the only safe ones to use.
+   *
+   * Throws rather than no-ops: unlike a delete, a write that quietly did
+   * nothing would leave the UI showing a value that was never stored.
+   */
+  async setValue(key, value) {
+    const entry = this.keys.get(key);
+    if (!this.module) throw new Error("No SecureStore module is registered");
+    if (!entry) throw new Error(`SecureStore key "${key}" is not registered`);
+    if (entry.options.requireAuthentication) {
+      throw new Error(`SecureStore key "${key}" is biometric-protected — DevTools never writes it`);
+    }
+    await this.module.setItemAsync(key, value, entry.options);
+  }
 }
 
 /**

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

@@ -0,0 +1,49 @@
+"use strict";
+
+/**
+ * Deleting storage keys, in one place.
+ *
+ * Each backend removes keys differently — AsyncStorage takes a batch,
+ * SecureStore has to go through the registry (only it knows each key's
+ * `keychainService` options), and MMKV deletes per registered instance. Two call
+ * sites need this (the selection action bar and a single row's "Delete key"),
+ * and a second copy of that fan-out is exactly how one backend quietly stops
+ * being cleaned up.
+ *
+ * Pro gating and confirmation are deliberately NOT here: they belong to the UI
+ * that has the user's attention. This function assumes the caller already asked.
+ */
+
+import { removeMany } from "./asyncStorageCompat";
+import { secureStoreRegistry } from "./SecureStoreRegistry";
+/**
+ * Removes every key from whichever backend holds it. Rejects on the first
+ * failure — callers surface that, rather than reporting a partial delete as
+ * success.
+ */
+export async function deleteStorageKeys(keys, mmkvInstances) {
+  if (keys.length === 0) return;
+  const asyncKeys = keys.filter(k => k.storageType === "async");
+  const mmkvKeys = keys.filter(k => k.storageType === "mmkv");
+  const secureKeys = keys.filter(k => k.storageType === "secure");
+  if (asyncKeys.length > 0) {
+    await removeMany(asyncKeys.map(k => k.key));
+  }
+  for (const k of secureKeys) {
+    await secureStoreRegistry.deleteValue(k.key);
+  }
+  if (mmkvKeys.length > 0) {
+    const byInstance = {};
+    mmkvKeys.forEach(k => {
+      const instanceId = k.instanceId || "default";
+      if (!byInstance[instanceId]) byInstance[instanceId] = [];
+      byInstance[instanceId].push(k.key);
+    });
+    Object.entries(byInstance).forEach(([instanceId, instanceKeys]) => {
+      const inst = mmkvInstances.find(i => i.id === instanceId);
+      if (inst) {
+        instanceKeys.forEach(key => inst.instance.delete(key));
+      }
+    });
+  }
+}

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

@@ -21,5 +21,8 @@ export { registerMMKVInstance, unregisterMMKVInstance, mmkvInstanceRegistry } fr
 // MMKV Listener
 export { addMMKVInstance, removeMMKVInstance, removeAllMMKVInstances, addMMKVListener, removeAllMMKVListeners, isMMKVInstanceMonitored, getMonitoredMMKVInstances, getMMKVInstanceCount, getMMKVListenerCount, isMMKVListening, mmkvListener } from "./MMKVListener";
 
+// Storage browser refresh signal (remote-mirror mode)
+export { onStorageBrowserRefresh, requestStorageBrowserRefresh } from "./storageBrowserRefresh";
+
 // MMKV Type Detection
 export { detectMMKVType, formatMMKVValue, isTypeMatch } from "./mmkvTypeDetection";

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

@@ -1,359 +1,12 @@
 "use strict";
 
 /**
- * Line-by-line diff computation for React Native
- * Adapted from react-diff-viewer for object comparison
+ * Line-by-line diff computation.
+ *
+ * This used to be a verbatim copy of the shared implementation, which meant a
+ * diff fix had to be made twice. It now re-exports the canonical one so the
+ * storage split view, the tree view, and every other tool's diff (redux, jotai,
+ * highlight-updates) share a single algorithm.
  */
 
-export let DiffType = /*#__PURE__*/function (DiffType) {
-  DiffType["DEFAULT"] = "unchanged";
-  DiffType["ADDED"] = "added";
-  DiffType["REMOVED"] = "removed";
-  DiffType["MODIFIED"] = "modified";
-  return DiffType;
-}({});
-/**
- * Compute diff based on method - for word-level diff within lines
- */
-function computeDiffByMethod(oldStr, newStr, method) {
-  let oldParts;
-  let newParts;
-  switch (method) {
-    case "chars":
-      // Split into individual characters
-      oldParts = oldStr.split("");
-      newParts = newStr.split("");
-      break;
-    case "words":
-      // Split by word boundaries, keeping whitespace
-      oldParts = oldStr.match(/\S+|\s+/g) || [];
-      newParts = newStr.match(/\S+|\s+/g) || [];
-      break;
-    case "trimmedLines":
-      {
-        // For trimmedLines, compare without leading/trailing whitespace
-        const oldTrimmed = oldStr.trim();
-        const newTrimmed = newStr.trim();
-        // But still do word-level diff on the trimmed content
-        oldParts = oldTrimmed.match(/\S+|\s+/g) || [];
-        newParts = newTrimmed.match(/\S+|\s+/g) || [];
-        break;
-      }
-    case "lines":
-    default:
-      // For lines mode, don't do word diff - just show the whole line
-      return {
-        left: [{
-          value: oldStr,
-          type: DiffType.REMOVED
-        }],
-        right: [{
-          value: newStr,
-          type: DiffType.ADDED
-        }]
-      };
-  }
-
-  // Simple LCS-like algorithm for better diff
-  const left = [];
-  const right = [];
-  let i = 0,
-    j = 0;
-
-  // Find matching parts
-  while (i < oldParts.length && j < newParts.length) {
-    if (oldParts[i] === newParts[j]) {
-      // Parts match
-      left.push({
-        value: oldParts[i],
-        type: DiffType.DEFAULT
-      });
-      right.push({
-        value: newParts[j],
-        type: DiffType.DEFAULT
-      });
-      i++;
-      j++;
-    } else {
-      // Look ahead for matches
-      let foundMatch = false;
-
-      // Check if we can find newParts[j] in upcoming oldParts
-      for (let k = i + 1; k < Math.min(i + 5, oldParts.length); k++) {
-        if (oldParts[k] === newParts[j]) {
-          // Mark everything from i to k-1 as removed
-          for (let m = i; m < k; m++) {
-            left.push({
-              value: oldParts[m],
-              type: DiffType.REMOVED
-            });
-          }
-          i = k;
-          foundMatch = true;
-          break;
-        }
-      }
-      if (!foundMatch) {
-        // Check if we can find oldParts[i] in upcoming newParts
-        for (let k = j + 1; k < Math.min(j + 5, newParts.length); k++) {
-          if (newParts[k] === oldParts[i]) {
-            // Mark everything from j to k-1 as added
-            for (let m = j; m < k; m++) {
-              right.push({
-                value: newParts[m],
-                type: DiffType.ADDED
-              });
-            }
-            j = k;
-            foundMatch = true;
-            break;
-          }
-        }
-      }
-      if (!foundMatch) {
-        // No match found nearby, mark as changed
-        left.push({
-          value: oldParts[i],
-          type: DiffType.REMOVED
-        });
-        right.push({
-          value: newParts[j],
-          type: DiffType.ADDED
-        });
-        i++;
-        j++;
-      }
-    }
-  }
-
-  // Handle remaining parts
-  while (i < oldParts.length) {
-    left.push({
-      value: oldParts[i],
-      type: DiffType.REMOVED
-    });
-    i++;
-  }
-  while (j < newParts.length) {
-    right.push({
-      value: newParts[j],
-      type: DiffType.ADDED
-    });
-    j++;
-  }
-  return {
-    left,
-    right
-  };
-}
-
-/**
- * Convert object to formatted JSON lines
- */
-function objectToLines(obj) {
-  if (obj === null || obj === undefined) {
-    return [String(obj)];
-  }
-  try {
-    // Pretty print JSON with 2 space indentation
-    const jsonStr = JSON.stringify(obj, null, 2);
-    // Split into lines and filter out empty lines that appear between array elements
-    const lines = jsonStr.split("\n");
-
-    // Remove empty lines but keep structure
-    const filteredLines = [];
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const trimmed = line.trim();
-
-      // Keep the line if it's not empty or if it's meaningful whitespace
-      if (trimmed !== "") {
-        filteredLines.push(line);
-      } else if (i === 0 || i === lines.length - 1) {
-        // Keep first and last empty lines if they exist (though they shouldn't)
-        filteredLines.push(line);
-      }
-      // Skip other empty lines
-    }
-    return filteredLines;
-  } catch {
-    return [String(obj)];
-  }
-}
-/**
- * Apply showDiffOnly filter with context lines
- */
-function filterDiffWithContext(diffs, contextLines) {
-  if (contextLines < 0) return diffs;
-  const result = [];
-  const changedIndices = [];
-
-  // Find all changed lines
-  diffs.forEach((diff, idx) => {
-    if (diff.type !== DiffType.DEFAULT) {
-      changedIndices.push(idx);
-    }
-  });
-
-  // If no changes, return empty
-  if (changedIndices.length === 0) {
-    return [];
-  }
-
-  // Build ranges to include
-  const ranges = [];
-  let currentStart = Math.max(0, changedIndices[0] - contextLines);
-  let currentEnd = Math.min(diffs.length - 1, changedIndices[0] + contextLines);
-  for (let i = 1; i < changedIndices.length; i++) {
-    const idx = changedIndices[i];
-    const rangeStart = Math.max(0, idx - contextLines);
-    const rangeEnd = Math.min(diffs.length - 1, idx + contextLines);
-
-    // If ranges overlap or are adjacent, merge them
-    if (rangeStart <= currentEnd + 1) {
-      currentEnd = Math.max(currentEnd, rangeEnd);
-    } else {
-      // Save current range and start a new one
-      ranges.push([currentStart, currentEnd]);
-      currentStart = rangeStart;
-      currentEnd = rangeEnd;
-    }
-  }
-
-  // Don't forget the last range
-  ranges.push([currentStart, currentEnd]);
-
-  // Build result from ranges
-  ranges.forEach(([start, end]) => {
-    for (let i = start; i <= end; i++) {
-      result.push(diffs[i]);
-    }
-  });
-  return result;
-}
-
-/**
- * Compare lines based on method
- */
-function compareLinesWithMethod(line1, line2, method) {
-  switch (method) {
-    case "trimmedLines":
-      return line1.trim() === line2.trim();
-    case "chars":
-    case "words":
-    case "lines":
-    default:
-      return line1 === line2;
-  }
-}
-
-/**
- * Compute line-by-line diff between two objects
- */
-export function computeLineDiff(oldValue, newValue, options = {}) {
-  const {
-    compareMethod = "words",
-    disableWordDiff = false,
-    showDiffOnly = false,
-    contextLines = 3
-  } = options;
-  const oldLines = objectToLines(oldValue);
-  const newLines = objectToLines(newValue);
-  const result = [];
-  let leftLineNum = 1;
-  let rightLineNum = 1;
-
-  // Simple line diff algorithm (can be improved with LCS)
-  let i = 0,
-    j = 0;
-  while (i < oldLines.length || j < newLines.length) {
-    if (i >= oldLines.length) {
-      // Rest are additions
-      result.push({
-        rightLineNumber: rightLineNum++,
-        type: DiffType.ADDED,
-        rightContent: newLines[j],
-        rightRaw: newLines[j]
-      });
-      j++;
-    } else if (j >= newLines.length) {
-      // Rest are removals
-      result.push({
-        leftLineNumber: leftLineNum++,
-        type: DiffType.REMOVED,
-        leftContent: oldLines[i],
-        leftRaw: oldLines[i]
-      });
-      i++;
-    } else if (compareLinesWithMethod(oldLines[i], newLines[j], compareMethod === "trimmedLines" ? "trimmedLines" : "lines")) {
-      // Lines match (possibly after trimming if trimmedLines)
-      result.push({
-        leftLineNumber: leftLineNum++,
-        rightLineNumber: rightLineNum++,
-        type: DiffType.DEFAULT,
-        leftContent: oldLines[i],
-        rightContent: newLines[j],
-        leftRaw: oldLines[i],
-        rightRaw: newLines[j]
-      });
-      i++;
-      j++;
-    } else {
-      // Lines differ - check if it's a modification or separate add/remove
-      const oldTrimmed = oldLines[i].trim();
-      const newTrimmed = newLines[j].trim();
-
-      // Simple heuristic: if lines start similarly, treat as modification
-      if (oldTrimmed && newTrimmed && (oldTrimmed.startsWith(newTrimmed.substring(0, 3)) || newTrimmed.startsWith(oldTrimmed.substring(0, 3)))) {
-        // Treat as modification - compute word diff if enabled
-        if (!disableWordDiff && compareMethod !== "lines") {
-          const wordDiff = computeDiffByMethod(oldLines[i], newLines[j], compareMethod);
-          result.push({
-            leftLineNumber: leftLineNum++,
-            rightLineNumber: rightLineNum++,
-            type: DiffType.MODIFIED,
-            leftContent: wordDiff.left,
-            rightContent: wordDiff.right,
-            leftRaw: oldLines[i],
-            rightRaw: newLines[j]
-          });
-        } else {
-          // No word diff - just mark lines as different
-          result.push({
-            leftLineNumber: leftLineNum++,
-            rightLineNumber: rightLineNum++,
-            type: DiffType.MODIFIED,
-            leftContent: oldLines[i],
-            rightContent: newLines[j],
-            leftRaw: oldLines[i],
-            rightRaw: newLines[j]
-          });
-        }
-        i++;
-        j++;
-      } else {
-        // Treat as separate remove and add
-        result.push({
-          leftLineNumber: leftLineNum++,
-          type: DiffType.REMOVED,
-          leftContent: oldLines[i],
-          leftRaw: oldLines[i]
-        });
-        result.push({
-          rightLineNumber: rightLineNum++,
-          type: DiffType.ADDED,
-          rightContent: newLines[j],
-          rightRaw: newLines[j]
-        });
-        i++;
-        j++;
-      }
-    }
-  }
-
-  // Apply showDiffOnly filter if enabled
-  if (showDiffOnly) {
-    return filterDiffWithContext(result, contextLines);
-  }
-  return result;
-}
+export { computeLineDiff, DiffType, ABSENT_VALUE, isAbsent } from "@buoy-gg/shared-ui/dataViewer";