@rejourneyco/react-native 1.0.7

package/lib/module/sdk/utils.js

@@ -0,0 +1,412 @@
+/**
+ * Copyright 2026 Rejourney
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * 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]';
+
+  /**
+   * 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.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) {
+      if (this.minimumLogLevel <= LogLevel.DEBUG) {
+        // Explicit Debug Mode: Show YellowBox
+        console.warn(this.prefix, ...args);
+      } else {
+        // Default Dev Mode: Log to console only, avoid YellowBox
+        console.log(this.prefix, '[WARN]', ...args);
+      }
+    }
+  }
+
+  /** Log an error message */
+  error(...args) {
+    if (this.minimumLogLevel <= LogLevel.ERROR) {
+      if (this.minimumLogLevel <= LogLevel.DEBUG) {
+        // Explicit Debug Mode: Show RedBox
+        console.error(this.prefix, ...args);
+      } else {
+        // Default Dev Mode: Log to console only, avoid RedBox
+        console.log(this.prefix, '[ERROR]', ...args);
+      }
+    }
+  }
+  notice(...args) {
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.info(this.prefix, ...args);
+    }
+  }
+
+  /**
+   * Log SDK initialization success.
+   * Only shown in development builds - this is the minimal "SDK started" log.
+   */
+  logInitSuccess(version) {
+    this.notice(`✓ 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) {
+    this.notice(`Session started: ${sessionId}`);
+  }
+
+  /**
+   * Log session end.
+   * Only shown in development builds.
+   */
+  logSessionEnd(sessionId) {
+    this.notice(`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');
+  }
+
+  /**
+   * Log network request details
+   */
+  logNetworkRequest(request) {
+    const statusIcon = request.error || request.statusCode && request.statusCode >= 400 ? '🔴' : '🟢';
+    const method = request.method || 'GET';
+    // Shorten URL to just path if possible
+    let url = request.url || '';
+    try {
+      if (url.startsWith('http')) {
+        const urlObj = new URL(url);
+        url = urlObj.pathname;
+      }
+    } catch {
+      // Keep full URL if parsing fails
+    }
+    const duration = request.duration ? `(${Math.round(request.duration)}ms)` : '';
+    const status = request.statusCode ? `${request.statusCode}` : 'ERR';
+    this.notice(`${statusIcon} [NET] ${status} ${method} ${url} ${duration} ${request.error ? `Error: ${request.error}` : ''}`);
+  }
+
+  /**
+   * Log frustration event (rage taps, etc)
+   */
+  logFrustration(kind) {
+    this.notice(`🤬 Frustration detected: ${kind}`);
+  }
+
+  /**
+   * Log error captured by SDK
+   */
+  logError(message) {
+    this.notice(`X Error captured: ${message}`);
+  }
+
+  /**
+   * Log lifecycle event (Background/Foreground)
+   * Visible in development builds.
+   */
+  logLifecycleEvent(event) {
+    this.notice(`🔄 Lifecycle: ${event}`);
+  }
+
+  /**
+   * Log upload statistics
+   */
+  logUploadStats(metrics) {
+    const success = metrics.uploadSuccessCount;
+    const failed = metrics.uploadFailureCount;
+    const bytes = formatBytes(metrics.totalBytesUploaded);
+
+    // Always show in dev mode for reassurance, even if 0
+    this.notice(`📡 Upload Stats: ${success} success, ${failed} failed (${bytes} uploaded)`);
+  }
+}
+export const logger = new Logger();
+//# sourceMappingURL=utils.js.map

package/lib/module/sdk/version.js

@@ -0,0 +1,7 @@
+/**
+ * Auto-generated file - DO NOT EDIT
+ * Generated by scripts/generate-version.js from package.json
+ */
+
+export const SDK_VERSION = '1.0.7';
+//# sourceMappingURL=version.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,160 @@
+/**
+ * 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;
+    }>;
+    getUserIdentity(): Promise<string | null>;
+    setDebugMode(enabled: boolean): Promise<{
+        success: boolean;
+    }>;
+    /**
+       * Set SDK version from JS (called during init with version from package.json)
+       */
+    setSDKVersion(version: string): void;
+    /**
+     * Set remote configuration from backend
+     * Called before startSession to apply server-side settings
+     */
+    setRemoteConfig(rejourneyEnabled: boolean, recordingEnabled: boolean, sampleRate: number, maxRecordingMinutes: number): Promise<{
+        success: boolean;
+    }>;
+    getDeviceInfo(): Promise<Object>;
+}
+/**
+ * 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,54 @@
+/**
+ * Copyright 2026 Rejourney
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * 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