@rejourneyco/react-native 1.0.1 → 1.0.3

package/src/sdk/constants.ts

@@ -7,26 +7,26 @@ export const SDK_VERSION = '1.0.0';
 /** Default configuration values */
 export const DEFAULT_CONFIG = {
   enabled: true,
-  captureFPS: 0.5, // Every 2 seconds (only used in timer mode)
-  captureOnEvents: true, // Event-driven capture (not time-based)
-  maxSessionDuration: 10 * 60 * 1000, // 10 minutes (project-level configurable, clamped 1–10)
-  maxStorageSize: 50 * 1024 * 1024, // 50MB
+  captureFPS: 0.5,
+  captureOnEvents: true,
+  maxSessionDuration: 10 * 60 * 1000,
+  maxStorageSize: 50 * 1024 * 1024,
   autoScreenTracking: true,
   autoGestureTracking: true,
   privacyOcclusion: true,
   enableCompression: true,
-  inactivityThreshold: 5000, // 5 seconds
+  inactivityThreshold: 5000,
   disableInDev: false,
   detectRageTaps: true,
   rageTapThreshold: 3,
-  rageTapTimeWindow: 1000, // 1 second
+  rageTapTimeWindow: 1000,
   debug: false,
   autoStartRecording: true,
-  collectDeviceInfo: true, // Collect detailed device information
-  collectGeoLocation: true, // Collect IP address and geolocation
-  postNavigationDelay: 300, // 300ms - allow navigation animations to complete
-  postGestureDelay: 200, // 200ms - show result of taps, not animations
-  postModalDelay: 400, // 400ms - ensure modals/alerts are fully rendered
+  collectDeviceInfo: true,
+  collectGeoLocation: true,
+  postNavigationDelay: 300,
+  postGestureDelay: 200,
+  postModalDelay: 400,
 } as const;
 
 /** Event type constants */
@@ -61,8 +61,8 @@ export const CAPTURE_SETTINGS = {
   DEFAULT_FPS: 0.5,
   MIN_FPS: 0.1,
   MAX_FPS: 2,
-  CAPTURE_SCALE: 0.25, // 25% resolution for video segments
-  MIN_CAPTURE_DELTA_TIME: 0.5, // Minimum 0.5s between captures (rate limiting)
+  CAPTURE_SCALE: 0.25,
+  MIN_CAPTURE_DELTA_TIME: 0.5,
 } as const;
 
 /** Memory management settings */

package/src/sdk/errorTracking.ts

@@ -7,7 +7,6 @@
 
 import type { ErrorEvent } from '../types';
 
-// Type declarations for browser globals (only used in hybrid apps where DOM is available)
 type OnErrorEventHandler = ((
     event: Event | string,
     source?: string,
@@ -21,7 +20,6 @@ interface PromiseRejectionEvent {
     promise?: Promise<any>;
 }
 
-// Cast globalThis to work with both RN and hybrid scenarios
 const _globalThis = globalThis as typeof globalThis & {
     onerror?: OnErrorEventHandler;
     addEventListener?: (type: string, handler: (event: any) => void) => void;
@@ -32,15 +30,11 @@ const _globalThis = globalThis as typeof globalThis & {
     };
 };
 
-// Original error handlers (for restoration)
 let originalErrorHandler: ((error: Error, isFatal: boolean) => void) | undefined;
 let originalOnError: OnErrorEventHandler | null = null;
 let originalOnUnhandledRejection: ((event: PromiseRejectionEvent) => void) | null = null;
-
-// Callbacks
 let onErrorCallback: ((error: ErrorEvent) => void) | null = null;
 
-// Metrics
 let errorCount = 0;
 
 /**
@@ -57,17 +51,14 @@ export function setupErrorTracking(
     onErrorCallback = onError;
     errorCount = 0;
 
-    // Track React Native errors
     if (config.trackReactNativeErrors !== false) {
         setupReactNativeErrorHandler();
     }
 
-    // Track JavaScript errors (only works in web/debug)
     if (config.trackJSErrors !== false && typeof _globalThis !== 'undefined') {
         setupJSErrorHandler();
     }
 
-    // Track unhandled promise rejections
     if (config.trackPromiseRejections !== false && typeof _globalThis !== 'undefined') {
         setupPromiseRejectionHandler();
     }
@@ -77,7 +68,6 @@ export function setupErrorTracking(
  * Cleanup error tracking and restore original handlers
  */
 export function cleanupErrorTracking(): void {
-    // Restore React Native handler
     if (originalErrorHandler) {
         try {
             const ErrorUtils = _globalThis.ErrorUtils;
@@ -90,13 +80,11 @@ export function cleanupErrorTracking(): void {
         originalErrorHandler = undefined;
     }
 
-    // Restore global onerror
     if (originalOnError !== null) {
         _globalThis.onerror = originalOnError;
         originalOnError = null;
     }
 
-    // Remove promise rejection handler
     if (originalOnUnhandledRejection && typeof _globalThis.removeEventListener !== 'undefined') {
         _globalThis.removeEventListener!('unhandledrejection', originalOnUnhandledRejection);
         originalOnUnhandledRejection = null;
@@ -155,10 +143,8 @@ function setupReactNativeErrorHandler(): void {
         const ErrorUtils = _globalThis.ErrorUtils;
         if (!ErrorUtils) return;
 
-        // Store original handler
         originalErrorHandler = ErrorUtils.getGlobalHandler();
 
-        // Set new handler
         ErrorUtils.setGlobalHandler((error: Error, isFatal: boolean) => {
             trackError({
                 type: 'error',
@@ -168,13 +154,12 @@ function setupReactNativeErrorHandler(): void {
                 name: error.name || 'Error',
             });
 
-            // Call original handler
             if (originalErrorHandler) {
                 originalErrorHandler(error, isFatal);
             }
         });
     } catch {
-        // ErrorUtils not available
+        // Ignore
     }
 }
 
@@ -200,7 +185,6 @@ function setupJSErrorHandler(): void {
                 name: error?.name || 'Error',
             });
 
-            // Call original handler
             if (originalOnError) {
                 return originalOnError(message, source, lineno, colno, error);
             }

package/src/sdk/index.ts

@@ -7,5 +7,3 @@ export * from './constants';
 export * from './utils';
 export * from './autoTracking';
 export * from './networkInterceptor';
-// Note: errorTracking and metricsTracking are internal modules
-// Their exports are re-exported through autoTracking for backward compatibility

package/src/sdk/metricsTracking.ts

@@ -10,41 +10,29 @@
  * Session metrics structure
  */
 export interface SessionMetrics {
-    // Core counts
     totalEvents: number;
     touchCount: number;
     scrollCount: number;
     gestureCount: number;
     inputCount: number;
     navigationCount: number;
-
-    // Issue tracking
     errorCount: number;
     rageTapCount: number;
-
-    // API metrics
     apiSuccessCount: number;
     apiErrorCount: number;
     apiTotalCount: number;
-
-    // Network timing (for avg calculation)
-    netTotalDurationMs: number;  // Sum of all API durations
-    netTotalBytes: number;       // Sum of all response bytes
-
-    // Screen tracking for funnels
+    netTotalDurationMs: number;
+    netTotalBytes: number;
     screensVisited: string[];
     uniqueScreensCount: number;
-
-    // Scores (0-100)
     interactionScore: number;
     explorationScore: number;
     uxScore: number;
 }
 
-// Metrics state
 let metrics: SessionMetrics = createEmptyMetrics();
 let sessionStartTime = 0;
-let maxSessionDurationMs = 10 * 60 * 1000; // 10 minutes default
+let maxSessionDurationMs = 10 * 60 * 1000;
 
 /**
  * Create empty metrics object
@@ -92,11 +80,9 @@ export function initMetrics(): void {
  * Get current session metrics with calculated scores
  */
 export function getSessionMetrics(): SessionMetrics {
-    // Calculate duration, clamped to max session duration
     const rawDuration = Date.now() - sessionStartTime;
     const durationMs = Math.min(rawDuration, maxSessionDurationMs);
 
-    // Calculate scores
     const interactionScore = calculateInteractionScore(durationMs);
     const explorationScore = calculateExplorationScore();
     const uxScore = calculateUXScore();
@@ -120,8 +106,6 @@ export function setMaxSessionDurationMinutes(minutes?: number): void {
     }
 }
 
-// ==================== Metric Increment Methods ====================
-
 export function incrementTouchCount(): void {
     metrics.touchCount++;
     metrics.totalEvents++;
@@ -173,8 +157,6 @@ export function trackAPIMetrics(
     }
 }
 
-// ==================== Score Calculations ====================
-
 /**
  * Calculate interaction score based on engagement with app
  * Higher = more engaged (more interactions per minute)
@@ -185,15 +167,12 @@ function calculateInteractionScore(durationMs: number): number {
     const durationMinutes = durationMs / 60000;
     const interactionsPerMinute = metrics.touchCount / Math.max(0.5, durationMinutes);
 
-    // Ideal: 10-30 interactions per minute
-    // Low (< 5): user passive/confused
-    // Very high (> 60): rage tapping
     if (interactionsPerMinute < 2) return 20;
     if (interactionsPerMinute < 5) return 50;
     if (interactionsPerMinute < 10) return 70;
     if (interactionsPerMinute <= 30) return 100;
     if (interactionsPerMinute <= 60) return 80;
-    return 50; // Very high might indicate frustration
+    return 50;
 }
 
 /**
@@ -203,13 +182,12 @@ function calculateInteractionScore(durationMs: number): number {
 function calculateExplorationScore(): number {
     const uniqueScreens = metrics.uniqueScreensCount;
 
-    // More unique screens = better exploration
     if (uniqueScreens >= 10) return 100;
     if (uniqueScreens >= 7) return 90;
     if (uniqueScreens >= 5) return 80;
     if (uniqueScreens >= 3) return 60;
     if (uniqueScreens >= 2) return 40;
-    return 20; // Single screen visit
+    return 20;
 }
 
 /**
@@ -219,14 +197,8 @@ function calculateExplorationScore(): number {
 function calculateUXScore(): number {
     let score = 100;
 
-    // Deduct for errors
     score -= metrics.errorCount * 10;
-
-    // Deduct heavily for rage taps
     score -= metrics.rageTapCount * 20;
-
-    // Deduct for API errors (less severe)
     score -= metrics.apiErrorCount * 5;
-
     return Math.max(0, Math.min(100, score));
 }

package/src/sdk/navigation.ts

@@ -20,15 +20,12 @@ export function normalizeScreenName(raw: string): string {
 
     let name = raw;
 
-    // 1. Remove non-printable characters and weird symbols (often from icons)
     name = name.replace(/[^\x20-\x7E\s]/g, '');
 
-    // 2. Handle hyphens: my-recipes -> My Recipes
     name = name.split(/[-_]/).map(word =>
         word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
     ).join(' ');
 
-    // 3. Remove common suffixes
     const suffixes = ['Screen', 'Page', 'View', 'Controller', 'ViewController', 'VC'];
     for (const suffix of suffixes) {
         if (name.endsWith(suffix) && name.length > suffix.length) {
@@ -36,7 +33,6 @@ export function normalizeScreenName(raw: string): string {
         }
     }
 
-    // 4. Remove common prefixes (React Native internals)
     const prefixes = ['RNS', 'RCT', 'RN', 'UI'];
     for (const prefix of prefixes) {
         if (name.startsWith(prefix) && name.length > prefix.length + 2) {
@@ -44,23 +40,18 @@ export function normalizeScreenName(raw: string): string {
         }
     }
 
-    // 5. Handle dynamic route params: [id] -> (omit), [userId] -> "User"
     name = name.replace(/\[([a-zA-Z]+)(?:Id)?\]/g, (_, param) => {
         const clean = param.replace(/Id$/i, '');
         if (clean.length < 2) return '';
         return clean.charAt(0).toUpperCase() + clean.slice(1);
     });
 
-    // 6. Remove leftover brackets
     name = name.replace(/\[\]/g, '');
 
-    // 7. Convert camelCase/PascalCase to Title Case with spaces
     name = name.replace(/([a-z])([A-Z])/g, '$1 $2');
 
-    // 8. Clean up multiple spaces and trim
     name = name.replace(/\s+/g, ' ').trim();
 
-    // 9. Capitalize first letter
     if (name.length > 0) {
         name = name.charAt(0).toUpperCase() + name.slice(1);
     }
@@ -76,24 +67,18 @@ export function normalizeScreenName(raw: string): string {
  * @returns Human-readable screen name
  */
 export function getScreenNameFromPath(pathname: string, segments: string[]): string {
-    // Use segments for cleaner names if available
     if (segments.length > 0) {
-        // Filter out group markers like (tabs), (auth), etc.
         const cleanSegments = segments.filter(s => !s.startsWith('(') && !s.endsWith(')'));
 
         if (cleanSegments.length > 0) {
-            // Process each segment
             const processedSegments = cleanSegments.map(s => {
-                // Handle dynamic params like [id]
                 if (s.startsWith('[') && s.endsWith(']')) {
                     const param = s.slice(1, -1);
-                    // Skip pure ID params, keep meaningful ones
                     if (param === 'id' || param === 'slug') return null;
-                    // Extract meaningful part: userId -> User
+                    if (param === 'id' || param === 'slug') return null;
                     const clean = param.replace(/Id$/i, '');
                     return clean.charAt(0).toUpperCase() + clean.slice(1);
                 }
-                // Regular segment - capitalize
                 return s.charAt(0).toUpperCase() + s.slice(1);
             }).filter(Boolean);
 
@@ -103,32 +88,27 @@ export function getScreenNameFromPath(pathname: string, segments: string[]): str
         }
     }
 
-    // Fall back to pathname
     if (!pathname || pathname === '/') {
         return 'Home';
     }
-
-    // Clean up the path
-    let cleanPath = pathname
-        .replace(/^\/(tabs)?/, '') // Remove leading slash and (tabs)
-        .replace(/\([^)]+\)/g, '') // Remove all group markers like (settings)
+    const cleanPath = pathname
+        .replace(/^\/(tabs)?/, '')
+        .replace(/\([^)]+\)/g, '')
         .replace(/\[([^\]]+)\]/g, (_, param) => {
-            // Handle dynamic params in path
             if (param === 'id' || param === 'slug') return '';
             const clean = param.replace(/Id$/i, '');
             return clean.charAt(0).toUpperCase() + clean.slice(1);
         })
-        .replace(/\/+/g, '/') // Collapse multiple slashes
-        .replace(/^\//, '') // Remove leading slash
-        .replace(/\/$/, '') // Remove trailing slash
-        .replace(/\//g, ' > ') // Replace slashes with arrows
+        .replace(/\/+/g, '/')
+        .replace(/^\//, '')
+        .replace(/\/$/, '')
+        .replace(/\//g, ' > ')
         .trim();
 
     if (!cleanPath) {
         return 'Home';
     }
 
-    // Capitalize first letter of each word
     return cleanPath
         .split(' > ')
         .map(s => s.charAt(0).toUpperCase() + s.slice(1))
@@ -148,7 +128,6 @@ export function getCurrentRouteFromState(state: any): string | null {
     const route = state.routes[state.index ?? state.routes.length - 1];
     if (!route) return null;
 
-    // If nested state, recurse
     if (route.state) {
         return getCurrentRouteFromState(route.state);
     }

package/src/sdk/networkInterceptor.ts

@@ -15,39 +15,32 @@
 
 import type { NetworkRequestParams } from '../types';
 
-// Store original implementations
 let originalFetch: typeof fetch | null = null;
 let originalXHROpen: typeof XMLHttpRequest.prototype.open | null = null;
 let originalXHRSend: typeof XMLHttpRequest.prototype.send | null = null;
 
-// Callback to log network requests (called asynchronously)
 let logCallback: ((request: NetworkRequestParams) => void) | null = null;
 
-// Pending requests buffer (circular buffer for memory efficiency)
 const MAX_PENDING_REQUESTS = 100;
 const pendingRequests: (NetworkRequestParams | null)[] = new Array(MAX_PENDING_REQUESTS).fill(null);
 let pendingHead = 0;
 let pendingTail = 0;
 let pendingCount = 0;
 
-// Flush timer
 let flushTimer: ReturnType<typeof setTimeout> | null = null;
-const FLUSH_INTERVAL = 500; // Flush every 500ms
+const FLUSH_INTERVAL = 500;
 
-// Sampling for high-frequency endpoints
 const endpointCounts = new Map<string, { count: number; lastReset: number }>();
-const SAMPLE_WINDOW = 10000; // 10 second window
-const MAX_PER_ENDPOINT = 20; // Max 20 requests per endpoint per window
+const SAMPLE_WINDOW = 10000;
+const MAX_PER_ENDPOINT = 20;
 
-// Configuration
 const config = {
   enabled: true,
-  ignorePatterns: [] as string[], // Simple string patterns for fast matching
-  maxUrlLength: 300, // Shorter for efficiency
-  captureSizes: false, // Disabled by default for performance
+  ignorePatterns: [] as string[],
+  maxUrlLength: 300,
+  captureSizes: false,
 };
 
-// PII Scrubbing - Sensitive keys to look for in query params
 const SENSITIVE_KEYS = ['token', 'key', 'secret', 'password', 'auth', 'access_token', 'api_key'];
 
 /**
@@ -55,7 +48,6 @@ const SENSITIVE_KEYS = ['token', 'key', 'secret', 'password', 'auth', 'access_to
  */
 function scrubUrl(url: string): string {
   try {
-    // Fast check if URL might contain params
     if (url.indexOf('?') === -1) return url;
 
     const urlObj = new URL(url);
@@ -68,12 +60,10 @@ function scrubUrl(url: string): string {
       }
     });
 
-    // Also scan for partial matches (case-insensitive) if strict scrubbing needed
-    // But for performance, we stick to exact keys or common variations
-
     return modified ? urlObj.toString() : url;
   } catch {
-    // If URL parsing fails (relative URL?), try primitive replacement
+    // Ignore error, fallback to primitive scrubbing
+
     let scrubbed = url;
     SENSITIVE_KEYS.forEach(key => {
       const regex = new RegExp(`([?&])${key}=[^&]*`, 'gi');
@@ -121,14 +111,12 @@ function queueRequest(request: NetworkRequestParams): void {
     pendingCount--;
   }
 
-  // Scrub URL before queuing
   request.url = scrubUrl(request.url);
 
   pendingRequests[pendingTail] = request;
   pendingTail = (pendingTail + 1) % MAX_PENDING_REQUESTS;
   pendingCount++;
 
-  // Schedule flush if not already scheduled
   if (!flushTimer) {
     flushTimer = setTimeout(flushPendingRequests, FLUSH_INTERVAL);
   }
@@ -141,8 +129,6 @@ function flushPendingRequests(): void {
   flushTimer = null;
 
   if (!logCallback || pendingCount === 0) return;
-
-  // Process all pending requests
   while (pendingCount > 0) {
     const request = pendingRequests[pendingHead];
     pendingRequests[pendingHead] = null; // Allow GC
@@ -153,7 +139,7 @@ function flushPendingRequests(): void {
       try {
         logCallback(request);
       } catch {
-        // Ignore logging errors
+        // Ignore
       }
     }
   }
@@ -167,11 +153,9 @@ function parseUrlFast(url: string): { host: string; path: string } {
   let hostEnd = -1;
   let pathStart = -1;
 
-  // Find :// 
   const protoEnd = url.indexOf('://');
   if (protoEnd !== -1) {
     const afterProto = protoEnd + 3;
-    // Find end of host (first / after ://)
     const slashPos = url.indexOf('/', afterProto);
     if (slashPos !== -1) {
       hostEnd = slashPos;
@@ -187,7 +171,6 @@ function parseUrlFast(url: string): { host: string; path: string } {
     };
   }
 
-  // Relative URL
   return { host: '', path: url };
 }
 
@@ -204,19 +187,16 @@ function interceptFetch(): void {
     input: RequestInfo | URL,
     init?: RequestInit
   ): Promise<Response> {
-    // Fast path: if disabled or no callback, skip entirely
     if (!config.enabled || !logCallback) {
       return originalFetch!(input, init);
     }
 
-    // Extract URL string (minimal work)
     const url = typeof input === 'string'
       ? input
       : input instanceof URL
         ? input.href
         : (input as Request).url;
 
-    // Fast ignore check
     if (shouldIgnoreUrl(url)) {
       return originalFetch!(input, init);
     }
@@ -227,14 +207,10 @@ function interceptFetch(): void {
       return originalFetch!(input, init);
     }
 
-    // Capture start time (only synchronous work)
     const startTime = Date.now();
     const method = ((init?.method || 'GET').toUpperCase()) as NetworkRequestParams['method'];
-
-    // Call original fetch
     return originalFetch!(input, init).then(
       (response) => {
-        // Success - queue the log asynchronously
         queueRequest({
           requestId: `f${startTime}`,
           method,
@@ -248,7 +224,6 @@ function interceptFetch(): void {
         return response;
       },
       (error) => {
-        // Error - queue the log asynchronously  
         queueRequest({
           requestId: `f${startTime}`,
           method,
@@ -285,7 +260,6 @@ function interceptXHR(): void {
   ): void {
     const urlString = typeof url === 'string' ? url : url.toString();
 
-    // Store minimal info
     (this as any).__rj = {
       m: method.toUpperCase(),
       u: urlString,
@@ -301,8 +275,6 @@ function interceptXHR(): void {
     if (!config.enabled || !logCallback || !data || shouldIgnoreUrl(data.u)) {
       return originalXHRSend!.call(this, body);
     }
-
-    // Check sampling
     const { path } = parseUrlFast(data.u);
     if (!shouldSampleRequest(path)) {
       return originalXHRSend!.call(this, body);
@@ -325,8 +297,6 @@ function interceptXHR(): void {
       });
     };
 
-    // Use load/error events (more efficient than readystatechange)
-    // Note: We use basic addEventListener without options for RN compatibility
     this.addEventListener('load', onComplete);
     this.addEventListener('error', onComplete);
     this.addEventListener('abort', onComplete);
@@ -347,11 +317,9 @@ export function initNetworkInterceptor(
 ): void {
   logCallback = callback;
 
-  // Convert patterns to simple strings for fast matching
   if (options?.ignoreUrls) {
     config.ignorePatterns = options.ignoreUrls
       .filter((p): p is string => typeof p === 'string');
-    // Note: RegExp patterns are not supported in optimized version for performance
   }
 
   if (options?.captureSizes !== undefined) {
@@ -368,7 +336,6 @@ export function initNetworkInterceptor(
 export function disableNetworkInterceptor(): void {
   config.enabled = false;
 
-  // Flush any pending requests
   if (flushTimer) {
     clearTimeout(flushTimer);
     flushTimer = null;