react-native-inapp-inspector 1.1.24 → 1.1.26

package/dist/commonjs/customHooks/networkLogger.js

@@ -5,11 +5,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addAxiosInterceptors = exports.setupNetworkLogger = exports.getNetworkLogs = exports.clearNetworkLogs = exports.subscribeNetworkLogs = void 0;
 const axios_1 = __importDefault(require("axios"));
+const crashHandler_1 = require("./crashHandler");
 let logs = [];
 let listeners = [];
 let counter = 0;
 const ALLOWED_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"];
-const IGNORED_URL_PATTERNS = [/\/symbolicate(?:[/?#]|$)/];
+const IGNORED_URL_PATTERNS = [
+    /\/symbolicate(?:[/?#]|$)/i,
+    /\/index\.bundle(?:\?|$)/i,
+    /\/hot(?:\?|$)/i,
+    /\/message(?:\?|$)/i,
+    /\/open-debugger(?:\?|$)/i,
+    /\/status(?:\?|$)/i,
+    /127\.0\.0\.1:(?:8081|8082|8083|19000|19001|19002|3000|8000)/i,
+    /localhost:(?:8081|8082|8083|19000|19001|19002|3000|8000)\/index\.bundle/i,
+];
 function shouldIgnoreUrl(url) {
     if (!url)
         return false;
@@ -142,65 +152,76 @@ const setupNetworkLogger = () => {
             const finalUrl = typeof url === "string" ? url : url?.url;
             if (shouldIgnoreUrl(finalUrl))
                 return originalFetch(url, options);
-            const requestHeaders = normaliseHeaders(options?.headers);
-            const caller = getCallerFromStack(); // ✅ Capture call line
-            addOrUpdateLog({
-                id,
-                url: finalUrl,
-                method,
-                startTime: start,
-                caller,
-                request: method === "GET" ? undefined : parseRequestData(options?.body),
-                requestHeaders,
-            });
+            let caller = "Unknown";
+            let requestHeaders;
             try {
-                const response = await originalFetch(url, options);
-                const duration = Date.now() - start;
-                const responseHeaders = normaliseHeaders(response.headers);
-                let data = null;
-                const contentType = responseHeaders?.["content-type"] ||
-                    responseHeaders?.["Content-Type"] ||
-                    "";
-                if (contentType.includes("image/")) {
-                    data = "[Image Data]";
-                }
-                else {
-                    try {
-                        const clone = response.clone();
-                        const text = await clone.text();
-                        try {
-                            data = JSON.parse(text);
-                        }
-                        catch {
-                            data = text;
-                        }
-                    }
-                    catch { }
-                }
+                requestHeaders = normaliseHeaders(options?.headers);
+                caller = getCallerFromStack(); // ✅ Capture call line
                 addOrUpdateLog({
                     id,
                     url: finalUrl,
                     method,
-                    status: response.status,
-                    response: data,
-                    duration,
                     startTime: start,
                     caller,
-                    responseHeaders,
+                    request: method === "GET" ? undefined : parseRequestData(options?.body),
+                    requestHeaders,
                 });
+            }
+            catch { }
+            try {
+                const response = await originalFetch(url, options);
+                const duration = Date.now() - start;
+                try {
+                    const responseHeaders = normaliseHeaders(response.headers);
+                    let data = null;
+                    const contentType = responseHeaders?.["content-type"] ||
+                        responseHeaders?.["Content-Type"] ||
+                        "";
+                    if (contentType.includes("image/")) {
+                        data = "[Image Data]";
+                    }
+                    else {
+                        try {
+                            const clone = response.clone();
+                            const text = await clone.text();
+                            try {
+                                data = JSON.parse(text);
+                            }
+                            catch {
+                                data = text;
+                            }
+                        }
+                        catch { }
+                    }
+                    addOrUpdateLog({
+                        id,
+                        url: finalUrl,
+                        method,
+                        status: response.status,
+                        response: data,
+                        duration,
+                        startTime: start,
+                        caller,
+                        responseHeaders,
+                    });
+                }
+                catch { }
                 return response;
             }
             catch (error) {
-                addOrUpdateLog({
-                    id,
-                    url: finalUrl,
-                    method,
-                    status: 0,
-                    startTime: start,
-                    response: error,
-                    caller,
-                    duration: Date.now() - start,
-                });
+                try {
+                    addOrUpdateLog({
+                        id,
+                        url: finalUrl,
+                        method,
+                        status: 0,
+                        startTime: start,
+                        response: error,
+                        caller,
+                        duration: Date.now() - start,
+                    });
+                }
+                catch { }
                 throw error;
             }
         };
@@ -222,6 +243,10 @@ const setupNetworkLogger = () => {
     catch (_e) {
         // Axios not available — fetch-only mode
     }
+    try {
+        (0, crashHandler_1.setupGlobalCrashHandler)();
+    }
+    catch { }
     globalThis.__NETWORK_LOGGER_INITIALIZED__ = true;
 };
 exports.setupNetworkLogger = setupNetworkLogger;

package/dist/commonjs/customHooks/performanceTracker.d.ts

@@ -54,6 +54,7 @@ export interface ComponentRenderProfile {
     fixKeys: PerformanceFixKey[];
     severity: 'optimal' | 'warning' | 'critical';
 }
+export declare const INITIAL_EVENTS: PerformanceEvent[];
 export declare const usePerformanceTracker: () => {
     isRecording: boolean;
     setIsRecording: import("react").Dispatch<import("react").SetStateAction<boolean>>;
@@ -82,3 +83,10 @@ export declare const usePerformanceTracker: () => {
     clearEvents: () => void;
     triggerGc: () => void;
 };
+export declare const logPerformanceEvent: (event: Omit<PerformanceEvent, "id" | "timestamp"> & {
+    id?: string;
+    timestamp?: number;
+}) => PerformanceEvent;
+export declare const clearPerformanceEvents: () => void;
+export declare const subscribePerformanceEvents: (listener: (events: PerformanceEvent[]) => void) => () => void;
+export declare const getPerformanceEvents: () => PerformanceEvent[];

package/dist/commonjs/customHooks/performanceTracker.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.usePerformanceTracker = void 0;
+exports.getPerformanceEvents = exports.subscribePerformanceEvents = exports.clearPerformanceEvents = exports.logPerformanceEvent = exports.usePerformanceTracker = exports.INITIAL_EVENTS = void 0;
 const AppColors_1 = require("../styles/AppColors");
 const react_1 = require("react");
 const INITIAL_RENDER_PROFILES = [
@@ -173,7 +173,7 @@ const INITIAL_RENDER_PROFILES = [
         severity: 'optimal',
     },
 ];
-const INITIAL_EVENTS = [
+exports.INITIAL_EVENTS = [
     {
         id: 'perf-1',
         timestamp: Date.now() - 48000,
@@ -351,7 +351,7 @@ const usePerformanceTracker = () => {
         allocationRateMbPerSec: 1.8,
     });
     const [renderProfiles, setRenderProfiles] = (0, react_1.useState)(INITIAL_RENDER_PROFILES);
-    const [events, setEvents] = (0, react_1.useState)(INITIAL_EVENTS);
+    const [events, setEvents] = (0, react_1.useState)(exports.INITIAL_EVENTS);
     const lastFrameTimeRef = (0, react_1.useRef)(Date.now());
     const rafIdRef = (0, react_1.useRef)(null);
     // Live Frame Measurement Loop
@@ -539,3 +539,44 @@ const usePerformanceTracker = () => {
     };
 };
 exports.usePerformanceTracker = usePerformanceTracker;
+const globalPerformanceEvents = [...exports.INITIAL_EVENTS];
+const performanceListeners = new Set();
+const logPerformanceEvent = (event) => {
+    const fullEvent = {
+        id: event.id || `perf-${Date.now()}-${Math.random().toString(36).substring(2, 6)}`,
+        timestamp: event.timestamp || Date.now(),
+        ...event,
+    };
+    globalPerformanceEvents.unshift(fullEvent);
+    if (globalPerformanceEvents.length > 100) {
+        globalPerformanceEvents.pop();
+    }
+    performanceListeners.forEach(listener => {
+        try {
+            listener([...globalPerformanceEvents]);
+        }
+        catch { }
+    });
+    return fullEvent;
+};
+exports.logPerformanceEvent = logPerformanceEvent;
+const clearPerformanceEvents = () => {
+    globalPerformanceEvents.length = 0;
+    performanceListeners.forEach(listener => {
+        try {
+            listener([]);
+        }
+        catch { }
+    });
+};
+exports.clearPerformanceEvents = clearPerformanceEvents;
+const subscribePerformanceEvents = (listener) => {
+    performanceListeners.add(listener);
+    listener([...globalPerformanceEvents]);
+    return () => {
+        performanceListeners.delete(listener);
+    };
+};
+exports.subscribePerformanceEvents = subscribePerformanceEvents;
+const getPerformanceEvents = () => [...globalPerformanceEvents];
+exports.getPerformanceEvents = getPerformanceEvents;

package/dist/commonjs/decorators/index.d.ts

@@ -0,0 +1,49 @@
+export interface InspectLogOptions {
+    tag?: string;
+    logArgs?: boolean;
+    logResult?: boolean;
+    logDuration?: boolean;
+}
+/**
+ * `@InspectLog`: Automatically logs method execution, arguments, duration, and return values
+ * to the In-App Inspector Console.
+ *
+ * @example
+ * ```ts
+ * class UserService {
+ *   @InspectLog({ tag: 'API', logArgs: true, logDuration: true })
+ *   async fetchUser(id: string) {
+ *     return api.get(`/users/${id}`);
+ *   }
+ * }
+ * ```
+ */
+export declare function InspectLog(options?: InspectLogOptions): (_target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * `@InspectTrackTime`: Measures and logs execution duration for critical functions.
+ *
+ * @example
+ * ```ts
+ * class FeedManager {
+ *   @InspectTrackTime('Feed Data Processing')
+ *   processFeedItems(items: FeedItem[]) { ... }
+ * }
+ * ```
+ */
+export declare function InspectTrackTime(label?: string): (_target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * `@InspectCatch`: Safely catches unhandled exceptions thrown inside the method,
+ * logs them to the In-App Inspector, and returns a fallback value.
+ *
+ * @example
+ * ```ts
+ * class AuthService {
+ *   @InspectCatch({ fallback: null, tag: 'AUTH' })
+ *   async getCachedToken() { ... }
+ * }
+ * ```
+ */
+export declare function InspectCatch(options?: {
+    fallback?: any;
+    tag?: string;
+}): (_target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/dist/commonjs/decorators/index.js

@@ -0,0 +1,142 @@
+"use strict";
+// ─── Method & Class Decorators for React Native In-App Inspector ─────────────
+//
+// Clean TypeScript decorators to seamlessly annotate methods, asynchronous actions,
+// and API services with automatic inspection, logging, timing, and error boundaries.
+// ─────────────────────────────────────────────────────────────────────────────
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InspectLog = InspectLog;
+exports.InspectTrackTime = InspectTrackTime;
+exports.InspectCatch = InspectCatch;
+/**
+ * `@InspectLog`: Automatically logs method execution, arguments, duration, and return values
+ * to the In-App Inspector Console.
+ *
+ * @example
+ * ```ts
+ * class UserService {
+ *   @InspectLog({ tag: 'API', logArgs: true, logDuration: true })
+ *   async fetchUser(id: string) {
+ *     return api.get(`/users/${id}`);
+ *   }
+ * }
+ * ```
+ */
+function InspectLog(options = {}) {
+    const { tag = 'Inspect', logArgs = true, logResult = true, logDuration = true, } = options;
+    return function (_target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            const start = Date.now();
+            const prefix = `[${tag}] ${propertyKey}`;
+            if (logArgs && args.length > 0) {
+                console.log(`${prefix} called with arguments:`, ...args);
+            }
+            else {
+                console.log(`${prefix} invoked`);
+            }
+            try {
+                const result = originalMethod.apply(this, args);
+                if (result && typeof result.then === 'function') {
+                    return result
+                        .then((asyncResult) => {
+                        const elapsed = Date.now() - start;
+                        if (logResult) {
+                            console.log(`${prefix} resolved${logDuration ? ` in ${elapsed}ms` : ''}:`, asyncResult);
+                        }
+                        return asyncResult;
+                    })
+                        .catch((err) => {
+                        const elapsed = Date.now() - start;
+                        console.error(`${prefix} rejected${logDuration ? ` in ${elapsed}ms` : ''}:`, err);
+                        throw err;
+                    });
+                }
+                const elapsed = Date.now() - start;
+                if (logResult) {
+                    console.log(`${prefix} returned${logDuration ? ` in ${elapsed}ms` : ''}:`, result);
+                }
+                return result;
+            }
+            catch (error) {
+                const elapsed = Date.now() - start;
+                console.error(`${prefix} failed${logDuration ? ` in ${elapsed}ms` : ''}:`, error);
+                throw error;
+            }
+        };
+        return descriptor;
+    };
+}
+/**
+ * `@InspectTrackTime`: Measures and logs execution duration for critical functions.
+ *
+ * @example
+ * ```ts
+ * class FeedManager {
+ *   @InspectTrackTime('Feed Data Processing')
+ *   processFeedItems(items: FeedItem[]) { ... }
+ * }
+ * ```
+ */
+function InspectTrackTime(label) {
+    return function (_target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const metricLabel = label || propertyKey;
+        descriptor.value = function (...args) {
+            const start = Date.now();
+            try {
+                const result = originalMethod.apply(this, args);
+                if (result && typeof result.then === 'function') {
+                    return result.finally(() => {
+                        const duration = Date.now() - start;
+                        console.log(`[PERF] ⚡ ${metricLabel} took ${duration}ms`);
+                    });
+                }
+                const duration = Date.now() - start;
+                console.log(`[PERF] ⚡ ${metricLabel} took ${duration}ms`);
+                return result;
+            }
+            catch (err) {
+                const duration = Date.now() - start;
+                console.error(`[PERF] ⚡ ${metricLabel} failed after ${duration}ms:`, err);
+                throw err;
+            }
+        };
+        return descriptor;
+    };
+}
+/**
+ * `@InspectCatch`: Safely catches unhandled exceptions thrown inside the method,
+ * logs them to the In-App Inspector, and returns a fallback value.
+ *
+ * @example
+ * ```ts
+ * class AuthService {
+ *   @InspectCatch({ fallback: null, tag: 'AUTH' })
+ *   async getCachedToken() { ... }
+ * }
+ * ```
+ */
+function InspectCatch(options = {}) {
+    const { fallback = undefined, tag = 'Catch' } = options;
+    return function (_target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            try {
+                const result = originalMethod.apply(this, args);
+                if (result && typeof result.then === 'function') {
+                    return result.catch((err) => {
+                        console.error(`[${tag}] Error caught in ${propertyKey}:`, err);
+                        return fallback;
+                    });
+                }
+                return result;
+            }
+            catch (err) {
+                console.error(`[${tag}] Error caught in ${propertyKey}:`, err);
+                return fallback;
+            }
+        };
+        return descriptor;
+    };
+}

package/dist/commonjs/helpers/gaAnalyticsRegistry.d.ts

@@ -0,0 +1,18 @@
+import { GAEventCategory } from '../types/enums';
+export { GAEventCategory };
+export interface GAPlugin {
+    name: string;
+    resolveCategory?: (eventName: string, params?: Record<string, any>) => GAEventCategory | string | null | undefined;
+}
+/**
+ * Register a dynamic Google Analytics / Firebase plugin or custom resolver.
+ */
+export declare const registerGAPlugin: (plugin: GAPlugin) => void;
+/**
+ * Dynamically resolves the GA4 event category using:
+ * 1. Registered dynamic GA plugins
+ * 2. Runtime Firebase Analytics inspection
+ * 3. GA4 standard event taxonomies (O(1) Set lookup)
+ * 4. Semantic pattern & prefix analysis
+ */
+export declare const getEventCategory: (name: string, params?: Record<string, any>) => GAEventCategory;

package/dist/commonjs/helpers/gaAnalyticsRegistry.js

@@ -0,0 +1,174 @@
+"use strict";
+// ─── Google Analytics (GA4) & Firebase Analytics Dynamic Registry ─────────────
+//
+// Dynamically inspects GA4 / Firebase Analytics runtime schemas, auto-detects
+// standard GA4 event taxonomies, and supports dynamic GA plugins.
+// ─────────────────────────────────────────────────────────────────────────────
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEventCategory = exports.registerGAPlugin = exports.GAEventCategory = void 0;
+const enums_1 = require("../types/enums");
+Object.defineProperty(exports, "GAEventCategory", { enumerable: true, get: function () { return enums_1.GAEventCategory; } });
+// ─── Official GA4 & Firebase Standard Event Sets ─────────────────────────────
+const GA4_PAGE_VIEW_EVENTS = new Set([
+    'screen_view',
+    'page_view',
+    'screen_active',
+    'screen_inactive',
+    'view_search_results',
+    'search',
+]);
+const GA4_ECOMMERCE_EVENTS = new Set([
+    'purchase',
+    'refund',
+    'add_to_cart',
+    'remove_from_cart',
+    'view_cart',
+    'begin_checkout',
+    'add_shipping_info',
+    'add_payment_info',
+    'view_item',
+    'view_item_list',
+    'select_item',
+    'select_promotion',
+    'view_promotion',
+    'add_to_wishlist',
+    'generate_lead',
+    'in_app_purchase',
+    'earn_virtual_currency',
+    'spend_virtual_currency',
+    'join_group',
+    'level_up',
+    'level_start',
+    'level_end',
+    'post_score',
+    'select_content',
+    'tutorial_begin',
+    'tutorial_complete',
+    'unlock_achievement',
+]);
+const GA4_SYSTEM_EVENTS = new Set([
+    'first_open',
+    'first_visit',
+    'session_start',
+    'user_engagement',
+    'app_clear_data',
+    'app_exception',
+    'app_remove',
+    'app_store_refund',
+    'app_store_subscription_cancel',
+    'app_store_subscription_convert',
+    'app_store_subscription_renew',
+    'app_update',
+    'os_update',
+    'notification_receive',
+    'notification_open',
+    'notification_dismiss',
+    'notification_foreground',
+    'dynamic_link_first_open',
+    'dynamic_link_app_open',
+    'dynamic_link_app_update',
+    'ad_impression',
+    'ad_click',
+    'ad_reward',
+    'ad_query',
+    'ad_exposure',
+]);
+// ─── Registered Dynamic Plugins ──────────────────────────────────────────────
+const registeredPlugins = [];
+/**
+ * Register a dynamic Google Analytics / Firebase plugin or custom resolver.
+ */
+const registerGAPlugin = (plugin) => {
+    if (!registeredPlugins.some(p => p.name === plugin.name)) {
+        registeredPlugins.push(plugin);
+    }
+};
+exports.registerGAPlugin = registerGAPlugin;
+/**
+ * Attempt dynamic inspection of host runtime Firebase / Google Analytics modules.
+ */
+const tryInspectRuntimeFirebaseAnalytics = () => {
+    try {
+        const firebaseAnalytics = require('@react-native-firebase/analytics');
+        const mod = firebaseAnalytics?.default || firebaseAnalytics;
+        if (mod?.EventNames) {
+            Object.keys(mod.EventNames).forEach(k => {
+                const val = mod.EventNames[k]?.toLowerCase();
+                if (val) {
+                    if (val.includes('cart') ||
+                        val.includes('checkout') ||
+                        val.includes('purchase') ||
+                        val.includes('item')) {
+                        GA4_ECOMMERCE_EVENTS.add(val);
+                    }
+                    else if (val.includes('screen') || val.includes('page')) {
+                        GA4_PAGE_VIEW_EVENTS.add(val);
+                    }
+                }
+            });
+        }
+    }
+    catch {
+        // Optional dependency - safe fallback to built-in GA4 taxonomy
+    }
+};
+// Initialize dynamic runtime inspection once
+tryInspectRuntimeFirebaseAnalytics();
+/**
+ * Dynamically resolves the GA4 event category using:
+ * 1. Registered dynamic GA plugins
+ * 2. Runtime Firebase Analytics inspection
+ * 3. GA4 standard event taxonomies (O(1) Set lookup)
+ * 4. Semantic pattern & prefix analysis
+ */
+const getEventCategory = (name, params) => {
+    if (!name || typeof name !== 'string')
+        return 'custom';
+    const cleanName = name.trim().toLowerCase();
+    // 1. Run through registered dynamic plugins
+    for (const plugin of registeredPlugins) {
+        if (plugin.resolveCategory) {
+            const category = plugin.resolveCategory(cleanName, params);
+            if (category)
+                return category;
+        }
+    }
+    // 2. Exact GA4 taxonomy matching (O(1))
+    if (GA4_PAGE_VIEW_EVENTS.has(cleanName)) {
+        return 'page_view';
+    }
+    if (GA4_ECOMMERCE_EVENTS.has(cleanName)) {
+        return 'ecommerce';
+    }
+    if (GA4_SYSTEM_EVENTS.has(cleanName)) {
+        return 'system';
+    }
+    // 3. Prefix & namespace detection
+    if (cleanName.startsWith('firebase_') ||
+        cleanName.startsWith('ga_') ||
+        cleanName.startsWith('gtag_') ||
+        cleanName.startsWith('_') ||
+        cleanName.startsWith('google_')) {
+        return 'system';
+    }
+    // 4. Semantic pattern matching
+    if (cleanName.endsWith('_view') ||
+        cleanName.endsWith('_screen') ||
+        cleanName.startsWith('screen_') ||
+        cleanName.startsWith('page_') ||
+        cleanName.includes('screen_view') ||
+        cleanName.includes('page_view')) {
+        return 'page_view';
+    }
+    if (cleanName.includes('cart') ||
+        cleanName.includes('checkout') ||
+        cleanName.includes('purchase') ||
+        cleanName.includes('payment') ||
+        cleanName.includes('order') ||
+        cleanName.includes('refund') ||
+        cleanName.includes('shipping')) {
+        return 'ecommerce';
+    }
+    return 'custom';
+};
+exports.getEventCategory = getEventCategory;

package/dist/commonjs/helpers/index.d.ts

@@ -1,4 +1,4 @@
-import { NetworkLog, RouteInfo, DiffResult, JsonContent } from '../types';
+import { NetworkLog, RouteInfo, DiffResult, JsonContent, StackFrameType } from '../types';
 export declare const getDomainColor: (domain: string) => string;
 export declare const formatDateTime: (timestamp: number) => string;
 export declare const getStatusColor: (status: number | null) => string;
@@ -40,17 +40,20 @@ export interface ParsedStackFrame {
     functionName: string;
     fileName: string;
     fullPath: string;
-    fileExt?: 'tsx' | 'jsx' | 'ts' | 'js' | 'other';
-    isUserCode?: boolean;
+    fileExt: string;
+    frameType: StackFrameType | 'app' | 'dependency' | 'runtime' | 'native';
+    isUserCode: boolean;
+    isRuntimeNoise: boolean;
     lineNumber?: string;
     columnNumber?: string;
     isOrigin?: boolean;
+    copyableLocation: string;
 }
 /** Parses a stack trace line to extract function name, file name, extension (.tsx/.jsx/.ts), line, and column numbers */
 export declare const parseStackLine: (rawLine: string, isOrigin?: boolean) => ParsedStackFrame;
 export declare const ANALYTICS_EVENT_PALETTE: string[];
 export declare const getEventColor: (name: string) => string;
-export declare const getEventCategory: (name: string) => "page_view" | "ecommerce" | "system" | "custom";
+export { getEventCategory, registerGAPlugin, type GAEventCategory, type GAPlugin, } from './gaAnalyticsRegistry';
 export declare const getCategoryColors: (category: string) => {
     bg: string;
     border: string;