@rejourneyco/react-native 1.0.0

package/lib/module/sdk/constants.js

@@ -0,0 +1,145 @@
+/**
+ * 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
+};
+
+/** Event type constants */
+export const EVENT_TYPES = {
+  GESTURE: 'gesture',
+  SCREEN_CHANGE: 'screen_change',
+  CUSTOM: 'custom',
+  APP_STATE: 'app_state',
+  FRUSTRATION: 'frustration',
+  ERROR: 'error'
+};
+
+/** 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'
+};
+
+/** Playback speeds */
+export const PLAYBACK_SPEEDS = [0.5, 1, 2, 4];
+
+/** 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)
+};
+
+/** 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
+};
+
+/** 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
+};
+
+/** 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
+};
+
+/** 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
+};
+
+/** Privacy constants */
+export const PRIVACY = {
+  OCCLUSION_COLOR: '#808080',
+  SENSITIVE_COMPONENT_TYPES: ['TextInput', 'SecureTextEntry', 'PasswordField']
+};
+//# sourceMappingURL=constants.js.map

package/lib/module/sdk/errorTracking.js

@@ -0,0 +1,189 @@
+/**
+ * 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.
+ */
+
+// Type declarations for browser globals (only used in hybrid apps where DOM is available)
+
+// Cast globalThis to work with both RN and hybrid scenarios
+const _globalThis = globalThis;
+
+// Original error handlers (for restoration)
+let originalErrorHandler;
+let originalOnError = null;
+let originalOnUnhandledRejection = null;
+
+// Callbacks
+let onErrorCallback = null;
+
+// Metrics
+let errorCount = 0;
+
+/**
+ * Setup error tracking with the given callback
+ */
+export function setupErrorTracking(config, onError) {
+  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() {
+  // 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() {
+  return errorCount;
+}
+
+/**
+ * Reset error count
+ */
+export function resetErrorCount() {
+  errorCount = 0;
+}
+
+/**
+ * Manually capture an error
+ */
+export function captureError(message, stack, name) {
+  trackError({
+    type: 'error',
+    timestamp: Date.now(),
+    message,
+    stack,
+    name: name || 'Error'
+  });
+}
+
+/**
+ * Track an error internally
+ */
+function trackError(error) {
+  errorCount++;
+  if (onErrorCallback) {
+    onErrorCallback(error);
+  }
+}
+
+/**
+ * Setup React Native ErrorUtils handler
+ */
+function setupReactNativeErrorHandler() {
+  try {
+    const ErrorUtils = _globalThis.ErrorUtils;
+    if (!ErrorUtils) return;
+
+    // Store original handler
+    originalErrorHandler = ErrorUtils.getGlobalHandler();
+
+    // Set new handler
+    ErrorUtils.setGlobalHandler((error, isFatal) => {
+      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() {
+  if (typeof _globalThis.onerror !== 'undefined') {
+    originalOnError = _globalThis.onerror;
+    _globalThis.onerror = (message, source, lineno, colno, 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() {
+  if (typeof _globalThis.addEventListener !== 'undefined') {
+    const handler = event => {
+      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);
+  }
+}
+//# sourceMappingURL=errorTracking.js.map

package/lib/module/sdk/index.js

@@ -0,0 +1,12 @@
+/**
+ * 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
+//# sourceMappingURL=index.js.map

package/lib/module/sdk/metricsTracking.js

@@ -0,0 +1,187 @@
+/**
+ * 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
+ */
+
+// Metrics state
+let metrics = createEmptyMetrics();
+let sessionStartTime = 0;
+let maxSessionDurationMs = 10 * 60 * 1000; // 10 minutes default
+
+/**
+ * Create empty metrics object
+ */
+export function createEmptyMetrics() {
+  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() {
+  metrics = createEmptyMetrics();
+  sessionStartTime = 0;
+}
+
+/**
+ * Initialize metrics for new session
+ */
+export function initMetrics() {
+  metrics = createEmptyMetrics();
+  sessionStartTime = Date.now();
+}
+
+/**
+ * Get current session metrics with calculated scores
+ */
+export function getSessionMetrics() {
+  // 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) {
+  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() {
+  metrics.touchCount++;
+  metrics.totalEvents++;
+}
+export function incrementScrollCount() {
+  metrics.scrollCount++;
+  metrics.totalEvents++;
+}
+export function incrementNavigationCount() {
+  metrics.navigationCount++;
+  metrics.totalEvents++;
+}
+export function incrementRageTapCount() {
+  metrics.rageTapCount++;
+}
+export function incrementErrorCount() {
+  metrics.errorCount++;
+  metrics.totalEvents++;
+}
+export function addScreenVisited(screenName) {
+  metrics.screensVisited.push(screenName);
+  metrics.uniqueScreensCount = new Set(metrics.screensVisited).size;
+}
+export function trackAPIMetrics(success, durationMs = 0, responseBytes = 0) {
+  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) {
+  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() {
+  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() {
+  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));
+}
+//# sourceMappingURL=metricsTracking.js.map

package/lib/module/sdk/navigation.js

@@ -0,0 +1,143 @@
+/**
+ * Rejourney Navigation Utilities
+ * 
+ * Helper functions for extracting human-readable screen names from
+ * React Navigation / Expo Router state.
+ * 
+ * These functions are used internally by the SDK's automatic navigation
+ * detection. You don't need to import or use these directly.
+ */
+
+/**
+ * Normalize a screen name to be human-readable
+ * Handles common patterns from React Native / Expo Router
+ * 
+ * @param raw - Raw screen name to normalize
+ * @returns Cleaned, human-readable screen name
+ */
+export function normalizeScreenName(raw) {
+  if (!raw) return 'Unknown';
+  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) {
+      name = name.slice(0, -suffix.length).trim();
+    }
+  }
+
+  // 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) {
+      name = name.slice(prefix.length).trim();
+    }
+  }
+
+  // 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);
+  }
+  return name || 'Unknown';
+}
+
+/**
+ * Get a human-readable screen name from Expo Router path and segments
+ * 
+ * @param pathname - The current route pathname
+ * @param segments - Route segments from useSegments()
+ * @returns Human-readable screen name
+ */
+export function getScreenNameFromPath(pathname, segments) {
+  // 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
+          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);
+      if (processedSegments.length > 0) {
+        return processedSegments.join(' > ');
+      }
+    }
+  }
+
+  // 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)
+  .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
+  .trim();
+  if (!cleanPath) {
+    return 'Home';
+  }
+
+  // Capitalize first letter of each word
+  return cleanPath.split(' > ').map(s => s.charAt(0).toUpperCase() + s.slice(1)).filter(s => s.length > 0).join(' > ') || 'Home';
+}
+
+/**
+ * Get the current route name from a navigation state object
+ * 
+ * @param state - React Navigation state object
+ * @returns Current route name or null
+ */
+export function getCurrentRouteFromState(state) {
+  if (!state || !state.routes) return 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);
+  }
+  return route.name || null;
+}
+//# sourceMappingURL=navigation.js.map