@rejourneyco/react-native 1.0.0

package/lib/typescript/sdk/autoTracking.d.ts

@@ -0,0 +1,204 @@
+/**
+ * Rejourney Auto Tracking Module
+ *
+ * Automatic tracking features that work with just init() - no additional code needed.
+ * This module handles:
+ * - Rage tap detection
+ * - Error tracking (JS + React Native)
+ * - Session metrics aggregation
+ * - Device info collection
+ * - Anonymous ID generation
+ * - Funnel/screen tracking
+ * - Score calculations
+ *
+ * IMPORTANT: This file uses lazy loading for react-native imports to avoid
+ * "PlatformConstants could not be found" errors on RN 0.81+.
+ */
+import type { DeviceInfo, ErrorEvent } from '../types';
+export interface TapEvent {
+    x: number;
+    y: number;
+    timestamp: number;
+    targetId?: string;
+}
+export interface SessionMetrics {
+    totalEvents: number;
+    touchCount: number;
+    scrollCount: number;
+    gestureCount: number;
+    inputCount: number;
+    navigationCount: number;
+    errorCount: number;
+    rageTapCount: number;
+    apiSuccessCount: number;
+    apiErrorCount: number;
+    apiTotalCount: number;
+    netTotalDurationMs: number;
+    netTotalBytes: number;
+    screensVisited: string[];
+    uniqueScreensCount: number;
+    interactionScore: number;
+    explorationScore: number;
+    uxScore: number;
+}
+export interface AutoTrackingConfig {
+    rageTapThreshold?: number;
+    rageTapTimeWindow?: number;
+    rageTapRadius?: number;
+    trackJSErrors?: boolean;
+    trackPromiseRejections?: boolean;
+    trackReactNativeErrors?: boolean;
+    collectDeviceInfo?: boolean;
+    maxSessionDurationMs?: number;
+}
+/**
+ * Initialize auto tracking features
+ * Called automatically by Rejourney.init() - no user action needed
+ */
+export declare function initAutoTracking(trackingConfig: AutoTrackingConfig, callbacks?: {
+    onRageTap?: (count: number, x: number, y: number) => void;
+    onError?: (error: ErrorEvent) => void;
+    onScreen?: (screenName: string, previousScreen?: string) => void;
+}): void;
+/**
+ * Cleanup auto tracking features
+ */
+export declare function cleanupAutoTracking(): void;
+/**
+ * Track a tap event for rage tap detection
+ * Called automatically from touch interceptor
+ */
+export declare function trackTap(tap: TapEvent): void;
+/**
+ * Notify that a state change occurred (navigation, modal, etc.)
+ * Kept for API compatibility
+ */
+export declare function notifyStateChange(): void;
+/**
+ * Manually track an error (for API errors, etc.)
+ */
+export declare function captureError(message: string, stack?: string, name?: string): void;
+/**
+ * Track a navigation state change from React Navigation.
+ *
+ * For bare React Native apps using @react-navigation/native.
+ * Just add this to your NavigationContainer's onStateChange prop.
+ *
+ * @example
+ * ```tsx
+ * import { trackNavigationState } from 'rejourney';
+ *
+ * <NavigationContainer onStateChange={trackNavigationState}>
+ *   ...
+ * </NavigationContainer>
+ * ```
+ */
+export declare function trackNavigationState(state: any): void;
+/**
+ * React hook for navigation tracking.
+ *
+ * Returns props to spread on NavigationContainer that will:
+ * 1. Track the initial screen on mount (via onReady)
+ * 2. Track all subsequent navigations (via onStateChange)
+ *
+ * This is the RECOMMENDED approach for bare React Native apps.
+ *
+ * @example
+ * ```tsx
+ * import { useNavigationTracking } from 'rejourney';
+ * import { NavigationContainer } from '@react-navigation/native';
+ *
+ * function App() {
+ *   const navigationTracking = useNavigationTracking();
+ *
+ *   return (
+ *     <NavigationContainer {...navigationTracking}>
+ *       <RootNavigator />
+ *     </NavigationContainer>
+ *   );
+ * }
+ * ```
+ */
+export declare function useNavigationTracking(): {
+    ref: any;
+    onReady: any;
+    onStateChange: typeof trackNavigationState;
+};
+/**
+ * Track a screen view
+ * This updates JS metrics AND notifies the native module to send to backend
+ */
+export declare function trackScreen(screenName: string): void;
+/**
+ * Track an API request with timing data
+ */
+export declare function trackAPIRequest(success: boolean, _statusCode: number, durationMs?: number, responseBytes?: number): void;
+/**
+ * Track a scroll event
+ */
+export declare function trackScroll(): void;
+/**
+ * Track a gesture event
+ */
+export declare function trackGesture(): void;
+/**
+ * Track an input event (keyboard)
+ */
+export declare function trackInput(): void;
+/**
+ * Get current session metrics
+ */
+export declare function getSessionMetrics(): SessionMetrics & {
+    netAvgDurationMs: number;
+};
+/**
+ * Reset metrics for new session
+ */
+export declare function resetMetrics(): void;
+/** Clamp and set max session duration in minutes (1–10). Defaults to 10. */
+export declare function setMaxSessionDurationMinutes(minutes?: number): void;
+/** Returns true if the current session exceeded the configured max duration. */
+export declare function hasExceededMaxSessionDuration(): boolean;
+/** Returns remaining milliseconds until the session should stop. */
+export declare function getRemainingSessionDurationMs(): number;
+/**
+ * Collect device information
+ */
+export declare function collectDeviceInfo(): DeviceInfo;
+/**
+ * Get the anonymous ID (synchronous - returns generated ID immediately)
+ * For persistent ID, call initAnonymousId() first
+ */
+export declare function getAnonymousId(): string;
+/**
+ * Ensure a stable, persisted anonymous/device ID is available.
+ * Returns the stored ID if present, otherwise generates and persists one.
+ */
+export declare function ensurePersistentAnonymousId(): Promise<string>;
+/**
+ * Load anonymous ID from persistent storage
+ * Call this at app startup for best results
+ */
+export declare function loadAnonymousId(): Promise<string>;
+/**
+ * Set a custom anonymous ID (e.g., from persistent storage)
+ */
+export declare function setAnonymousId(id: string): void;
+declare const _default: {
+    init: typeof initAutoTracking;
+    cleanup: typeof cleanupAutoTracking;
+    trackTap: typeof trackTap;
+    trackScroll: typeof trackScroll;
+    trackGesture: typeof trackGesture;
+    trackInput: typeof trackInput;
+    trackScreen: typeof trackScreen;
+    trackAPIRequest: typeof trackAPIRequest;
+    captureError: typeof captureError;
+    getMetrics: typeof getSessionMetrics;
+    resetMetrics: typeof resetMetrics;
+    collectDeviceInfo: typeof collectDeviceInfo;
+    getAnonymousId: typeof getAnonymousId;
+    setAnonymousId: typeof setAnonymousId;
+};
+export default _default;
+//# sourceMappingURL=autoTracking.d.ts.map

package/lib/typescript/sdk/constants.d.ts

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

package/lib/typescript/sdk/errorTracking.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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';
+/**
+ * Setup error tracking with the given callback
+ */
+export declare function setupErrorTracking(config: {
+    trackJSErrors?: boolean;
+    trackPromiseRejections?: boolean;
+    trackReactNativeErrors?: boolean;
+}, onError: (error: ErrorEvent) => void): void;
+/**
+ * Cleanup error tracking and restore original handlers
+ */
+export declare function cleanupErrorTracking(): void;
+/**
+ * Get current error count
+ */
+export declare function getErrorCount(): number;
+/**
+ * Reset error count
+ */
+export declare function resetErrorCount(): void;
+/**
+ * Manually capture an error
+ */
+export declare function captureError(message: string, stack?: string, name?: string): void;
+//# sourceMappingURL=errorTracking.d.ts.map

package/lib/typescript/sdk/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Rejourney SDK
+ * Session recording and replay for React Native
+ */
+export * from './constants';
+export * from './utils';
+export * from './autoTracking';
+export * from './networkInterceptor';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/sdk/metricsTracking.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 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 {
+    totalEvents: number;
+    touchCount: number;
+    scrollCount: number;
+    gestureCount: number;
+    inputCount: number;
+    navigationCount: number;
+    errorCount: number;
+    rageTapCount: number;
+    apiSuccessCount: number;
+    apiErrorCount: number;
+    apiTotalCount: number;
+    netTotalDurationMs: number;
+    netTotalBytes: number;
+    screensVisited: string[];
+    uniqueScreensCount: number;
+    interactionScore: number;
+    explorationScore: number;
+    uxScore: number;
+}
+/**
+ * Create empty metrics object
+ */
+export declare function createEmptyMetrics(): SessionMetrics;
+/**
+ * Reset all metrics
+ */
+export declare function resetMetrics(): void;
+/**
+ * Initialize metrics for new session
+ */
+export declare function initMetrics(): void;
+/**
+ * Get current session metrics with calculated scores
+ */
+export declare function getSessionMetrics(): SessionMetrics;
+/**
+ * Set max session duration (in minutes)
+ */
+export declare function setMaxSessionDurationMinutes(minutes?: number): void;
+export declare function incrementTouchCount(): void;
+export declare function incrementScrollCount(): void;
+export declare function incrementNavigationCount(): void;
+export declare function incrementRageTapCount(): void;
+export declare function incrementErrorCount(): void;
+export declare function addScreenVisited(screenName: string): void;
+export declare function trackAPIMetrics(success: boolean, durationMs?: number, responseBytes?: number): void;
+//# sourceMappingURL=metricsTracking.d.ts.map

package/lib/typescript/sdk/navigation.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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 declare function normalizeScreenName(raw: string): string;
+/**
+ * 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 declare function getScreenNameFromPath(pathname: string, segments: string[]): string;
+/**
+ * Get the current route name from a navigation state object
+ *
+ * @param state - React Navigation state object
+ * @returns Current route name or null
+ */
+export declare function getCurrentRouteFromState(state: any): string | null;
+//# sourceMappingURL=navigation.d.ts.map

package/lib/typescript/sdk/networkInterceptor.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Network Interceptor for Rejourney - Optimized Version
+ *
+ * Automatically intercepts fetch() and XMLHttpRequest to log API calls.
+ *
+ * PERFORMANCE OPTIMIZATIONS:
+ * - Minimal synchronous overhead (just captures timing, no processing)
+ * - Batched async logging (doesn't block requests)
+ * - Circular buffer with max size limit
+ * - Sampling for high-frequency endpoints
+ * - No string allocations in hot path
+ * - Lazy URL parsing
+ * - PII Scrubbing for query parameters
+ */
+import type { NetworkRequestParams } from '../types';
+/**
+ * Initialize network interception
+ */
+export declare function initNetworkInterceptor(callback: (request: NetworkRequestParams) => void, options?: {
+    ignoreUrls?: (string | RegExp)[];
+    captureSizes?: boolean;
+}): void;
+/**
+ * Disable network interception
+ */
+export declare function disableNetworkInterceptor(): void;
+/**
+ * Re-enable network interception
+ */
+export declare function enableNetworkInterceptor(): void;
+/**
+ * Force flush pending requests (call before app termination)
+ */
+export declare function flushNetworkRequests(): void;
+/**
+ * Restore original fetch and XHR
+ */
+export declare function restoreNetworkInterceptor(): void;
+/**
+ * Get stats for debugging
+ */
+export declare function getNetworkInterceptorStats(): {
+    pendingCount: number;
+    endpointCount: number;
+    enabled: boolean;
+};
+//# sourceMappingURL=networkInterceptor.d.ts.map

package/lib/typescript/sdk/utils.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Rejourney Utility Functions
+ *
+ * IMPORTANT: This file uses lazy loading for react-native imports to avoid
+ * "PlatformConstants could not be found" errors on RN 0.81+.
+ */
+import type { TouchPoint, GestureType } from '../types';
+/**
+ * Generate a unique ID
+ */
+export declare function generateId(): string;
+/**
+ * Generate a session ID
+ */
+export declare function generateSessionId(): string;
+/**
+ * Get current timestamp in milliseconds
+ */
+export declare function now(): number;
+/**
+ * Check if running in development mode
+ */
+export declare function isDevelopment(): boolean;
+/**
+ * Check platform
+ */
+export declare function isIOS(): boolean;
+export declare function isAndroid(): boolean;
+/**
+ * Calculate distance between two points
+ */
+export declare function distance(p1: TouchPoint, p2: TouchPoint): number;
+/**
+ * Calculate velocity between two points
+ */
+export declare function velocity(p1: TouchPoint, p2: TouchPoint): {
+    x: number;
+    y: number;
+};
+/**
+ * Determine gesture type from touch points
+ */
+export declare function classifyGesture(touches: TouchPoint[], duration: number): GestureType;
+/**
+ * Throttle function execution
+ */
+export declare function throttle<T extends (...args: any[]) => any>(fn: T, delay: number): (...args: Parameters<T>) => void;
+/**
+ * Debounce function execution
+ */
+export declare function debounce<T extends (...args: any[]) => any>(fn: T, delay: number): (...args: Parameters<T>) => void;
+/**
+ * Format bytes to human readable string
+ */
+export declare function formatBytes(bytes: number): string;
+/**
+ * Format duration to human readable string
+ */
+export declare function formatDuration(ms: number): string;
+/**
+ * Format timestamp to readable time
+ */
+export declare function formatTime(ms: number): string;
+/**
+ * Create a simple hash of a string
+ */
+export declare function simpleHash(str: string): string;
+/**
+ * Log levels for controlling verbosity.
+ *
+ * Default behavior minimizes log pollution for integrators:
+ * - Release/Production: SILENT (no logs)
+ * - Development: ERROR (only critical issues)
+ */
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARNING = 2,
+    ERROR = 3,
+    SILENT = 4
+}
+/**
+ * Logger with production-aware log levels.
+ *
+ * Designed to minimize log pollution for integrators:
+ * - Production/Release: SILENT (completely silent, no logs)
+ * - Development/Debug: ERROR (only critical errors)
+ *
+ * Only essential lifecycle logs (init success, session start/end) bypass
+ * these levels via dedicated methods.
+ */
+declare class Logger {
+    private prefix;
+    private debugMode;
+    /**
+     * Minimum log level to display.
+     *
+     * Defaults to SILENT to avoid polluting integrator's console.
+     * SDK developers can adjust this for internal debugging.
+     *
+     * Note: In production builds, this should remain SILENT.
+     * The native layers handle build-type detection automatically.
+     */
+    private minimumLogLevel;
+    /**
+     * Set the minimum log level. Logs below this level will be suppressed.
+     * SDK developers can use this for internal debugging.
+     */
+    setLogLevel(level: LogLevel): void;
+    setDebugMode(enabled: boolean): void;
+    /** Log a debug message - SDK internal use only */
+    debug(...args: any[]): void;
+    /** Log an info message - SDK internal use only */
+    info(...args: any[]): void;
+    /** Log a warning message */
+    warn(...args: any[]): void;
+    /** Log an error message */
+    error(...args: any[]): void;
+    notice(...args: any[]): void;
+    /**
+     * Log SDK initialization success.
+     * Only shown in development builds - this is the minimal "SDK started" log.
+     */
+    logInitSuccess(version: string): void;
+    /**
+     * Log SDK initialization failure.
+     * Always shown - this is a critical error.
+     */
+    logInitFailure(reason: string): void;
+    /**
+     * Log session start.
+     * Only shown in development builds.
+     */
+    logSessionStart(sessionId: string): void;
+    /**
+     * Log session end.
+     * Only shown in development builds.
+     */
+    logSessionEnd(sessionId: string): void;
+    logObservabilityStart(): void;
+    logRecordingStart(): void;
+    logRecordingRemoteDisabled(): void;
+    logInvalidProjectKey(): void;
+    logPackageMismatch(): void;
+}
+export declare const logger: Logger;
+export {};
+//# sourceMappingURL=utils.d.ts.map