@rejourneyco/react-native 1.0.0

package/lib/module/sdk/utils.js

@@ -0,0 +1,342 @@
+/**
+ * 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+.
+ */
+
+// Lazy-loaded Platform module
+let _Platform = null;
+function getPlatform() {
+  if (_Platform) return _Platform;
+  try {
+    const RN = require('react-native');
+    _Platform = RN.Platform;
+    return _Platform;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Generate a unique ID
+ */
+export function generateId() {
+  const timestamp = Date.now().toString(36);
+  const randomPart = Math.random().toString(36).substring(2, 9);
+  return `${timestamp}-${randomPart}`;
+}
+
+/**
+ * Generate a session ID
+ */
+export function generateSessionId() {
+  const date = new Date();
+  const dateStr = date.toISOString().split('T')[0]?.replace(/-/g, '') ?? '';
+  const timeStr = date.toTimeString().split(' ')[0]?.replace(/:/g, '') ?? '';
+  const random = Math.random().toString(36).substring(2, 6);
+  return `session_${dateStr}_${timeStr}_${random}`;
+}
+
+/**
+ * Get current timestamp in milliseconds
+ */
+export function now() {
+  return Date.now();
+}
+
+/**
+ * Check if running in development mode
+ */
+export function isDevelopment() {
+  return __DEV__;
+}
+
+/**
+ * Check platform
+ */
+export function isIOS() {
+  const platform = getPlatform();
+  return platform?.OS === 'ios';
+}
+export function isAndroid() {
+  const platform = getPlatform();
+  return platform?.OS === 'android';
+}
+
+/**
+ * Calculate distance between two points
+ */
+export function distance(p1, p2) {
+  const dx = p2.x - p1.x;
+  const dy = p2.y - p1.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+
+/**
+ * Calculate velocity between two points
+ */
+export function velocity(p1, p2) {
+  const dt = p2.timestamp - p1.timestamp;
+  if (dt === 0) return {
+    x: 0,
+    y: 0
+  };
+  return {
+    x: (p2.x - p1.x) / dt,
+    y: (p2.y - p1.y) / dt
+  };
+}
+
+/**
+ * Determine gesture type from touch points
+ */
+export function classifyGesture(touches, duration) {
+  if (touches.length < 2) {
+    if (duration > 500) return 'long_press';
+    return 'tap';
+  }
+  const first = touches[0];
+  const last = touches[touches.length - 1];
+  if (!first || !last) return 'tap';
+  const dx = last.x - first.x;
+  const dy = last.y - first.y;
+  const dist = distance(first, last);
+
+  // If very little movement, it's a tap
+  if (dist < 10) {
+    if (duration > 500) return 'long_press';
+    return 'tap';
+  }
+
+  // Determine swipe direction
+  const absX = Math.abs(dx);
+  const absY = Math.abs(dy);
+  if (absX > absY) {
+    return dx > 0 ? 'swipe_right' : 'swipe_left';
+  } else {
+    return dy > 0 ? 'swipe_down' : 'swipe_up';
+  }
+}
+
+/**
+ * Throttle function execution
+ */
+export function throttle(fn, delay) {
+  let lastCall = 0;
+  return (...args) => {
+    const currentTime = now();
+    if (currentTime - lastCall >= delay) {
+      lastCall = currentTime;
+      fn(...args);
+    }
+  };
+}
+
+/**
+ * Debounce function execution
+ */
+export function debounce(fn, delay) {
+  let timeoutId = null;
+  return (...args) => {
+    if (timeoutId) clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => fn(...args), delay);
+  };
+}
+
+/**
+ * Format bytes to human readable string
+ */
+export function formatBytes(bytes) {
+  if (bytes === 0) return '0 Bytes';
+  const k = 1024;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+
+/**
+ * Format duration to human readable string
+ */
+export function formatDuration(ms) {
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ${seconds % 60}s`;
+  }
+  return `${seconds}s`;
+}
+
+/**
+ * Format timestamp to readable time
+ */
+export function formatTime(ms) {
+  const totalSeconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
+}
+
+/**
+ * Create a simple hash of a string
+ */
+export function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash; // Convert to 32bit integer
+  }
+  return Math.abs(hash).toString(36);
+}
+
+/**
+ * Log levels for controlling verbosity.
+ * 
+ * Default behavior minimizes log pollution for integrators:
+ * - Release/Production: SILENT (no logs)
+ * - Development: ERROR (only critical issues)
+ */
+export let LogLevel = /*#__PURE__*/function (LogLevel) {
+  LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+  LogLevel[LogLevel["INFO"] = 1] = "INFO";
+  LogLevel[LogLevel["WARNING"] = 2] = "WARNING";
+  LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+  LogLevel[LogLevel["SILENT"] = 4] = "SILENT";
+  return LogLevel;
+}({});
+
+/**
+ * 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.
+ */
+class Logger {
+  prefix = '[Rejourney]';
+  debugMode = false;
+
+  /**
+   * 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.
+   */
+  minimumLogLevel = typeof __DEV__ !== 'undefined' && __DEV__ ? LogLevel.ERROR : LogLevel.SILENT;
+
+  /**
+   * Set the minimum log level. Logs below this level will be suppressed.
+   * SDK developers can use this for internal debugging.
+   */
+  setLogLevel(level) {
+    this.minimumLogLevel = level;
+  }
+  setDebugMode(enabled) {
+    this.debugMode = enabled;
+    this.minimumLogLevel = enabled ? LogLevel.DEBUG : typeof __DEV__ !== 'undefined' && __DEV__ ? LogLevel.ERROR : LogLevel.SILENT;
+  }
+
+  /** Log a debug message - SDK internal use only */
+  debug(...args) {
+    if (this.minimumLogLevel <= LogLevel.DEBUG) {
+      console.log(this.prefix, ...args);
+    }
+  }
+
+  /** Log an info message - SDK internal use only */
+  info(...args) {
+    if (this.minimumLogLevel <= LogLevel.INFO) {
+      console.info(this.prefix, ...args);
+    }
+  }
+
+  /** Log a warning message */
+  warn(...args) {
+    if (this.minimumLogLevel <= LogLevel.WARNING) {
+      console.warn(this.prefix, ...args);
+    }
+  }
+
+  /** Log an error message */
+  error(...args) {
+    if (this.minimumLogLevel <= LogLevel.ERROR) {
+      console.error(this.prefix, ...args);
+    }
+  }
+  notice(...args) {
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.info(this.prefix, ...args);
+    }
+  }
+
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  // Lifecycle Logs - Industry standard minimal logging
+  // These are the only logs integrators will see in debug builds
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  /**
+   * Log SDK initialization success.
+   * Only shown in development builds - this is the minimal "SDK started" log.
+   */
+  logInitSuccess(version) {
+    if (this.debugMode) {
+      this.info(`✓ SDK initialized (v${version})`);
+    }
+  }
+
+  /**
+   * Log SDK initialization failure.
+   * Always shown - this is a critical error.
+   */
+  logInitFailure(reason) {
+    console.error(this.prefix, `✗ Initialization failed: ${reason}`);
+  }
+
+  /**
+   * Log session start.
+   * Only shown in development builds.
+   */
+  logSessionStart(sessionId) {
+    if (this.debugMode) {
+      this.info(`Session started: ${sessionId}`);
+    }
+  }
+
+  /**
+   * Log session end.
+   * Only shown in development builds.
+   */
+  logSessionEnd(sessionId) {
+    if (this.debugMode) {
+      this.info(`Session ended: ${sessionId}`);
+    }
+  }
+  logObservabilityStart() {
+    this.notice('Starting Rejourney observability');
+  }
+  logRecordingStart() {
+    this.notice('Starting recording');
+  }
+  logRecordingRemoteDisabled() {
+    this.notice('Recording disabled by remote toggle');
+  }
+  logInvalidProjectKey() {
+    this.notice('Invalid project API key');
+  }
+  logPackageMismatch() {
+    this.notice('Bundle ID / package name mismatch');
+  }
+}
+export const logger = new Logger();
+//# sourceMappingURL=utils.js.map

package/lib/module/types/expo-router.d.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=expo-router.d.js.map

package/lib/module/types/index.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=index.js.map

package/lib/typescript/NativeRejourney.d.ts

@@ -0,0 +1,147 @@
+/**
+ * TurboModule spec for Rejourney SDK
+ *
+ * This file defines the native module interface for React Native's New Architecture.
+ * It follows the official React Native TurboModules pattern for Codegen compatibility.
+ *
+ * IMPORTANT: This spec file is used by Codegen to generate native bindings.
+ * The default export MUST be a direct TurboModuleRegistry.get() call.
+ *
+ * @see https://reactnative.dev/docs/turbo-native-modules-introduction
+ */
+import type { TurboModule } from 'react-native';
+/**
+ * SDK telemetry metrics for observability
+ */
+export interface SDKMetrics {
+    uploadSuccessCount: number;
+    uploadFailureCount: number;
+    retryAttemptCount: number;
+    circuitBreakerOpenCount: number;
+    memoryEvictionCount: number;
+    offlinePersistCount: number;
+    sessionStartCount: number;
+    crashCount: number;
+    uploadSuccessRate: number;
+    avgUploadDurationMs: number;
+    currentQueueDepth: number;
+    lastUploadTime: number | null;
+    lastRetryTime: number | null;
+    totalBytesUploaded: number;
+    totalBytesEvicted: number;
+}
+/**
+ * Native Rejourney module specification for TurboModules (New Architecture)
+ *
+ * This interface defines all methods exposed by the native module.
+ * Codegen uses this to generate:
+ * - iOS: RejourneySpec.h (protocol) and RejourneySpec-generated.mm (JSI bindings)
+ * - Android: NativeRejourneySpec.java (interface)
+ */
+export interface Spec extends TurboModule {
+    /**
+     * Start a recording session
+     */
+    startSession(userId: string, apiUrl: string, publicKey: string): Promise<{
+        success: boolean;
+        sessionId: string;
+        error?: string;
+    }>;
+    /**
+     * Stop the current recording session
+     */
+    stopSession(): Promise<{
+        success: boolean;
+        sessionId: string;
+        uploadSuccess?: boolean;
+        warning?: string;
+        error?: string;
+    }>;
+    /**
+     * Log a custom event
+     */
+    logEvent(eventType: string, details: Object): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Notify of a screen change
+     */
+    screenChanged(screenName: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Report scroll offset for timeline correlation
+     */
+    onScroll(offsetY: number): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Mark a visual change that should be captured
+     */
+    markVisualChange(reason: string, importance: string): Promise<boolean>;
+    /**
+     * Notify that an external URL is being opened
+     */
+    onExternalURLOpened(urlScheme: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Notify that an OAuth flow is starting
+     */
+    onOAuthStarted(provider: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Notify that an OAuth flow has completed
+     */
+    onOAuthCompleted(provider: string, success: boolean): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Get SDK telemetry metrics for observability
+     */
+    getSDKMetrics(): Promise<SDKMetrics>;
+    /**
+     * Trigger a debug crash (Dev only)
+     */
+    debugCrash(): void;
+    /**
+     * Trigger a debug ANR (Dev only)
+     * Blocks the main thread for the specified duration
+     */
+    debugTriggerANR(durationMs: number): void;
+    /**
+     * Get the current session ID
+     */
+    getSessionId(): Promise<string | null>;
+    /**
+     * Mask a view by its nativeID prop (will be occluded in recordings)
+     */
+    maskViewByNativeID(nativeID: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Unmask a view by its nativeID prop
+     */
+    unmaskViewByNativeID(nativeID: string): Promise<{
+        success: boolean;
+    }>;
+    setUserIdentity(userId: string): Promise<{
+        success: boolean;
+    }>;
+    setDebugMode(enabled: boolean): Promise<{
+        success: boolean;
+    }>;
+}
+/**
+ * Default export for Codegen.
+ *
+ * CRITICAL: This MUST be a direct TurboModuleRegistry.get() call.
+ * Codegen parses this file statically and requires this exact pattern.
+ *
+ * Using getEnforcing() would throw if module not found.
+ * Using get() returns null, which is safer during development/testing.
+ */
+declare const _default: Spec | null;
+export default _default;
+//# sourceMappingURL=NativeRejourney.d.ts.map

package/lib/typescript/components/Mask.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Mask Component
+ *
+ * Wrapper component to mask sensitive content in session replays.
+ * All children wrapped in this component will be obscured in recordings.
+ *
+ * IMPORTANT: This file uses lazy loading to avoid "PlatformConstants could not be found"
+ * errors on React Native 0.81+ with New Architecture (Bridgeless).
+ *
+ * @example
+ * ```tsx
+ * import { Mask } from 'rejourney';
+ *
+ * // Mask sensitive user ID
+ * <Mask>
+ *   <Text>User ID: {user.id}</Text>
+ * </Mask>
+ *
+ * // Mask credit card info
+ * <Mask>
+ *   <CreditCardDisplay card={card} />
+ * </Mask>
+ * ```
+ */
+import React from 'react';
+import type { ViewProps } from 'react-native';
+export interface MaskProps extends ViewProps {
+    children: React.ReactNode;
+}
+/**
+ * Wrapper component to mask sensitive content in session replays.
+ * All children will be obscured in recordings.
+ *
+ * Uses accessibilityHint to signal to the native capture engine
+ * that this view and its contents should be masked.
+ */
+export declare const Mask: React.FC<MaskProps>;
+export default Mask;
+//# sourceMappingURL=Mask.d.ts.map

package/lib/typescript/index.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Rejourney - Session Recording and Replay SDK for React Native
+ *
+ * Captures user interactions, gestures, and screen states for replay and analysis.
+ *
+ * Just call initRejourney() - everything else is automatic!
+ *
+ * Copyright (c) 2026 Rejourney
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * See LICENSE-APACHE for full terms.
+ *
+ * @example
+ * ```typescript
+ * import { initRejourney } from 'rejourney';
+ *
+ * // Initialize the SDK with your public key - that's it!
+ * initRejourney('pk_live_xxxxxxxxxxxx');
+ *
+ * // Or with options:
+ * initRejourney('pk_live_xxxxxxxxxxxx', { debug: true });
+ * ```
+ */
+import type { RejourneyConfig, RejourneyAPI } from './types';
+/**
+ * Main Rejourney API (Internal)
+ */
+declare const Rejourney: RejourneyAPI;
+/**
+ * Initialize Rejourney SDK - STEP 1 of 3
+ *
+ * This sets up the SDK, handles attestation, and prepares for recording,
+ * but does NOT start recording automatically. Call startRejourney() after
+ * obtaining user consent to begin recording.
+ *
+ * @param publicRouteKey - Your public route key from the Rejourney dashboard
+ * @param options - Optional configuration options
+ *
+ * @example
+ * ```typescript
+ * import { initRejourney, startRejourney } from 'rejourney';
+ *
+ * // Step 1: Initialize SDK (safe to call on app start)
+ * initRejourney('pk_live_xxxxxxxxxxxx');
+ *
+ * // Step 2: After obtaining user consent
+ * startRejourney();
+ *
+ * // With options
+ * initRejourney('pk_live_xxxxxxxxxxxx', {
+ *   debug: true,
+ *   apiUrl: 'https://api.yourdomain.com',
+ *   projectId: 'your-project-id',
+ * });
+ * ```
+ */
+export declare function initRejourney(publicRouteKey: string, options?: Omit<RejourneyConfig, 'publicRouteKey'>): void;
+/**
+ * Start recording - STEP 2 of 3 (call after user consent)
+ *
+ * Begins session recording. Call this after obtaining user consent for recording.
+ *
+ * @example
+ * ```typescript
+ * import { initRejourney, startRejourney } from 'rejourney';
+ *
+ * initRejourney('pk_live_xxxxxxxxxxxx');
+ *
+ * // After user accepts consent dialog
+ * startRejourney();
+ * ```
+ */
+export declare function startRejourney(): void;
+/**
+ * Stop recording and cleanup all resources.
+ *
+ * Note: This is usually not needed as the SDK handles cleanup automatically.
+ * Only call this if you want to explicitly stop recording.
+ */
+export declare function stopRejourney(): void;
+export default Rejourney;
+export * from './types';
+export { trackTap, trackScroll, trackGesture, trackInput, trackScreen, captureError, getSessionMetrics, } from './sdk/autoTracking';
+export { trackNavigationState, useNavigationTracking } from './sdk/autoTracking';
+export { LogLevel } from './sdk/utils';
+/**
+ * Configure SDK log verbosity.
+ *
+ * By default, the SDK logs minimally to avoid polluting your app's console:
+ * - Production/Release: SILENT (no logs at all)
+ * - Development/Debug: Only critical errors shown
+ *
+ * Essential lifecycle events (init success, session start/end) are automatically
+ * logged in debug builds only - you don't need to configure anything.
+ *
+ * Use this function only if you need to troubleshoot SDK behavior.
+ *
+ * @param level - Minimum log level to display
+ *
+ * @example
+ * ```typescript
+ * import { setLogLevel, LogLevel } from 'rejourney';
+ *
+ * // Enable verbose logging for SDK debugging (not recommended for regular use)
+ * setLogLevel(LogLevel.DEBUG);
+ *
+ * // Show warnings and errors (for troubleshooting)
+ * setLogLevel(LogLevel.WARNING);
+ *
+ * // Silence all logs (default behavior in production)
+ * setLogLevel(LogLevel.SILENT);
+ * ```
+ */
+export declare function setLogLevel(level: number): void;
+export { Mask } from './components/Mask';
+//# sourceMappingURL=index.d.ts.map