react-native-userleap 4.1.0 → 4.2.0

package/android/build.gradle

@@ -85,6 +85,6 @@ dependencies {
     if (findProject(':userleap-android-sdk') != null) {
         implementation project(':userleap-android-sdk')
     } else {
-        implementation ("com.userleap:userleap-android-sdk:2.27.0") // update this version on android updates
+        implementation ("com.userleap:userleap-android-sdk:2.28.0") // update this version on android updates
     }
 }

package/android/src/main/java/com/userleap/reactnative/UserLeapModule.kt

@@ -17,6 +17,7 @@ import com.userleap.SprigSurveyResult
 import com.userleap.SurveyState
 import com.userleap.UserLeap
 import com.userleap.SprigUserInterfaceMode
+import com.userleap.ReplaySessionRecordingFormat
 import org.json.JSONObject
 
 class UserLeapModule(reactContext: ReactApplicationContext) :
@@ -186,6 +187,15 @@ class UserLeapModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    // Android-only: iOS's SDK has no equivalent. `format` is the ReplaySessionRecordingFormat
+    // ordinal value (0 = SCREENSHOT, 1 = WIREFRAME) passed as a Double across the RN bridge.
+    override fun setReplaySessionRecordingFormat(format: Double) {
+        val formatInt = format.toInt()
+        ReplaySessionRecordingFormat.values().firstOrNull { it.value == formatInt }?.let {
+            UserLeap.setReplaySessionRecordingFormat(it)
+        }
+    }
+
     override fun trackEvent(eventName: String, surveyResultCallback: Callback) {
         trackEventAndIdentify(eventName, null, null, surveyResultCallback)
     }

package/index.d.ts

@@ -11,6 +11,14 @@ declare namespace UserLeap {
         dark: number;
     };
 
+    /** Android only — replay session recording formats for {@link setAndroidReplaySessionRecordingFormat}. */
+    const ReplaySessionRecordingFormat: {
+        /** Full-fidelity screenshots (the native default). */
+        screenshot: number;
+        /** Lightweight wireframe of the view hierarchy. */
+        wireframe: number;
+    };
+
     /** Lifecycle event names for {@link addEventListener}. */
     const SprigEventName: {
         sdkReady: "sdkReady";
@@ -90,6 +98,11 @@ declare namespace UserLeap {
     }
 
     function overrideUserInterfaceMode(mode: SprigUserInterfaceMode): void;
+    /**
+     * Android only — selects the replay session recording format. No-op on iOS,
+     * whose native SDK has no equivalent API.
+     */
+    function setAndroidReplaySessionRecordingFormat(format: number): void;
     function visitorIdentifier(): number;
     function visitorIdentifierString(): string;
     function sdkVersion(): string;

package/index.js

@@ -15,6 +15,12 @@ const SprigUserInterfaceMode = {
     dark: 2,
 };
 
+// Android only: iOS's native SDK has no equivalent replay-format API.
+const ReplaySessionRecordingFormat = {
+  screenshot: 0,
+  wireframe: 1,
+};
+
 const SprigEventName = {
   sdkReady: "sdkReady",
   visitorIdUpdated: "visitorIdUpdated",
@@ -361,6 +367,13 @@ const overrideUserInterfaceMode = (mode) => {
   }
 }
 
+// Android only: iOS's native SDK has no equivalent, so this is a no-op on iOS.
+const setAndroidReplaySessionRecordingFormat = (format) => {
+  if (Platform.OS === "android" && isValidPlatform()) {
+    NativeModules.UserLeapBindings.setReplaySessionRecordingFormat(format);
+  }
+};
+
 /**
  * Subscribe to a native SDK lifecycle event. Returns a subscription whose
  * `.remove()` unsubscribes only this listener.
@@ -445,6 +458,7 @@ const UserLeap = {
   pauseDisplayingSurveys,
   unpauseDisplayingSurveys,
   overrideUserInterfaceMode,
+  setAndroidReplaySessionRecordingFormat,
   addEventListener,
   removeAllEventListeners,
   getSupportedEventNames,
@@ -452,6 +466,7 @@ const UserLeap = {
 
 UserLeap.SurveyState = SurveyState;
 UserLeap.SprigUserInterfaceMode = SprigUserInterfaceMode;
+UserLeap.ReplaySessionRecordingFormat = ReplaySessionRecordingFormat;
 UserLeap.SprigEventName = SprigEventName;
 
 export default UserLeap;

package/ios/UserLeapBindings.h

@@ -1,7 +1,8 @@
 #import <UserLeapKit/UserLeapKit.h>
 #import <UserLeapKit/UserLeapKit-Swift.h>
 
+#import <React/RCTInvalidating.h>
 #import <RNUserLeapBindingsSpec/RNUserLeapBindingsSpec.h>
 
-@interface UserLeapBindings : NativeUserLeapBindingsSpecBase <NativeUserLeapBindingsSpec, _SGRNExtractor>
+@interface UserLeapBindings : NativeUserLeapBindingsSpecBase <NativeUserLeapBindingsSpec, _SGRNExtractor, RCTInvalidating>
 @end

package/ios/UserLeapBindings.mm

@@ -1,5 +1,7 @@
 #import "UserLeapBindings.h"
 #import <React/RCTUtils.h>
+#import <ReactCommon/CallInvoker.h>
+#import <os/lock.h>
 // Legacy Paper includes gated on RCT_REMOVE_LEGACY_ARCH: these classes are removed on RN 0.85+.
 #ifndef RCT_REMOVE_LEGACY_ARCH
 #import <React/RCTTextView.h>
@@ -16,7 +18,9 @@
 #import <RNUserLeapBindingsSpec/RNUserLeapBindingsSpec.h>
 
 @implementation UserLeapBindings {
+    os_unfair_lock _lock;   // guards _alive and _jsInvoker (shared_ptr copy isn't atomic); never held across an emit
     BOOL _alive;
+    std::shared_ptr<facebook::react::CallInvoker> _jsInvoker;
 }
 
 + (BOOL)requiresMainQueueSetup
@@ -27,16 +31,25 @@
 - (instancetype)init
 {
     if (self = [super init]) {
+        _lock = OS_UNFAIR_LOCK_INIT;
         _alive = YES;
-        // emitOnSprigEvent is a safe no-op when JS has no listener, so eager subscription is fine.
         [self subscribeToSdkEvents];
     }
     return self;
 }
 
-- (void)dealloc
+// Deterministic teardown hook: stop delivering before the runtime is destroyed.
+- (void)invalidate
 {
+    os_unfair_lock_lock(&_lock);
     _alive = NO;
+    os_unfair_lock_unlock(&_lock);
+    [self unsubscribeFromSdkEvents];
+}
+
+- (void)dealloc
+{
+    // Backstop; -invalidate is the real teardown path.
     [self unsubscribeFromSdkEvents];
 }
 
@@ -177,6 +190,14 @@ RCT_EXPORT_MODULE()
     [[UserLeap shared] overrideUserInterfaceModeWithMode:(enum SprigUserInterfaceMode)(NSInteger)mode];
 }
 
+// Android-only API. iOS's UserLeapKit SDK has no replay recording-format selector,
+// so this is an intentional no-op that satisfies the shared codegen spec. The JS
+// layer guards this call to Android, so it is never invoked on iOS.
+- (void)setReplaySessionRecordingFormat:(double)format
+{
+    // No-op: not supported on iOS.
+}
+
 - (void)trackEvent:(NSString *)eventName
 surveyResultCallback:(RCTResponseSenderBlock)surveyResultCallback
 {
@@ -433,11 +454,26 @@ surveyStateCallback:(RCTResponseSenderBlock)surveyStateCallback
 
         [sdk registerEventListenerFor:eventType listener:^(NSDictionary<NSString *,id> * _Nonnull data) {
             __strong __typeof(weakSelf) strongSelf = weakSelf;
-            // Weak capture + _alive guard: a callback firing during teardown must not touch a dead module.
-            if (!strongSelf || !strongSelf->_alive) return;
+            if (!strongSelf) return;
+
+            // Snapshot liveness + invoker under the lock; bail if torn down.
+            std::shared_ptr<facebook::react::CallInvoker> invoker;
+            os_unfair_lock_lock(&strongSelf->_lock);
+            if (strongSelf->_alive) { invoker = strongSelf->_jsInvoker; }
+            os_unfair_lock_unlock(&strongSelf->_lock);
+            if (!invoker) return;
+
             NSDictionary *payload = [strongSelf normalizePayloadForEvent:name data:data];
             NSString *json = [strongSelf jsonStringFromDictionary:payload];
-            [strongSelf emitOnSprigEvent:@{@"name": name, @"json": json}];
+
+            // Emit on the JS thread so it can't race runtime teardown; dropped if already invalidated.
+            invoker->invokeAsync([strongSelf, name, json]() {
+                os_unfair_lock_lock(&strongSelf->_lock);
+                BOOL alive = strongSelf->_alive;
+                os_unfair_lock_unlock(&strongSelf->_lock);
+                if (!alive) return;
+                [strongSelf emitOnSprigEvent:@{@"name": name, @"json": json}];
+            });
         }];
     }
 }
@@ -453,6 +489,10 @@ surveyStateCallback:(RCTResponseSenderBlock)surveyStateCallback
 
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params
 {
+    // Capture the JS CallInvoker so event callbacks can marshal emits onto the JS thread.
+    os_unfair_lock_lock(&_lock);
+    _jsInvoker = params.jsInvoker;
+    os_unfair_lock_unlock(&_lock);
     return std::make_shared<facebook::react::NativeUserLeapBindingsSpecJSI>(params);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-userleap",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "description": "React Native module for UserLeap",
   "main": "index.js",
   "types": "index.d.ts",

package/react-native-userleap.podspec

@@ -18,7 +18,7 @@ Pod::Spec.new do |s|
   s.source_files = "ios/**/*.{h,c,m,mm,swift}"
   s.requires_arc = true
 
-  s.dependency "UserLeapKit", "4.33.0"
+  s.dependency "UserLeapKit", "4.34.0"
 
   # New Architecture: wires up the React-Codegen dependency and header search
   # paths so the generated RNUserLeapBindingsSpec (Obj-C++) resolves.

package/src/NativeUserLeapBindings.ts

@@ -50,6 +50,13 @@ export interface Spec extends TurboModule {
   ): void;
   overrideUserInterfaceMode(mode: number): void;
 
+  /**
+   * Android only. Selects the replay session recording format
+   * (0 = SCREENSHOT, 1 = WIREFRAME). No-op on iOS, whose native SDK has no
+   * equivalent API; the JS layer guards this call to Android.
+   */
+  setReplaySessionRecordingFormat(format: number): void;
+
   trackEvent(
     eventName: string,
     surveyResultCallback: (result: SurveyResult) => void,