@buoy-gg/storage 7.0.41 → 7.0.43

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{}})}

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

@@ -1,9 +1 @@
-"use strict";
-
-export const storageLabels = {
-  async: 'Async',
-  asyncFull: 'AsyncStorage',
-  mmkv: 'MMKV',
-  secure: 'Secure',
-  hasSecure: true
-};
+"use strict";export const storageLabels={async:"Async",asyncFull:"AsyncStorage",mmkv:"MMKV",secure:"Secure",hasSecure:true};

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

@@ -1,9 +1 @@
-"use strict";
-
-export const storageLabels = {
-  async: 'Local',
-  asyncFull: 'localStorage',
-  mmkv: 'Session',
-  secure: 'Secure',
-  hasSecure: false
-};
+"use strict";export const storageLabels={async:"Local",asyncFull:"localStorage",mmkv:"Session",secure:"Secure",hasSecure:false};

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

@@ -1,46 +1 @@
-"use strict";
-
-/**
- * The five operations a storage event can be, and how to recognise one.
- *
- * AsyncStorage and MMKV each have their own action union, and neither maps
- * cleanly onto what a reader wants to see — `multiRemove`, `removeItem` and
- * `delete` are one idea wearing three names. These collapse both onto a single
- * vocabulary so every surface labels, filters and colours events the same way.
- *
- * This is semantics, not presentation: it lives in `utils` rather than beside
- * any one view, so a view can be deleted without taking the vocabulary with it.
- */
-
-import { macOSColors } from "@buoy-gg/shared-ui";
-export const STORAGE_OPS = ["SET", "GET", "MERGE", "DELETE", "CLEAR"];
-const OP_DOT = {
-  SET: macOSColors.semantic.info,
-  GET: macOSColors.text.muted,
-  MERGE: macOSColors.semantic.debug,
-  DELETE: macOSColors.semantic.error,
-  CLEAR: macOSColors.semantic.warning
-};
-export function storageOpDot(op) {
-  return OP_DOT[op];
-}
-
-/** Both backends' action unions, collapsed onto the five display operations. */
-export function storageOpOf(event) {
-  const action = event.action;
-  if (action === "clear" || action === "clearAll") return "CLEAR";
-  if (action.startsWith("get.")) return "GET";
-  if (action === "removeItem" || action === "multiRemove" || action === "delete") return "DELETE";
-  if (action === "mergeItem" || action === "multiMerge") return "MERGE";
-  return "SET";
-}
-
-/**
- * The store synthesises one event per existing key when it first subscribes, so
- * the list isn't empty on open. Those are a SNAPSHOT, not a write: the key
- * already held that value, so there is no "before" to diff against and showing
- * one would invent a change that never happened.
- */
-export function isInitialScan(event) {
-  return Boolean(event.data?.initialScan);
-}
+"use strict";import{macOSColors as r}from"@buoy-gg/shared-ui";export const STORAGE_OPS=["SET","GET","MERGE","DELETE","CLEAR"];const n={SET:r.semantic.info,GET:r.text.muted,MERGE:r.semantic.debug,DELETE:r.semantic.error,CLEAR:r.semantic.warning};export function storageOpDot(e){return n[e]}export function storageOpOf(e){const t=e.action;if(t==="clear"||t==="clearAll")return"CLEAR";if(t.startsWith("get."))return"GET";if(t==="removeItem"||t==="multiRemove"||t==="delete")return"DELETE";if(t==="mergeItem"||t==="multiMerge")return"MERGE";return"SET"}export function isInitialScan(e){return Boolean(e.data?.initialScan)}

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

@@ -1,30 +1 @@
-"use strict";
-
-import { gameUIColors } from "@buoy-gg/shared-ui";
-/** Human readable label for a storage type id. */
-export function getStorageTypeLabel(storageType) {
-  switch (storageType) {
-    case "mmkv":
-      return "MMKV";
-    case "async":
-      return "Async";
-    case "secure":
-      return "Secure";
-    default:
-      return storageType;
-  }
-}
-
-/** Preferred color token for rendering a given storage type. */
-export function getStorageTypeHexColor(storageType) {
-  switch (storageType) {
-    case "mmkv":
-      return gameUIColors.info;
-    case "async":
-      return gameUIColors.warning;
-    case "secure":
-      return gameUIColors.success;
-    default:
-      return gameUIColors.muted;
-  }
-}
+"use strict";import{gameUIColors as r}from"@buoy-gg/shared-ui";export function getStorageTypeLabel(e){switch(e){case"mmkv":return"MMKV";case"async":return"Async";case"secure":return"Secure";default:return e}}export function getStorageTypeHexColor(e){switch(e){case"mmkv":return r.info;case"async":return r.warning;case"secure":return r.success;default:return r.muted}}