@scalebun/react-native 1.0.2 → 1.0.4

package/src/features/replay/integrations/logs/consoleIntegration.ts

@@ -1,116 +1,116 @@
-/**
- * Session Replay SDK — Console Log Integration
- *
- * Patches console.log/warn/error to capture log breadcrumbs.
- * Can be enabled/disabled at runtime.
- */
-
-import { breadcrumbCollector } from '../../replay/breadcrumbs/breadcrumbCollector';
-import { logger } from '../../core/logger/logger';
-import { SessionManager } from '../../../session/SessionManager';
-
-let _installed = false;
-let _enabled = true;
-
-/**
- * Map a patched console method to the neutral log `level` carried on the
- * platform-agnostic logs lane. console.info collapses to 'info'; everything else maps
- * 1:1. Kept here (the JS producer) so the lane/backend never learn console method names.
- */
-const CONSOLE_LEVEL: Record<string, string> = {
-    log: 'log',
-    info: 'info',
-    warn: 'warn',
-    error: 'error',
-    debug: 'debug',
-};
-
-/**
- * First producer into the logs lane: forward this console call to the backend logs
- * queue (source='console', platform='js'). Additive to the existing breadcrumb capture
- * — never throws, no-ops cleanly when no SaaS backend transport is attached. A future
- * native producer feeds the SAME queue with its own source/platform.
- */
-function forwardToLogsLane(method: string, message: string): void {
-    try {
-        const transport = SessionManager.getExistingInstance()?.getBackendTransport();
-        if (!transport) return;
-        transport.queueLog({
-            level: CONSOLE_LEVEL[method] ?? method,
-            message,
-            source: 'console',
-            platform: 'js',
-            timestamp: new Date().toISOString(),
-        });
-    } catch {
-        // Never crash in console interceptor.
-    }
-}
-
-const _originals = {
-    log: console.log,
-    info: console.info,
-    warn: console.warn,
-    error: console.error,
-    debug: console.debug,
-};
-
-/**
- * Install console interceptors.
- * Safe to call multiple times — only installs once.
- */
-export function installConsoleIntegration(): void {
-    if (_installed) return;
-    _installed = true;
-
-    const methods: Array<keyof typeof _originals> = ['log', 'info', 'warn', 'error', 'debug'];
-
-    for (const method of methods) {
-        const original = _originals[method];
-        (console as any)[method] = (...args: any[]) => {
-            // Skip SDK-internal logs before calling original to prevent the
-            // Expo/RN error overlay from triggering on SDK-internal errors.
-            const firstArg = args[0];
-            if (typeof firstArg === 'string' && firstArg.startsWith('[ReplaySdk]')) return;
-
-            // Always call original for non-SDK logs
-            original.apply(console, args);
-
-            if (_enabled) {
-                try {
-                    const message = args.map(a => {
-                        if (typeof a === 'string') return a;
-                        try { return JSON.stringify(a); }
-                        catch { return String(a); }
-                    }).join(' ');
-
-                    const truncated = message.slice(0, 1024);
-                    breadcrumbCollector.addConsoleBreadcrumb(method, truncated).catch(() => { });
-                    // Additive: same tap also feeds the platform-agnostic logs lane.
-                    forwardToLogsLane(method, truncated);
-                } catch {
-                    // Never crash in console interceptor
-                }
-            }
-        };
-    }
-}
-
-/**
- * Remove console interceptors and restore originals.
- */
-export function uninstallConsoleIntegration(): void {
-    if (!_installed) return;
-    _installed = false;
-
-    console.log = _originals.log;
-    console.info = _originals.info;
-    console.warn = _originals.warn;
-    console.error = _originals.error;
-    console.debug = _originals.debug;
-}
-
-/** Enable/disable console breadcrumb capture at runtime */
-export function setConsoleEnabled(enabled: boolean): void {
-    _enabled = enabled;
-}
+/**
+ * Session Replay SDK — Console Log Integration
+ *
+ * Patches console.log/warn/error to capture log breadcrumbs.
+ * Can be enabled/disabled at runtime.
+ */
+
+import { breadcrumbCollector } from '../../replay/breadcrumbs/breadcrumbCollector';
+import { logger } from '../../core/logger/logger';
+import { SessionManager } from '../../../session/SessionManager';
+
+let _installed = false;
+let _enabled = true;
+
+/**
+ * Map a patched console method to the neutral log `level` carried on the
+ * platform-agnostic logs lane. console.info collapses to 'info'; everything else maps
+ * 1:1. Kept here (the JS producer) so the lane/backend never learn console method names.
+ */
+const CONSOLE_LEVEL: Record<string, string> = {
+    log: 'log',
+    info: 'info',
+    warn: 'warn',
+    error: 'error',
+    debug: 'debug',
+};
+
+/**
+ * First producer into the logs lane: forward this console call to the backend logs
+ * queue (source='console', platform='js'). Additive to the existing breadcrumb capture
+ * — never throws, no-ops cleanly when no SaaS backend transport is attached. A future
+ * native producer feeds the SAME queue with its own source/platform.
+ */
+function forwardToLogsLane(method: string, message: string): void {
+    try {
+        const transport = SessionManager.getExistingInstance()?.getBackendTransport();
+        if (!transport) return;
+        transport.queueLog({
+            level: CONSOLE_LEVEL[method] ?? method,
+            message,
+            source: 'console',
+            platform: 'js',
+            timestamp: new Date().toISOString(),
+        });
+    } catch {
+        // Never crash in console interceptor.
+    }
+}
+
+const _originals = {
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error,
+    debug: console.debug,
+};
+
+/**
+ * Install console interceptors.
+ * Safe to call multiple times — only installs once.
+ */
+export function installConsoleIntegration(): void {
+    if (_installed) return;
+    _installed = true;
+
+    const methods: Array<keyof typeof _originals> = ['log', 'info', 'warn', 'error', 'debug'];
+
+    for (const method of methods) {
+        const original = _originals[method];
+        (console as any)[method] = (...args: any[]) => {
+            // Skip SDK-internal logs before calling original to prevent the
+            // Expo/RN error overlay from triggering on SDK-internal errors.
+            const firstArg = args[0];
+            if (typeof firstArg === 'string' && firstArg.startsWith('[ReplaySdk]')) return;
+
+            // Always call original for non-SDK logs
+            original.apply(console, args);
+
+            if (_enabled) {
+                try {
+                    const message = args.map(a => {
+                        if (typeof a === 'string') return a;
+                        try { return JSON.stringify(a); }
+                        catch { return String(a); }
+                    }).join(' ');
+
+                    const truncated = message.slice(0, 1024);
+                    breadcrumbCollector.addConsoleBreadcrumb(method, truncated).catch(() => { });
+                    // Additive: same tap also feeds the platform-agnostic logs lane.
+                    forwardToLogsLane(method, truncated);
+                } catch {
+                    // Never crash in console interceptor
+                }
+            }
+        };
+    }
+}
+
+/**
+ * Remove console interceptors and restore originals.
+ */
+export function uninstallConsoleIntegration(): void {
+    if (!_installed) return;
+    _installed = false;
+
+    console.log = _originals.log;
+    console.info = _originals.info;
+    console.warn = _originals.warn;
+    console.error = _originals.error;
+    console.debug = _originals.debug;
+}
+
+/** Enable/disable console breadcrumb capture at runtime */
+export function setConsoleEnabled(enabled: boolean): void {
+    _enabled = enabled;
+}

package/src/features/replay/integrations/network/networkAdapter.ts

@@ -1,128 +1,128 @@
-/**
- * Session Replay SDK — Network Adapter
- *
- * Provides network breadcrumb integration via adapter pattern.
- * Does NOT monkey-patch XMLHttpRequest or fetch.
- * Instead, provides a report function that users or other interceptors can call.
- *
- * Usage:
- *   import { reportNetworkRequest } from '@scalebun/replay-sdk';
- *
- *   // After your network request completes:
- *   reportNetworkRequest({
- *       method: 'GET',
- *       url: 'https://api.example.com/data',
- *       statusCode: 200,
- *       durationMs: 150,
- *       requestSizeBytes: 0,
- *       responseSizeBytes: 1024,
- *       error: false,
- *       startTimestamp: Date.now() - 150,
- *   });
- */
-
-import type { NetworkRequestSummary } from '../../public/types';
-import { breadcrumbCollector } from '../../replay/breadcrumbs/breadcrumbCollector';
-import { logger } from '../../core/logger/logger';
-
-let _enabled = true;
-let _urlFilter: ((url: string) => boolean) | null = null;
-
-/**
- * Report a completed network request as a replay breadcrumb.
- * Safe to call from anywhere — no-throw.
- */
-export function reportNetworkRequest(request: NetworkRequestSummary): void {
-    if (!_enabled) return;
-
-    try {
-        // Apply URL filter
-        if (_urlFilter && !_urlFilter(request.url)) return;
-
-        // Sanitize URL (strip query params with sensitive data patterns)
-        const sanitized: NetworkRequestSummary = {
-            ...request,
-            url: sanitizeUrl(request.url),
-        };
-
-        breadcrumbCollector.addNetworkBreadcrumb(sanitized).catch(() => { });
-    } catch (err: any) {
-        logger.debug(`Network breadcrumb failed: ${err?.message}`);
-    }
-}
-
-/**
- * Set a filter function to control which URLs are recorded.
- * Return true to include, false to exclude.
- */
-export function setNetworkUrlFilter(filter: ((url: string) => boolean) | null): void {
-    _urlFilter = filter;
-}
-
-/** Enable/disable network breadcrumb collection */
-export function setNetworkEnabled(enabled: boolean): void {
-    _enabled = enabled;
-}
-
-/**
- * Optional: create a fetch wrapper that auto-reports requests.
- * This does NOT replace global fetch — it wraps it for convenience.
- */
-export function createTrackedFetch(originalFetch: typeof fetch): typeof fetch {
-    return async function trackedFetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
-        const startTime = Date.now();
-        const method = init?.method ?? 'GET';
-        const url = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
-        const requestSize = init?.body ? new Blob([init.body as any]).size : 0;
-
-        try {
-            const response = await originalFetch(input, init);
-            const duration = Date.now() - startTime;
-
-            reportNetworkRequest({
-                method,
-                url,
-                statusCode: response.status,
-                durationMs: duration,
-                requestSizeBytes: requestSize,
-                responseSizeBytes: 0, // Can't reliably get without reading body
-                error: !response.ok,
-                startTimestamp: startTime,
-            });
-
-            return response;
-        } catch (err: any) {
-            const duration = Date.now() - startTime;
-
-            reportNetworkRequest({
-                method,
-                url,
-                statusCode: 0,
-                durationMs: duration,
-                requestSizeBytes: requestSize,
-                responseSizeBytes: 0,
-                error: true,
-                errorMessage: err?.message,
-                startTimestamp: startTime,
-            });
-
-            throw err;
-        }
-    };
-}
-
-/** Basic URL sanitization: mask tokens/keys in query params */
-function sanitizeUrl(url: string): string {
-    try {
-        const u = new URL(url);
-        const sensitiveKeys = ['token', 'key', 'apikey', 'api_key', 'secret', 'password', 'auth'];
-        for (const key of u.searchParams.keys()) {
-            if (sensitiveKeys.some(s => key.toLowerCase().includes(s))) {
-                u.searchParams.set(key, '***');
-            }
-        }
-        return u.toString();
-    } catch {
-        return url.slice(0, 2048);
-    }
-}
+/**
+ * Session Replay SDK — Network Adapter
+ *
+ * Provides network breadcrumb integration via adapter pattern.
+ * Does NOT monkey-patch XMLHttpRequest or fetch.
+ * Instead, provides a report function that users or other interceptors can call.
+ *
+ * Usage:
+ *   import { reportNetworkRequest } from '@scalebun/replay-sdk';
+ *
+ *   // After your network request completes:
+ *   reportNetworkRequest({
+ *       method: 'GET',
+ *       url: 'https://api.example.com/data',
+ *       statusCode: 200,
+ *       durationMs: 150,
+ *       requestSizeBytes: 0,
+ *       responseSizeBytes: 1024,
+ *       error: false,
+ *       startTimestamp: Date.now() - 150,
+ *   });
+ */
+
+import type { NetworkRequestSummary } from '../../public/types';
+import { breadcrumbCollector } from '../../replay/breadcrumbs/breadcrumbCollector';
+import { logger } from '../../core/logger/logger';
+
+let _enabled = true;
+let _urlFilter: ((url: string) => boolean) | null = null;
+
+/**
+ * Report a completed network request as a replay breadcrumb.
+ * Safe to call from anywhere — no-throw.
+ */
+export function reportNetworkRequest(request: NetworkRequestSummary): void {
+    if (!_enabled) return;
+
+    try {
+        // Apply URL filter
+        if (_urlFilter && !_urlFilter(request.url)) return;
+
+        // Sanitize URL (strip query params with sensitive data patterns)
+        const sanitized: NetworkRequestSummary = {
+            ...request,
+            url: sanitizeUrl(request.url),
+        };
+
+        breadcrumbCollector.addNetworkBreadcrumb(sanitized).catch(() => { });
+    } catch (err: any) {
+        logger.debug(`Network breadcrumb failed: ${err?.message}`);
+    }
+}
+
+/**
+ * Set a filter function to control which URLs are recorded.
+ * Return true to include, false to exclude.
+ */
+export function setNetworkUrlFilter(filter: ((url: string) => boolean) | null): void {
+    _urlFilter = filter;
+}
+
+/** Enable/disable network breadcrumb collection */
+export function setNetworkEnabled(enabled: boolean): void {
+    _enabled = enabled;
+}
+
+/**
+ * Optional: create a fetch wrapper that auto-reports requests.
+ * This does NOT replace global fetch — it wraps it for convenience.
+ */
+export function createTrackedFetch(originalFetch: typeof fetch): typeof fetch {
+    return async function trackedFetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
+        const startTime = Date.now();
+        const method = init?.method ?? 'GET';
+        const url = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
+        const requestSize = init?.body ? new Blob([init.body as any]).size : 0;
+
+        try {
+            const response = await originalFetch(input, init);
+            const duration = Date.now() - startTime;
+
+            reportNetworkRequest({
+                method,
+                url,
+                statusCode: response.status,
+                durationMs: duration,
+                requestSizeBytes: requestSize,
+                responseSizeBytes: 0, // Can't reliably get without reading body
+                error: !response.ok,
+                startTimestamp: startTime,
+            });
+
+            return response;
+        } catch (err: any) {
+            const duration = Date.now() - startTime;
+
+            reportNetworkRequest({
+                method,
+                url,
+                statusCode: 0,
+                durationMs: duration,
+                requestSizeBytes: requestSize,
+                responseSizeBytes: 0,
+                error: true,
+                errorMessage: err?.message,
+                startTimestamp: startTime,
+            });
+
+            throw err;
+        }
+    };
+}
+
+/** Basic URL sanitization: mask tokens/keys in query params */
+function sanitizeUrl(url: string): string {
+    try {
+        const u = new URL(url);
+        const sensitiveKeys = ['token', 'key', 'apikey', 'api_key', 'secret', 'password', 'auth'];
+        for (const key of u.searchParams.keys()) {
+            if (sensitiveKeys.some(s => key.toLowerCase().includes(s))) {
+                u.searchParams.set(key, '***');
+            }
+        }
+        return u.toString();
+    } catch {
+        return url.slice(0, 2048);
+    }
+}

package/src/features/replay/integrations/react-navigation/navigationIntegration.ts

@@ -1,89 +1,89 @@
-/**
- * Session Replay SDK — React Navigation Integration
- *
- * Listens to React Navigation route changes and reports them
- * as screen views to the native replay module.
- *
- * Usage:
- *   import { useReplayNavigation } from '@scalebun/replay-sdk';
- *   const navigationRef = useNavigationContainerRef();
- *   useReplayNavigation(navigationRef);
- */
-
-import { useEffect, useRef } from 'react';
-import { bridgeAdapter } from '../../bridge/adapters/bridgeAdapter';
-import { sessionOrchestrator } from '../../replay/session/sessionOrchestrator';
-import { logger } from '../../core/logger/logger';
-import { fireAndForget } from '../../core/errors/safeCall';
-
-/** Extract the current route name from a React Navigation ref */
-function getActiveRouteName(state: any): string | undefined {
-    if (!state) return undefined;
-    const route = state.routes?.[state.index ?? 0];
-    if (!route) return undefined;
-    if (route.state) return getActiveRouteName(route.state);
-    return route.name;
-}
-
-/**
- * React hook to integrate React Navigation with Session Replay.
- *
- * Automatically tracks screen changes and triggers frame captures.
- *
- * @param navigationRef - The navigation container ref from React Navigation
- */
-export function useReplayNavigation(navigationRef: any): void {
-    const routeNameRef = useRef<string | undefined>(undefined);
-
-    useEffect(() => {
-        if (!navigationRef?.current) return;
-
-        const nav = navigationRef.current;
-
-        // Get initial route
-        const initialState = nav.getRootState?.();
-        routeNameRef.current = getActiveRouteName(initialState);
-        if (routeNameRef.current) {
-            fireAndForget('initial-screen', () =>
-                sessionOrchestrator.setCurrentScreen(routeNameRef.current!),
-            );
-        }
-
-        // Listen to state changes
-        const unsubscribe = nav.addListener?.('state', (event: any) => {
-            const previousRouteName = routeNameRef.current;
-            const currentRouteName = getActiveRouteName(event?.data?.state) ?? getActiveRouteName(nav.getRootState?.());
-
-            if (currentRouteName && currentRouteName !== previousRouteName) {
-                routeNameRef.current = currentRouteName;
-
-                fireAndForget('screen-change', async () => {
-                    await sessionOrchestrator.setCurrentScreen(currentRouteName);
-                    // Trigger capture on navigation change (all modes capture on nav)
-                    if (sessionOrchestrator.isRecording) {
-                        await bridgeAdapter.captureFrame('navigation');
-                    }
-                });
-
-                logger.debug(`Screen: ${previousRouteName ?? '(none)'} → ${currentRouteName}`);
-            }
-        });
-
-        return () => {
-            unsubscribe?.();
-        };
-    }, [navigationRef]);
-}
-
-/**
- * Manual screen tracking for apps not using React Navigation.
- * Call this whenever the user navigates to a new screen.
- */
-export function trackScreen(screenName: string): void {
-    fireAndForget('track-screen', async () => {
-        await sessionOrchestrator.setCurrentScreen(screenName);
-        if (sessionOrchestrator.isRecording) {
-            await bridgeAdapter.captureFrame('navigation');
-        }
-    });
-}
+/**
+ * Session Replay SDK — React Navigation Integration
+ *
+ * Listens to React Navigation route changes and reports them
+ * as screen views to the native replay module.
+ *
+ * Usage:
+ *   import { useReplayNavigation } from '@scalebun/replay-sdk';
+ *   const navigationRef = useNavigationContainerRef();
+ *   useReplayNavigation(navigationRef);
+ */
+
+import { useEffect, useRef } from 'react';
+import { bridgeAdapter } from '../../bridge/adapters/bridgeAdapter';
+import { sessionOrchestrator } from '../../replay/session/sessionOrchestrator';
+import { logger } from '../../core/logger/logger';
+import { fireAndForget } from '../../core/errors/safeCall';
+
+/** Extract the current route name from a React Navigation ref */
+function getActiveRouteName(state: any): string | undefined {
+    if (!state) return undefined;
+    const route = state.routes?.[state.index ?? 0];
+    if (!route) return undefined;
+    if (route.state) return getActiveRouteName(route.state);
+    return route.name;
+}
+
+/**
+ * React hook to integrate React Navigation with Session Replay.
+ *
+ * Automatically tracks screen changes and triggers frame captures.
+ *
+ * @param navigationRef - The navigation container ref from React Navigation
+ */
+export function useReplayNavigation(navigationRef: any): void {
+    const routeNameRef = useRef<string | undefined>(undefined);
+
+    useEffect(() => {
+        if (!navigationRef?.current) return;
+
+        const nav = navigationRef.current;
+
+        // Get initial route
+        const initialState = nav.getRootState?.();
+        routeNameRef.current = getActiveRouteName(initialState);
+        if (routeNameRef.current) {
+            fireAndForget('initial-screen', () =>
+                sessionOrchestrator.setCurrentScreen(routeNameRef.current!),
+            );
+        }
+
+        // Listen to state changes
+        const unsubscribe = nav.addListener?.('state', (event: any) => {
+            const previousRouteName = routeNameRef.current;
+            const currentRouteName = getActiveRouteName(event?.data?.state) ?? getActiveRouteName(nav.getRootState?.());
+
+            if (currentRouteName && currentRouteName !== previousRouteName) {
+                routeNameRef.current = currentRouteName;
+
+                fireAndForget('screen-change', async () => {
+                    await sessionOrchestrator.setCurrentScreen(currentRouteName);
+                    // Trigger capture on navigation change (all modes capture on nav)
+                    if (sessionOrchestrator.isRecording) {
+                        await bridgeAdapter.captureFrame('navigation');
+                    }
+                });
+
+                logger.debug(`Screen: ${previousRouteName ?? '(none)'} → ${currentRouteName}`);
+            }
+        });
+
+        return () => {
+            unsubscribe?.();
+        };
+    }, [navigationRef]);
+}
+
+/**
+ * Manual screen tracking for apps not using React Navigation.
+ * Call this whenever the user navigates to a new screen.
+ */
+export function trackScreen(screenName: string): void {
+    fireAndForget('track-screen', async () => {
+        await sessionOrchestrator.setCurrentScreen(screenName);
+        if (sessionOrchestrator.isRecording) {
+            await bridgeAdapter.captureFrame('navigation');
+        }
+    });
+}