@rejourneyco/react-native 1.0.9 → 1.0.10

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

@@ -25,6 +25,8 @@ export interface RejourneyConfig {
     maxStorageSize?: number;
     /** Enable automatic screen name detection with React Navigation (default: true) */
     autoScreenTracking?: boolean;
+    /** Enable automatic screen name detection with Expo Router (default: true) */
+    autoTrackExpoRouter?: boolean;
     /** Enable automatic gesture detection (default: true) */
     autoGestureTracking?: boolean;
     /** Enable privacy occlusion for text inputs (default: true) */
@@ -433,7 +435,17 @@ export interface RejourneyNativeModule {
 export interface RejourneyAPI {
     /** SDK version */
     readonly version: string;
-    /** Internal method to start recording session (called by startRejourney) */
+    /**
+     * Initialize Rejourney SDK
+     * @param publicRouteKey - Your public route key from the Rejourney dashboard
+     * @param options - Optional configuration options
+     */
+    init(publicRouteKey: string, options?: Omit<RejourneyConfig, 'publicRouteKey'>): void;
+    /** Start recording (call after user consent) */
+    start(): void;
+    /** Stop recording */
+    stop(): void;
+    /** Internal method to start recording session (called by start() / startRejourney()) */
     _startSession(): Promise<boolean>;
     /** Internal method to stop recording session (called by stopRejourney) */
     _stopSession(): Promise<void>;
@@ -443,8 +455,18 @@ export interface RejourneyAPI {
     setUserIdentity(userId: string): void;
     /** Clear user identity */
     clearUserIdentity(): void;
-    /** Tag current screen */
-    tagScreen(screenName: string, params?: Record<string, unknown>): void;
+    /**
+     * Set custom session metadata.
+     * Can be called with a single key-value pair or an object of properties.
+     * Useful for filtering sessions later (e.g., plan: 'premium', role: 'admin').
+     * Caps at 100 properties per session.
+     *
+     * @param keyOrProperties Property name string, or an object containing key-value pairs
+     * @param value Property value (if first argument is a string)
+     */
+    setMetadata(keyOrProperties: string | Record<string, string | number | boolean>, value?: string | number | boolean): void;
+    /** Track current screen (manual) */
+    trackScreen(screenName: string, params?: Record<string, unknown>): void;
     /** Mark a view as sensitive (will be occluded in recording) */
     setOccluded(viewRef: {
         current: any;
@@ -540,6 +562,21 @@ export interface RejourneyAPI {
      * @param nativeID - The nativeID prop of the view to unmask
      */
     unmaskView(nativeID: string): void;
+    /**
+     * Hook for automatic React Navigation tracking.
+     * Pass the returned object to your NavigationContainer props.
+     *
+     * @example
+     * ```tsx
+     * const navigationTracking = Rejourney.useNavigationTracking();
+     * <NavigationContainer {...navigationTracking}>
+     * ```
+     */
+    useNavigationTracking(): {
+        ref: any;
+        onReady: () => void;
+        onStateChange: (state: any) => void;
+    };
 }
 /**
  * SDK telemetry metrics for observability
@@ -607,6 +644,8 @@ export interface UseRejourneyResult {
     stopRecording: () => Promise<void>;
     /** Log custom event */
     logEvent: (name: string, properties?: Record<string, unknown>) => void;
+    /** Set custom session metadata */
+    setMetadata: (keyOrProperties: string | Record<string, string | number | boolean>, value?: string | number | boolean) => void;
     /** Error if any */
     error: Error | null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rejourneyco/react-native",
-    "version": "1.0.9",
+    "version": "1.0.10",
     "description": "Rejourney Session Recording SDK for React Native",
     "main": "lib/commonjs/index.js",
     "module": "lib/module/index.js",
@@ -92,6 +92,26 @@
         "@react-navigation/native": ">=6.0.0",
         "expo-router": ">=3.0.0"
     },
+    "peerDependenciesMeta": {
+        "expo-router": {
+            "optional": true
+        }
+    },
+    "exports": {
+        ".": {
+            "types": "./lib/typescript/index.d.ts",
+            "react-native": "./lib/module/index.js",
+            "import": "./lib/module/index.js",
+            "require": "./lib/commonjs/index.js"
+        },
+        "./expo-router": {
+            "types": "./lib/typescript/expoRouterTracking.d.ts",
+            "react-native": "./lib/module/expoRouterTracking.js",
+            "import": "./lib/module/expoRouterTracking.js",
+            "require": "./lib/commonjs/expoRouterTracking.js",
+            "default": "./lib/module/expoRouterTracking.js"
+        }
+    },
     "codegenConfig": {
         "name": "RejourneySpec",
         "type": "modules",
@@ -119,4 +139,4 @@
             ]
         ]
     }
-}
+}

package/src/expoRouterTracking.ts

@@ -0,0 +1,167 @@
+/**
+ * Optional Expo Router integration for @rejourneyco/react-native
+ *
+ * This file is only loaded when you import '@rejourneyco/react-native/expo-router'.
+ * It contains require('expo-router') and related subpaths. Metro bundles require()
+ * at build time, so keeping this in a separate entry ensures apps that use
+ * Expo with react-navigation (without expo-router) never pull in expo-router
+ * and avoid "Requiring unknown module" crashes.
+ *
+ * If you use expo-router, add this once (e.g. in your root _layout.tsx):
+ *   import '@rejourneyco/react-native/expo-router';
+ */
+
+import { trackScreen, setExpoRouterPollingInterval, isExpoRouterTrackingEnabled } from './sdk/autoTracking';
+import { normalizeScreenName, getScreenNameFromPath } from './sdk/navigation';
+
+const MAX_POLLING_ERRORS = 10;
+
+function extractScreenNameFromRouterState(
+  state: any,
+  getScreenNameFromPathFn: (path: string, segments: string[]) => string,
+  normalizeScreenNameFn: (name: string) => string,
+  accumulatedSegments: string[] = []
+): string | null {
+  if (!state?.routes) return null;
+
+  const route = state.routes[state.index ?? state.routes.length - 1];
+  if (!route) return null;
+
+  const newSegments = [...accumulatedSegments, route.name];
+
+  if (route.state) {
+    return extractScreenNameFromRouterState(
+      route.state,
+      getScreenNameFromPathFn,
+      normalizeScreenNameFn,
+      newSegments
+    );
+  }
+
+  const cleanSegments = newSegments.filter((s) => !s.startsWith('(') && !s.endsWith(')'));
+
+  if (cleanSegments.length === 0) {
+    for (let i = newSegments.length - 1; i >= 0; i--) {
+      const seg = newSegments[i];
+      if (seg && !seg.startsWith('(') && !seg.endsWith(')')) {
+        cleanSegments.push(seg);
+        break;
+      }
+    }
+  }
+
+  const pathname = '/' + cleanSegments.join('/');
+  return getScreenNameFromPathFn(pathname, newSegments);
+}
+
+function setupExpoRouterPolling(): void {
+  let lastDetectedScreen = '';
+  let pollingErrors = 0;
+
+  try {
+    const EXPO_ROUTER = 'expo-router';
+    const expoRouter = require(EXPO_ROUTER);
+    const router = expoRouter.router;
+
+    if (!router) {
+      if (typeof __DEV__ !== 'undefined' && __DEV__) {
+        console.debug('[Rejourney] Expo Router: router object not found');
+      }
+      return;
+    }
+
+    const intervalId = setInterval(() => {
+      try {
+        let state: any = null;
+        if (typeof router.getState === 'function') {
+          state = router.getState();
+        } else if ((router as any).rootState) {
+          state = (router as any).rootState;
+        }
+
+        if (!state) {
+          try {
+            const STORE_PATH = 'expo-router/build/global-state/router-store';
+            const storeModule = require(STORE_PATH);
+            if (storeModule?.store) {
+              state = storeModule.store.state;
+              if (!state && storeModule.store.navigationRef?.current) {
+                state = storeModule.store.navigationRef.current.getRootState?.();
+              }
+              if (!state) {
+                state = storeModule.store.rootState || storeModule.store.initialState;
+              }
+            }
+          } catch {
+            // Ignore
+          }
+        }
+
+        if (!state) {
+          try {
+            const IMPERATIVE_PATH = 'expo-router/build/imperative-api';
+            const imperative = require(IMPERATIVE_PATH);
+            if (imperative?.router) {
+              state = imperative.router.getState?.();
+            }
+          } catch {
+            // Ignore
+          }
+        }
+
+        if (state) {
+          pollingErrors = 0;
+          const screenName = extractScreenNameFromRouterState(
+            state,
+            getScreenNameFromPath,
+            normalizeScreenName
+          );
+          if (screenName && screenName !== lastDetectedScreen) {
+            lastDetectedScreen = screenName;
+            trackScreen(screenName);
+          }
+        } else {
+          pollingErrors++;
+          if (pollingErrors >= MAX_POLLING_ERRORS) {
+            clearInterval(intervalId);
+            setExpoRouterPollingInterval(null);
+          }
+        }
+      } catch {
+        pollingErrors++;
+        if (pollingErrors >= MAX_POLLING_ERRORS) {
+          clearInterval(intervalId);
+          setExpoRouterPollingInterval(null);
+        }
+      }
+    }, 500);
+
+    setExpoRouterPollingInterval(intervalId);
+  } catch (e) {
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.debug('[Rejourney] Expo Router not available:', e);
+    }
+  }
+}
+
+let attempts = 0;
+const maxAttempts = 5;
+
+function trySetup(): void {
+  attempts++;
+  try {
+    const EXPO_ROUTER = 'expo-router';
+    const expoRouter = require(EXPO_ROUTER);
+    if (expoRouter?.router && isExpoRouterTrackingEnabled()) {
+      setupExpoRouterPolling();
+      return;
+    }
+  } catch {
+    // Not ready or not installed
+  }
+  if (attempts < maxAttempts) {
+    setTimeout(trySetup, 200 * attempts);
+  }
+}
+
+setTimeout(trySetup, 200);

package/src/index.ts

@@ -171,6 +171,7 @@ let _autoTracking: {
   resetMetrics: typeof import('./sdk/autoTracking').resetMetrics;
   collectDeviceInfo: typeof import('./sdk/autoTracking').collectDeviceInfo;
   ensurePersistentAnonymousId: typeof import('./sdk/autoTracking').ensurePersistentAnonymousId;
+  useNavigationTracking: typeof import('./sdk/autoTracking').useNavigationTracking;
 } | null = null;
 
 // No-op auto tracking for when SDK is disabled
@@ -185,6 +186,7 @@ const noopAutoTracking = {
   resetMetrics: () => { },
   collectDeviceInfo: async () => ({} as any),
   ensurePersistentAnonymousId: async () => 'anonymous',
+  useNavigationTracking: () => ({ ref: null, onReady: () => { }, onStateChange: () => { } }),
 };
 
 function getAutoTracking() {
@@ -209,6 +211,11 @@ let _appStateSubscription: { remove: () => void } | null = null;
 let _authErrorSubscription: { remove: () => void } | null = null;
 let _currentAppState: string = 'active'; // Default to active, will be updated on init
 let _userIdentity: string | null = null;
+let _backgroundEntryTime: number | null = null; // Track when app went to background
+let _storedMetadata: Record<string, string | number | boolean> = {}; // Accumulate metadata for session rollover
+
+// Session timeout - must match native side (60 seconds)
+const SESSION_TIMEOUT_MS = 60_000;
 
 // Scroll throttling - reduce native bridge calls from 60fps to at most 10/sec
 let _lastScrollTime: number = 0;
@@ -481,7 +488,7 @@ function safeNativeCallSync<T>(
 /**
  * Main Rejourney API (Internal)
  */
-const Rejourney: RejourneyAPI = {
+export const Rejourney: RejourneyAPI = {
   /**
    * SDK Version
    */
@@ -637,6 +644,7 @@ const Rejourney: RejourneyAPI = {
           trackReactNativeErrors: true,
           trackConsoleLogs: _storedConfig?.trackConsoleLogs ?? true,
           collectDeviceInfo: _storedConfig?.collectDeviceInfo !== false,
+          autoTrackExpoRouter: _storedConfig?.autoTrackExpoRouter !== false,
         },
         {
           // Rage tap callback - log as frustration event
@@ -680,6 +688,8 @@ const Rejourney: RejourneyAPI = {
             '/api/ingest/presign',
             '/api/ingest/batch/complete',
             '/api/ingest/session/end',
+            '/api/ingest/segment/presign',
+            '/api/ingest/segment/complete',
             ...(_storedConfig?.networkIgnoreUrls || []),
           ];
 
@@ -806,22 +816,56 @@ const Rejourney: RejourneyAPI = {
   },
 
   /**
-   * Tag the current screen
+  /**
+   * Set custom session metadata.
+   * Can be called with a single key-value pair or an object of properties.
+   * Useful for filtering sessions later (e.g., plan: 'premium', role: 'admin').
+   * Caps at 100 properties per session.
+   * 
+   * @param keyOrProperties Property name string, or an object containing key-value pairs
+   * @param value Property value (if first argument is a string)
+   */
+  setMetadata(keyOrProperties: string | Record<string, string | number | boolean>, value?: string | number | boolean): void {
+    if (typeof keyOrProperties === 'string') {
+      const key = keyOrProperties;
+      if (!key) {
+        getLogger().warn('setMetadata requires a non-empty string key');
+        return;
+      }
+      if (value !== undefined && typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean') {
+        getLogger().warn('setMetadata value must be a string, number, or boolean when using a key string');
+        return;
+      }
+      this.logEvent('$user_property', { key, value });
+      // Track for session rollover restoration
+      _storedMetadata[key] = value!;
+    } else if (keyOrProperties && typeof keyOrProperties === 'object') {
+      const properties = keyOrProperties;
+      const validProps: Record<string, any> = {};
+      for (const [k, v] of Object.entries(properties)) {
+        if (typeof k === 'string' && k &&
+          (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean')) {
+          validProps[k] = v;
+        }
+      }
+      if (Object.keys(validProps).length > 0) {
+        this.logEvent('$user_property', validProps);
+        // Track for session rollover restoration
+        Object.assign(_storedMetadata, validProps);
+      }
+    } else {
+      getLogger().warn('setMetadata requires a string key and value, or a properties object');
+    }
+  },
+
+  /**
+   * Track current screen (manual)
    * 
    * @param screenName - Screen name
    * @param params - Optional screen parameters
    */
-  tagScreen(screenName: string, _params?: Record<string, unknown>): void {
+  trackScreen(screenName: string, _params?: Record<string, unknown>): void {
     getAutoTracking().trackScreen(screenName);
-    getAutoTracking().notifyStateChange();
-
-    safeNativeCallSync(
-      'tagScreen',
-      () => {
-        getRejourneyNative()!.screenChanged(screenName).catch(() => { });
-      },
-      undefined
-    );
   },
 
   /**
@@ -1271,12 +1315,121 @@ const Rejourney: RejourneyAPI = {
       undefined
     );
   },
+
+  /**
+   * Initialize Rejourney SDK
+   */
+  init(publicRouteKey: string, options?: Omit<RejourneyConfig, 'publicRouteKey'>): void {
+    initRejourney(publicRouteKey, options);
+  },
+
+  /**
+   * Start recording
+   */
+  start(): void {
+    startRejourney();
+  },
+
+  /**
+   * Stop recording
+   */
+  stop(): void {
+    stopRejourney();
+  },
+
+  /**
+   * Hook for automatic React Navigation tracking.
+   */
+  useNavigationTracking() {
+    return getAutoTracking().useNavigationTracking();
+  },
 };
 
+/**
+ * Reinitialize JS-side auto-tracking for a new session after background timeout.
+ *
+ * When the app was in background for >60s the native layer rolls over to a
+ * fresh session automatically.  The JS side must tear down stale tracking
+ * state (metrics, console-log counter, screen history, error handlers) and
+ * re-initialize so that trackScreen, logEvent, setMetadata, etc. work
+ * correctly against the new native session.
+ */
+function _reinitAutoTrackingForNewSession(): void {
+  try {
+    // 1. Tear down old session's auto-tracking state
+    getAutoTracking().cleanupAutoTracking();
+
+    // 2. Re-initialize auto-tracking with the same config
+    getAutoTracking().initAutoTracking(
+      {
+        rageTapThreshold: _storedConfig?.rageTapThreshold ?? 3,
+        rageTapTimeWindow: _storedConfig?.rageTapTimeWindow ?? 500,
+        rageTapRadius: 50,
+        trackJSErrors: true,
+        trackPromiseRejections: true,
+        trackReactNativeErrors: true,
+        trackConsoleLogs: _storedConfig?.trackConsoleLogs ?? true,
+        collectDeviceInfo: _storedConfig?.collectDeviceInfo !== false,
+        autoTrackExpoRouter: _storedConfig?.autoTrackExpoRouter !== false,
+      },
+      {
+        onRageTap: (count: number, x: number, y: number) => {
+          Rejourney.logEvent('frustration', {
+            frustrationKind: 'rage_tap',
+            tapCount: count,
+            x,
+            y,
+          });
+          getLogger().logFrustration(`Rage tap (${count} taps)`);
+        },
+        onError: (error: { message: string; stack?: string; name?: string }) => {
+          getLogger().logError(error.message);
+        },
+        onScreen: (_screenName: string, _previousScreen?: string) => {
+        },
+      }
+    );
+
+    // 3. Re-collect device info for the new session
+    if (_storedConfig?.collectDeviceInfo !== false) {
+      getAutoTracking().collectDeviceInfo().then((deviceInfo) => {
+        Rejourney.logEvent('device_info', deviceInfo as unknown as Record<string, unknown>);
+      }).catch(() => { });
+    }
+
+    // 4. Re-send user identity to the new native session
+    if (_userIdentity) {
+      safeNativeCallSync(
+        'setUserIdentity',
+        () => {
+          getRejourneyNative()!.setUserIdentity(_userIdentity!).catch(() => { });
+        },
+        undefined
+      );
+      getLogger().debug(`Restored user identity '${_userIdentity}' to new session`);
+    }
+
+    // 5. Re-send any stored metadata to the new native session
+    if (Object.keys(_storedMetadata).length > 0) {
+      for (const [key, value] of Object.entries(_storedMetadata)) {
+        if (value !== undefined && value !== null) {
+          Rejourney.setMetadata(key, value);
+        }
+      }
+      getLogger().debug('Restored metadata to new session');
+    }
+
+    getLogger().logLifecycleEvent('JS auto-tracking reinitialized for new session');
+  } catch (error) {
+    getLogger().warn('Failed to reinitialize auto-tracking after session rollover:', error);
+  }
+}
+
 /**
  * Handle app state changes for automatic session management
  * - Pauses recording when app goes to background
  * - Resumes recording when app comes back to foreground
+ * - Reinitializes JS-side auto-tracking when native rolls over to a new session
  * - Cleans up properly when app is terminated
  */
 function handleAppStateChange(nextAppState: string): void {
@@ -1286,9 +1439,24 @@ function handleAppStateChange(nextAppState: string): void {
     if (_currentAppState.match(/active/) && nextAppState === 'background') {
       // App going to background - native module handles this automatically
       getLogger().logLifecycleEvent('App moving to background');
+      _backgroundEntryTime = Date.now();
     } else if (_currentAppState.match(/inactive|background/) && nextAppState === 'active') {
       // App coming back to foreground
       getLogger().logLifecycleEvent('App returning to foreground');
+
+      // Check if we exceeded the session timeout (60s).
+      // Native side will have already ended the old session and started a new
+      // one — we need to reset JS-side auto-tracking state to match.
+      if (_backgroundEntryTime && _isRecording) {
+        const backgroundDurationMs = Date.now() - _backgroundEntryTime;
+        if (backgroundDurationMs > SESSION_TIMEOUT_MS) {
+          getLogger().debug(
+            `Session rollover: background ${Math.round(backgroundDurationMs / 1000)}s > ${SESSION_TIMEOUT_MS / 1000}s timeout`
+          );
+          _reinitAutoTrackingForNewSession();
+        }
+      }
+      _backgroundEntryTime = null;
     }
     _currentAppState = nextAppState;
   } catch (error) {
@@ -1371,8 +1539,10 @@ function setupAuthErrorListener(): void {
         }
       );
     }
-  } catch (error) {
-    getLogger().debug('Auth error listener not available:', error);
+  } catch {
+    // Expected on some architectures where NativeEventEmitter isn't fully supported.
+    // Auth errors are still handled synchronously via native callback — this listener
+    // is purely supplementary. No need to log.
   }
 }
 
@@ -1518,7 +1688,6 @@ export function stopRejourney(): void {
     getLogger().warn('Error stopping Rejourney:', error);
   }
 }
-
 export default Rejourney;
 
 export * from './types';
@@ -1528,7 +1697,6 @@ export {
   trackScroll,
   trackGesture,
   trackInput,
-  trackScreen,
   captureError,
   getSessionMetrics,
 } from './sdk/autoTracking';