react-native-inapp-inspector 1.1.1 → 1.1.3

package/dist/esm/customHooks/reduxLogger.js

@@ -1,8 +1,28 @@
+// #8 — Redux inspector module.
+//
+// Two integration paths, both feeding the same timeline/state snapshot:
+//
+//   1. `inspectorReduxMiddleware` (recommended) — a standard Redux middleware.
+//      Because it sits inside the middleware chain it sees EVERY action,
+//      including ones dispatched from thunks, sagas, listeners and RTK Query.
+//
+//   2. `connectReduxStore(store)` — zero-config fallback. It wraps the outer
+//      `store.dispatch` AND diffs state on `store.subscribe`, so even actions
+//      that bypass the wrapped dispatch (thunk/saga internals capture the raw
+//      dispatch reference at store-creation time) still update the state tree
+//      and per-reducer "last action" consistently.
 let currentReduxState = null;
 const listeners = new Set();
 let globalReduxAutoRefresh = true;
 let lastActionForReducer = {};
 let actionHistory = [];
+const MAX_HISTORY = 50;
+let historyIdSeq = 0;
+// Guards against double-instrumentation (e.g. connectReduxStore called twice,
+// or middleware + connect used together) which previously produced duplicate
+// timeline entries and inconsistent counts.
+const connectedStores = new WeakSet();
+let middlewareAttached = false;
 export const getReduxState = () => currentReduxState;
 export const setReduxAutoRefresh = (val) => {
     globalReduxAutoRefresh = val;
@@ -11,16 +31,16 @@ export const getReduxAutoRefresh = () => globalReduxAutoRefresh;
 export const getLastActionForReducer = () => lastActionForReducer;
 export const clearLastActionForReducer = () => {
     lastActionForReducer = {};
-    listeners.forEach(cb => cb());
+    notify();
 };
 export const getActionHistory = () => actionHistory;
 export const clearActionHistory = () => {
     actionHistory = [];
-    listeners.forEach(cb => cb());
+    notify();
 };
 export const setReduxState = (state) => {
     currentReduxState = state;
-    listeners.forEach(cb => cb());
+    notify();
 };
 export const subscribeReduxState = (cb) => {
     listeners.add(cb);
@@ -28,6 +48,82 @@ export const subscribeReduxState = (cb) => {
         listeners.delete(cb);
     };
 };
+function notify() {
+    listeners.forEach(cb => cb());
+}
+function actionTypeOf(action) {
+    if (typeof action === 'string')
+        return action;
+    if (action && typeof action === 'object' && action.type != null) {
+        return String(action.type);
+    }
+    if (typeof action === 'function') {
+        return action.name ? `thunk: ${action.name}` : 'thunk';
+    }
+    return 'UNKNOWN_ACTION';
+}
+function recordAction(action, prevState, nextState) {
+    const type = actionTypeOf(action);
+    const payload = action && typeof action === 'object' && action.payload !== undefined
+        ? action.payload
+        : null;
+    const timestamp = new Date().toLocaleTimeString();
+    const affectedSlices = [];
+    if (prevState &&
+        nextState &&
+        typeof prevState === 'object' &&
+        typeof nextState === 'object') {
+        Object.keys(nextState).forEach(key => {
+            if (prevState[key] !== nextState[key]) {
+                lastActionForReducer[key] = { type, payload, timestamp };
+                affectedSlices.push(key);
+            }
+        });
+    }
+    actionHistory.unshift({
+        id: ++historyIdSeq,
+        type,
+        payload,
+        timestamp,
+        affectedSlices,
+    });
+    if (actionHistory.length > MAX_HISTORY) {
+        actionHistory.length = MAX_HISTORY;
+    }
+    if (globalReduxAutoRefresh) {
+        currentReduxState = nextState;
+    }
+    // Timeline / last-action map always changed — notify even when the state
+    // tree snapshot is paused so those panels stay live.
+    notify();
+}
+/**
+ * Standard Redux middleware — add it to your store to capture every action,
+ * including those dispatched from thunks, sagas and RTK Query:
+ *
+ *   const store = configureStore({
+ *     reducer,
+ *     middleware: gDM => gDM().concat(inspectorReduxMiddleware),
+ *   });
+ *
+ * Pair with `connectReduxStore(store)` (safe — they de-duplicate) or rely on
+ * the middleware alone; the initial snapshot is taken on the first action.
+ */
+export const inspectorReduxMiddleware = (storeApi) => (next) => (action) => {
+    middlewareAttached = true;
+    // Thunks are functions — let them run; their inner plain-action dispatches
+    // pass back through this same middleware, so nothing is lost.
+    if (typeof action === 'function') {
+        return next(action);
+    }
+    const prevState = storeApi.getState();
+    const result = next(action);
+    const nextState = storeApi.getState();
+    if (currentReduxState == null)
+        currentReduxState = nextState;
+    recordAction(action, prevState, nextState);
+    return result;
+};
 export const connectReduxStore = (store) => {
     if (!store ||
         typeof store.getState !== 'function' ||
@@ -35,60 +131,62 @@ export const connectReduxStore = (store) => {
         console.warn('[NetworkInspector] Invalid Redux store passed to connectReduxStore.');
         return;
     }
-    // Intercept dispatch calls to log actions and tie them to modified state slices
+    // Idempotent — connecting the same store twice must not double-wrap
+    // dispatch or double-record the timeline.
+    if (connectedStores.has(store)) {
+        return;
+    }
+    connectedStores.add(store);
+    // Wrap the outer dispatch so directly dispatched actions get full
+    // type/payload attribution. Skipped when the middleware is already
+    // attached, otherwise every direct dispatch would be recorded twice.
     const originalDispatch = store.dispatch.bind(store);
+    let inWrappedDispatch = false;
     store.dispatch = (action) => {
-        const prevState = store.getState();
-        const result = originalDispatch(action);
-        const nextState = store.getState();
-        // Map the dispatched action to state slices that actually changed
-        const affectedSlices = [];
-        if (prevState &&
-            nextState &&
-            typeof prevState === 'object' &&
-            typeof nextState === 'object' &&
-            action &&
-            typeof action === 'object') {
-            Object.keys(nextState).forEach(key => {
-                if (prevState[key] !== nextState[key]) {
-                    const actionObj = {
-                        type: action.type || 'UNKNOWN_ACTION',
-                        payload: action.payload !== undefined ? action.payload : null,
-                        timestamp: new Date().toLocaleTimeString(),
-                    };
-                    lastActionForReducer[key] = actionObj;
-                    affectedSlices.push(key);
-                }
-            });
-            // Push to history
-            actionHistory.unshift({
-                id: Date.now() + Math.random(),
-                type: action.type || 'UNKNOWN_ACTION',
-                payload: action.payload !== undefined ? action.payload : null,
-                timestamp: new Date().toLocaleTimeString(),
-                affectedSlices,
-            });
-            // Cap size at 50
-            if (actionHistory.length > 50) {
-                actionHistory.pop();
+        if (middlewareAttached || typeof action === 'function') {
+            // Middleware handles recording, or it's a thunk whose inner dispatches
+            // will be picked up individually.
+            inWrappedDispatch = true;
+            try {
+                return originalDispatch(action);
+            }
+            finally {
+                inWrappedDispatch = false;
             }
         }
-        if (globalReduxAutoRefresh) {
-            // Refresh the displayed state tree snapshot.
-            setReduxState(nextState);
+        const prevState = store.getState();
+        inWrappedDispatch = true;
+        let result;
+        try {
+            result = originalDispatch(action);
         }
-        else {
-            // Tree is paused, but the action timeline / last-action map still changed,
-            // so notify subscribers to re-render those without moving the tree snapshot.
-            listeners.forEach(cb => cb());
+        finally {
+            inWrappedDispatch = false;
         }
+        recordAction(action, prevState, store.getState());
         return result;
     };
     setReduxState(store.getState());
-    // Listen to subscription for devtools updates or any other state changes
+    // Subscribe-diff fallback: catches state changes whose dispatch bypassed
+    // the wrapper above (thunk/saga internals hold the raw dispatch reference).
+    // Without this, the tree and per-reducer last-action drifted out of sync.
+    let lastSeenState = store.getState();
     store.subscribe(() => {
-        if (globalReduxAutoRefresh) {
-            setReduxState(store.getState());
+        const nextState = store.getState();
+        if (nextState === lastSeenState)
+            return;
+        const prevState = lastSeenState;
+        lastSeenState = nextState;
+        if (inWrappedDispatch || middlewareAttached) {
+            // Already recorded with proper attribution; just refresh the snapshot.
+            if (globalReduxAutoRefresh) {
+                currentReduxState = nextState;
+                notify();
+            }
+            return;
         }
+        // Change arrived outside the wrapped dispatch — record it so the
+        // timeline stays consistent, even without the original action type.
+        recordAction({ type: '@@inspector/EXTERNAL_STATE_CHANGE' }, prevState, nextState);
     });
 };

package/dist/esm/customHooks/webViewLogger.js

@@ -287,14 +287,19 @@ export const WebView = forwardRef((props, ref) => {
         onNavigationStateChange: handleNavigationStateChange,
         onLoadStart: handleLoadStart,
         onLoadEnd: handleLoadEnd,
-    }), loading && showLoader && React.createElement(View, {
-        style: {
-            ...StyleSheet.absoluteFill,
-            justifyContent: 'center',
-            alignItems: 'center',
-            backgroundColor: 'rgba(255, 255, 255, 0.4)',
-        },
-    }, React.createElement(ActivityIndicator, { size: 'large', color: '#684B9B' })));
+    }), loading &&
+        showLoader &&
+        React.createElement(View, {
+            style: {
+                ...StyleSheet.absoluteFill,
+                justifyContent: 'center',
+                alignItems: 'center',
+                backgroundColor: 'rgba(255, 255, 255, 0.4)',
+            },
+        }, React.createElement(ActivityIndicator, {
+            size: 'large',
+            color: '#684B9B',
+        })));
 });
 // Perform monkey-patching to intercept react-native-webview exports globally
 try {

package/dist/esm/helpers/settingsStore.d.ts

@@ -0,0 +1,24 @@
+export interface PersistedSettings {
+    isDark?: boolean;
+    modalHeightPercent?: number;
+    tabVisibility?: Record<string, boolean>;
+    defaultTab?: string;
+    maxNetworkLogs?: number;
+    maxConsoleLogs?: number;
+    showConsoleLevels?: {
+        info: boolean;
+        warn: boolean;
+        error: boolean;
+    };
+    webViewCaptureCssJs?: boolean;
+    reduxAutoRefresh?: boolean;
+    reduxExpandDepth?: number;
+    slowRequestThreshold?: number;
+    insightsShowConsoleAlerts?: boolean;
+    showDuplicateLogs?: boolean;
+}
+export declare function loadSettings(): Promise<PersistedSettings>;
+/** Debounced save so rapid toggling doesn't hammer storage. */
+export declare function saveSettings(settings: PersistedSettings): void;
+export declare function clearPersistedSettings(): Promise<void>;
+export declare const isPersistentStorageAvailable: () => boolean;

package/dist/esm/helpers/settingsStore.js

@@ -0,0 +1,67 @@
+// #5 — Persistence layer for the inspector's settings selections.
+//
+// Backed by @react-native-async-storage/async-storage when the host app has it
+// installed (most RN apps do), with a transparent in-memory fallback so this
+// library never crashes and never forces a new native dependency.
+let storage = null;
+try {
+    // Optional dependency — resolved only if the host app already ships it.
+    const mod = require('@react-native-async-storage/async-storage');
+    storage = mod?.default ?? mod ?? null;
+    if (storage && typeof storage.getItem !== 'function')
+        storage = null;
+}
+catch {
+    storage = null;
+}
+// In-memory fallback (settings survive for the app session only).
+const memory = new Map();
+const SETTINGS_KEY = 'rn-inapp-inspector.settings.v1';
+export async function loadSettings() {
+    try {
+        const raw = storage
+            ? await storage.getItem(SETTINGS_KEY)
+            : memory.get(SETTINGS_KEY) ?? null;
+        if (!raw)
+            return {};
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+let saveTimer = null;
+/** Debounced save so rapid toggling doesn't hammer storage. */
+export function saveSettings(settings) {
+    if (saveTimer)
+        clearTimeout(saveTimer);
+    saveTimer = setTimeout(async () => {
+        try {
+            const raw = JSON.stringify(settings);
+            if (storage) {
+                await storage.setItem(SETTINGS_KEY, raw);
+            }
+            else {
+                memory.set(SETTINGS_KEY, raw);
+            }
+        }
+        catch {
+            // Persistence is best-effort — never crash the host app over it.
+        }
+    }, 250);
+}
+export async function clearPersistedSettings() {
+    try {
+        if (storage) {
+            await storage.removeItem(SETTINGS_KEY);
+        }
+        else {
+            memory.delete(SETTINGS_KEY);
+        }
+    }
+    catch {
+        // ignore
+    }
+}
+export const isPersistentStorageAvailable = () => storage != null;

package/dist/esm/index.d.ts

@@ -6,4 +6,4 @@ export { setupConsoleLogger, clearConsoleLogs, subscribeConsoleLogs, } from './c
 export { setupAnalyticsLogger, logAnalyticsEvent, subscribeAnalyticsEvents, clearAnalyticsEvents, } from './customHooks/analyticsLogger';
 export { WebView, getWebViewLogs, getWebViewNavHistory, getWebViewHtml, getWebViewCss, getWebViewJs, getWebViewHtmlUrl, clearWebViewData, subscribeWebView, } from './customHooks/webViewLogger';
 export { default as ErrorBoundary } from './components/ErrorBoundary';
-export { connectReduxStore, getReduxState, subscribeReduxState, } from './customHooks/reduxLogger';
+export { connectReduxStore, inspectorReduxMiddleware, getReduxState, subscribeReduxState, getActionHistory, clearActionHistory, } from './customHooks/reduxLogger';