@rejourneyco/react-native 1.0.9 → 1.0.10

package/ios/Utility/DataCompression.swift

@@ -26,8 +26,8 @@ extension Data {
             stream.avail_in = uint(self.count)
             stream.total_out = 0
             
-            // MAX_WBITS + 16 = gzip format
-            if deflateInit2_(&stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED, MAX_WBITS + 16, 8, Z_DEFAULT_STRATEGY, ZLIB_VERSION, Int32(MemoryLayout<z_stream>.size)) != Z_OK {
+            // MAX_WBITS + 16 = gzip format; level 9 for best ratio (smaller S3 payloads)
+            if deflateInit2_(&stream, 9, Z_DEFLATED, MAX_WBITS + 16, 8, Z_DEFAULT_STRATEGY, ZLIB_VERSION, Int32(MemoryLayout<z_stream>.size)) != Z_OK {
                 return nil
             }
             

package/lib/commonjs/expoRouterTracking.js

@@ -0,0 +1,137 @@
+"use strict";
+
+var _autoTracking = require("./sdk/autoTracking");
+var _navigation = require("./sdk/navigation");
+/**
+ * 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';
+ */
+
+const MAX_POLLING_ERRORS = 10;
+function extractScreenNameFromRouterState(state, getScreenNameFromPathFn, normalizeScreenNameFn, accumulatedSegments = []) {
+  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() {
+  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 = null;
+        if (typeof router.getState === 'function') {
+          state = router.getState();
+        } else if (router.rootState) {
+          state = router.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, _navigation.getScreenNameFromPath, _navigation.normalizeScreenName);
+          if (screenName && screenName !== lastDetectedScreen) {
+            lastDetectedScreen = screenName;
+            (0, _autoTracking.trackScreen)(screenName);
+          }
+        } else {
+          pollingErrors++;
+          if (pollingErrors >= MAX_POLLING_ERRORS) {
+            clearInterval(intervalId);
+            (0, _autoTracking.setExpoRouterPollingInterval)(null);
+          }
+        }
+      } catch {
+        pollingErrors++;
+        if (pollingErrors >= MAX_POLLING_ERRORS) {
+          clearInterval(intervalId);
+          (0, _autoTracking.setExpoRouterPollingInterval)(null);
+        }
+      }
+    }, 500);
+    (0, _autoTracking.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() {
+  attempts++;
+  try {
+    const EXPO_ROUTER = 'expo-router';
+    const expoRouter = require(EXPO_ROUTER);
+    if (expoRouter?.router && (0, _autoTracking.isExpoRouterTrackingEnabled)()) {
+      setupExpoRouterPolling();
+      return;
+    }
+  } catch {
+    // Not ready or not installed
+  }
+  if (attempts < maxAttempts) {
+    setTimeout(trySetup, 200 * attempts);
+  }
+}
+setTimeout(trySetup, 200);
+//# sourceMappingURL=expoRouterTracking.js.map

package/lib/commonjs/index.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 var _exportNames = {
+  Rejourney: true,
   initRejourney: true,
   startRejourney: true,
   stopRejourney: true,
@@ -12,7 +13,6 @@ var _exportNames = {
   trackScroll: true,
   trackGesture: true,
   trackInput: true,
-  trackScreen: true,
   captureError: true,
   getSessionMetrics: true,
   trackNavigationState: true,
@@ -32,6 +32,7 @@ Object.defineProperty(exports, "Mask", {
     return _Mask.Mask;
   }
 });
+exports.Rejourney = void 0;
 Object.defineProperty(exports, "captureError", {
   enumerable: true,
   get: function () {
@@ -67,12 +68,6 @@ Object.defineProperty(exports, "trackNavigationState", {
     return _autoTracking2.trackNavigationState;
   }
 });
-Object.defineProperty(exports, "trackScreen", {
-  enumerable: true,
-  get: function () {
-    return _autoTracking2.trackScreen;
-  }
-});
 Object.defineProperty(exports, "trackScroll", {
   enumerable: true,
   get: function () {
@@ -268,7 +263,12 @@ const noopAutoTracking = {
   getSessionMetrics: () => ({}),
   resetMetrics: () => {},
   collectDeviceInfo: async () => ({}),
-  ensurePersistentAnonymousId: async () => 'anonymous'
+  ensurePersistentAnonymousId: async () => 'anonymous',
+  useNavigationTracking: () => ({
+    ref: null,
+    onReady: () => {},
+    onStateChange: () => {}
+  })
 };
 function getAutoTracking() {
   if (_sdkDisabled) return noopAutoTracking;
@@ -291,6 +291,11 @@ let _appStateSubscription = null;
 let _authErrorSubscription = null;
 let _currentAppState = 'active'; // Default to active, will be updated on init
 let _userIdentity = null;
+let _backgroundEntryTime = null; // Track when app went to background
+let _storedMetadata = {}; // 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 = 0;
@@ -545,7 +550,7 @@ function safeNativeCallSync(methodName, fn, defaultValue) {
 /**
  * Main Rejourney API (Internal)
  */
-const Rejourney = {
+const Rejourney = exports.Rejourney = {
   /**
    * SDK Version
    */
@@ -681,7 +686,8 @@ const Rejourney = {
         trackPromiseRejections: true,
         trackReactNativeErrors: true,
         trackConsoleLogs: _storedConfig?.trackConsoleLogs ?? true,
-        collectDeviceInfo: _storedConfig?.collectDeviceInfo !== false
+        collectDeviceInfo: _storedConfig?.collectDeviceInfo !== false,
+        autoTrackExpoRouter: _storedConfig?.autoTrackExpoRouter !== false
       }, {
         // Rage tap callback - log as frustration event
         onRageTap: (count, x, y) => {
@@ -714,7 +720,7 @@ const Rejourney = {
           // RejourneyNetworkInterceptor on Android) are supplementary — they capture
           // native-originated HTTP calls that bypass JS fetch(), but cannot intercept
           // RN's own networking since it creates its NSURLSession/OkHttpClient at init time.
-          const ignoreUrls = [apiUrl, '/api/sdk/config', '/api/ingest/presign', '/api/ingest/batch/complete', '/api/ingest/session/end', ...(_storedConfig?.networkIgnoreUrls || [])];
+          const ignoreUrls = [apiUrl, '/api/sdk/config', '/api/ingest/presign', '/api/ingest/batch/complete', '/api/ingest/session/end', '/api/ingest/segment/presign', '/api/ingest/segment/complete', ...(_storedConfig?.networkIgnoreUrls || [])];
           getNetworkInterceptor().initNetworkInterceptor(request => {
             getAutoTracking().trackAPIRequest(request.success || false, request.statusCode, request.duration || 0, request.responseBodySize || 0);
             Rejourney.logNetworkRequest(request);
@@ -803,17 +809,57 @@ const Rejourney = {
     }
   },
   /**
-   * 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, value) {
+    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 = {};
+      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, _params) {
+  trackScreen(screenName, _params) {
     getAutoTracking().trackScreen(screenName);
-    getAutoTracking().notifyStateChange();
-    safeNativeCallSync('tagScreen', () => {
-      getRejourneyNative().screenChanged(screenName).catch(() => {});
-    }, undefined);
   },
   /**
    * Mark a view as sensitive (will be occluded in recordings)
@@ -1202,13 +1248,109 @@ const Rejourney = {
     safeNativeCallSync('unmaskView', () => {
       getRejourneyNative().unmaskViewByNativeID(nativeID).catch(() => {});
     }, undefined);
+  },
+  /**
+   * Initialize Rejourney SDK
+   */
+  init(publicRouteKey, options) {
+    initRejourney(publicRouteKey, options);
+  },
+  /**
+   * Start recording
+   */
+  start() {
+    startRejourney();
+  },
+  /**
+   * Stop recording
+   */
+  stop() {
+    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() {
+  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, x, y) => {
+        Rejourney.logEvent('frustration', {
+          frustrationKind: 'rage_tap',
+          tapCount: count,
+          x,
+          y
+        });
+        getLogger().logFrustration(`Rage tap (${count} taps)`);
+      },
+      onError: error => {
+        getLogger().logError(error.message);
+      },
+      onScreen: (_screenName, _previousScreen) => {}
+    });
+
+    // 3. Re-collect device info for the new session
+    if (_storedConfig?.collectDeviceInfo !== false) {
+      getAutoTracking().collectDeviceInfo().then(deviceInfo => {
+        Rejourney.logEvent('device_info', deviceInfo);
+      }).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) {
@@ -1217,9 +1359,22 @@ function handleAppStateChange(nextAppState) {
     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) {
@@ -1284,8 +1439,10 @@ function setupAuthErrorListener() {
         }
       });
     }
-  } 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.
   }
 }