react-native-qalink 0.1.1 → 0.1.3

package/dist/interceptors/console.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setupConsoleInterceptor = setupConsoleInterceptor;
+exports.setupConsoleInterceptor = void 0;
 const session_1 = require("../core/session");
-// Guardamos referencia a los métodos originales ANTES de sobrescribir
+
 const originalConsole = {
     log: console.log.bind(console),
     warn: console.warn.bind(console),
@@ -10,132 +10,88 @@ const originalConsole = {
     info: console.info.bind(console),
     debug: console.debug.bind(console),
 };
-/**
- * Patrones que identifican logs internos de React Native
- * para clasificarlos correctamente en el dashboard.
- */
-const RN_WARNING_PATTERNS = [
-    'Warning:',
-    'VirtualizedList',
-    'Each child in a list',
-    'componentWillMount',
-    'componentWillReceiveProps',
-    'componentWillUpdate',
-    'findDOMNode',
-    'ReactDOM.render',
-    'key prop',
-    'unique "key"',
-    'Maximum update depth',
-];
-const RN_ERROR_PATTERNS = [
-    'Invariant Violation',
-    'Text strings must be rendered',
-    'Cannot update a component',
-    'Element type is invalid',
-    'Objects are not valid as a React child',
-    'TypeError',
-    'ReferenceError',
-    'Cannot read property',
-    'Cannot read properties',
-    'is not a function',
-    'undefined is not an object',
-    'null is not an object',
-];
-const METRO_ERROR_PATTERNS = [
-    'Unable to resolve module',
-    'Module not found',
-    'SyntaxError',
-    'TransformError',
-    'bundling failed',
-    'Metro Bundler',
-    'Error: Metro',
-];
-const THIRD_PARTY_PATTERNS = [
-    '[react-navigation]',
-    '[react-query]',
-    '[redux]',
-    '[mobx]',
-    '[zustand]',
-    'Reanimated',
-    'Gesture Handler',
-    'SafeAreaProvider',
-];
+
+const RN_WARNING_PATTERNS = ['Warning:', 'VirtualizedList', 'Each child in a list', 'componentWillMount', 'componentWillReceiveProps', 'componentWillUpdate', 'findDOMNode', 'ReactDOM.render', 'key prop', 'unique "key"', 'Maximum update depth'];
+const RN_ERROR_PATTERNS = ['Invariant Violation', 'Text strings must be rendered', 'Cannot update a component', 'Element type is invalid', 'Objects are not valid as a React child', 'TypeError', 'ReferenceError', 'Cannot read property', 'Cannot read properties', 'is not a function', 'undefined is not an object', 'null is not an object'];
+const METRO_ERROR_PATTERNS = ['Unable to resolve module', 'Module not found', 'SyntaxError', 'TransformError', 'bundling failed', 'Metro Bundler', 'Error: Metro'];
+const THIRD_PARTY_PATTERNS = ['[react-navigation]', '[react-query]', '[redux]', '[mobx]', '[zustand]', 'Reanimated', 'Gesture Handler', 'SafeAreaProvider'];
+
 function classifyConsoleMessage(message) {
-    if (METRO_ERROR_PATTERNS.some(p => message.includes(p)))
-        return 'rn_error';
-    if (RN_ERROR_PATTERNS.some(p => message.includes(p)))
-        return 'rn_error';
-    if (RN_WARNING_PATTERNS.some(p => message.includes(p)))
-        return 'rn_warning';
-    if (THIRD_PARTY_PATTERNS.some(p => message.includes(p)))
-        return 'third_party';
+    if (METRO_ERROR_PATTERNS.some(p => message.includes(p))) return 'rn_error';
+    if (RN_ERROR_PATTERNS.some(p => message.includes(p))) return 'rn_error';
+    if (RN_WARNING_PATTERNS.some(p => message.includes(p))) return 'rn_warning';
+    if (THIRD_PARTY_PATTERNS.some(p => message.includes(p))) return 'third_party';
     return 'user_log';
 }
+
 function serializeArg(arg) {
-    var _a;
-    if (arg === null)
-        return 'null';
-    if (arg === undefined)
-        return 'undefined';
-    if (typeof arg === 'string')
-        return arg;
-    if (typeof arg === 'number' || typeof arg === 'boolean')
-        return String(arg);
-    if (arg instanceof Error)
-        return `${arg.name}: ${arg.message}\n${(_a = arg.stack) !== null && _a !== void 0 ? _a : ''}`;
-    try {
-        return JSON.stringify(arg, null, 2);
-    }
-    catch (_b) {
-        return String(arg);
-    }
+    if (arg === null) return 'null';
+    if (arg === undefined) return 'undefined';
+    if (typeof arg === 'string') return arg;
+    if (typeof arg === 'number' || typeof arg === 'boolean') return String(arg);
+    if (arg instanceof Error) return `${arg.name}: ${arg.message}\n${arg.stack ?? ''}`;
+    try { return JSON.stringify(arg, null, 2); } catch { return String(arg); }
 }
+
 function shouldCapture(message, config) {
-    var _a;
-    if (!config)
-        return true;
-    // Ignorar si matchea algún patrón de exclusión
-    if ((_a = config.ignorePatterns) === null || _a === void 0 ? void 0 : _a.some(p => message.includes(p)))
-        return false;
-    // Si hay patrones de inclusión, solo capturar si matchea alguno
+    if (!config) return true;
+    if (config.ignorePatterns?.some(p => message.includes(p))) return false;
     if (config.includePatterns && config.includePatterns.length > 0) {
         return config.includePatterns.some(p => message.includes(p));
     }
     return true;
 }
+
+// FLAG para prevenir loops de recursión
+let _isSending = false;
+
 function setupConsoleInterceptor(transport, config, getCurrentScreen) {
-    var _a;
-    const consoleConfig = (_a = config.console) !== null && _a !== void 0 ? _a : {};
-    const { captureLogs = true, captureWarnings = true, captureErrors = true, } = consoleConfig;
+    const consoleConfig = config.console ?? {};
+    const { captureLogs = true, captureWarnings = true, captureErrors = true } = consoleConfig;
+
     function intercept(level, eventType, originalFn) {
         return (...args) => {
-            var _a;
-            // Siempre llamar al original primero — Metro sigue mostrando todo
+            // SIEMPRE llamar el original primero
             originalFn(...args);
+
+            // Evitar loop recursivo — si ya estamos enviando, no volver a entrar
+            if (_isSending) return;
+
             const serializedArgs = args.map(serializeArg);
             const message = serializedArgs.join(' ');
-            if (!shouldCapture(message, consoleConfig))
-                return;
-            // Evitar loop infinito si QALink mismo hace console.log en debug mode
-            if (message.startsWith('[QALink]'))
-                return;
-            const category = classifyConsoleMessage(message);
-            const event = {
-                id: (0, session_1.generateId)(),
-                type: eventType,
-                level,
-                message,
-                args: serializedArgs,
-                category,
-                timestamp: Date.now(),
-                screen: getCurrentScreen(),
-                sessionId: (0, session_1.getSessionId)(),
-            };
-            transport.send(event);
-            (_a = config.onEvent) === null || _a === void 0 ? void 0 : _a.call(config, event);
+
+            // Ignorar logs internos de QALink
+            if (message.startsWith('[QALink]')) return;
+
+            // Ignorar errores de call stack para evitar loop infinito
+            if (message.includes('Maximum call stack') || message.includes('call stack size exceeded')) return;
+
+            if (!shouldCapture(message, consoleConfig)) return;
+
+            try {
+                _isSending = true;
+                const category = classifyConsoleMessage(message);
+                const event = {
+                    id: (0, session_1.generateId)(),
+                    type: eventType,
+                    level,
+                    message,
+                    args: serializedArgs,
+                    category,
+                    timestamp: Date.now(),
+                    screen: getCurrentScreen(),
+                    sessionId: (0, session_1.getSessionId)(),
+                };
+                transport.send(event);
+                config.onEvent?.(event);
+            } catch {
+                // Nunca romper la app por un error del interceptor
+            } finally {
+                _isSending = false;
+            }
         };
     }
-    // Sobrescribir métodos de consola
+
     if (captureLogs) {
         console.log = intercept('log', 'console_log', originalConsole.log);
         console.info = intercept('info', 'console_log', originalConsole.info);
@@ -147,7 +103,7 @@ function setupConsoleInterceptor(transport, config, getCurrentScreen) {
     if (captureErrors) {
         console.error = intercept('error', 'console_error', originalConsole.error);
     }
-    // Cleanup: restaurar consola original
+
     return () => {
         console.log = originalConsole.log;
         console.warn = originalConsole.warn;
@@ -156,4 +112,4 @@ function setupConsoleInterceptor(transport, config, getCurrentScreen) {
         console.debug = originalConsole.debug;
     };
 }
-//# sourceMappingURL=console.js.map
+exports.setupConsoleInterceptor = setupConsoleInterceptor;

package/dist/interceptors/runtime.js

@@ -1,141 +1,83 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setupRuntimeErrorHandler = setupRuntimeErrorHandler;
+exports.setupRuntimeErrorHandler = void 0;
 const session_1 = require("../core/session");
-/**
- * Captura los errores del runtime de React Native:
- *
- * 1. ErrorUtils.setGlobalHandler → captura la PANTALLA ROJA (errores fatales)
- *    Son los errores que crashean la app completamente. React Native los
- *    intercepta antes de mostrar el red screen y nosotros nos enganchamos ahí.
- *
- * 2. LogBox.ignoreLogs / console.error → captura las CAJAS AMARILLAS (warnings)
- *    Son los warnings que RN muestra en desarrollo. Se generan a través de
- *    console.error internamente, así que el interceptor de consola los captura,
- *    pero aquí los marcamos también con el handler de RN para mayor precisión.
- *
- * 3. NativeModules errors → errores del bridge JS<->Native
- *    Ocurren cuando un módulo nativo falla o no está disponible.
- */
+
 function classifyRuntimeError(message, isFatal) {
-    if (isFatal)
-        return 'red_screen';
-    if (message.includes('NativeModule') ||
-        message.includes('Native module') ||
-        message.includes('TurboModule') ||
-        message.includes('requireNativeComponent')) {
-        return 'native_module';
-    }
-    if (message.includes('bridge') ||
-        message.includes('JSContext') ||
-        message.includes('RCTBridge') ||
-        message.includes('JavaScriptCore')) {
-        return 'bridge';
-    }
-    if (message.startsWith('Warning:') || message.includes('deprecated')) {
-        return 'yellow_box';
-    }
+    if (isFatal) return 'red_screen';
+    if (message.includes('NativeModule') || message.includes('Native module') || message.includes('TurboModule') || message.includes('requireNativeComponent')) return 'native_module';
+    if (message.includes('bridge') || message.includes('JSContext') || message.includes('RCTBridge') || message.includes('JavaScriptCore')) return 'bridge';
+    if (message.startsWith('Warning:') || message.includes('deprecated')) return 'yellow_box';
     return 'unknown';
 }
+
 function setupRuntimeErrorHandler(transport, config, getCurrentScreen) {
-    var _a, _b;
     const cleanups = [];
-    // ── 1. Handler global de errores fatales (pantalla roja) ──────────────────
-    // React Native expone ErrorUtils para capturar errores antes de que
-    // la app crashee y muestre el red screen.
+
+    // ── 1. Handler global de errores fatales ──────────────────────────────────
     try {
-        const originalGlobalHandler = ErrorUtils.getGlobalHandler();
-        ErrorUtils.setGlobalHandler((error, isFatal) => {
-            var _a, _b, _c;
-            const fatal = isFatal !== null && isFatal !== void 0 ? isFatal : false;
-            const category = classifyRuntimeError((_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : '', fatal);
-            const event = {
-                id: (0, session_1.generateId)(),
-                type: 'runtime_error',
-                level: fatal ? 'fatal' : 'error',
-                message: (_b = error === null || error === void 0 ? void 0 : error.message) !== null && _b !== void 0 ? _b : String(error),
-                stack: error === null || error === void 0 ? void 0 : error.stack,
-                isFatal: fatal,
-                category,
-                timestamp: Date.now(),
-                screen: getCurrentScreen(),
-                sessionId: (0, session_1.getSessionId)(),
-            };
-            transport.send(event);
-            (_c = config.onEvent) === null || _c === void 0 ? void 0 : _c.call(config, event);
-            // CRÍTICO: siempre llamar al handler original
-            // Si no lo hacemos, RN no muestra la pantalla roja y el error se pierde
-            originalGlobalHandler(error, isFatal);
-        });
-        cleanups.push(() => {
-            ErrorUtils.setGlobalHandler(originalGlobalHandler);
-        });
-    }
-    catch (e) {
-        // ErrorUtils puede no estar disponible en algunos entornos (ej: Jest)
-    }
+        if (typeof ErrorUtils !== 'undefined' && ErrorUtils.getGlobalHandler) {
+            const originalGlobalHandler = ErrorUtils.getGlobalHandler();
+            ErrorUtils.setGlobalHandler((error, isFatal) => {
+                try {
+                    const fatal = isFatal ?? false;
+                    const category = classifyRuntimeError(error?.message ?? '', fatal);
+                    const event = {
+                        id: (0, session_1.generateId)(),
+                        type: 'runtime_error',
+                        level: fatal ? 'fatal' : 'error',
+                        message: error?.message ?? String(error),
+                        stack: error?.stack,
+                        isFatal: fatal,
+                        category,
+                        timestamp: Date.now(),
+                        screen: getCurrentScreen(),
+                        sessionId: (0, session_1.getSessionId)(),
+                    };
+                    transport.send(event);
+                    config.onEvent?.(event);
+                } catch {}
+                originalGlobalHandler(error, isFatal);
+            });
+            cleanups.push(() => {
+                try { ErrorUtils.setGlobalHandler(originalGlobalHandler); } catch {}
+            });
+        }
+    } catch {}
+
     // ── 2. Promesas rechazadas no manejadas ───────────────────────────────────
-    // Cuando un Promise.reject() no tiene .catch(), RN lo captura aquí.
-    // Ejemplo típico: llamada a API sin try/catch
-    const unhandledRejectionHandler = (event) => {
-        var _a, _b, _c;
-        const error = event === null || event === void 0 ? void 0 : event.reason;
-        const message = (_b = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : String(error)) !== null && _b !== void 0 ? _b : 'Unhandled Promise Rejection';
-        const runtimeEvent = {
-            id: (0, session_1.generateId)(),
-            type: 'runtime_error',
-            level: 'error',
-            message,
-            stack: error === null || error === void 0 ? void 0 : error.stack,
-            isFatal: false,
-            category: 'unknown',
-            timestamp: Date.now(),
-            screen: getCurrentScreen(),
-            sessionId: (0, session_1.getSessionId)(),
-        };
-        transport.send(runtimeEvent);
-        (_c = config.onEvent) === null || _c === void 0 ? void 0 : _c.call(config, runtimeEvent);
-    };
-    if (typeof global !== 'undefined') {
-        (_b = (_a = global).addEventListener) === null || _b === void 0 ? void 0 : _b.call(_a, 'unhandledrejection', unhandledRejectionHandler);
-        cleanups.push(() => {
-            var _a, _b;
-            (_b = (_a = global).removeEventListener) === null || _b === void 0 ? void 0 : _b.call(_a, 'unhandledrejection', unhandledRejectionHandler);
-        });
-    }
-    // ── 3. Warnings de LogBox (cajas amarillas) ───────────────────────────────
-    // En RN >= 0.64 los warnings se manejan via LogBox.
-    // Nos enganchamos al método interno que registra los warnings.
     try {
-        const LogBox = require('react-native/Libraries/LogBox/LogBox');
-        if (LogBox && LogBox.__warn) {
-            const originalWarn = LogBox.__warn.bind(LogBox);
-            LogBox.__warn = (message, stack) => {
-                var _a;
-                const event = {
+        const unhandledRejectionHandler = (event) => {
+            try {
+                const error = event?.reason;
+                const message = error?.message ?? String(error) ?? 'Unhandled Promise Rejection';
+                const runtimeEvent = {
                     id: (0, session_1.generateId)(),
                     type: 'runtime_error',
-                    level: 'warning',
+                    level: 'error',
                     message,
-                    stack,
+                    stack: error?.stack,
                     isFatal: false,
-                    category: 'yellow_box',
+                    category: 'unknown',
                     timestamp: Date.now(),
                     screen: getCurrentScreen(),
                     sessionId: (0, session_1.getSessionId)(),
                 };
-                transport.send(event);
-                (_a = config.onEvent) === null || _a === void 0 ? void 0 : _a.call(config, event);
-                originalWarn(message, stack);
-            };
+                transport.send(runtimeEvent);
+                config.onEvent?.(runtimeEvent);
+            } catch {}
+        };
+        if (typeof global !== 'undefined' && global.addEventListener) {
+            global.addEventListener('unhandledrejection', unhandledRejectionHandler);
             cleanups.push(() => {
-                LogBox.__warn = originalWarn;
+                try { global.removeEventListener('unhandledrejection', unhandledRejectionHandler); } catch {}
             });
         }
-    }
-    catch (_c) {
-        // LogBox puede no estar disponible en versiones viejas de RN
-    }
-    return () => cleanups.forEach(fn => fn());
+    } catch {}
+
+    // NOTE: LogBox.__warn removido — causa crash en bridge nativo C++
+    // Los warnings ya son capturados por el interceptor de console.warn
+
+    return () => cleanups.forEach(fn => { try { fn(); } catch {} });
 }
-//# sourceMappingURL=runtime.js.map
+exports.setupRuntimeErrorHandler = setupRuntimeErrorHandler;

package/package.json

@@ -1,29 +1,16 @@
 {
   "name": "react-native-qalink",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Real-time error capture SDK for React Native — helps QA teams identify if bugs are frontend or backend",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "keywords": [
-    "react-native",
-    "debugging",
-    "qa",
-    "error-tracking",
-    "network-interceptor"
-  ],
+  "files": ["dist", "README.md"],
+  "keywords": ["react-native", "debugging", "qa", "error-tracking", "network-interceptor"],
   "peerDependencies": {
     "react-native": ">=0.70.0",
     "axios": ">=1.0.0"
   },
-  "peerDependenciesMeta": {
-    "axios": {
-      "optional": true
-    }
-  },
+  "peerDependenciesMeta": { "axios": { "optional": true } },
   "devDependencies": {
     "typescript": "^5.0.0",
     "@types/react-native": "^0.72.0"