react-native-inapp-inspector 1.1.23 → 1.1.25

package/dist/esm/customHooks/consoleLogger.js

@@ -1,3 +1,4 @@
+import { NativeModules } from 'react-native';
 import { IGNORED_LOG_PREFIXES } from './logFilters';
 let logs = [];
 let listeners = [];
@@ -24,12 +25,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 +53,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 +214,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 +227,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);

package/dist/esm/customHooks/networkLogger.js

@@ -3,7 +3,16 @@ 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;

package/dist/esm/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/esm/customHooks/performanceTracker.js

@@ -170,7 +170,7 @@ const INITIAL_RENDER_PROFILES = [
         severity: 'optimal',
     },
 ];
-const INITIAL_EVENTS = [
+export const INITIAL_EVENTS = [
     {
         id: 'perf-1',
         timestamp: Date.now() - 48000,
@@ -535,3 +535,40 @@ export const usePerformanceTracker = () => {
         triggerGc,
     };
 };
+const globalPerformanceEvents = [...INITIAL_EVENTS];
+const performanceListeners = new Set();
+export 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;
+};
+export const clearPerformanceEvents = () => {
+    globalPerformanceEvents.length = 0;
+    performanceListeners.forEach(listener => {
+        try {
+            listener([]);
+        }
+        catch { }
+    });
+};
+export const subscribePerformanceEvents = (listener) => {
+    performanceListeners.add(listener);
+    listener([...globalPerformanceEvents]);
+    return () => {
+        performanceListeners.delete(listener);
+    };
+};
+export const getPerformanceEvents = () => [...globalPerformanceEvents];

package/dist/esm/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/esm/decorators/index.js

@@ -0,0 +1,137 @@
+// ─── 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.
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * `@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 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[]) { ... }
+ * }
+ * ```
+ */
+export 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() { ... }
+ * }
+ * ```
+ */
+export 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/esm/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/esm/helpers/gaAnalyticsRegistry.js

@@ -0,0 +1,169 @@
+// ─── 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.
+// ─────────────────────────────────────────────────────────────────────────────
+import { GAEventCategory } from '../types/enums';
+export { 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.
+ */
+export const registerGAPlugin = (plugin) => {
+    if (!registeredPlugins.some(p => p.name === plugin.name)) {
+        registeredPlugins.push(plugin);
+    }
+};
+/**
+ * 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
+ */
+export const getEventCategory = (name, params) => {
+    if (!name)
+        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';
+};

package/dist/esm/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;