@rejourneyco/react-native 1.0.0

package/lib/commonjs/sdk/utils.js

@@ -0,0 +1,363 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LogLevel = void 0;
+exports.classifyGesture = classifyGesture;
+exports.debounce = debounce;
+exports.distance = distance;
+exports.formatBytes = formatBytes;
+exports.formatDuration = formatDuration;
+exports.formatTime = formatTime;
+exports.generateId = generateId;
+exports.generateSessionId = generateSessionId;
+exports.isAndroid = isAndroid;
+exports.isDevelopment = isDevelopment;
+exports.isIOS = isIOS;
+exports.logger = void 0;
+exports.now = now;
+exports.simpleHash = simpleHash;
+exports.throttle = throttle;
+exports.velocity = velocity;
+/**
+ * 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
+ */
+function generateId() {
+  const timestamp = Date.now().toString(36);
+  const randomPart = Math.random().toString(36).substring(2, 9);
+  return `${timestamp}-${randomPart}`;
+}
+
+/**
+ * Generate a session ID
+ */
+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
+ */
+function now() {
+  return Date.now();
+}
+
+/**
+ * Check if running in development mode
+ */
+function isDevelopment() {
+  return __DEV__;
+}
+
+/**
+ * Check platform
+ */
+function isIOS() {
+  const platform = getPlatform();
+  return platform?.OS === 'ios';
+}
+function isAndroid() {
+  const platform = getPlatform();
+  return platform?.OS === 'android';
+}
+
+/**
+ * Calculate distance between two points
+ */
+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
+ */
+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
+ */
+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
+ */
+function throttle(fn, delay) {
+  let lastCall = 0;
+  return (...args) => {
+    const currentTime = now();
+    if (currentTime - lastCall >= delay) {
+      lastCall = currentTime;
+      fn(...args);
+    }
+  };
+}
+
+/**
+ * Debounce function execution
+ */
+function debounce(fn, delay) {
+  let timeoutId = null;
+  return (...args) => {
+    if (timeoutId) clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => fn(...args), delay);
+  };
+}
+
+/**
+ * Format bytes to human readable string
+ */
+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
+ */
+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
+ */
+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
+ */
+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)
+ */
+let LogLevel = exports.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');
+  }
+}
+const logger = exports.logger = new Logger();
+//# sourceMappingURL=utils.js.map

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

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

package/lib/commonjs/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=index.js.map

package/lib/module/NativeRejourney.js

@@ -0,0 +1,38 @@
+/**
+ * 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 { TurboModuleRegistry } from 'react-native';
+
+/**
+ * SDK telemetry metrics for observability
+ */
+
+/**
+ * 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)
+ */
+
+/**
+ * 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.
+ */
+export default TurboModuleRegistry.get('Rejourney');
+//# sourceMappingURL=NativeRejourney.js.map

package/lib/module/components/Mask.js

@@ -0,0 +1,72 @@
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+/**
+ * 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';
+// Lazy-loaded React Native modules
+let _RN = null;
+function getRN() {
+  if (_RN) return _RN;
+  try {
+    _RN = require('react-native');
+    return _RN;
+  } catch {
+    return null;
+  }
+}
+/**
+ * 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 const Mask = ({
+  children,
+  style,
+  ...props
+}) => {
+  const RN = getRN();
+
+  // If RN isn't loaded yet (shouldn't happen in practice), render children directly
+  if (!RN) {
+    return /*#__PURE__*/React.createElement(React.Fragment, null, children);
+  }
+  const {
+    View,
+    StyleSheet
+  } = RN;
+  const styles = StyleSheet.create({
+    container: {
+      // Minimal container style - doesn't affect layout
+    }
+  });
+  return /*#__PURE__*/React.createElement(View, _extends({}, props, {
+    style: [styles.container, style],
+    accessibilityHint: "rejourney_occlude",
+    collapsable: false
+  }), children);
+};
+export default Mask;
+//# sourceMappingURL=Mask.js.map