@buoy-gg/storage 7.0.41 → 7.0.42

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}

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