@buoy-gg/storage 1.7.2

package/lib/typescript/storage/utils/lineDiff.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Line-by-line diff computation for React Native
+ * Adapted from react-diff-viewer for object comparison
+ */
+export declare enum DiffType {
+    DEFAULT = "unchanged",
+    ADDED = "added",
+    REMOVED = "removed",
+    MODIFIED = "modified"
+}
+export interface WordDiff {
+    value: string;
+    type: DiffType;
+}
+export interface LineDiffInfo {
+    leftLineNumber?: number;
+    rightLineNumber?: number;
+    type: DiffType;
+    leftContent?: string | WordDiff[];
+    rightContent?: string | WordDiff[];
+    leftRaw?: string;
+    rightRaw?: string;
+}
+export interface DiffComputeOptions {
+    compareMethod?: "chars" | "words" | "lines" | "trimmedLines";
+    disableWordDiff?: boolean;
+    showDiffOnly?: boolean;
+    contextLines?: number;
+}
+/**
+ * Compute line-by-line diff between two objects
+ */
+export declare function computeLineDiff(oldValue: unknown, newValue: unknown, options?: DiffComputeOptions): LineDiffInfo[];
+//# sourceMappingURL=lineDiff.d.ts.map

package/lib/typescript/storage/utils/lineDiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lineDiff.d.ts","sourceRoot":"","sources":["../../../../src/storage/utils/lineDiff.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,oBAAY,QAAQ;IAClB,OAAO,cAAc;IACrB,KAAK,UAAU;IACf,OAAO,YAAY;IACnB,QAAQ,aAAa;CACtB;AAED,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,CAAC;CAChB;AAED,MAAM,WAAW,YAAY;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,IAAI,EAAE,QAAQ,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,GAAG,QAAQ,EAAE,CAAC;IAClC,YAAY,CAAC,EAAE,MAAM,GAAG,QAAQ,EAAE,CAAC;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAqJD,MAAM,WAAW,kBAAkB;IACjC,aAAa,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,cAAc,CAAC;IAC7D,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AA+ED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,OAAO,EACjB,QAAQ,EAAE,OAAO,EACjB,OAAO,GAAE,kBAAuB,GAC/B,YAAY,EAAE,CA4HhB"}

package/lib/typescript/storage/utils/mmkvAvailability.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ */
+/**
+ * Check if MMKV is available in the current environment
+ *
+ * @returns True if react-native-mmkv is installed and available
+ */
+export declare function isMMKVAvailable(): boolean;
+/**
+ * Get the MMKV class if available
+ *
+ * @returns MMKV class or null if not available
+ */
+export declare function getMMKVClass(): any | null;
+/**
+ * Get a user-friendly error message when MMKV is not available
+ */
+export declare function getMMKVUnavailableMessage(): string;
+//# sourceMappingURL=mmkvAvailability.d.ts.map

package/lib/typescript/storage/utils/mmkvAvailability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mmkvAvailability.d.ts","sourceRoot":"","sources":["../../../../src/storage/utils/mmkvAvailability.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAoBzC;AAED;;;;GAIG;AACH,wBAAgB,YAAY,IAAI,GAAG,GAAG,IAAI,CAKzC;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,CAElD"}

package/lib/typescript/storage/utils/mmkvTypeDetection.d.ts

@@ -0,0 +1,71 @@
+/**
+ * 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.
+ */
+type MMKV = any;
+export type MMKVValueType = 'string' | 'number' | 'boolean' | 'buffer' | 'unknown';
+export interface MMKVValueInfo {
+    value: any;
+    type: MMKVValueType;
+}
+/**
+ * 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 declare function detectMMKVType(instance: MMKV, key: string): MMKVValueInfo;
+/**
+ * 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 declare function formatMMKVValue(value: any, type: MMKVValueType): string;
+/**
+ * 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 declare function isTypeMatch(actualType: MMKVValueType, expectedType: string): boolean;
+export {};
+//# sourceMappingURL=mmkvTypeDetection.d.ts.map

package/lib/typescript/storage/utils/mmkvTypeDetection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mmkvTypeDetection.d.ts","sourceRoot":"","sources":["../../../../src/storage/utils/mmkvTypeDetection.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,KAAK,IAAI,GAAG,GAAG,CAAC;AAEhB,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEnF,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,GAAG,CAAC;IACX,IAAI,EAAE,aAAa,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,aAAa,CA+BzE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,aAAa,GAAG,MAAM,CAmBvE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,UAAU,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAEpF"}

package/lib/typescript/storage/utils/objectDiff.d.ts

@@ -0,0 +1,35 @@
+export interface DiffItem {
+    type: "CREATE" | "REMOVE" | "CHANGE";
+    path: (string | number)[];
+    value?: unknown;
+    oldValue?: unknown;
+}
+/**
+ * Generate a comprehensive diff between two objects or values
+ *
+ * This function performs a deep comparison between two values and returns
+ * a detailed list of all differences, including additions, removals, and changes.
+ * Each difference includes the exact path where the change occurred.
+ *
+ * @param oldObj - The original object/value to compare from
+ * @param newObj - The new object/value to compare to
+ * @returns Array of DiffItem objects describing all differences
+ *
+ * @example
+ * ```typescript
+ * const oldData = { user: { name: "John", age: 30 }, items: [1, 2] };
+ * const newData = { user: { name: "Jane", age: 30 }, items: [1, 2, 3] };
+ *
+ * const diffs = objectDiff(oldData, newData);
+ * // Returns:
+ * // [
+ * //   { type: "CHANGE", path: ["user", "name"], oldValue: "John", value: "Jane" },
+ * //   { type: "CREATE", path: ["items", 2], value: 3 }
+ * // ]
+ * ```
+ *
+ * @performance Handles circular references and deep nesting efficiently
+ * @performance Uses Set for key deduplication to optimize comparison speed
+ */
+export declare function objectDiff(oldObj: unknown, newObj: unknown): DiffItem[];
+//# sourceMappingURL=objectDiff.d.ts.map

package/lib/typescript/storage/utils/objectDiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objectDiff.d.ts","sourceRoot":"","sources":["../../../../src/storage/utils/objectDiff.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACrC,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAC1B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AA2GD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,QAAQ,EAAE,CA+BvE"}

package/lib/typescript/storage/utils/safeAsyncStorage.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Safe AsyncStorage wrapper that handles missing dependencies gracefully.
+ *
+ * This wrapper allows the storage dev tools to work even when
+ * @react-native-async-storage/async-storage is not installed in the host app.
+ *
+ * When AsyncStorage is not available:
+ * - All operations return empty results or no-ops
+ * - No errors are thrown
+ * - The dev tools can still load (but storage features will be limited)
+ */
+/**
+ * Returns true if AsyncStorage is available in the host app
+ */
+export declare function isAsyncStorageAvailable(): boolean;
+/**
+ * Safe AsyncStorage wrapper that provides no-op fallbacks when unavailable.
+ *
+ * Usage:
+ * ```ts
+ * import { safeAsyncStorage } from './utils/safeAsyncStorage';
+ *
+ * // This will work even if AsyncStorage is not installed
+ * const value = await safeAsyncStorage.getItem('myKey');
+ * ```
+ */
+export declare const safeAsyncStorage: {
+    getItem: (_key: string) => Promise<string | null>;
+    setItem: (_key: string, _value: string) => Promise<void>;
+    removeItem: (_key: string) => Promise<void>;
+    getAllKeys: () => Promise<string[]>;
+    multiGet: (_keys: string[]) => Promise<[string, string | null][]>;
+    multiSet: (_keyValuePairs: [string, string][]) => Promise<void>;
+    multiRemove: (_keys: string[]) => Promise<void>;
+    clear: () => Promise<void>;
+    mergeItem: (_key: string, _value: string) => Promise<void>;
+    multiMerge: (_keyValuePairs: [string, string][]) => Promise<void>;
+};
+/**
+ * Get the actual AsyncStorage instance if available, or null if not.
+ * Use this when you need to check if AsyncStorage is available before using it.
+ *
+ * @example
+ * ```ts
+ * const storage = getAsyncStorageInstance();
+ * if (storage) {
+ *   // AsyncStorage is available
+ *   await storage.setItem('key', 'value');
+ * } else {
+ *   // AsyncStorage is not available, handle gracefully
+ *   console.warn('AsyncStorage not available');
+ * }
+ * ```
+ */
+export declare function getAsyncStorageInstance(): any | null;
+//# sourceMappingURL=safeAsyncStorage.d.ts.map

package/lib/typescript/storage/utils/safeAsyncStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeAsyncStorage.d.ts","sourceRoot":"","sources":["../../../../src/storage/utils/safeAsyncStorage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAgDH;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,OAAO,CAEjD;AAkBD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB;oBAvBL,MAAM,KAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;oBAC/B,MAAM,UAAU,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;uBACnC,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;sBACzB,OAAO,CAAC,MAAM,EAAE,CAAC;sBACf,MAAM,EAAE,KAAG,OAAO,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;+BACpC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,KAAG,OAAO,CAAC,IAAI,CAAC;yBACxC,MAAM,EAAE,KAAG,OAAO,CAAC,IAAI,CAAC;iBAClC,OAAO,CAAC,IAAI,CAAC;sBACN,MAAM,UAAU,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;iCAC3B,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,KAAG,OAAO,CAAC,IAAI,CAAC;CAmCrE,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,uBAAuB,IAAI,GAAG,GAAG,IAAI,CAGpD"}

package/lib/typescript/storage/utils/storageActionHelpers.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Translates storage action types to human-readable labels
+ */
+export declare function translateStorageAction(action: string): string;
+//# sourceMappingURL=storageActionHelpers.d.ts.map

package/lib/typescript/storage/utils/storageActionHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storageActionHelpers.d.ts","sourceRoot":"","sources":["../../../../src/storage/utils/storageActionHelpers.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAqC7D"}

package/lib/typescript/storage/utils/storageQueryUtils.d.ts

@@ -0,0 +1,6 @@
+export type StorageType = "mmkv" | "async" | "secure";
+/** Human readable label for a storage type id. */
+export declare function getStorageTypeLabel(storageType: StorageType): string;
+/** Preferred color token for rendering a given storage type. */
+export declare function getStorageTypeHexColor(storageType: StorageType): string;
+//# sourceMappingURL=storageQueryUtils.d.ts.map

package/lib/typescript/storage/utils/storageQueryUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storageQueryUtils.d.ts","sourceRoot":"","sources":["../../../../src/storage/utils/storageQueryUtils.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEtD,kDAAkD;AAClD,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM,CAWpE;AAED,gEAAgE;AAChE,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM,CAWvE"}

package/lib/typescript/storage/utils/valueType.d.ts

@@ -0,0 +1,3 @@
+/** Return a concise string describing the JavaScript type of the provided value. */
+export declare function getValueTypeLabel(value: unknown): string;
+//# sourceMappingURL=valueType.d.ts.map

package/lib/typescript/storage/utils/valueType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueType.d.ts","sourceRoot":"","sources":["../../../../src/storage/utils/valueType.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAYxD"}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@buoy-gg/storage",
+  "version": "1.7.2",
+  "description": "storage package",
+  "main": "lib/commonjs/index.js",
+  "module": "lib/module/index.js",
+  "types": "lib/typescript/index.d.ts",
+  "react-native": "src/index.tsx",
+  "source": "src/index.tsx",
+  "files": [
+    "lib"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "bob build",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "bob build",
+    "clean": "rimraf lib",
+    "test": "pnpm run typecheck"
+  },
+  "dependencies": {
+    "@buoy-gg/floating-tools-core": "workspace:*",
+    "@buoy-gg/shared-ui": "workspace:*"
+  },
+  "peerDependencies": {
+    "@react-native-async-storage/async-storage": ">=1.0.0",
+    "react": "*",
+    "react-native": "*"
+  },
+  "devDependencies": {
+    "@react-native-async-storage/async-storage": "^2.1.0",
+    "@types/react": "^19.1.0",
+    "@types/react-native": "^0.73.0",
+    "typescript": "~5.8.3"
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "commonjs",
+        {
+          "sourceMaps": false
+        }
+      ],
+      [
+        "module",
+        {
+          "sourceMaps": false
+        }
+      ],
+      "typescript"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LovesWorking/react-native-buoy.git",
+    "directory": "packages/storage"
+  },
+  "bugs": {
+    "url": "https://github.com/LovesWorking/react-native-buoy/issues"
+  },
+  "homepage": "https://github.com/LovesWorking/react-native-buoy/tree/main/packages/storage#readme",
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  }
+}