react-native-inapp-inspector 1.1.24 → 1.1.26

package/dist/esm/customHooks/consoleLogger.d.ts

@@ -1,4 +1,5 @@
 import { ConsoleLog } from '../types';
+export declare const addLogFromCrash: (error: any, message: string, stack?: string, isFatal?: boolean) => ConsoleLog;
 export declare const subscribeConsoleLogs: (callback: (logs: ConsoleLog[]) => void) => () => void;
 export declare const clearConsoleLogs: () => void;
 export declare const getConsoleLogs: () => ConsoleLog[];

package/dist/esm/customHooks/consoleLogger.js

@@ -1,4 +1,6 @@
+import { NativeModules } from 'react-native';
 import { IGNORED_LOG_PREFIXES } from './logFilters';
+import { setupGlobalCrashHandler } from './crashHandler';
 let logs = [];
 let listeners = [];
 let counter = 0;
@@ -24,12 +26,25 @@ const formatArgs = (args) => {
     })
         .join(' ');
 };
-// ─── Symbolication Helper for React Native Metro ────────────────────────────
+// ─── Dynamic Symbolication Helper for React Native Metro ────────────────────
+const getMetroSymbolicateUrl = () => {
+    try {
+        const scriptURL = NativeModules.SourceCode?.scriptURL;
+        if (typeof scriptURL === 'string') {
+            const match = scriptURL.match(/^(https?:\/\/[^\/]+)/);
+            if (match) {
+                return `${match[1]}/symbolicate`;
+            }
+        }
+    }
+    catch { }
+    return 'http://localhost:8081/symbolicate';
+};
 const symbolicateStack = async (stackString) => {
-    if (typeof __DEV__ === 'undefined' || !__DEV__)
+    if (typeof __DEV__ === 'undefined' || !__DEV__ || !stackString)
         return null;
+    // 1. Try React Native built-in symbolicateStackTrace if available
     try {
-        // 1. Try React Native's built-in symbolicateStackTrace if available
         let symModule = null;
         try {
             // @ts-ignore
@@ -39,24 +54,61 @@ const symbolicateStack = async (stackString) => {
         const symFn = symModule?.default || symModule;
         if (typeof symFn === 'function') {
             const res = await symFn(stackString);
-            if (res && Array.isArray(res.stack)) {
+            if (res && Array.isArray(res.stack) && res.stack.length > 0) {
                 return res.stack;
             }
         }
     }
     catch { }
+    // 2. Direct HTTP symbolication to dynamic Metro packager endpoint
     try {
-        // 2. Direct HTTP symbolication to Metro packager endpoint
-        const metroUrl = 'http://localhost:8081/symbolicate';
-        const response = await fetch(metroUrl, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ stack: stackString }),
-        });
-        if (response.ok) {
-            const json = await response.json();
-            if (json && Array.isArray(json.stack)) {
-                return json.stack;
+        const metroUrl = getMetroSymbolicateUrl();
+        const scriptURL = NativeModules.SourceCode?.scriptURL || 'http://localhost:8081/index.bundle?platform=ios&dev=true';
+        // Parse Hermes stack string into frame objects for Metro symbolicate endpoint
+        const lines = stackString.split('\n');
+        const inputFrames = [];
+        for (const rawLine of lines) {
+            const line = rawLine.trim().replace(/^at /, '');
+            if (!line)
+                continue;
+            let methodName = '<anonymous>';
+            let locationPart = line;
+            const parenMatch = line.match(/^(.*?)\s*\((.*?)\)$/);
+            if (parenMatch) {
+                methodName = parenMatch[1].trim() || '<anonymous>';
+                locationPart = parenMatch[2].trim();
+            }
+            else if (line.includes('@')) {
+                const atIdx = line.indexOf('@');
+                methodName = line.substring(0, atIdx).trim() || '<anonymous>';
+                locationPart = line.substring(atIdx + 1).trim();
+            }
+            locationPart = locationPart.replace(/^address at /, '');
+            const locMatch = locationPart.match(/^(.*?):(\d+):(\d+)$/);
+            if (locMatch) {
+                let file = locMatch[1];
+                if (!file.startsWith('http') && file !== 'native' && !file.includes('InternalBytecode')) {
+                    file = scriptURL;
+                }
+                inputFrames.push({
+                    file,
+                    lineNumber: parseInt(locMatch[2], 10),
+                    column: parseInt(locMatch[3], 10),
+                    methodName,
+                });
+            }
+        }
+        if (inputFrames.length > 0) {
+            const response = await fetch(metroUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ stack: inputFrames }),
+            });
+            if (response.ok) {
+                const json = await response.json();
+                if (json && Array.isArray(json.stack) && json.stack.length > 0) {
+                    return json.stack;
+                }
             }
         }
     }
@@ -163,34 +215,10 @@ const addLog = (type, args, sourceMethod) => {
         logs = logs.slice(0, MAX_LOGS);
         notify();
         // Asynchronously symbolicate stack trace via Metro in development
-        if (newLog.stack && typeof __DEV__ !== 'undefined' && __DEV__) {
-            symbolicateStack(newLog.stack)
-                .then(symbolicatedFrames => {
-                if (symbolicatedFrames && symbolicatedFrames.length > 0) {
-                    const validFrames = symbolicatedFrames.filter(f => f.file &&
-                        !f.file.includes('react-native/Libraries') &&
-                        !f.file.includes('node_modules') &&
-                        !isLoggerInternal(f.file) &&
-                        !isLoggerInternal(f.methodName || ''));
-                    const topFrame = validFrames[0] || symbolicatedFrames[0];
-                    if (topFrame) {
-                        const cleanMethod = topFrame.methodName || 'anonymous';
-                        const cleanFile = topFrame.file.split('/').pop() || topFrame.file;
-                        newLog.caller = `${cleanMethod} (${cleanFile}:${topFrame.lineNumber || 1}:${topFrame.column || 1})`;
-                    }
-                    newLog.stack = symbolicatedFrames
-                        .filter(f => !isLoggerInternal(f.file || '') && !isLoggerInternal(f.methodName || ''))
-                        .map(f => `    at ${f.methodName || 'anonymous'} (${f.file}:${f.lineNumber || 1}:${f.column || 1})`)
-                        .join('\n');
-                    notify();
-                }
-            })
-                .catch(() => { });
-        }
-        // Asynchronously symbolicate stack trace using Metro in DEV mode
-        if (stackToUse && typeof __DEV__ !== 'undefined' && __DEV__) {
+        const stackToSymbolicate = errorStack || stackToUse || stack;
+        if (stackToSymbolicate && typeof __DEV__ !== 'undefined' && __DEV__) {
             const currentLogId = newLog.id;
-            symbolicateStack(stackToUse)
+            symbolicateStack(stackToSymbolicate)
                 .then(symFrames => {
                 if (symFrames && Array.isArray(symFrames) && symFrames.length > 0) {
                     const symLines = [];
@@ -200,19 +228,30 @@ const addLog = (type, args, sourceMethod) => {
                         const method = frame.methodName || '<anonymous>';
                         const line = frame.lineNumber != null ? `:${frame.lineNumber}` : '';
                         const col = frame.column != null ? `:${frame.column}` : '';
+                        // Skip logger internal frames
+                        const isInternal = file.includes('customHooks/consoleLogger') ||
+                            file.includes('setupConsoleLogger') ||
+                            file.includes('getStackDetails') ||
+                            file.includes('react-native-inapp-inspector/dist') ||
+                            file.includes('react-native-inapp-inspector/src') ||
+                            method === 'getStackDetails' ||
+                            method === 'addLog' ||
+                            (method === 'log' && file.includes('consoleLogger'));
+                        if (isInternal) {
+                            continue;
+                        }
                         const lineStr = `at ${method} (${file}${line}${col})`;
                         symLines.push(lineStr);
                         const isUserFile = file &&
                             !file.includes('node_modules') &&
                             !file.includes('react-native/') &&
-                            !file.includes('consoleLogger') &&
-                            !file.includes('setupConsoleLogger') &&
                             (file.endsWith('.tsx') ||
                                 file.endsWith('.jsx') ||
                                 file.endsWith('.ts') ||
                                 file.endsWith('.js'));
                         if (!symUserCaller && isUserFile) {
-                            symUserCaller = `${method} (${file}${line}${col})`;
+                            const cleanFile = file.split('/').pop() || file;
+                            symUserCaller = `${method} (${cleanFile}${line}${col})`;
                         }
                     }
                     const targetLog = logs.find(l => l.id === currentLogId);
@@ -241,6 +280,43 @@ const addLog = (type, args, sourceMethod) => {
     }
 };
 // ─── Public API ───────────────────────────────────────────────────────────────
+export const addLogFromCrash = (error, message, stack, isFatal) => {
+    const { caller, errorStack } = getStackDetails([error]);
+    const newLog = {
+        id: counter++,
+        type: 'error',
+        message: message || (error?.message ?? 'Runtime Crash'),
+        timestamp: Date.now(),
+        caller: caller !== 'Unknown'
+            ? caller
+            : isFatal
+                ? 'Fatal Crash'
+                : 'Unhandled Exception',
+        stack: stack || error?.stack || errorStack,
+        errorStack: stack || error?.stack,
+        rawArgs: [error],
+        sourceMethod: 'error',
+    };
+    logs.unshift(newLog);
+    logs = logs.slice(0, MAX_LOGS);
+    notify();
+    const stackToSym = stack || error?.stack || errorStack;
+    if (stackToSym && typeof __DEV__ !== 'undefined' && __DEV__) {
+        symbolicateStack(stackToSym)
+            .then(symFrames => {
+            if (symFrames && Array.isArray(symFrames) && symFrames.length > 0) {
+                const symLines = symFrames.map(f => `at ${f.methodName || '<anonymous>'} (${(f.file || '').replace(/^webpack:\/\/\/?/, '')}:${f.lineNumber ?? 0}:${f.column ?? 0})`);
+                const target = logs.find(l => l.id === newLog.id);
+                if (target) {
+                    target.stack = symLines.join('\n');
+                    notify();
+                }
+            }
+        })
+            .catch(() => { });
+    }
+    return newLog;
+};
 export const subscribeConsoleLogs = (callback) => {
     listeners.push(callback);
     callback([...logs]);
@@ -264,23 +340,48 @@ export const setupConsoleLogger = () => {
     };
     // Intercept console.log
     console.log = (...args) => {
-        addLog('info', args, 'log');
+        try {
+            addLog('info', args, 'log');
+        }
+        catch { }
         originalConsole.log(...args);
     };
     // Intercept console.info
     console.info = (...args) => {
-        addLog('info', args, 'info');
+        try {
+            addLog('info', args, 'info');
+        }
+        catch { }
         originalConsole.info(...args);
     };
     // Intercept console.warn
     console.warn = (...args) => {
-        addLog('warn', args, 'warn');
+        try {
+            addLog('warn', args, 'warn');
+        }
+        catch { }
         originalConsole.warn(...args);
     };
     // Intercept console.error
     console.error = (...args) => {
-        addLog('error', args, 'error');
-        originalConsole.error(...args);
+        try {
+            addLog('error', args, 'error');
+        }
+        catch { }
+        const firstArg = args && args[0];
+        const isRenderError = typeof firstArg === 'string' &&
+            (firstArg.includes('The above error occurred in') ||
+                firstArg.includes('Render Error') ||
+                firstArg.includes('ReferenceError') ||
+                firstArg.includes('TypeError'));
+        // Suppress console.error if it's a React render crash to prevent RedBox dialog
+        if (!isRenderError) {
+            originalConsole.error(...args);
+        }
     };
+    try {
+        setupGlobalCrashHandler();
+    }
+    catch { }
     globalThis.__CONSOLE_LOGGER_INITIALIZED__ = true;
 };

package/dist/esm/customHooks/crashHandler.d.ts

@@ -0,0 +1,64 @@
+import { CrashRecord, ParsedStackFrame, CrashBreadcrumb } from '../types';
+import { CrashExportFormat, CrashType } from '../types/enums';
+export interface CrashEventPayload {
+    error: Error | any;
+    isFatal?: boolean;
+    message: string;
+    stack?: string;
+    timestamp: number;
+    logId?: number;
+    crashRecord?: CrashRecord;
+}
+export { CrashExportFormat };
+type CrashListener = (payload: CrashEventPayload) => void;
+export declare const setMaxCrashLogsLimit: (max: number) => void;
+export declare const addCrashBreadcrumb: (type: CrashBreadcrumb["type"], message: string, data?: any) => void;
+export declare const recordNavigationBreadcrumb: (fromRoute: string, toRoute: string) => void;
+export declare const recordNetworkBreadcrumb: (url: string, method: string, status?: number, duration?: number) => void;
+export declare const recordReduxBreadcrumb: (actionType: string, payload?: any) => void;
+export declare const recordUserActionBreadcrumb: (action: string, metadata?: any) => void;
+export declare const clearCrashBreadcrumbs: () => void;
+export declare const getCrashBreadcrumbs: () => CrashBreadcrumb[];
+/**
+ * Intelligent stack trace parser with multi-engine support:
+ * - Hermes bytecode & source maps
+ * - Android Java / Kotlin native frames
+ * - iOS Objective-C / Swift symbols
+ * - JavaScript standard V8 & SpiderMonkey
+ */
+export declare const parseCrashStackTrace: (stack?: string) => ParsedStackFrame[];
+/**
+ * Computes a unique fingerprint signature to group recurring crash occurrences.
+ */
+export declare const computeCrashFingerprint: (crash: CrashRecord) => string;
+export declare const getCrashRecords: () => CrashRecord[];
+export declare const clearCrashRecords: () => void;
+export declare const subscribeCrashEvents: (listener: CrashListener) => (() => void);
+export declare const emitCrashEvent: (payload: CrashEventPayload) => void;
+/**
+ * Core exception interceptor. Ingests all forms of errors, parses call stacks,
+ * collects device telemetry, records breadcrumbs, and updates the store.
+ */
+export declare const handleInterceptedCrash: (errorOrTitle: any, rawStack?: any, isFatal?: boolean, customType?: CrashType, componentStack?: string) => CrashRecord;
+/**
+ * Manually report a caught error with custom metadata.
+ */
+export declare const recordCustomCrash: (error: Error | string, options?: {
+    isFatal?: boolean;
+    type?: CrashType;
+    componentStack?: string;
+}) => CrashRecord;
+/**
+ * Simulates a crash for developer testing without crashing the host app.
+ * Uses real runtime Error objects — no mocked file paths or fake stacks.
+ */
+export declare const simulateTestCrash: (type?: CrashType, customMessage?: string, customStack?: string) => CrashRecord;
+/**
+ * Formats a crash into Text, Markdown, or JSON.
+ */
+export declare const exportCrashReport: (crash: CrashRecord, format?: CrashExportFormat) => string;
+/**
+ * Natively intercepts and prevents crashes, native RedBox dialogues,
+ * unhandled JS errors, and unhandled promise rejections.
+ */
+export declare const setupGlobalCrashHandler: () => void;