@rejourneyco/react-native 1.0.0

package/lib/commonjs/sdk/constants.js

@@ -0,0 +1,151 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UPLOAD_SETTINGS = exports.STORAGE_SETTINGS = exports.SDK_VERSION = exports.PRIVACY = exports.PLAYBACK_SPEEDS = exports.MEMORY_SETTINGS = exports.GESTURE_TYPES = exports.EVENT_TYPES = exports.DEFAULT_CONFIG = exports.CPU_SETTINGS = exports.CAPTURE_SETTINGS = void 0;
+/**
+ * Rejourney SDK Constants
+ */
+
+const SDK_VERSION = exports.SDK_VERSION = '1.0.0';
+
+/** Default configuration values */
+const DEFAULT_CONFIG = exports.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 */
+const EVENT_TYPES = exports.EVENT_TYPES = {
+  GESTURE: 'gesture',
+  SCREEN_CHANGE: 'screen_change',
+  CUSTOM: 'custom',
+  APP_STATE: 'app_state',
+  FRUSTRATION: 'frustration',
+  ERROR: 'error'
+};
+
+/** Gesture type constants */
+const GESTURE_TYPES = exports.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 */
+const PLAYBACK_SPEEDS = exports.PLAYBACK_SPEEDS = [0.5, 1, 2, 4];
+
+/** Capture settings */
+const CAPTURE_SETTINGS = exports.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 */
+const MEMORY_SETTINGS = exports.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 */
+const CPU_SETTINGS = exports.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 */
+const STORAGE_SETTINGS = exports.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 */
+const UPLOAD_SETTINGS = exports.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 */
+const PRIVACY = exports.PRIVACY = {
+  OCCLUSION_COLOR: '#808080',
+  SENSITIVE_COMPONENT_TYPES: ['TextInput', 'SecureTextEntry', 'PasswordField']
+};
+//# sourceMappingURL=constants.js.map

package/lib/commonjs/sdk/errorTracking.js

@@ -0,0 +1,199 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.captureError = captureError;
+exports.cleanupErrorTracking = cleanupErrorTracking;
+exports.getErrorCount = getErrorCount;
+exports.resetErrorCount = resetErrorCount;
+exports.setupErrorTracking = setupErrorTracking;
+/**
+ * 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
+ */
+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
+ */
+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
+ */
+function getErrorCount() {
+  return errorCount;
+}
+
+/**
+ * Reset error count
+ */
+function resetErrorCount() {
+  errorCount = 0;
+}
+
+/**
+ * Manually capture an error
+ */
+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/commonjs/sdk/index.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _constants = require("./constants");
+Object.keys(_constants).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _constants[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _constants[key];
+    }
+  });
+});
+var _utils = require("./utils");
+Object.keys(_utils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _utils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _utils[key];
+    }
+  });
+});
+var _autoTracking = require("./autoTracking");
+Object.keys(_autoTracking).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _autoTracking[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _autoTracking[key];
+    }
+  });
+});
+var _networkInterceptor = require("./networkInterceptor");
+Object.keys(_networkInterceptor).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _networkInterceptor[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _networkInterceptor[key];
+    }
+  });
+});
+//# sourceMappingURL=index.js.map

package/lib/commonjs/sdk/metricsTracking.js

@@ -0,0 +1,204 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addScreenVisited = addScreenVisited;
+exports.createEmptyMetrics = createEmptyMetrics;
+exports.getSessionMetrics = getSessionMetrics;
+exports.incrementErrorCount = incrementErrorCount;
+exports.incrementNavigationCount = incrementNavigationCount;
+exports.incrementRageTapCount = incrementRageTapCount;
+exports.incrementScrollCount = incrementScrollCount;
+exports.incrementTouchCount = incrementTouchCount;
+exports.initMetrics = initMetrics;
+exports.resetMetrics = resetMetrics;
+exports.setMaxSessionDurationMinutes = setMaxSessionDurationMinutes;
+exports.trackAPIMetrics = trackAPIMetrics;
+/**
+ * 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
+ */
+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
+ */
+function resetMetrics() {
+  metrics = createEmptyMetrics();
+  sessionStartTime = 0;
+}
+
+/**
+ * Initialize metrics for new session
+ */
+function initMetrics() {
+  metrics = createEmptyMetrics();
+  sessionStartTime = Date.now();
+}
+
+/**
+ * Get current session metrics with calculated scores
+ */
+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)
+ */
+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 ====================
+
+function incrementTouchCount() {
+  metrics.touchCount++;
+  metrics.totalEvents++;
+}
+function incrementScrollCount() {
+  metrics.scrollCount++;
+  metrics.totalEvents++;
+}
+function incrementNavigationCount() {
+  metrics.navigationCount++;
+  metrics.totalEvents++;
+}
+function incrementRageTapCount() {
+  metrics.rageTapCount++;
+}
+function incrementErrorCount() {
+  metrics.errorCount++;
+  metrics.totalEvents++;
+}
+function addScreenVisited(screenName) {
+  metrics.screensVisited.push(screenName);
+  metrics.uniqueScreensCount = new Set(metrics.screensVisited).size;
+}
+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