@buoy-gg/storage 7.0.40 → 7.0.42

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

@@ -1,209 +1 @@
-"use strict";
-
-/**
- * Writing a storage value back, in one place.
- *
- * The counterpart to `deleteStorageKeys` — and the same reasoning applies: each
- * backend writes differently, and a second copy of that fan-out is how one
- * backend quietly starts corrupting values.
- *
- * The hard part is NOT the write, it's the types:
- *
- * - **AsyncStorage** stores strings only. A value that was stored as JSON must
- *   stay valid JSON, or an object silently becomes a quoted string and the app
- *   that reads it breaks in a way that looks nothing like a devtools edit.
- * - **MMKV** is natively typed (string / number / boolean / buffer). Writing
- *   `"42"` over a number turns it into a string, so the original type is
- *   restored from `valueType`. Buffers can't round-trip at all — the snapshot
- *   only ever carried a `<ArrayBuffer n bytes>` placeholder.
- * - **SecureStore** stores strings, and biometric-protected keys are never
- *   touched (writing needs the same auth prompt reading does).
- *
- * Pro gating and confirmation are deliberately NOT here; they belong to the UI
- * that has the user's attention. This assumes the caller already asked.
- */
-
-import AsyncStorage from "@react-native-async-storage/async-storage";
-import { secureStoreRegistry } from "./SecureStoreRegistry";
-/**
- * Why a key can't be edited, or null when it can. UI uses this both to hide the
- * edit affordance and to explain itself, rather than failing at save time.
- */
-export function storageEditBlockedReason(storageKey, mmkvInstances = []) {
-  if (storageKey.storageType === "mmkv") {
-    if (storageKey.valueType === "buffer") {
-      return "Buffer values can't be edited — the tool only ever sees their byte length, not their contents.";
-    }
-    const instance = mmkvInstances.find(i => i.id === (storageKey.instanceId || "default"));
-    if (instance?.readOnly) {
-      return `MMKV instance "${instance.id}" is registered read-only.`;
-    }
-  }
-  if (storageKey.storageType === "secure") {
-    const entry = secureStoreRegistry.getAll().find(e => e.key === storageKey.key);
-    if (entry?.options.requireAuthentication) {
-      return "Biometric-protected keys can't be edited — writing one would fire an auth prompt.";
-    }
-    if (!secureStoreRegistry.getModule()) {
-      return "No SecureStore module is registered.";
-    }
-  }
-  return null;
-}
-
-/**
- * Validate `raw` for this key WITHOUT writing. Returns an error message, or
- * null when the text is acceptable. The editor calls this as you type.
- */
-export function validateStorageValue(storageKey, raw) {
-  if (storageKey.storageType === "mmkv") {
-    const type = mmkvTargetType(storageKey);
-    if (type === "number") {
-      if (raw.trim() === "" || Number.isNaN(Number(raw))) {
-        return "Must be a number — this MMKV key is stored as a number.";
-      }
-    }
-    if (type === "boolean") {
-      const t = raw.trim().toLowerCase();
-      if (t !== "true" && t !== "false") {
-        return 'Must be "true" or "false" — this MMKV key is stored as a boolean.';
-      }
-    }
-    return null;
-  }
-
-  // AsyncStorage + SecureStore are string-valued. Only guard the case where
-  // the CURRENT value is structured: silently flattening an object into a
-  // string is the corruption worth preventing. A plain string stays free-form.
-  if (isStructured(storageKey.value)) {
-    try {
-      JSON.parse(raw);
-    } catch (e) {
-      return `This key holds JSON — ${e instanceof Error ? e.message : "invalid JSON"}`;
-    }
-  }
-  return null;
-}
-
-/**
- * The text an editor should open with: JSON pretty-printed so it's actually
- * editable, everything else verbatim.
- */
-export function storageValueToEditableText(value) {
-  if (value === undefined || value === null) return "";
-  if (typeof value === "string") {
-    // Values arrive already parsed when they were JSON, so a string here is a
-    // real string — except AsyncStorage hands back raw JSON text sometimes.
-    const trimmed = value.trim();
-    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-      try {
-        return JSON.stringify(JSON.parse(value), null, 2);
-      } catch {
-        return value;
-      }
-    }
-    return value;
-  }
-  if (typeof value === "object") return JSON.stringify(value, null, 2);
-  return String(value);
-}
-
-/**
- * The value as a STRUCTURE, for the tree editor to apply ops against.
- *
- * Backends disagree on how far they've already parsed: `useAsyncStorageKeys`
- * hands back a parsed object, while MMKV reports its native type so a JSON blob
- * arrives as the raw string. Both have to end up as the same thing before an op
- * can address a path inside them.
- *
- * Returns `undefined` when the value isn't a container — scalars are edited
- * through the plain value editor, not the tree.
- */
-export function structuredStorageValue(storageKey) {
-  const {
-    value
-  } = storageKey;
-  if (value !== null && typeof value === "object") return value;
-  if (typeof value === "string") {
-    const trimmed = value.trim();
-    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return undefined;
-    try {
-      const parsed = JSON.parse(value);
-      return parsed !== null && typeof parsed === "object" ? parsed : undefined;
-    } catch {
-      return undefined;
-    }
-  }
-  return undefined;
-}
-
-/**
- * Write `raw` to whichever backend holds this key, restoring the value's
- * original type. Rejects (rather than writing something lossy) when the key
- * isn't editable or the text doesn't fit the type — callers surface that.
- */
-export async function setStorageValue(storageKey, raw, mmkvInstances = []) {
-  const blocked = storageEditBlockedReason(storageKey, mmkvInstances);
-  if (blocked) throw new Error(blocked);
-  const invalid = validateStorageValue(storageKey, raw);
-  if (invalid) throw new Error(invalid);
-  switch (storageKey.storageType) {
-    case "async":
-      {
-        await AsyncStorage.setItem(storageKey.key, normalizeJsonText(storageKey, raw));
-        return;
-      }
-    case "secure":
-      {
-        await secureStoreRegistry.setValue(storageKey.key, normalizeJsonText(storageKey, raw));
-        return;
-      }
-    case "mmkv":
-      {
-        const instanceId = storageKey.instanceId || "default";
-        const target = mmkvInstances.find(i => i.id === instanceId);
-        if (!target) {
-          throw new Error(`MMKV instance "${instanceId}" is not registered.`);
-        }
-        target.instance.set(storageKey.key, coerceMMKV(storageKey, raw));
-        return;
-      }
-    default:
-      {
-        throw new Error(`Unsupported storage type "${String(storageKey.storageType)}"`);
-      }
-  }
-}
-
-/** True when the value is an object/array (so its text must stay valid JSON). */
-function isStructured(value) {
-  return value !== null && typeof value === "object";
-}
-
-/**
- * Re-serialize JSON so the stored string is compact and canonical, matching
- * what the app itself would have written with `JSON.stringify`. Free-form
- * strings pass through untouched.
- */
-function normalizeJsonText(storageKey, raw) {
-  if (!isStructured(storageKey.value)) return raw;
-  return JSON.stringify(JSON.parse(raw));
-}
-
-/** The MMKV native type to write back, defaulting to the current JS type. */
-function mmkvTargetType(storageKey) {
-  if (storageKey.valueType) return storageKey.valueType;
-  if (typeof storageKey.value === "number") return "number";
-  if (typeof storageKey.value === "boolean") return "boolean";
-  return "string";
-}
-function coerceMMKV(storageKey, raw) {
-  switch (mmkvTargetType(storageKey)) {
-    case "number":
-      return Number(raw);
-    case "boolean":
-      return raw.trim().toLowerCase() === "true";
-    default:
-      return raw;
-  }
-}
+"use strict";import l from"@react-native-async-storage/async-storage";import{secureStoreRegistry as i}from"./SecureStoreRegistry";export function storageEditBlockedReason(e,t=[]){if(e.storageType==="mmkv"){if(e.valueType==="buffer"){return"Buffer values can't be edited \u2014 the tool only ever sees their byte length, not their contents."}const r=t.find(n=>n.id===(e.instanceId||"default"));if(r?.readOnly){return`MMKV instance "${r.id}" is registered read-only.`}}if(e.storageType==="secure"){const r=i.getAll().find(n=>n.key===e.key);if(r?.options.requireAuthentication){return"Biometric-protected keys can't be edited \u2014 writing one would fire an auth prompt."}if(!i.getModule()){return"No SecureStore module is registered."}}return null}export function validateStorageValue(e,t){if(e.storageType==="mmkv"){const r=a(e);if(r==="number"){if(t.trim()===""||Number.isNaN(Number(t))){return"Must be a number \u2014 this MMKV key is stored as a number."}}if(r==="boolean"){const n=t.trim().toLowerCase();if(n!=="true"&&n!=="false"){return'Must be "true" or "false" \u2014 this MMKV key is stored as a boolean.'}}return null}if(f(e.value)){try{JSON.parse(t)}catch(r){return`This key holds JSON \u2014 ${r instanceof Error?r.message:"invalid JSON"}`}}return null}export function storageValueToEditableText(e){if(e===void 0||e===null)return"";if(typeof e==="string"){const t=e.trim();if(t.startsWith("{")||t.startsWith("[")){try{return JSON.stringify(JSON.parse(e),null,2)}catch{return e}}return e}if(typeof e==="object")return JSON.stringify(e,null,2);return String(e)}export function structuredStorageValue(e){const{value:t}=e;if(t!==null&&typeof t==="object")return t;if(typeof t==="string"){const r=t.trim();if(!r.startsWith("{")&&!r.startsWith("["))return void 0;try{const n=JSON.parse(t);return n!==null&&typeof n==="object"?n:void 0}catch{return void 0}}return void 0}export async function setStorageValue(e,t,r=[]){const n=storageEditBlockedReason(e,r);if(n)throw new Error(n);const u=validateStorageValue(e,t);if(u)throw new Error(u);switch(e.storageType){case"async":{await l.setItem(e.key,c(e,t));return}case"secure":{await i.setValue(e.key,c(e,t));return}case"mmkv":{const o=e.instanceId||"default";const s=r.find(d=>d.id===o);if(!s){throw new Error(`MMKV instance "${o}" is not registered.`)}s.instance.set(e.key,p(e,t));return}default:{throw new Error(`Unsupported storage type "${String(e.storageType)}"`)}}}function f(e){return e!==null&&typeof e==="object"}function c(e,t){if(!f(e.value))return t;return JSON.stringify(JSON.parse(t))}function a(e){if(e.valueType)return e.valueType;if(typeof e.value==="number")return"number";if(typeof e.value==="boolean")return"boolean";return"string"}function p(e,t){switch(a(e)){case"number":return Number(t);case"boolean":return t.trim().toLowerCase()==="true";default:return t}}

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

@@ -1,380 +1 @@
-"use strict";
-
-/**
- * Time Machine snapshot provider for device storage (AsyncStorage + MMKV +
- * SecureStore).
- *
- * Registered into @buoy-gg/shared-ui's stateSnapshotRegistry at module init;
- * consumed by @buoy-gg/time-machine.
- *
- * Buoy's own keys (isDevToolsStorageKey — @react_buoy*, @buoy*, buoy-*,
- * legacy patterns) are excluded on BOTH capture and restore, so a snapshot
- * can never clobber dev-tool settings. Restore is a diff: app keys missing
- * from the snapshot are deleted, snapshot entries are written back.
- *
- * Known-lossy by design (each surfaces a warning/skip):
- * - MMKV ArrayBuffer values are never transported.
- * - SecureStore biometric keys are never read or written (auth prompt).
- * - SecureStore keys outside the registered descriptor list are invisible.
- */
-import AsyncStorage from "@react-native-async-storage/async-storage";
-import { classifyPreviewItem, createRestoreScope, emptyRestoreResult, failedRestore, isDevToolsStorageKey, registerStateSnapshotProvider, unionKeys, wontApply } from "@buoy-gg/shared-ui";
-import { readMany, writeMany, removeMany } from "./asyncStorageCompat";
-import { clearAllAppStorage } from "./clearAllStorage";
-import { mmkvInstanceRegistry } from "./MMKVInstanceRegistry";
-import { detectMMKVType } from "./mmkvTypeDetection";
-import { secureStoreRegistry } from "./SecureStoreRegistry";
-function deleteMMKVKey(instance, key) {
-  // v4 renamed delete() to remove() — support both
-  if (instance.remove) instance.remove(key);else instance.delete?.(key);
-}
-function status() {
-  return {
-    canCapture: true,
-    canRestore: true
-  };
-}
-
-/** Shared by capture() and the live side of previewItems(). */
-async function captureStorageData() {
-  const warnings = [];
-  const appKeys = (await AsyncStorage.getAllKeys()).filter(k => !isDevToolsStorageKey(k));
-  const asyncPairs = (await readMany(appKeys)).filter(pair => pair[1] !== null);
-  const mmkv = {};
-  for (const {
-    id,
-    instance
-  } of mmkvInstanceRegistry.getAll()) {
-    try {
-      mmkv[id] = instance.getAllKeys().filter(key => !isDevToolsStorageKey(key)).map(key => {
-        const {
-          value,
-          type: valueType
-        } = detectMMKVType(instance, key);
-        if (valueType === "buffer") {
-          warnings.push(`mmkv "${id}"/"${key}": ArrayBuffer value not capturable`);
-        }
-        return {
-          key,
-          value,
-          valueType
-        };
-      });
-    } catch {
-      warnings.push(`mmkv "${id}": unreadable, captured without entries`);
-      mmkv[id] = [];
-    }
-  }
-  const secure = {};
-  const secureModule = secureStoreRegistry.getModule();
-  for (const {
-    key,
-    options
-  } of secureStoreRegistry.getAll()) {
-    if (options.requireAuthentication) {
-      warnings.push(`secure "${key}": biometric-protected, not capturable`);
-      continue;
-    }
-    let value = null;
-    if (secureModule) {
-      try {
-        value = await secureModule.getItemAsync(key, options);
-      } catch {
-        warnings.push(`secure "${key}": unreadable, captured as unset`);
-      }
-    }
-    secure[key] = value;
-  }
-  return {
-    data: {
-      async: asyncPairs,
-      mmkv,
-      secure
-    },
-    warnings
-  };
-}
-async function capture() {
-  const {
-    data,
-    warnings
-  } = await captureStorageData();
-  return {
-    data,
-    warnings
-  };
-}
-async function restore(data, options) {
-  const snapshot = data;
-  const scope = createRestoreScope(options);
-  /** True when this item may be touched (scope + exclusions agree). */
-  const touch = scope.touch;
-  const result = emptyRestoreResult();
-  if (!snapshot) {
-    return failedRestore("empty storage snapshot");
-  }
-
-  // ── AsyncStorage: delete app keys missing from the snapshot, write the rest ──
-  try {
-    const snapPairs = (snapshot.async ?? []).filter(([k]) => !isDevToolsStorageKey(k) && touch(`async:${k}`));
-    const snapKeys = new Set(snapPairs.map(([k]) => k));
-    const liveKeys = (await AsyncStorage.getAllKeys()).filter(k => !isDevToolsStorageKey(k));
-    const toRemove = liveKeys.filter(k => !snapKeys.has(k) && touch(`async:${k}`));
-    scope.countExcluded((snapshot.async ?? []).length - snapPairs.length);
-    if (toRemove.length > 0) await removeMany(toRemove);
-    if (snapPairs.length > 0) await writeMany(snapPairs);
-    result.applied += snapPairs.length + toRemove.length;
-  } catch (e) {
-    result.ok = false;
-    result.warnings.push(`asyncstorage restore failed: ${String(e)}`);
-  }
-
-  // ── MMKV: per registered writable instance, diff against the snapshot ──
-  for (const [id, entries] of Object.entries(snapshot.mmkv ?? {})) {
-    const registered = mmkvInstanceRegistry.get(id);
-    if (!registered) {
-      result.skipped.push({
-        id: `mmkv:${id}`,
-        reason: "instance not registered"
-      });
-      continue;
-    }
-    if (registered.instance.isReadOnly) {
-      result.skipped.push({
-        id: `mmkv:${id}`,
-        reason: "instance registered read-only"
-      });
-      continue;
-    }
-    const {
-      instance
-    } = registered;
-    try {
-      const snapKeys = new Set(entries.map(e => e.key));
-      const liveKeys = instance.getAllKeys().filter(key => !isDevToolsStorageKey(key));
-      for (const key of liveKeys) {
-        if (!scope.allows(`mmkv:${id}/${key}`)) continue;
-        if (!snapKeys.has(key)) {
-          deleteMMKVKey(instance, key);
-          result.applied += 1;
-        }
-      }
-      for (const entry of entries) {
-        if (isDevToolsStorageKey(entry.key)) continue;
-        if (!touch(`mmkv:${id}/${entry.key}`)) continue;
-        if (entry.valueType === "buffer") {
-          result.skipped.push({
-            id: `mmkv:${id}/${entry.key}`,
-            reason: "ArrayBuffer values cannot be restored"
-          });
-          continue;
-        }
-        instance.set(entry.key, entry.value);
-        result.applied += 1;
-      }
-    } catch (e) {
-      result.ok = false;
-      result.warnings.push(`mmkv "${id}" restore failed: ${String(e)}`);
-    }
-  }
-
-  // ── SecureStore: diff over the registered, non-biometric descriptor list ──
-  const secureSnap = snapshot.secure ?? {};
-  for (const {
-    key,
-    options
-  } of secureStoreRegistry.getAll()) {
-    if (!scope.allows(`secure:${key}`)) continue;
-    if (options.requireAuthentication) {
-      if (key in secureSnap) {
-        result.skipped.push({
-          id: `secure:${key}`,
-          reason: "biometric-protected keys are never written"
-        });
-      }
-      continue;
-    }
-    try {
-      if (key in secureSnap) {
-        const value = secureSnap[key];
-        if (value === null) await secureStoreRegistry.deleteValue(key);else await secureStoreRegistry.setValue(key, value);
-      } else {
-        // Registered key with no snapshot entry — snapshot predates it; unset.
-        await secureStoreRegistry.deleteValue(key);
-      }
-      result.applied += 1;
-    } catch (e) {
-      result.ok = false;
-      result.warnings.push(`secure "${key}" restore failed: ${String(e)}`);
-    }
-  }
-  for (const key of Object.keys(secureSnap)) {
-    if (!touch(`secure:${key}`)) continue;
-    if (!secureStoreRegistry.getAll().some(e => e.key === key)) {
-      result.skipped.push({
-        id: `secure:${key}`,
-        reason: "key no longer registered with registerSecureStoreKeys"
-      });
-    }
-  }
-  const excludedWarning = scope.excludedWarning("item(s)");
-  if (excludedWarning) result.warnings.push(excludedWarning);
-  return result;
-}
-
-/** Wipe to fresh-install state (Buoy keys preserved). Used by baseline restore. */
-async function clear() {
-  const result = emptyRestoreResult();
-  try {
-    await clearAllAppStorage();
-    result.applied += 1;
-  } catch (e) {
-    result.ok = false;
-    result.warnings.push(`asyncstorage clear failed: ${String(e)}`);
-  }
-  for (const {
-    id,
-    instance
-  } of mmkvInstanceRegistry.getAll()) {
-    if (instance.isReadOnly) {
-      result.skipped.push({
-        id: `mmkv:${id}`,
-        reason: "instance registered read-only"
-      });
-      continue;
-    }
-    try {
-      for (const key of instance.getAllKeys().filter(k => !isDevToolsStorageKey(k))) {
-        deleteMMKVKey(instance, key);
-        result.applied += 1;
-      }
-    } catch (e) {
-      result.ok = false;
-      result.warnings.push(`mmkv "${id}" clear failed: ${String(e)}`);
-    }
-  }
-  for (const {
-    key,
-    options
-  } of secureStoreRegistry.getAll()) {
-    if (options.requireAuthentication) {
-      result.skipped.push({
-        id: `secure:${key}`,
-        reason: "biometric-protected keys are never written"
-      });
-      continue;
-    }
-    try {
-      await secureStoreRegistry.deleteValue(key);
-      result.applied += 1;
-    } catch (e) {
-      result.ok = false;
-      result.warnings.push(`secure "${key}" clear failed: ${String(e)}`);
-    }
-  }
-  return result;
-}
-const ITEM_RENDER_CHAR_LIMIT = 256 * 1024;
-
-/**
- * Storage values are strings (or MMKV primitives): identity equality and a
- * character-length size gate are the right tests, not a deep walk.
- */
-function classifyValue(key, label, oldValue, newValue, inOld, inNew) {
-  return classifyPreviewItem({
-    key,
-    label,
-    oldValue,
-    newValue,
-    inOld,
-    inNew
-  }, {
-    equal: Object.is,
-    tooLarge: value => typeof value === "string" && value.length > ITEM_RENDER_CHAR_LIMIT,
-    tooLargeReason: "value too large to render a diff — restore still applies it"
-  });
-}
-
-/** Per-key restore preview across all three backends. */
-async function previewItems(target, base) {
-  const targetData = target ?? {
-    async: [],
-    mmkv: {},
-    secure: {}
-  };
-  const liveMode = base === undefined;
-  const baseData = liveMode ? (await captureStorageData()).data : base ?? {
-    async: [],
-    mmkv: {},
-    secure: {}
-  };
-  const items = [];
-  const notes = [];
-
-  // ── AsyncStorage ──
-  const oldAsync = new Map(baseData.async ?? []);
-  const newAsync = new Map(targetData.async ?? []);
-  for (const key of unionKeys(oldAsync, newAsync)) {
-    if (isDevToolsStorageKey(key)) continue;
-    items.push(classifyValue(`async:${key}`, key, oldAsync.get(key), newAsync.get(key), oldAsync.has(key), newAsync.has(key)));
-  }
-
-  // ── MMKV ──
-  for (const id of unionKeys(baseData.mmkv, targetData.mmkv)) {
-    const registered = liveMode ? mmkvInstanceRegistry.get(id) : null;
-    const instanceUnavailable = liveMode && !registered;
-    const readOnly = liveMode && registered?.instance.isReadOnly === true;
-    const oldEntries = new Map((baseData.mmkv?.[id] ?? []).map(e => [e.key, e]));
-    const newEntries = new Map((targetData.mmkv?.[id] ?? []).map(e => [e.key, e]));
-    for (const key of unionKeys(oldEntries, newEntries)) {
-      if (isDevToolsStorageKey(key)) continue;
-      const itemKey = `mmkv:${id}/${key}`;
-      const label = `${id} · ${key}`;
-      const oldE = oldEntries.get(key);
-      const newE = newEntries.get(key);
-      let item = classifyValue(itemKey, label, oldE?.value, newE?.value, oldEntries.has(key), newEntries.has(key));
-      if (instanceUnavailable) {
-        item = wontApply(item, "MMKV instance not registered");
-      } else if (readOnly) {
-        item = wontApply(item, "MMKV instance registered read-only");
-      } else if (newE?.valueType === "buffer" || oldE?.valueType === "buffer") {
-        item = wontApply(item, "ArrayBuffer values cannot be restored");
-      }
-      items.push(item);
-    }
-  }
-
-  // ── SecureStore ──
-  const oldSecure = baseData.secure ?? {};
-  const newSecure = targetData.secure ?? {};
-  const registeredSecure = liveMode ? new Map(secureStoreRegistry.getAll().map(e => [e.key, e])) : null;
-  for (const key of unionKeys(oldSecure, newSecure)) {
-    let item = classifyValue(`secure:${key}`, key, oldSecure[key], newSecure[key], key in oldSecure, key in newSecure);
-    if (liveMode) {
-      const entry = registeredSecure?.get(key);
-      if (!entry) {
-        item = wontApply(item, "key no longer registered with registerSecureStoreKeys");
-      } else if (entry.options.requireAuthentication) {
-        item = wontApply(item, "biometric-protected keys are never written");
-      }
-    }
-    items.push(item);
-  }
-  // No blanket "N biometric-protected keys" note: a biometric key a restore
-  // would actually touch already gets its own won't-apply row carrying that
-  // exact reason, so the note only ever restated it for keys nothing was
-  // going to do anything with.
-  return {
-    items,
-    notes
-  };
-}
-registerStateSnapshotProvider({
-  id: "storage",
-  label: "Storage",
-  status,
-  capture,
-  restore,
-  clear,
-  previewItems
-});
+"use strict";import R from"@react-native-async-storage/async-storage";import{classifyPreviewItem as D,createRestoreScope as P,emptyRestoreResult as V,failedRestore as j,isDevToolsStorageKey as h,registerStateSnapshotProvider as x,unionKeys as w,wontApply as v}from"@buoy-gg/shared-ui";import{readMany as B,writeMany as L,removeMany as _}from"./asyncStorageCompat";import{clearAllAppStorage as C}from"./clearAllStorage";import{mmkvInstanceRegistry as $}from"./MMKVInstanceRegistry";import{detectMMKVType as W}from"./mmkvTypeDetection";import{secureStoreRegistry as m}from"./SecureStoreRegistry";function E(n,a){if(n.remove)n.remove(a);else n.delete?.(a)}function H(){return{canCapture:true,canRestore:true}}async function T(){const n=[];const a=(await R.getAllKeys()).filter(o=>!h(o));const i=(await B(a)).filter(o=>o[1]!==null);const r={};for(const{id:o,instance:y}of $.getAll()){try{r[o]=y.getAllKeys().filter(e=>!h(e)).map(e=>{const{value:f,type:l}=W(y,e);if(l==="buffer"){n.push(`mmkv "${o}"/"${e}": ArrayBuffer value not capturable`)}return{key:e,value:f,valueType:l}})}catch{n.push(`mmkv "${o}": unreadable, captured without entries`);r[o]=[]}}const u={};const s=m.getModule();for(const{key:o,options:y}of m.getAll()){if(y.requireAuthentication){n.push(`secure "${o}": biometric-protected, not capturable`);continue}let e=null;if(s){try{e=await s.getItemAsync(o,y)}catch{n.push(`secure "${o}": unreadable, captured as unset`)}}u[o]=e}return{data:{async:i,mmkv:r,secure:u},warnings:n}}async function N(){const{data:n,warnings:a}=await T();return{data:n,warnings:a}}async function U(n,a){const i=n;const r=P(a);const u=r.touch;const s=V();if(!i){return j("empty storage snapshot")}try{const e=(i.async??[]).filter(([t])=>!h(t)&&u(`async:${t}`));const f=new Set(e.map(([t])=>t));const l=(await R.getAllKeys()).filter(t=>!h(t));const g=l.filter(t=>!f.has(t)&&u(`async:${t}`));r.countExcluded((i.async??[]).length-e.length);if(g.length>0)await _(g);if(e.length>0)await L(e);s.applied+=e.length+g.length}catch(e){s.ok=false;s.warnings.push(`asyncstorage restore failed: ${String(e)}`)}for(const[e,f]of Object.entries(i.mmkv??{})){const l=$.get(e);if(!l){s.skipped.push({id:`mmkv:${e}`,reason:"instance not registered"});continue}if(l.instance.isReadOnly){s.skipped.push({id:`mmkv:${e}`,reason:"instance registered read-only"});continue}const{instance:g}=l;try{const t=new Set(f.map(c=>c.key));const d=g.getAllKeys().filter(c=>!h(c));for(const c of d){if(!r.allows(`mmkv:${e}/${c}`))continue;if(!t.has(c)){E(g,c);s.applied+=1}}for(const c of f){if(h(c.key))continue;if(!u(`mmkv:${e}/${c.key}`))continue;if(c.valueType==="buffer"){s.skipped.push({id:`mmkv:${e}/${c.key}`,reason:"ArrayBuffer values cannot be restored"});continue}g.set(c.key,c.value);s.applied+=1}}catch(t){s.ok=false;s.warnings.push(`mmkv "${e}" restore failed: ${String(t)}`)}}const o=i.secure??{};for(const{key:e,options:f}of m.getAll()){if(!r.allows(`secure:${e}`))continue;if(f.requireAuthentication){if(e in o){s.skipped.push({id:`secure:${e}`,reason:"biometric-protected keys are never written"})}continue}try{if(e in o){const l=o[e];if(l===null)await m.deleteValue(e);else await m.setValue(e,l)}else{await m.deleteValue(e)}s.applied+=1}catch(l){s.ok=false;s.warnings.push(`secure "${e}" restore failed: ${String(l)}`)}}for(const e of Object.keys(o)){if(!u(`secure:${e}`))continue;if(!m.getAll().some(f=>f.key===e)){s.skipped.push({id:`secure:${e}`,reason:"key no longer registered with registerSecureStoreKeys"})}}const y=r.excludedWarning("item(s)");if(y)s.warnings.push(y);return s}async function z(){const n=V();try{await C();n.applied+=1}catch(a){n.ok=false;n.warnings.push(`asyncstorage clear failed: ${String(a)}`)}for(const{id:a,instance:i}of $.getAll()){if(i.isReadOnly){n.skipped.push({id:`mmkv:${a}`,reason:"instance registered read-only"});continue}try{for(const r of i.getAllKeys().filter(u=>!h(u))){E(i,r);n.applied+=1}}catch(r){n.ok=false;n.warnings.push(`mmkv "${a}" clear failed: ${String(r)}`)}}for(const{key:a,options:i}of m.getAll()){if(i.requireAuthentication){n.skipped.push({id:`secure:${a}`,reason:"biometric-protected keys are never written"});continue}try{await m.deleteValue(a);n.applied+=1}catch(r){n.ok=false;n.warnings.push(`secure "${a}" clear failed: ${String(r)}`)}}return n}const F=256*1024;function M(n,a,i,r,u,s){return D({key:n,label:a,oldValue:i,newValue:r,inOld:u,inNew:s},{equal:Object.is,tooLarge:o=>typeof o==="string"&&o.length>F,tooLargeReason:"value too large to render a diff \u2014 restore still applies it"})}async function G(n,a){const i=n??{async:[],mmkv:{},secure:{}};const r=a===void 0;const u=r?(await T()).data:a??{async:[],mmkv:{},secure:{}};const s=[];const o=[];const y=new Map(u.async??[]);const e=new Map(i.async??[]);for(const t of w(y,e)){if(h(t))continue;s.push(M(`async:${t}`,t,y.get(t),e.get(t),y.has(t),e.has(t)))}for(const t of w(u.mmkv,i.mmkv)){const d=r?$.get(t):null;const c=r&&!d;const I=r&&d?.instance.isReadOnly===true;const A=new Map((u.mmkv?.[t]??[]).map(p=>[p.key,p]));const S=new Map((i.mmkv?.[t]??[]).map(p=>[p.key,p]));for(const p of w(A,S)){if(h(p))continue;const O=`mmkv:${t}/${p}`;const q=`${t} \xB7 ${p}`;const b=A.get(p);const K=S.get(p);let k=M(O,q,b?.value,K?.value,A.has(p),S.has(p));if(c){k=v(k,"MMKV instance not registered")}else if(I){k=v(k,"MMKV instance registered read-only")}else if(K?.valueType==="buffer"||b?.valueType==="buffer"){k=v(k,"ArrayBuffer values cannot be restored")}s.push(k)}}const f=u.secure??{};const l=i.secure??{};const g=r?new Map(m.getAll().map(t=>[t.key,t])):null;for(const t of w(f,l)){let d=M(`secure:${t}`,t,f[t],l[t],t in f,t in l);if(r){const c=g?.get(t);if(!c){d=v(d,"key no longer registered with registerSecureStoreKeys")}else if(c.options.requireAuthentication){d=v(d,"biometric-protected keys are never written")}}s.push(d)}return{items:s,notes:o}}x({id:"storage",label:"Storage",status:H,capture:N,restore:U,clear:z,previewItems:G});

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

@@ -1,42 +1 @@
-"use strict";
-
-/**
- * Translates storage action types to human-readable labels
- */
-export function translateStorageAction(action) {
-  switch (action) {
-    // AsyncStorage actions
-    case "setItem":
-      return "SET";
-    case "removeItem":
-      return "REMOVE";
-    case "mergeItem":
-      return "MERGE";
-    case "clear":
-      return "CLEAR";
-    case "multiSet":
-      return "MULTI SET";
-    case "multiRemove":
-      return "MULTI REMOVE";
-    case "multiMerge":
-      return "MULTI MERGE";
-
-    // MMKV actions - simplified to match AsyncStorage
-    case "set.string":
-    case "set.number":
-    case "set.boolean":
-    case "set.buffer":
-      return "SET";
-    case "delete":
-      return "REMOVE";
-    case "clearAll":
-      return "CLEAR";
-    case "get.string":
-    case "get.number":
-    case "get.boolean":
-    case "get.buffer":
-      return "GET";
-    default:
-      return "UNKNOWN ACTION";
-  }
-}
+"use strict";export function translateStorageAction(e){switch(e){case"setItem":return"SET";case"removeItem":return"REMOVE";case"mergeItem":return"MERGE";case"clear":return"CLEAR";case"multiSet":return"MULTI SET";case"multiRemove":return"MULTI REMOVE";case"multiMerge":return"MULTI MERGE";case"set.string":case"set.number":case"set.boolean":case"set.buffer":return"SET";case"delete":return"REMOVE";case"clearAll":return"CLEAR";case"get.string":case"get.number":case"get.boolean":case"get.buffer":return"GET";default:return"UNKNOWN ACTION"}}

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

@@ -1,44 +1 @@
-"use strict";
-
-/**
- * A "the underlying storage changed, re-read it" signal for the storage
- * browser.
- *
- * On device the browser refreshes itself from the AsyncStorage/MMKV listeners,
- * but those never fire in remote-mirror mode (the desktop dashboard suppresses
- * local capture and receives the device's events as snapshots instead). Without
- * this seam the browse tab is a one-shot read at mount — values stay frozen
- * until the panel remounts, which is exactly the "shows old data until I switch
- * tools and come back" behaviour.
- *
- * The dashboard calls {@link requestStorageBrowserRefresh} whenever a fresh
- * device snapshot lands; the browser re-reads all three backends (debounced).
- * It is a no-op when nothing is listening.
- */
-
-const listeners = new Set();
-
-/**
- * Subscribe to external refresh requests. Returns an unsubscribe function.
- * @internal — used by the storage browser.
- */
-export function onStorageBrowserRefresh(listener) {
-  listeners.add(listener);
-  return () => {
-    listeners.delete(listener);
-  };
-}
-
-/**
- * Ask any mounted storage browser to re-read AsyncStorage, MMKV and
- * SecureStore. Safe to call at any rate — the browser debounces.
- */
-export function requestStorageBrowserRefresh() {
-  listeners.forEach(listener => {
-    try {
-      listener();
-    } catch {
-      // Listener errors are not ours
-    }
-  });
-}
+"use strict";const r=new Set;export function onStorageBrowserRefresh(e){r.add(e);return()=>{r.delete(e)}}export function requestStorageBrowserRefresh(){r.forEach(e=>{try{e()}catch{}})}