@buoy-gg/storage 7.0.40 → 7.0.42

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

@@ -1,194 +1 @@
-"use strict";
-
-/**
- * Expo SecureStore Registry
- *
- * SecureStore (iOS Keychain / Android KeyStore) has NO key-enumeration API —
- * unlike AsyncStorage (`getAllKeys`) and MMKV (`getAllKeys()`), there is no way
- * to ask "what's stored?". Apps must therefore register the keys they want
- * visible in the Storage tool.
- *
- * The SecureStore module itself is passed in at registration (never imported
- * here) — the same Metro-safe pattern as `registerMMKVInstance`: this package
- * has zero dependency on `expo-secure-store`, so bare RN apps without it
- * bundle fine.
- *
- * @module SecureStoreRegistry
- */
-
-/**
- * Subset of expo-secure-store's SecureStoreOptions that the tool tracks.
- * `keychainService` MUST match what the value was written with, or reads
- * return null. `requireAuthentication` keys trigger a biometric prompt on
- * read, so the tool never auto-reads them.
- *
- * @public
- */
-
-/**
- * Structural type for the expo-secure-store module. Matches
- * `import * as SecureStore from "expo-secure-store"` without depending on it.
- *
- * @public
- */
-
-/**
- * A key to expose in the Storage tool: either a bare key name, or a key with
- * the SecureStore options it was written with (+ optional description shown
- * in the expanded card).
- *
- * @public
- */
-
-/**
- * Normalized info for a registered SecureStore key.
- *
- * @public
- */
-
-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" ? {
-        key: d,
-        options: {}
-      } : {
-        key: d.key,
-        description: d.description,
-        options: {
-          keychainService: d.keychainService,
-          requireAuthentication: d.requireAuthentication,
-          authenticationPrompt: d.authenticationPrompt
-        }
-      };
-      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) {
-    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. */
-  getModule() {
-    return this.module;
-  }
-
-  /** All registered key entries. */
-  getAll() {
-    return Array.from(this.keys.values());
-  }
-
-  /** Number of registered keys. */
-  count() {
-    return this.keys.size;
-  }
-
-  /**
-   * Delete a stored value via the registered module, using the options the
-   * key was registered with (required for keychainService-scoped keys).
-   */
-  async deleteValue(key) {
-    const entry = this.keys.get(key);
-    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);
-  }
-}
-
-/**
- * Singleton registry instance (advanced usage — most apps only need
- * {@link registerSecureStoreKeys}).
- */
-export const secureStoreRegistry = new SecureStoreRegistry();
-
-/**
- * Register Expo SecureStore keys with React Buoy DevTools.
- *
- * **⚠️ REQUIRED for SecureStore visibility**: SecureStore has no
- * key-enumeration API, so the tool can only show keys you declare here.
- * Pass the module itself so this package never has to import
- * `expo-secure-store`.
- *
- * @example
- * ```typescript
- * import * as SecureStore from "expo-secure-store";
- * import { registerSecureStoreKeys } from "@buoy-gg/storage";
- *
- * registerSecureStoreKeys(SecureStore, [
- *   "auth.token",
- *   { key: "session", keychainService: "com.myapp.auth" },
- *   // Never auto-read; shown as biometric-protected:
- *   { key: "pin", requireAuthentication: true },
- * ]);
- * ```
- */
-export function registerSecureStoreKeys(module, keys) {
-  secureStoreRegistry.register(module, keys);
-}
-
-/**
- * Remove a key from the DevTools registry (the stored value is untouched).
- */
-export function unregisterSecureStoreKey(key) {
-  secureStoreRegistry.unregister(key);
-}
+"use strict";class n{module=null;keys=new Map;listeners=new Set;register(e,r){const i=this.signature();this.module=e;for(const t of r){const o=typeof t==="string"?{key:t,options:{}}:{key:t.key,description:t.description,options:{keychainService:t.keychainService,requireAuthentication:t.requireAuthentication,authenticationPrompt:t.authenticationPrompt}};this.keys.set(o.key,o)}if(this.signature()!==i)this.notify()}unregister(e){if(this.keys.delete(e))this.notify()}subscribe(e){this.listeners.add(e);return()=>{this.listeners.delete(e)}}signature(){return JSON.stringify(Array.from(this.keys.values()))}notify(){this.listeners.forEach(e=>{try{e()}catch{}})}getModule(){return this.module}getAll(){return Array.from(this.keys.values())}count(){return this.keys.size}async deleteValue(e){const r=this.keys.get(e);if(!this.module||!r)return;await this.module.deleteItemAsync(e,r.options)}async setValue(e,r){const i=this.keys.get(e);if(!this.module)throw new Error("No SecureStore module is registered");if(!i)throw new Error(`SecureStore key "${e}" is not registered`);if(i.options.requireAuthentication){throw new Error(`SecureStore key "${e}" is biometric-protected \u2014 DevTools never writes it`)}await this.module.setItemAsync(e,r,i.options)}}export const secureStoreRegistry=new n;export function registerSecureStoreKeys(s,e){secureStoreRegistry.register(s,e)}export function unregisterSecureStoreKey(s){secureStoreRegistry.unregister(s)}

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

@@ -1,81 +1 @@
-"use strict";
-
-/**
- * AsyncStorage compatibility adapter (v2 + v3)
- *
- * `@react-native-async-storage/async-storage` 3.x reshaped the default-export
- * API. The single-item methods kept their v2 signatures, but the batch + merge
- * methods changed:
- *
- *   v2 (what this package was written against)   v3
- *   ------------------------------------------   --------------------------------
- *   multiGet(keys): [key, value|null][]          getMany(keys): Record<key, value|null>
- *   multiSet([[k, v]]): void                     setMany({ k: v }): void
- *   multiRemove(keys): void                      removeMany(keys): void
- *   mergeItem / multiMerge                       removed entirely
- *
- * This module is the single seam between the storage tool and whichever
- * async-storage version the host app installed. The rest of the package always
- * speaks the v2 tuple-shaped API; we translate to v3 here when needed.
- *
- * Reads (`readMany`) are routed through the *unswizzled* native methods, so the
- * event listener can safely call them while capturing previous values without
- * re-triggering itself.
- */
-import RawAsyncStorage from "@react-native-async-storage/async-storage";
-
-// Loosely typed because the surface differs across major versions; callers go
-// through the helpers below rather than touching this directly.
-
-/** The live default-export object (methods may be swizzled by the listener). */
-export const asyncStorage = RawAsyncStorage;
-
-/**
- * Capability flags describing which API surface the installed version exposes.
- * `multiGet` only exists on v2; `mergeItem` was removed in v3.
- */
-export const asyncStorageCaps = {
-  /** v2 exposes multiGet/multiSet/multiRemove; v3 renamed these to *Many. */
-  hasLegacyMultiApi: typeof asyncStorage?.multiGet === "function",
-  /** v3 removed mergeItem/multiMerge with no replacement. */
-  hasMergeApi: typeof asyncStorage?.mergeItem === "function"
-};
-
-/**
- * Batch-read keys, normalized to the v2 `[key, value|null][]` tuple shape and
- * preserving the requested key order regardless of installed version.
- */
-export async function readMany(keys) {
-  if (typeof asyncStorage.multiGet === "function") {
-    return await asyncStorage.multiGet(keys);
-  }
-  // v3: getMany returns a Record; rebuild ordered tuples ("what you request is
-  // what you get" — missing keys come back as null).
-  const record = await asyncStorage.getMany(keys);
-  return keys.map(key => [key, record[key] ?? null]);
-}
-
-/**
- * Batch-write key/value pairs. Calls the live method (which may be swizzled by
- * the listener on v2's `multiSet` / v3's `setMany`) so writes still emit events.
- */
-export async function writeMany(pairs) {
-  if (typeof asyncStorage.multiSet === "function") {
-    return asyncStorage.multiSet(pairs);
-  }
-  const record = {};
-  for (const [key, value] of pairs) record[key] = value;
-  return asyncStorage.setMany(record);
-}
-
-/**
- * Batch-remove keys via the live method (swizzled on v2's `multiRemove` /
- * v3's `removeMany`).
- */
-export async function removeMany(keys) {
-  if (typeof asyncStorage.multiRemove === "function") {
-    return asyncStorage.multiRemove(keys);
-  }
-  return asyncStorage.removeMany(keys);
-}
-export default asyncStorage;
+"use strict";import r from"@react-native-async-storage/async-storage";export const asyncStorage=r;export const asyncStorageCaps={hasLegacyMultiApi:typeof asyncStorage?.multiGet==="function",hasMergeApi:typeof asyncStorage?.mergeItem==="function"};export async function readMany(t){if(typeof asyncStorage.multiGet==="function"){return await asyncStorage.multiGet(t)}const e=await asyncStorage.getMany(t);return t.map(n=>[n,e[n]??null])}export async function writeMany(t){if(typeof asyncStorage.multiSet==="function"){return asyncStorage.multiSet(t)}const e={};for(const[n,o]of t)e[n]=o;return asyncStorage.setMany(e)}export async function removeMany(t){if(typeof asyncStorage.multiRemove==="function"){return asyncStorage.multiRemove(t)}return asyncStorage.removeMany(t)}export default asyncStorage;

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

@@ -0,0 +1 @@
+"use strict";export function startBrowserStorageCapture(){return()=>{}}

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

@@ -0,0 +1 @@
+"use strict";import{getBrowserStorage as i,subscribeToBrowserStorage as u}from"@buoy-gg/shared-ui/utils";import{registerMMKVInstance as a,unregisterMMKVInstance as g}from"./MMKVInstanceRegistry";let n=0;const r=()=>i("sessionStorage");const s=()=>Array.from({length:r().length},(e,t)=>r().key(t)).filter(e=>e!==null);const f={set(e,t){r().setItem(e,String(t))},getString(e){return r().getItem(e)??void 0},getNumber(){return void 0},getBoolean(){return void 0},getBuffer(){return void 0},contains(e){return r().getItem(e)!==null},delete(e){const t=this.contains(e);r().removeItem(e);return t},getAllKeys:s,clearAll(){r().clear()},get size(){return s().reduce((e,t)=>e+2*(t.length+(r().getItem(t)?.length??0)),0)},addOnValueChangedListener(e){return{remove:u(t=>{if(t.area!=="sessionStorage")return;if(t.key!==void 0)e(t.key);else t.prevPairs?.forEach(([o])=>e(o))})}}};export function startBrowserStorageCapture(){if(typeof window==="undefined")return()=>{};try{r()}catch{return()=>{}}if(++n===1)a("sessionStorage",f);let e=true;return()=>{if(e){e=false;if(--n===0)g("sessionStorage")}}}

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

@@ -1,43 +1 @@
-"use strict";
-
-import AsyncStorage from "@react-native-async-storage/async-storage";
-import { removeMany } from "./asyncStorageCompat";
-import { isDevToolsStorageKey } from "@buoy-gg/shared-ui";
-
-/**
- * Clear all storage data except dev tools keys
- * This preserves dev tool settings while clearing app data
- */
-export async function clearAllAppStorage() {
-  // Get all keys
-  const allKeys = await AsyncStorage.getAllKeys();
-  if (!allKeys || allKeys.length === 0) {
-    // No keys to clear
-    return;
-  }
-
-  // Filter out dev tool keys - we don't want to clear those
-  const keysToRemove = allKeys.filter(key => !isDevToolsStorageKey(key));
-  if (keysToRemove.length === 0) {
-    // No app keys to clear (only dev tool keys found)
-    return;
-  }
-
-  // Clearing ${keysToRemove.length} app storage keys
-
-  // Remove all non-dev-tool keys
-  await removeMany(keysToRemove);
-
-  // Successfully cleared app storage
-}
-
-/**
- * Clear absolutely all storage data including dev tools
- * Use with caution - this will reset all dev tool settings
- */
-export async function clearAllStorageIncludingDevTools() {
-  // Clear everything
-  await AsyncStorage.clear();
-
-  // Successfully cleared all storage including dev tools
-}
+"use strict";import o from"@react-native-async-storage/async-storage";import{removeMany as a}from"./asyncStorageCompat";import{isDevToolsStorageKey as l}from"@buoy-gg/shared-ui";export async function clearAllAppStorage(){const e=await o.getAllKeys();if(!e||e.length===0){return}const t=e.filter(r=>!l(r));if(t.length===0){return}await a(t)}export async function clearAllStorageIncludingDevTools(){await o.clear()}

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

@@ -1,78 +1 @@
-"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. A
- * second copy of that fan-out is exactly how one backend quietly stops being
- * cleaned up — which is not hypothetical: the MMKV branch called a method
- * react-native-mmkv v4 had renamed, and deleting an MMKV key silently did
- * nothing until an e2e test deleted from all three backends at once.
- *
- * One call site today: the selection action bar. Deleting is deliberately not
- * an affordance on the row itself — see `StorageKeyRow`, whose expanded card
- * carries three actions and only one of them changes anything.
- *
- * 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";
-/**
- * Remove one key from an MMKV instance, whichever version it is.
- *
- * react-native-mmkv v4 renamed `delete(key)` to `remove(key)`. Calling the old
- * name on a v4 instance throws, and because the callers wrap deletion in a
- * try/catch that only surfaces an alert, the visible result was a key that
- * refused to delete — the same shape as a permissions problem or a read-only
- * instance, and nothing to point at the real cause.
- *
- * `storageSyncAdapter` and `snapshotProvider` already did this; this path was
- * the one that missed it.
- */
-function removeMMKVKey(instance, key) {
-  if (typeof instance.remove === "function") {
-    instance.remove(key);
-    return;
-  }
-  if (typeof instance.delete === "function") {
-    instance.delete(key);
-    return;
-  }
-  throw new Error("MMKV instance exposes neither remove() nor delete()");
-}
-
-/**
- * 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 => removeMMKVKey(inst.instance, key));
-      }
-    });
-  }
-}
+"use strict";import{removeMany as y}from"./asyncStorageCompat";import{secureStoreRegistry as m}from"./SecureStoreRegistry";function u(t,o){if(typeof t.remove==="function"){t.remove(o);return}if(typeof t.delete==="function"){t.delete(o);return}throw new Error("MMKV instance exposes neither remove() nor delete()")}export async function deleteStorageKeys(t,o){if(t.length===0)return;const i=t.filter(e=>e.storageType==="async");const f=t.filter(e=>e.storageType==="mmkv");const a=t.filter(e=>e.storageType==="secure");if(i.length>0){await y(i.map(e=>e.key))}for(const e of a){await m.deleteValue(e.key)}if(f.length>0){const e={};f.forEach(n=>{const r=n.instanceId||"default";if(!e[r])e[r]=[];e[r].push(n.key)});Object.entries(e).forEach(([n,r])=>{const c=o.find(s=>s.id===n);if(c){r.forEach(s=>u(c.instance,s))}})}}

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

@@ -1,12 +1 @@
-"use strict";
-
-/**
- * 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 { computeLineDiff, DiffType, ABSENT_VALUE, isAbsent } from "@buoy-gg/shared-ui/dataViewer";
+"use strict";export{computeLineDiff,DiffType,ABSENT_VALUE,isAbsent}from"@buoy-gg/shared-ui/dataViewer";

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

@@ -1,56 +1 @@
-"use strict";
-
-/**
- * MMKV Availability Detection
- *
- * Safely detects if react-native-mmkv is available in the current environment.
- * This allows the app to work in Expo Go where native modules aren't available.
- */
-
-let _isMMKVAvailable = null;
-let _MMKVClass = null;
-
-/**
- * Check if MMKV is available in the current environment
- *
- * @returns True if react-native-mmkv is installed and available
- */
-export function isMMKVAvailable() {
-  // Cache the result after first check
-  if (_isMMKVAvailable !== null) {
-    return _isMMKVAvailable;
-  }
-  try {
-    // Attempt to require MMKV
-    const MMKVModule = require('react-native-mmkv');
-
-    // v4 uses createMMKV factory function, v3 used MMKV class
-    // Try v4 API first (recommended), fall back to v3
-    _MMKVClass = MMKVModule.createMMKV || MMKVModule.MMKV;
-    _isMMKVAvailable = _MMKVClass !== undefined;
-    return _isMMKVAvailable;
-  } catch (error) {
-    // MMKV is not available (e.g., Expo Go, not installed)
-    _isMMKVAvailable = false;
-    return false;
-  }
-}
-
-/**
- * Get the MMKV class if available
- *
- * @returns MMKV class or null if not available
- */
-export function getMMKVClass() {
-  if (!isMMKVAvailable()) {
-    return null;
-  }
-  return _MMKVClass;
-}
-
-/**
- * Get a user-friendly error message when MMKV is not available
- */
-export function getMMKVUnavailableMessage() {
-  return 'MMKV is not available in this environment. MMKV requires native modules and cannot run in Expo Go. Please use a development build or EAS Build.';
-}
+"use strict";let e=null;let t=null;export function isMMKVAvailable(){if(e!==null){return e}try{const n=require("react-native-mmkv");t=n.createMMKV||n.MMKV;e=t!==void 0;return e}catch(n){e=false;return false}}export function getMMKVClass(){if(!isMMKVAvailable()){return null}return t}export function getMMKVUnavailableMessage(){return"MMKV is not available in this environment. MMKV requires native modules and cannot run in Expo Go. Please use a development build or EAS Build."}

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

@@ -0,0 +1 @@
+"use strict";export function isMMKVAvailable(){try{return typeof window!=="undefined"&&!!window.sessionStorage}catch{return false}}export function getMMKVClass(){return null}export function getMMKVUnavailableMessage(){return"Session storage is unavailable in this browser context."}

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

@@ -1,148 +1 @@
-"use strict";
-
-/**
- * MMKV Type Detection Utilities
- *
- * MMKV stores values with native types (string, number, boolean, ArrayBuffer).
- * This module provides utilities to detect the type of a stored value by trying
- * each getter sequentially.
- */
-
-// Use 'any' type for MMKV to avoid hard dependency on react-native-mmkv
-
-/**
- * Detect the type of a value stored in MMKV by trying each getter.
- *
- * Since MMKV doesn't provide a getType() method, we must try each getter
- * (getString, getNumber, getBoolean, getBuffer) until one returns a value.
- *
- * Order matters: We try in order of most common types first.
- *
- * @param instance - MMKV instance to read from
- * @param key - Storage key
- * @returns Value and its detected type
- *
- * @example
- * ```typescript
- * const instance = createMMKV();
- * instance.set('name', 'John');
- * instance.set('age', 30);
- * instance.set('active', true);
- *
- * detectMMKVType(instance, 'name');   // { value: 'John', type: 'string' }
- * detectMMKVType(instance, 'age');    // { value: 30, type: 'number' }
- * detectMMKVType(instance, 'active'); // { value: true, type: 'boolean' }
- * detectMMKVType(instance, 'missing');// { value: undefined, type: 'unknown' }
- * ```
- */
-export function detectMMKVType(instance, key) {
-  // MMKV stores no type metadata, so the native getters can cross-read: in
-  // particular `getString` returns "" (an empty string, NOT undefined) for many
-  // non-string values like numbers and `false`. Trying getString first and
-  // trusting its result therefore mis-detects those as empty strings — e.g.
-  // a key set to 42 or false would render as "". Probe the getters and only let
-  // getString win when it returns a NON-empty string; treat an empty result as
-  // ambiguous and prefer the number/boolean getters.
-  const stringValue = instance.getString(key);
-
-  // A non-empty string is unambiguously a string.
-  if (stringValue !== undefined && stringValue !== '') {
-    return {
-      value: stringValue,
-      type: 'string'
-    };
-  }
-
-  // Empty getString result is ambiguous (genuine "" vs a number/boolean the
-  // native layer decoded to ""). Prefer typed getters when they have a value.
-  const numberValue = instance.getNumber(key);
-  if (numberValue !== undefined) {
-    return {
-      value: numberValue,
-      type: 'number'
-    };
-  }
-  const booleanValue = instance.getBoolean(key);
-  if (booleanValue !== undefined) {
-    return {
-      value: booleanValue,
-      type: 'boolean'
-    };
-  }
-
-  // getString returned "" and nothing else matched -> a genuine empty string.
-  if (stringValue === '') {
-    return {
-      value: '',
-      type: 'string'
-    };
-  }
-
-  // Try buffer (least common)
-  const bufferValue = instance.getBuffer(key);
-  if (bufferValue !== undefined) {
-    // Format buffer for display (don't return raw ArrayBuffer)
-    return {
-      value: `<ArrayBuffer ${bufferValue.byteLength} bytes>`,
-      type: 'buffer'
-    };
-  }
-
-  // Key doesn't exist or unknown type
-  return {
-    value: undefined,
-    type: 'unknown'
-  };
-}
-
-/**
- * Format an MMKV value for display in the UI.
- *
- * @param value - The value to format
- * @param type - The detected type
- * @returns Formatted string representation
- *
- * @example
- * ```typescript
- * formatMMKVValue('hello', 'string');  // '"hello"'
- * formatMMKVValue(42, 'number');       // '42'
- * formatMMKVValue(true, 'boolean');    // 'true'
- * formatMMKVValue('<ArrayBuffer 1024 bytes>', 'buffer'); // '<ArrayBuffer 1024 bytes>'
- * ```
- */
-export function formatMMKVValue(value, type) {
-  if (value === undefined) return 'undefined';
-  if (value === null) return 'null';
-  switch (type) {
-    case 'string':
-      return `"${value}"`;
-    case 'number':
-      return String(value);
-    case 'boolean':
-      return value ? 'true' : 'false';
-    case 'buffer':
-      // Value is already formatted as "<ArrayBuffer X bytes>"
-      return value;
-    case 'unknown':
-      return 'unknown';
-    default:
-      return String(value);
-  }
-}
-
-/**
- * Check if a value type matches an expected type for validation.
- *
- * @param actualType - Detected type
- * @param expectedType - Expected type from configuration
- * @returns True if types match
- *
- * @example
- * ```typescript
- * isTypeMatch('string', 'string');  // true
- * isTypeMatch('number', 'string');  // false
- * ```
- */
-export function isTypeMatch(actualType, expectedType) {
-  return actualType === expectedType;
-}
+"use strict";export function detectMMKVType(e,n){const r=e.getString(n);if(r!==void 0&&r!==""){return{value:r,type:"string"}}const t=e.getNumber(n);if(t!==void 0){return{value:t,type:"number"}}const u=e.getBoolean(n);if(u!==void 0){return{value:u,type:"boolean"}}if(r===""){return{value:"",type:"string"}}const f=e.getBuffer(n);if(f!==void 0){return{value:`<ArrayBuffer ${f.byteLength} bytes>`,type:"buffer"}}return{value:void 0,type:"unknown"}}export function formatMMKVValue(e,n){if(e===void 0)return"undefined";if(e===null)return"null";switch(n){case"string":return`"${e}"`;case"number":return String(e);case"boolean":return e?"true":"false";case"buffer":return e;case"unknown":return"unknown";default:return String(e)}}export function isTypeMatch(e,n){return e===n}

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

@@ -1,13 +1 @@
-"use strict";
-
-/**
- * Whether a required-key declaration should be enforced by a given backend
- * hook. Explicit `storageType` wins; bare string keys default to AsyncStorage
- * (the historical zero-config backend). Objects without `storageType` still
- * apply to every backend — matching prior behavior for apps that never set it.
- */
-export function requiredKeyAppliesTo(req, backend) {
-  if (typeof req === "string") return backend === "async";
-  if (req.storageType) return req.storageType === backend;
-  return true;
-}
+"use strict";export function requiredKeyAppliesTo(e,r){if(typeof e==="string")return r==="async";if(e.storageType)return e.storageType===r;return true}