react-native-inapp-inspector 2.2.2 → 2.2.4

package/dist/esm/customHooks/storageInspector.js

@@ -0,0 +1,469 @@
+// Universal In-App Storage Inspector Adapter for AsyncStorage & MMKV
+// Supports automatic module resolution, NativeModules SQLite fallback, custom instances, and full CRUD operations.
+import { NativeModules } from 'react-native';
+// In-memory registered storage references
+let customAsyncStorage = null;
+const customMMKVInstances = new Map();
+// Listeners for storage mutations
+const changeListeners = new Set();
+const notifyChange = () => {
+    changeListeners.forEach(listener => {
+        try {
+            listener();
+        }
+        catch { }
+    });
+};
+/**
+ * Register an AsyncStorage instance with the inspector (optional override).
+ */
+export const connectAsyncStorage = (storageInstance) => {
+    if (storageInstance) {
+        customAsyncStorage = storageInstance;
+        notifyChange();
+    }
+};
+/**
+ * Register an MMKV instance with the inspector (optional override).
+ */
+export const connectMMKV = (mmkvInstance, id = 'default') => {
+    if (mmkvInstance) {
+        customMMKVInstances.set(id, mmkvInstance);
+        notifyChange();
+    }
+};
+/**
+ * Native Bridge Fallback for AsyncStorage:
+ * Directly interfaces with NativeModules.RNCAsyncStorage without needing JS package imports.
+ */
+const getNativeAsyncStorageBridge = () => {
+    const nativeModule = NativeModules.RNCAsyncStorage ||
+        NativeModules.RNC_AsyncSQLiteDBStorage ||
+        NativeModules.AsyncSQLiteDBStorage;
+    if (nativeModule) {
+        return {
+            getAllKeys: () => {
+                return new Promise((resolve, reject) => {
+                    if (typeof nativeModule.getAllKeys !== 'function') {
+                        resolve([]);
+                        return;
+                    }
+                    nativeModule.getAllKeys((err, keys) => {
+                        if (err)
+                            reject(err);
+                        else
+                            resolve(keys || []);
+                    });
+                });
+            },
+            multiGet: (keys) => {
+                return new Promise((resolve, reject) => {
+                    if (typeof nativeModule.multiGet !== 'function') {
+                        resolve([]);
+                        return;
+                    }
+                    nativeModule.multiGet(keys, (err, result) => {
+                        if (err)
+                            reject(err);
+                        else
+                            resolve(result || []);
+                    });
+                });
+            },
+            getItem: (key) => {
+                return new Promise((resolve, reject) => {
+                    if (typeof nativeModule.multiGet !== 'function') {
+                        resolve(null);
+                        return;
+                    }
+                    nativeModule.multiGet([key], (err, result) => {
+                        if (err)
+                            reject(err);
+                        else
+                            resolve(result?.[0]?.[1] ?? null);
+                    });
+                });
+            },
+            setItem: (key, value) => {
+                return new Promise((resolve, reject) => {
+                    if (typeof nativeModule.multiSet !== 'function') {
+                        resolve();
+                        return;
+                    }
+                    nativeModule.multiSet([[key, value]], (err) => {
+                        if (err)
+                            reject(err);
+                        else
+                            resolve();
+                    });
+                });
+            },
+            removeItem: (key) => {
+                return new Promise((resolve, reject) => {
+                    if (typeof nativeModule.multiRemove !== 'function') {
+                        resolve();
+                        return;
+                    }
+                    nativeModule.multiRemove([key], (err) => {
+                        if (err)
+                            reject(err);
+                        else
+                            resolve();
+                    });
+                });
+            },
+            clear: () => {
+                return new Promise((resolve, reject) => {
+                    if (typeof nativeModule.clear !== 'function') {
+                        resolve();
+                        return;
+                    }
+                    nativeModule.clear((err) => {
+                        if (err)
+                            reject(err);
+                        else
+                            resolve();
+                    });
+                });
+            },
+        };
+    }
+    return null;
+};
+/**
+ * Auto-detect AsyncStorage:
+ * 1. Explicit connection
+ * 2. Global instance
+ * 3. Dynamic require '@react-native-async-storage/async-storage'
+ * 4. Native Bridge Direct interface
+ */
+export const getResolvedAsyncStorage = () => {
+    if (customAsyncStorage)
+        return customAsyncStorage;
+    // 1. Global instances
+    try {
+        const maybeReq = globalThis?.__inAppAsyncStorage ||
+            globalThis?.AsyncStorage ||
+            global?.AsyncStorage;
+        if (maybeReq && typeof maybeReq.getAllKeys === 'function') {
+            return maybeReq;
+        }
+    }
+    catch { }
+    // 2. Dynamic runtime require
+    try {
+        const req = typeof globalThis?.require === 'function'
+            ? globalThis.require
+            : typeof require === 'function'
+                ? require
+                : null;
+        if (req) {
+            try {
+                const mod = req('@react-native-async-storage/async-storage');
+                const resolved = mod?.default || mod;
+                if (resolved && typeof resolved.getAllKeys === 'function') {
+                    return resolved;
+                }
+            }
+            catch { }
+            try {
+                const legacyMod = req('@react-native-community/async-storage');
+                const resolved = legacyMod?.default || legacyMod;
+                if (resolved && typeof resolved.getAllKeys === 'function') {
+                    return resolved;
+                }
+            }
+            catch { }
+        }
+    }
+    catch { }
+    // 3. Native Bridge Fallback (Direct SQLite)
+    const nativeBridge = getNativeAsyncStorageBridge();
+    if (nativeBridge) {
+        return nativeBridge;
+    }
+    return null;
+};
+/**
+ * Auto-detect MMKV:
+ * 1. Explicit connection
+ * 2. Dynamic require 'react-native-mmkv' & instantiate default instance
+ * 3. Global MMKV / JSI instances
+ */
+export const getResolvedMMKV = (id = 'default') => {
+    if (customMMKVInstances.has(id)) {
+        return customMMKVInstances.get(id);
+    }
+    // 1. Dynamic require
+    try {
+        const req = typeof globalThis?.require === 'function'
+            ? globalThis.require
+            : typeof require === 'function'
+                ? require
+                : null;
+        if (req) {
+            const mmkvMod = req('react-native-mmkv');
+            const MMKVClass = mmkvMod?.MMKV || mmkvMod?.default?.MMKV;
+            if (MMKVClass && typeof MMKVClass === 'function') {
+                if (!customMMKVInstances.has('default')) {
+                    try {
+                        const defaultInst = new MMKVClass();
+                        customMMKVInstances.set('default', defaultInst);
+                    }
+                    catch { }
+                }
+            }
+        }
+    }
+    catch { }
+    // 2. Global references
+    try {
+        const globalMMKV = globalThis?.mmkv ||
+            global?.mmkv ||
+            globalThis?.__MMKV__;
+        if (globalMMKV && typeof globalMMKV.getAllKeys === 'function') {
+            if (!customMMKVInstances.has('default')) {
+                customMMKVInstances.set('default', globalMMKV);
+            }
+        }
+    }
+    catch { }
+    if (customMMKVInstances.has(id)) {
+        return customMMKVInstances.get(id);
+    }
+    if (customMMKVInstances.size > 0) {
+        return customMMKVInstances.values().next().value;
+    }
+    return null;
+};
+export const isAsyncStorageConnected = () => {
+    return Boolean(getResolvedAsyncStorage());
+};
+export const isMMKVConnected = () => {
+    return Boolean(getResolvedMMKV());
+};
+export const getRegisteredMMKVInstanceIds = () => {
+    getResolvedMMKV(); // trigger auto-discovery
+    return Array.from(customMMKVInstances.keys());
+};
+/**
+ * Calculate approximate byte size of a UTF-8 string
+ */
+export const calculateByteSize = (str) => {
+    if (!str)
+        return 0;
+    return str.length * 2;
+};
+/**
+ * Determine type and format value safely
+ */
+export const analyzeStorageValue = (rawVal) => {
+    if (rawVal === null || rawVal === undefined) {
+        return { strVal: 'null', type: 'null', byteSize: 4 };
+    }
+    const strVal = typeof rawVal === 'string' ? rawVal : String(rawVal);
+    const byteSize = calculateByteSize(strVal);
+    if (typeof rawVal === 'number') {
+        return { strVal, parsedVal: rawVal, type: 'number', byteSize };
+    }
+    if (typeof rawVal === 'boolean') {
+        return { strVal, parsedVal: rawVal, type: 'boolean', byteSize };
+    }
+    const trimmed = strVal.trim();
+    if ((trimmed.startsWith('{') && trimmed.endsWith('}')) ||
+        (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            return { strVal, parsedVal: parsed, type: 'json', byteSize };
+        }
+        catch { }
+    }
+    if (trimmed === 'true' || trimmed === 'false') {
+        return { strVal, parsedVal: trimmed === 'true', type: 'boolean', byteSize };
+    }
+    if (!isNaN(Number(trimmed)) && trimmed !== '') {
+        return { strVal, parsedVal: Number(trimmed), type: 'number', byteSize };
+    }
+    return { strVal, type: 'string', byteSize };
+};
+/**
+ * Fetch all storage entries for given driver
+ */
+export const fetchStorageEntries = async (driver, instanceId) => {
+    const entries = [];
+    if (driver === 'asyncStorage') {
+        const storage = getResolvedAsyncStorage();
+        if (!storage || typeof storage.getAllKeys !== 'function') {
+            return [];
+        }
+        try {
+            const keys = await storage.getAllKeys();
+            if (!keys || keys.length === 0)
+                return [];
+            if (typeof storage.multiGet === 'function') {
+                const pairs = await storage.multiGet(keys);
+                for (const [k, v] of pairs) {
+                    const analysis = analyzeStorageValue(v);
+                    entries.push({
+                        key: k,
+                        value: analysis.strVal,
+                        parsedValue: analysis.parsedVal,
+                        type: analysis.type,
+                        byteSize: analysis.byteSize,
+                    });
+                }
+            }
+            else {
+                for (const k of keys) {
+                    const v = await storage.getItem(k);
+                    const analysis = analyzeStorageValue(v);
+                    entries.push({
+                        key: k,
+                        value: analysis.strVal,
+                        parsedValue: analysis.parsedVal,
+                        type: analysis.type,
+                        byteSize: analysis.byteSize,
+                    });
+                }
+            }
+        }
+        catch (err) {
+            console.warn('[StorageInspector] Error reading AsyncStorage keys:', err);
+        }
+    }
+    else if (driver === 'mmkv') {
+        const mmkv = getResolvedMMKV(instanceId);
+        if (!mmkv || typeof mmkv.getAllKeys !== 'function') {
+            return [];
+        }
+        try {
+            const keys = mmkv.getAllKeys();
+            for (const k of keys) {
+                let rawVal = null;
+                if (typeof mmkv.getString === 'function') {
+                    rawVal = mmkv.getString(k);
+                }
+                if (rawVal === undefined || rawVal === null) {
+                    if (typeof mmkv.getNumber === 'function') {
+                        const num = mmkv.getNumber(k);
+                        if (num !== undefined && !isNaN(num))
+                            rawVal = num;
+                    }
+                }
+                if (rawVal === undefined || rawVal === null) {
+                    if (typeof mmkv.getBoolean === 'function') {
+                        const bool = mmkv.getBoolean(k);
+                        if (bool !== undefined)
+                            rawVal = bool;
+                    }
+                }
+                const analysis = analyzeStorageValue(rawVal);
+                entries.push({
+                    key: k,
+                    value: analysis.strVal,
+                    parsedValue: analysis.parsedVal,
+                    type: analysis.type,
+                    byteSize: analysis.byteSize,
+                });
+            }
+        }
+        catch (err) {
+            console.warn('[StorageInspector] Error reading MMKV keys:', err);
+        }
+    }
+    // Sort alphabetically by key
+    entries.sort((a, b) => a.key.localeCompare(b.key));
+    return entries;
+};
+/**
+ * Create or Update a key-value entry (CRUD: Create / Update)
+ */
+export const setStorageEntry = async (driver, key, value, instanceId) => {
+    if (!key.trim())
+        return false;
+    try {
+        if (driver === 'asyncStorage') {
+            const storage = getResolvedAsyncStorage();
+            if (!storage || typeof storage.setItem !== 'function')
+                return false;
+            await storage.setItem(key.trim(), value);
+            notifyChange();
+            return true;
+        }
+        else if (driver === 'mmkv') {
+            const mmkv = getResolvedMMKV(instanceId);
+            if (!mmkv || typeof mmkv.set !== 'function')
+                return false;
+            mmkv.set(key.trim(), value);
+            notifyChange();
+            return true;
+        }
+    }
+    catch (err) {
+        console.warn('[StorageInspector] Error setting storage item:', err);
+    }
+    return false;
+};
+/**
+ * Delete a single key (CRUD: Delete)
+ */
+export const removeStorageEntry = async (driver, key, instanceId) => {
+    try {
+        if (driver === 'asyncStorage') {
+            const storage = getResolvedAsyncStorage();
+            if (!storage || typeof storage.removeItem !== 'function')
+                return false;
+            await storage.removeItem(key);
+            notifyChange();
+            return true;
+        }
+        else if (driver === 'mmkv') {
+            const mmkv = getResolvedMMKV(instanceId);
+            if (!mmkv || typeof mmkv.delete !== 'function')
+                return false;
+            mmkv.delete(key);
+            notifyChange();
+            return true;
+        }
+    }
+    catch (err) {
+        console.warn('[StorageInspector] Error removing storage item:', err);
+    }
+    return false;
+};
+/**
+ * Wipe all keys for given storage (CRUD: Clear All)
+ */
+export const clearStorageDriver = async (driver, instanceId) => {
+    try {
+        if (driver === 'asyncStorage') {
+            const storage = getResolvedAsyncStorage();
+            if (!storage || typeof storage.clear !== 'function')
+                return false;
+            await storage.clear();
+            notifyChange();
+            return true;
+        }
+        else if (driver === 'mmkv') {
+            const mmkv = getResolvedMMKV(instanceId);
+            if (!mmkv || typeof mmkv.clearAll !== 'function')
+                return false;
+            mmkv.clearAll();
+            notifyChange();
+            return true;
+        }
+    }
+    catch (err) {
+        console.warn('[StorageInspector] Error clearing storage:', err);
+    }
+    return false;
+};
+/**
+ * Subscribe to storage mutations
+ */
+export const subscribeToStorageChanges = (listener) => {
+    changeListeners.add(listener);
+    return () => {
+        changeListeners.delete(listener);
+    };
+};

package/dist/esm/i18n/locales/en.json

@@ -36,7 +36,12 @@
         "apis": "APIs",
         "logs": "Logs",
         "analytics": "Analytics",
-        "redux": "Redux"
+        "redux": "Redux",
+        "bundle": "Bundle",
+        "performance": "Performance",
+        "crash": "Crash",
+        "device": "Device",
+        "storage": "Storage"
     },
     "settings": {
         "mainTitle": "Settings & Modules",
@@ -51,7 +56,8 @@
         "dormantBadge": "DORMANT",
         "protectedBadge": "PROTECTED",
         "modulesAndTools": "Modules & Tools",
-        "uiPreferences": "UI Preferences",
+        "uiPreferences": "UI & Display",
+        "ramLimits": "RAM & Limits",
         "zeroOverheadTitle": "Zero Background Overhead",
         "zeroOverheadDesc": "Check the modules you wish to activate. Disabled modules consume 0% CPU & memory until saved.",
         "unsavedPending": "● Unsaved selections pending",

package/dist/esm/index.d.ts

@@ -21,4 +21,5 @@ export { setMaxAnalyticsLogsLimit, getMaxAnalyticsLogsLimit, pruneAnalyticsLogs,
 export { getMaxCrashLogsLimit, pruneCrashRecords, } from './customHooks/crashHandler';
 export { setMaxPerformanceEventsLimit, getMaxPerformanceEventsLimit, prunePerformanceEvents, } from './customHooks/performanceTracker';
 export { BrandSquareIcon, BrandCircleIcon, } from './components/NetworkIcons';
+export { connectAsyncStorage, connectMMKV, isAsyncStorageConnected, isMMKVConnected, getRegisteredMMKVInstanceIds, fetchStorageEntries, setStorageEntry, removeStorageEntry, clearStorageDriver, subscribeToStorageChanges, type StorageEntry, type StorageDriver, } from './customHooks/storageInspector';
 export { ActiveTab, Method, StatusFilter, SortOrder, LocalFilter, ModalAnimationType, SettingsPage, SettingsSubTab, LogFilter, ConsoleLogType, AnalyticsEventSource, GAEventCategory, StackFrameType, DiffResultType, BundleSubTab, PerformanceSubTab, CrashType, CrashExportFormat, CrashDetailSubTab, CrashFilterType, BreadcrumbType, } from './types';

package/dist/esm/index.js

@@ -183,6 +183,8 @@ const NetworkInspector = ({ enabled = true, isEnabled = true, storage, navigatio
         bundle: false,
         performance: false,
         crash: false,
+        device: true,
+        storage: true,
     });
     const [maxNetworkLogs, setMaxNetworkLogs] = useState(100);
     const [maxAnalyticsEventsLimit, setMaxAnalyticsEventsLimit] = useState(75);
@@ -237,6 +239,8 @@ const NetworkInspector = ({ enabled = true, isEnabled = true, storage, navigatio
             bundle: false,
             performance: false,
             crash: false,
+            device: true,
+            storage: true,
         });
         setDefaultTab('apis');
         setIsAutoRamLimitEnabled(true);
@@ -1828,4 +1832,5 @@ export { setMaxAnalyticsLogsLimit, getMaxAnalyticsLogsLimit, pruneAnalyticsLogs,
 export { getMaxCrashLogsLimit, pruneCrashRecords, } from './customHooks/crashHandler';
 export { setMaxPerformanceEventsLimit, getMaxPerformanceEventsLimit, prunePerformanceEvents, } from './customHooks/performanceTracker';
 export { BrandSquareIcon, BrandCircleIcon, } from './components/NetworkIcons';
+export { connectAsyncStorage, connectMMKV, isAsyncStorageConnected, isMMKVConnected, getRegisteredMMKVInstanceIds, fetchStorageEntries, setStorageEntry, removeStorageEntry, clearStorageDriver, subscribeToStorageChanges, } from './customHooks/storageInspector';
 export { ActiveTab, Method, StatusFilter, SortOrder, LocalFilter, ModalAnimationType, SettingsPage, SettingsSubTab, LogFilter, ConsoleLogType, AnalyticsEventSource, GAEventCategory, StackFrameType, DiffResultType, BundleSubTab, PerformanceSubTab, CrashType, CrashExportFormat, CrashDetailSubTab, CrashFilterType, BreadcrumbType, } from './types';

package/dist/esm/storage.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Sub-module entry point: react-native-inapp-inspector/storage
+ * Universal AsyncStorage and MMKV live inspector with full CRUD operations.
+ */
+export { connectAsyncStorage, connectMMKV, isAsyncStorageConnected, isMMKVConnected, getRegisteredMMKVInstanceIds, fetchStorageEntries, setStorageEntry, removeStorageEntry, clearStorageDriver, subscribeToStorageChanges, type StorageEntry, type StorageDriver, } from './customHooks/storageInspector';

package/dist/esm/storage.js

@@ -0,0 +1,5 @@
+/**
+ * Sub-module entry point: react-native-inapp-inspector/storage
+ * Universal AsyncStorage and MMKV live inspector with full CRUD operations.
+ */
+export { connectAsyncStorage, connectMMKV, isAsyncStorageConnected, isMMKVConnected, getRegisteredMMKVInstanceIds, fetchStorageEntries, setStorageEntry, removeStorageEntry, clearStorageDriver, subscribeToStorageChanges, } from './customHooks/storageInspector';

package/dist/esm/types/enums.d.ts

@@ -6,6 +6,8 @@ export declare const ActiveTab: {
     readonly Bundle: "bundle";
     readonly Performance: "performance";
     readonly Crash: "crash";
+    readonly Device: "device";
+    readonly Storage: "storage";
 };
 export type ActiveTab = (typeof ActiveTab)[keyof typeof ActiveTab];
 export declare const Method: {
@@ -52,11 +54,14 @@ export declare const SettingsPage: {
     readonly Bundle: "bundle";
     readonly Performance: "performance";
     readonly Crash: "crash";
+    readonly Device: "device";
+    readonly Storage: "storage";
 };
 export type SettingsPage = (typeof SettingsPage)[keyof typeof SettingsPage] | null;
 export declare const SettingsSubTab: {
     readonly Module: "module";
     readonly Ui: "ui";
+    readonly Limits: "limits";
 };
 export type SettingsSubTab = (typeof SettingsSubTab)[keyof typeof SettingsSubTab];
 export declare const LogFilter: {

package/dist/esm/types/enums.js

@@ -9,6 +9,8 @@ export const ActiveTab = {
     Bundle: 'bundle',
     Performance: 'performance',
     Crash: 'crash',
+    Device: 'device',
+    Storage: 'storage',
 };
 export const Method = {
     All: 'ALL',
@@ -49,10 +51,13 @@ export const SettingsPage = {
     Bundle: 'bundle',
     Performance: 'performance',
     Crash: 'crash',
+    Device: 'device',
+    Storage: 'storage',
 };
 export const SettingsSubTab = {
     Module: 'module',
     Ui: 'ui',
+    Limits: 'limits',
 };
 export const LogFilter = {
     All: 'all',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-inapp-inspector",
-  "version": "2.2.2",
+  "version": "2.2.4",
   "description": "The zero-config, all-in-one in-app debugger for React Native & Expo. Inspect Network (fetch/axios), Console logs, Stack Traces, Redux State, Firebase Analytics, and JS Bundle size directly on device.",
   "repository": {
     "type": "git",
@@ -73,10 +73,18 @@
       "require": "./dist/commonjs/bundle.js",
       "default": "./dist/commonjs/bundle.js"
     },
+    "./storage": {
+      "react-native": "./dist/commonjs/storage.js",
+      "types": "./dist/commonjs/storage.d.ts",
+      "import": "./dist/esm/storage.js",
+      "require": "./dist/commonjs/storage.js",
+      "default": "./dist/commonjs/storage.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
     "dist",
+    "src",
     "README.md",
     "android",
     "ios",

package/src/analytics.ts

@@ -0,0 +1,35 @@
+/**
+ * Sub-module entry point: react-native-inapp-inspector/analytics
+ * Clean tree-shaking & isolated Firebase/custom Analytics logger.
+ */
+export {
+  setupAnalyticsLogger,
+  autoSetupAnalyticsLogger,
+  logAnalyticsEvent,
+  subscribeAnalyticsEvents,
+  clearAnalyticsEvents,
+  getAnalyticsEvents,
+  isAnalyticsConnected,
+  isFirebaseAnalyticsPatched,
+  setAnalyticsModuleEnabled,
+  getAnalyticsModuleEnabled,
+  getCurrentUserProperties,
+  getCurrentUserId,
+  getDefaultEventParameters,
+  getCollectionEnabled,
+  setMaxAnalyticsLogsLimit,
+  getMaxAnalyticsLogsLimit,
+  pruneAnalyticsLogs,
+} from './customHooks/analyticsLogger';
+
+export {
+  getEventCategory,
+  registerGAPlugin,
+  type GAPlugin,
+} from './helpers/gaAnalyticsRegistry';
+
+export type {
+  AnalyticsEvent,
+  AnalyticsEventSource,
+  GAEventCategory,
+} from './types';

package/src/bundle.ts

@@ -0,0 +1,25 @@
+/**
+ * Sub-module entry point: react-native-inapp-inspector/bundle
+ * Clean tree-shaking & isolated JS bundle size analyzer.
+ */
+export {
+  analyzeHostAppBundle,
+  parseBundleSource,
+  getInitialBundleAnalysis,
+  getCachedBundleAnalysis,
+  clearCachedBundleAnalysis,
+  setBundleModuleEnabled,
+  getBundleModuleEnabled,
+  getHostScriptURL,
+  trackRuntimeModuleExecution,
+  trackRuntimeDefine,
+  type HostBundleAnalysisResult,
+  type HostBundleFileItem,
+  type HostBundlePackageItem,
+  type HostBinaryComponentItem,
+  type FileTypeCategory,
+} from './customHooks/bundleAnalyzer';
+
+export {
+  BundleSubTab,
+} from './types';