@rejourneyco/react-native 1.0.0

package/src/sdk/constants.ts

@@ -0,0 +1,134 @@
+/**
+ * Rejourney SDK Constants
+ */
+
+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
+  autoScreenTracking: true,
+  autoGestureTracking: true,
+  privacyOcclusion: true,
+  enableCompression: true,
+  inactivityThreshold: 5000, // 5 seconds
+  disableInDev: false,
+  detectRageTaps: true,
+  rageTapThreshold: 3,
+  rageTapTimeWindow: 1000, // 1 second
+  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
+} as const;
+
+/** Event type constants */
+export const EVENT_TYPES = {
+  GESTURE: 'gesture',
+  SCREEN_CHANGE: 'screen_change',
+  CUSTOM: 'custom',
+  APP_STATE: 'app_state',
+  FRUSTRATION: 'frustration',
+  ERROR: 'error',
+} as const;
+
+/** Gesture type constants */
+export const GESTURE_TYPES = {
+  TAP: 'tap',
+  DOUBLE_TAP: 'double_tap',
+  LONG_PRESS: 'long_press',
+  SWIPE_LEFT: 'swipe_left',
+  SWIPE_RIGHT: 'swipe_right',
+  SWIPE_UP: 'swipe_up',
+  SWIPE_DOWN: 'swipe_down',
+  PINCH: 'pinch',
+  SCROLL: 'scroll',
+  RAGE_TAP: 'rage_tap',
+} as const;
+
+/** Playback speeds */
+export const PLAYBACK_SPEEDS = [0.5, 1, 2, 4] as const;
+
+/** Capture settings */
+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)
+} as const;
+
+/** Memory management settings */
+export const MEMORY_SETTINGS = {
+  /** Maximum events to keep in memory before flushing */
+  MAX_EVENTS_IN_MEMORY: 100,
+  /** Memory warning threshold in MB (flush when exceeded) */
+  MEMORY_WARNING_THRESHOLD_MB: 100,
+  /** Enable aggressive memory cleanup during low memory */
+  AGGRESSIVE_CLEANUP_ENABLED: true,
+  /** Bitmap pool size for reusing bitmaps (Android) */
+  BITMAP_POOL_SIZE: 3,
+} as const;
+
+/** CPU throttling settings */
+export const CPU_SETTINGS = {
+  /** Throttle captures when CPU usage exceeds this percentage */
+  CPU_THROTTLE_THRESHOLD: 80,
+  /** Minimum interval between captures when throttled (seconds) */
+  THROTTLED_MIN_INTERVAL: 2.0,
+  /** Skip captures when battery is below this level (0-100) */
+  LOW_BATTERY_THRESHOLD: 15,
+  /** Skip captures when device is thermally throttled */
+  THERMAL_THROTTLE_ENABLED: true,
+  /** Maximum consecutive captures before forced cooldown */
+  MAX_CONSECUTIVE_CAPTURES: 10,
+  /** Cooldown period after max consecutive captures (ms) */
+  CAPTURE_COOLDOWN_MS: 1000,
+} as const;
+
+/** Storage management settings */
+export const STORAGE_SETTINGS = {
+  /** Maximum total storage for session data (bytes) */
+  MAX_STORAGE_SIZE: 50 * 1024 * 1024, // 50MB
+  /** Storage warning threshold - start cleanup at this level */
+  STORAGE_WARNING_THRESHOLD: 0.8, // 80% of max
+  /** Number of old sessions to keep */
+  MAX_SESSIONS_TO_KEEP: 5,
+  /** Auto-delete sessions older than this (hours) */
+  SESSION_EXPIRY_HOURS: 24,
+  /** Use efficient binary storage format */
+  USE_BINARY_FORMAT: true,
+} as const;
+
+/** Network/Upload settings */
+export const UPLOAD_SETTINGS = {
+  /** Batch upload interval (ms) */
+  BATCH_INTERVAL_MS: 30000, // 30 seconds
+  /** Max retry attempts for failed uploads */
+  MAX_RETRY_ATTEMPTS: 3,
+  /** Retry delay multiplier (exponential backoff) */
+  RETRY_DELAY_MULTIPLIER: 2,
+  /** Initial retry delay (ms) */
+  INITIAL_RETRY_DELAY_MS: 1000,
+  /** Max events per upload batch */
+  MAX_EVENTS_PER_BATCH: 50,
+  /** Skip uploads when on cellular and battery is low */
+  CELLULAR_BATTERY_AWARE: true,
+} as const;
+
+/** Privacy constants */
+export const PRIVACY = {
+  OCCLUSION_COLOR: '#808080',
+  SENSITIVE_COMPONENT_TYPES: [
+    'TextInput',
+    'SecureTextEntry',
+    'PasswordField',
+  ],
+} as const;

package/src/sdk/errorTracking.ts

@@ -0,0 +1,231 @@
+/**
+ * Error Tracking Module for Rejourney SDK
+ * 
+ * Handles JS error capture, React Native ErrorUtils, and unhandled promise rejections.
+ * Split from autoTracking.ts for better code organization.
+ */
+
+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,
+    lineno?: number,
+    colno?: number,
+    error?: Error
+) => boolean | void) | null;
+
+interface PromiseRejectionEvent {
+    reason?: any;
+    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;
+    removeEventListener?: (type: string, handler: (event: any) => void) => void;
+    ErrorUtils?: {
+        getGlobalHandler: () => ((error: Error, isFatal: boolean) => void) | undefined;
+        setGlobalHandler: (handler: (error: Error, isFatal: boolean) => void) => void;
+    };
+};
+
+// 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;
+
+/**
+ * Setup error tracking with the given callback
+ */
+export function setupErrorTracking(
+    config: {
+        trackJSErrors?: boolean;
+        trackPromiseRejections?: boolean;
+        trackReactNativeErrors?: boolean;
+    },
+    onError: (error: ErrorEvent) => void
+): void {
+    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();
+    }
+}
+
+/**
+ * Cleanup error tracking and restore original handlers
+ */
+export function cleanupErrorTracking(): void {
+    // Restore React Native handler
+    if (originalErrorHandler) {
+        try {
+            const ErrorUtils = _globalThis.ErrorUtils;
+            if (ErrorUtils) {
+                ErrorUtils.setGlobalHandler(originalErrorHandler);
+            }
+        } catch {
+            // Ignore
+        }
+        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;
+    }
+
+    onErrorCallback = null;
+}
+
+/**
+ * Get current error count
+ */
+export function getErrorCount(): number {
+    return errorCount;
+}
+
+/**
+ * Reset error count
+ */
+export function resetErrorCount(): void {
+    errorCount = 0;
+}
+
+/**
+ * Manually capture an error
+ */
+export function captureError(
+    message: string,
+    stack?: string,
+    name?: string
+): void {
+    trackError({
+        type: 'error',
+        timestamp: Date.now(),
+        message,
+        stack,
+        name: name || 'Error',
+    });
+}
+
+/**
+ * Track an error internally
+ */
+function trackError(error: ErrorEvent): void {
+    errorCount++;
+
+    if (onErrorCallback) {
+        onErrorCallback(error);
+    }
+}
+
+/**
+ * Setup React Native ErrorUtils handler
+ */
+function setupReactNativeErrorHandler(): void {
+    try {
+        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',
+                timestamp: Date.now(),
+                message: error.message || String(error),
+                stack: error.stack,
+                name: error.name || 'Error',
+            });
+
+            // Call original handler
+            if (originalErrorHandler) {
+                originalErrorHandler(error, isFatal);
+            }
+        });
+    } catch {
+        // ErrorUtils not available
+    }
+}
+
+/**
+ * Setup global JS error handler
+ */
+function setupJSErrorHandler(): void {
+    if (typeof _globalThis.onerror !== 'undefined') {
+        originalOnError = _globalThis.onerror;
+
+        _globalThis.onerror = (
+            message: string | Event,
+            source?: string,
+            lineno?: number,
+            colno?: number,
+            error?: Error
+        ) => {
+            trackError({
+                type: 'error',
+                timestamp: Date.now(),
+                message: typeof message === 'string' ? message : 'Unknown error',
+                stack: error?.stack || `${source}:${lineno}:${colno}`,
+                name: error?.name || 'Error',
+            });
+
+            // Call original handler
+            if (originalOnError) {
+                return originalOnError(message, source, lineno, colno, error);
+            }
+            return false;
+        };
+    }
+}
+
+/**
+ * Setup unhandled promise rejection handler
+ */
+function setupPromiseRejectionHandler(): void {
+    if (typeof _globalThis.addEventListener !== 'undefined') {
+        const handler = (event: PromiseRejectionEvent) => {
+            const reason = event.reason;
+            trackError({
+                type: 'error',
+                timestamp: Date.now(),
+                message: reason?.message || String(reason) || 'Unhandled Promise Rejection',
+                stack: reason?.stack,
+                name: reason?.name || 'UnhandledRejection',
+            });
+        };
+
+        originalOnUnhandledRejection = handler;
+        _globalThis.addEventListener!('unhandledrejection', handler);
+    }
+}

package/src/sdk/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Rejourney SDK
+ * Session recording and replay for React Native
+ */
+
+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

@@ -0,0 +1,232 @@
+/**
+ * Session Metrics Module for Rejourney SDK
+ * 
+ * Tracks and calculates session metrics including interaction scores,
+ * API performance, and user engagement metrics.
+ * Split from autoTracking.ts for better code organization.
+ */
+
+/**
+ * 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
+    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
+
+/**
+ * Create empty metrics object
+ */
+export function createEmptyMetrics(): SessionMetrics {
+    return {
+        totalEvents: 0,
+        touchCount: 0,
+        scrollCount: 0,
+        gestureCount: 0,
+        inputCount: 0,
+        navigationCount: 0,
+        errorCount: 0,
+        rageTapCount: 0,
+        apiSuccessCount: 0,
+        apiErrorCount: 0,
+        apiTotalCount: 0,
+        netTotalDurationMs: 0,
+        netTotalBytes: 0,
+        screensVisited: [],
+        uniqueScreensCount: 0,
+        interactionScore: 100,
+        explorationScore: 100,
+        uxScore: 100,
+    };
+}
+
+/**
+ * Reset all metrics
+ */
+export function resetMetrics(): void {
+    metrics = createEmptyMetrics();
+    sessionStartTime = 0;
+}
+
+/**
+ * Initialize metrics for new session
+ */
+export function initMetrics(): void {
+    metrics = createEmptyMetrics();
+    sessionStartTime = Date.now();
+}
+
+/**
+ * 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();
+
+    return {
+        ...metrics,
+        interactionScore,
+        explorationScore,
+        uxScore,
+    };
+}
+
+/**
+ * Set max session duration (in minutes)
+ */
+export function setMaxSessionDurationMinutes(minutes?: number): void {
+    if (minutes !== undefined && minutes > 0) {
+        // Clamp to 1-10 minutes
+        const clampedMinutes = Math.max(1, Math.min(10, minutes));
+        maxSessionDurationMs = clampedMinutes * 60 * 1000;
+    }
+}
+
+// ==================== Metric Increment Methods ====================
+
+export function incrementTouchCount(): void {
+    metrics.touchCount++;
+    metrics.totalEvents++;
+}
+
+export function incrementScrollCount(): void {
+    metrics.scrollCount++;
+    metrics.totalEvents++;
+}
+
+export function incrementNavigationCount(): void {
+    metrics.navigationCount++;
+    metrics.totalEvents++;
+}
+
+export function incrementRageTapCount(): void {
+    metrics.rageTapCount++;
+}
+
+export function incrementErrorCount(): void {
+    metrics.errorCount++;
+    metrics.totalEvents++;
+}
+
+export function addScreenVisited(screenName: string): void {
+    metrics.screensVisited.push(screenName);
+    metrics.uniqueScreensCount = new Set(metrics.screensVisited).size;
+}
+
+export function trackAPIMetrics(
+    success: boolean,
+    durationMs: number = 0,
+    responseBytes: number = 0
+): void {
+    metrics.apiTotalCount++;
+
+    if (durationMs > 0) {
+        metrics.netTotalDurationMs += durationMs;
+    }
+    if (responseBytes > 0) {
+        metrics.netTotalBytes += responseBytes;
+    }
+
+    if (success) {
+        metrics.apiSuccessCount++;
+    } else {
+        metrics.apiErrorCount++;
+        metrics.errorCount++;
+    }
+}
+
+// ==================== Score Calculations ====================
+
+/**
+ * Calculate interaction score based on engagement with app
+ * Higher = more engaged (more interactions per minute)
+ */
+function calculateInteractionScore(durationMs: number): number {
+    if (durationMs <= 0) return 100;
+
+    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
+}
+
+/**
+ * Calculate exploration score based on screens visited
+ * Higher = user explored more of the app
+ */
+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
+}
+
+/**
+ * Calculate UX score based on errors and frustration
+ * Higher = better experience (fewer issues)
+ */
+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));
+}