react-native-userleap 4.0.0 → 4.1.1

package/index.js

@@ -1,4 +1,4 @@
-import { Platform, NativeModules } from "react-native";
+import { Platform, NativeModules, TurboModuleRegistry } from "react-native";
 
 import { version } from "./package.json";
 
@@ -15,6 +15,100 @@ const SprigUserInterfaceMode = {
     dark: 2,
 };
 
+const SprigEventName = {
+  sdkReady: "sdkReady",
+  visitorIdUpdated: "visitorIdUpdated",
+  surveyHeight: "surveyHeight",
+  surveyStateReturned: "surveyStateReturned",
+  surveyWillPresent: "surveyWillPresent",
+  surveyPresented: "surveyPresented",
+  surveyAppeared: "surveyAppeared",
+  questionAnswered: "questionAnswered",
+  surveyCloseRequested: "surveyCloseRequested",
+  surveyWillClose: "surveyWillClose",
+  surveyClosed: "surveyClosed",
+  surveyCompleted: "surveyCompleted",
+  replayCapture: "replayCapture",
+  replayCaptureStarted: "replayCaptureStarted",
+  replayCaptureStopped: "replayCaptureStopped",
+  replayCaptureCompleted: "replayCaptureCompleted",
+  replayRenderingCompleted: "replayRenderingCompleted",
+  replayUploadCompleted: "replayUploadCompleted",
+  replayEventsUploadCompleted: "replayEventsUploadCompleted",
+  loggingEvent: "loggingEvent",
+};
+
+// Resolved lazily; needed for the onSprigEvent channel (a JSI EventEmitter the legacy NativeModules interop doesn't expose).
+let _module = null;
+const getModule = () => {
+  if (_module) return _module;
+  _module =
+    (TurboModuleRegistry && TurboModuleRegistry.get
+      ? TurboModuleRegistry.get("UserLeapBindings")
+      : null) ||
+    NativeModules.UserLeapBindings ||
+    null;
+  return _module;
+};
+
+// All native events arrive on one onSprigEvent channel as a {name,json} JSON-string envelope
+// (payloads are heterogeneous); we subscribe once and fan out to per-event listeners.
+const _listenersByEvent = new Map();
+let _channelSub = null;
+
+const ensureChannelSubscribed = () => {
+  if (_channelSub) return;
+  const mod = getModule();
+  if (!mod || typeof mod.onSprigEvent !== "function") return;
+  _channelSub = mod.onSprigEvent((envelope) => {
+    if (!envelope || !envelope.name) return;
+    const set = _listenersByEvent.get(envelope.name);
+    if (!set || set.size === 0) return;
+
+    let payload;
+    try {
+      payload = envelope.json ? JSON.parse(envelope.json) : {};
+    } catch (e) {
+      payload = {};
+    }
+    if (payload && typeof payload === "object") {
+      payload.type = envelope.name;
+    }
+
+    // Copy so a listener (un)subscribing during dispatch can't mutate the set we're walking.
+    for (const cb of Array.from(set)) {
+      try {
+        cb(payload);
+      } catch (err) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.warn(
+            '[Sprig] listener for "' + envelope.name + '" threw:',
+            err
+          );
+        }
+      }
+    }
+  });
+};
+
+const NOOP_SUBSCRIPTION = { remove: () => {} };
+
+let _supportedEventNamesCache = null;
+const getSupportedEventNames = () => {
+  if (_supportedEventNamesCache !== null) return _supportedEventNamesCache;
+  if (!isValidPlatform()) {
+    _supportedEventNamesCache = [];
+    return _supportedEventNamesCache;
+  }
+  try {
+    const result = NativeModules.UserLeapBindings.getSupportedEventNames();
+    _supportedEventNamesCache = Array.isArray(result) ? result : [];
+  } catch (err) {
+    _supportedEventNamesCache = [];
+  }
+  return _supportedEventNamesCache;
+};
+
 
 const stringifyAttributes = (attributes) => {
   if (!(attributes instanceof Object && attributes.constructor === Object))
@@ -42,11 +136,7 @@ const visitorIdentifier = () => {
 };
 
 const sdkVersion = () => {
-  if (Platform.OS === "ios") {
-    if (String(Platform.Version) >= "15.0") {
-      return NativeModules.UserLeapBindings.sdkVersion();
-    }
-  } else {
+  if (isValidPlatform()) {
     return NativeModules.UserLeapBindings.getSdkVersion();
   }
   return "0.0.0";
@@ -271,6 +361,63 @@ const overrideUserInterfaceMode = (mode) => {
   }
 }
 
+/**
+ * Subscribe to a native SDK lifecycle event. Returns a subscription whose
+ * `.remove()` unsubscribes only this listener.
+ * @param {string} eventName
+ * @param {(data: object) => void} callback
+ * @returns {{ remove: () => void }} subscription
+ */
+const addEventListener = (eventName, callback) => {
+  if (!isValidPlatform()) return NOOP_SUBSCRIPTION;
+
+  const supported = getSupportedEventNames();
+  if (supported.length > 0 && !supported.includes(eventName)) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.warn(
+        '[Sprig] "' + eventName +
+        '" is not emitted on this platform (' +
+        Platform.OS + '); subscription is a no-op.'
+      );
+    }
+    return NOOP_SUBSCRIPTION;
+  }
+
+  ensureChannelSubscribed();
+
+  let set = _listenersByEvent.get(eventName);
+  if (!set) {
+    set = new Set();
+    _listenersByEvent.set(eventName, set);
+  }
+  set.add(callback);
+
+  let removed = false;
+  return {
+    remove: () => {
+      if (removed) return;
+      removed = true;
+      const s = _listenersByEvent.get(eventName);
+      if (s) {
+        s.delete(callback);
+        if (s.size === 0) _listenersByEvent.delete(eventName);
+      }
+    },
+  };
+};
+
+/**
+ * Remove every listener for the given event name, or all listeners if no name is given.
+ * @param {string} [eventName]
+ */
+const removeAllEventListeners = (eventName) => {
+  if (eventName) {
+    _listenersByEvent.delete(eventName);
+    return;
+  }
+  _listenersByEvent.clear();
+};
+
 
 const UserLeap = {
   visitorIdentifier,
@@ -298,9 +445,13 @@ const UserLeap = {
   pauseDisplayingSurveys,
   unpauseDisplayingSurveys,
   overrideUserInterfaceMode,
+  addEventListener,
+  removeAllEventListeners,
+  getSupportedEventNames,
 };
 
 UserLeap.SurveyState = SurveyState;
 UserLeap.SprigUserInterfaceMode = SprigUserInterfaceMode;
+UserLeap.SprigEventName = SprigEventName;
 
 export default UserLeap;

package/ios/UserLeapBindings.h

@@ -1,6 +1,8 @@
-#import <React/RCTBridgeModule.h>
-@import UserLeapKit;
+#import <UserLeapKit/UserLeapKit.h>
+#import <UserLeapKit/UserLeapKit-Swift.h>
 
-@interface UserLeapBindings : NSObject <RCTBridgeModule, _SGRNExtractor>
-@property (nonatomic, weak) RCTBridge *bridge;
+#import <React/RCTInvalidating.h>
+#import <RNUserLeapBindingsSpec/RNUserLeapBindingsSpec.h>
+
+@interface UserLeapBindings : NativeUserLeapBindingsSpecBase <NativeUserLeapBindingsSpec, _SGRNExtractor, RCTInvalidating>
 @end

package/ios/UserLeapBindings.mm

@@ -0,0 +1,491 @@
+#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>
+#import <React/RCTUIManager.h>
+#import <React/RCTTextShadowView.h>
+#import <React/RCTShadowView.h>
+#import <React/RCTRawTextShadowView.h>
+#import <React/RCTVirtualTextShadowView.h>
+#import <React/RCTUIManagerUtils.h>
+#endif
+#import <React/RCTView.h>
+
+// The codegen spec header is Obj-C++ only, which is why this file is `.mm`.
+#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
+{
+    return YES;
+}
+
+- (instancetype)init
+{
+    if (self = [super init]) {
+        _lock = OS_UNFAIR_LOCK_INIT;
+        _alive = YES;
+        [self subscribeToSdkEvents];
+    }
+    return self;
+}
+
+// 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];
+}
+
+- (dispatch_queue_t)methodQueue
+{
+    return dispatch_get_main_queue();
+}
+
+- (NSDictionary *)parseSurveyResult:(SprigSurveyResult *)result {
+    SurveyState state = [result surveyState];
+    NSString *surveyStateString = [self getSurveyState:state];
+    NSInteger surveyId = [result surveyId];
+    return @{@"surveyState": surveyStateString, @"surveyId": @(surveyId)};
+}
+
+- (NSString *)getSurveyState:(SurveyState)surveyState
+{
+    NSString *surveyStateBinding = @"NO_SURVEY";
+    switch(surveyState) {
+        case SurveyStateDisabled:
+            surveyStateBinding = @"DISABLED";
+            break;
+        case SurveyStateReady:
+            surveyStateBinding = @"READY";
+            break;
+        case SurveyStateNoSurvey:
+            surveyStateBinding = @"NO_SURVEY";
+            break;
+        case SurveyStatePreviousSurveyReady:
+            surveyStateBinding = @"PREVIOUS_SURVEY_READY";
+            break;
+    }
+    return surveyStateBinding;
+}
+
+RCT_EXPORT_MODULE()
+
+- (NSNumber *)visitorIdentifier
+{
+    // No @() boxing: @() expects a primitive C type, and the SDK already returns NSNumber *.
+    return [[UserLeap shared] visitorIdentifier];
+}
+
+- (NSString *)visitorIdentifierString
+{
+    return [[UserLeap shared] visitorIdentifierString];
+}
+
+- (NSString *)getSdkVersion
+{
+    // Renamed from `sdkVersion` to `getSdkVersion` so iOS and Android share one spec method name.
+    return [[UserLeap shared] sdkVersion];
+}
+
+- (void)configure:(NSString *)environmentId configuration:(NSDictionary *)configuration
+{
+    [[UserLeap shared] configureWithEnvironment:environmentId configuration:configuration];
+    [[UserLeap shared] _passWithRnExtractor:self];
+}
+
+- (void)setPreviewKey:(NSString *)previewKey
+{
+    [[UserLeap shared] setPreviewKey:previewKey];
+}
+
+- (void)setUserIdentifier:(NSString *)identifier
+{
+    [[UserLeap shared] setUserIdentifier:identifier];
+}
+
+- (void)setEmailAddress:(NSString *)emailAddress
+{
+    [[UserLeap shared] setEmailAddress:emailAddress];
+}
+
+- (void)logout
+{
+    [[UserLeap shared] logout];
+}
+
+- (void)setVisitorAttribute:(NSString *)key value:(NSString *)value
+{
+    [[UserLeap shared] setVisitorAttributeWithKey:key value:value];
+}
+
+- (void)setVisitorAttributes:(NSDictionary *)attributes
+{
+    [[UserLeap shared] setVisitorAttributes:attributes];
+}
+
+- (void)removeVisitorAttributes:(NSArray *)keys
+{
+    [[UserLeap shared] removeVisitorAttributes:keys];
+}
+
+- (void)setVisitorAttributesAndIdentify:(NSDictionary *)attributes
+                                 userId:(NSString *)userId
+                     partnerAnonymousId:(NSString *)partnerAnonymousId
+{
+    [[UserLeap shared] setVisitorAttributes:attributes userId:userId partnerAnonymousId:partnerAnonymousId];
+}
+
+- (void)presentSurvey
+{
+    [[UserLeap shared] presentSurveyFrom:RCTPresentedViewController()];
+}
+
+- (void)dismissActiveSurvey
+{
+    [[UserLeap shared] dismissActiveSurvey];
+}
+
+- (void)pauseDisplayingSurveys
+{
+    [[UserLeap shared] pauseDisplayingSurveys];
+}
+
+- (void)unpauseDisplayingSurveys
+{
+    [[UserLeap shared] unpauseDisplayingSurveys];
+}
+
+- (void)trackAndPresent:(NSString *)eventName
+{
+    [[UserLeap shared] trackAndPresentWithEventName:eventName from:RCTPresentedViewController()];
+}
+
+- (void)trackIdentifyAndPresent:(NSString *)eventName
+                         userId:(NSString *)userId
+             partnerAnonymousId:(NSString *)partnerAnonymousId
+{
+    [[UserLeap shared] trackAndPresentWithEventName:eventName userId:userId partnerAnonymousId:partnerAnonymousId from:RCTPresentedViewController()];
+}
+
+- (void)overrideUserInterfaceMode:(double)mode
+{
+    // Explicit enum cast required: Obj-C++ won't implicitly convert numeric → enum.
+    [[UserLeap shared] overrideUserInterfaceModeWithMode:(enum SprigUserInterfaceMode)(NSInteger)mode];
+}
+
+- (void)trackEvent:(NSString *)eventName
+surveyResultCallback:(RCTResponseSenderBlock)surveyResultCallback
+{
+    EventPayload *payload = [[EventPayload alloc] initWithEventName:eventName
+                                                             userId:nil
+                                                 partnerAnonymousId:nil
+                                                         properties:nil
+                                                            handler:nil
+                                                      resultHandler:^(SprigSurveyResult * result) {
+        if (surveyResultCallback != nil) {
+            surveyResultCallback(@[[self parseSurveyResult:result]]);
+        }
+    }];
+    [[UserLeap shared] trackWithPayload:payload];
+}
+
+- (void)trackEventWithProperties:(NSString *)eventName
+                          userId:(NSString *)userId
+              partnerAnonymousId:(NSString *)partnerAnonymousId
+                      properties:(NSDictionary *)properties
+            surveyResultCallback:(RCTResponseSenderBlock)surveyResultCallback
+{
+    EventPayload *payload = [[EventPayload alloc] initWithEventName:eventName
+                                                             userId:userId
+                                                 partnerAnonymousId:partnerAnonymousId
+                                                         properties:properties
+                                                            handler:nil
+                                                      resultHandler:^(SprigSurveyResult * result) {
+        if (surveyResultCallback != nil) {
+            surveyResultCallback(@[[self parseSurveyResult:result]]);
+        }
+    }];
+    [[UserLeap shared] trackWithPayload:payload];
+}
+
+- (void)trackEventAndIdentify:(NSString *)eventName
+                       userId:(NSString *)userId
+           partnerAnonymousId:(NSString *)partnerAnonymousId
+         surveyResultCallback:(RCTResponseSenderBlock)surveyResultCallback
+{
+    EventPayload *payload = [[EventPayload alloc] initWithEventName:eventName
+                                                             userId:userId
+                                                 partnerAnonymousId:partnerAnonymousId
+                                                         properties:nil
+                                                            handler:nil
+                                                      resultHandler:^(SprigSurveyResult * result) {
+        if (surveyResultCallback != nil) {
+            surveyResultCallback(@[[self parseSurveyResult:result]]);
+        }
+    }];
+    [[UserLeap shared] trackWithPayload:payload];
+}
+
+- (void)track:(NSString *)eventName
+surveyStateCallback:(RCTResponseSenderBlock)surveyStateCallback
+{
+    if (surveyStateCallback != nil) {
+        [[UserLeap shared] trackWithEventName:eventName handler:^(enum SurveyState surveyState) {
+            surveyStateCallback(@[[self getSurveyState:surveyState]]);
+        }];
+    } else {
+        [[UserLeap shared] trackWithEventName:eventName handler:nil];
+    }
+}
+
+- (void)trackWithProperties:(NSString *)eventName
+                     userId:(NSString *)userId
+         partnerAnonymousId:(NSString *)partnerAnonymousId
+                 properties:(NSDictionary *)properties
+        surveyStateCallback:(RCTResponseSenderBlock)surveyStateCallback
+{
+    [[UserLeap shared] trackWithEventName:eventName
+                                   userId:userId
+                       partnerAnonymousId:partnerAnonymousId
+                               properties:properties
+                                  handler:^(enum SurveyState surveyState) {
+        if (surveyStateCallback != nil) {
+            surveyStateCallback(@[[self getSurveyState:surveyState]]);
+        }
+    }];
+}
+
+- (void)trackAndIdentify:(NSString *)eventName
+                  userId:(NSString *)userId
+      partnerAnonymousId:(NSString *)partnerAnonymousId
+     surveyStateCallback:(RCTResponseSenderBlock)surveyStateCallback
+{
+    if (surveyStateCallback != nil) {
+        [[UserLeap shared] trackWithEventName:eventName
+                                       userId:userId
+                           partnerAnonymousId:partnerAnonymousId
+                                      handler:^(enum SurveyState surveyState) {
+            surveyStateCallback(@[[self getSurveyState:surveyState]]);
+        }];
+    } else {
+        [[UserLeap shared] trackWithEventName:eventName
+                                       userId:userId
+                           partnerAnonymousId:partnerAnonymousId
+                                      handler:nil];
+    }
+}
+
+- (_SGRNTextProperties *)textPropertiesFromView:(UIView * _Nonnull)passedView {
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+    if ([passedView isKindOfClass:[RCTTextView class]]) {
+        RCTUIManager* uiManager = [self.bridge moduleForClass:[RCTUIManager class]];
+        RCTTextView *textView = (RCTTextView *)passedView;
+        __block _SGRNTextProperties *textProperties = [[_SGRNTextProperties alloc] init];
+        dispatch_sync(RCTGetUIManagerQueue(), ^{
+            RCTShadowView *shadowView = [uiManager shadowViewForReactTag:textView.reactTag];
+            if ([shadowView isKindOfClass:[RCTTextShadowView class]]) {
+                RCTTextShadowView *textShadowView = (RCTTextShadowView *)shadowView;
+                NSString *text = [self extractText: textShadowView.reactSubviews];
+                if (text.length == 0) return;
+                textProperties.text = text;
+                textProperties.color = textShadowView.textAttributes.foregroundColor;
+                textProperties.alignment = textShadowView.textAttributes.alignment;
+                textProperties.font = textShadowView.textAttributes.effectiveFont;
+            }
+        });
+        if (textProperties.text.length == 0) return nil;
+        return textProperties;
+    }
+#endif
+
+    Class ParagraphComponentView = NSClassFromString(@"RCTParagraphComponentView");
+    if (ParagraphComponentView && [passedView isKindOfClass:ParagraphComponentView]) {
+        NSString *text = [self extractTextFromParagraphComponentView:passedView];
+        if (text.length == 0) return nil;
+        _SGRNTextProperties *textProperties = [[_SGRNTextProperties alloc] init];
+        textProperties.text = text;
+        if ([passedView respondsToSelector:@selector(attributedText)]) {
+            NSAttributedString *attrText = [passedView performSelector:@selector(attributedText)];
+            if (attrText.length > 0) {
+                NSDictionary *attrs = [attrText attributesAtIndex:0 effectiveRange:nil];
+                if (!textProperties.color && attrs[NSForegroundColorAttributeName]) {
+                    textProperties.color = attrs[NSForegroundColorAttributeName];
+                }
+                if (!textProperties.font && attrs[NSFontAttributeName]) {
+                    textProperties.font = attrs[NSFontAttributeName];
+                }
+                NSParagraphStyle *style = attrs[NSParagraphStyleAttributeName];
+                if (style) {
+                    textProperties.alignment = style.alignment;
+                }
+            }
+        }
+        return textProperties;
+    }
+    return nil;
+}
+
+- (_SGRNViewProperties * _Nullable)propertiesFromView:(UIView * _Nonnull)passedView {
+    if ([passedView isKindOfClass:[RCTView class]]) {
+        RCTView *rView = (RCTView *) passedView;
+        if (rView.borderWidth > 0) {
+            _SGRNViewProperties *props = [[_SGRNViewProperties alloc] init];
+            props.borderColor = rView.borderColor;
+            props.borderWidth = rView.borderWidth;
+            return props;
+        }
+    }
+    return nil;
+}
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+- (NSString * _Nullable)extractText:(NSArray<RCTShadowView *> * _Nonnull) subviews {
+    NSMutableString *text = [[NSMutableString alloc] init];
+    for (RCTShadowView *subview in subviews) {
+        if ([subview isKindOfClass:[RCTRawTextShadowView class]]) {
+            [text appendString:((RCTRawTextShadowView *)subview).text];
+        }
+        if ([subview isKindOfClass:[RCTVirtualTextShadowView class]]) {
+            // Append, don't early-return: returning here would drop text already collected.
+            NSString *nested = [self extractText: ((RCTVirtualTextShadowView *)subview).reactSubviews];
+            if (nested) [text appendString:nested];
+        }
+    }
+    return text;
+}
+#endif
+
+- (NSString *)extractTextFromParagraphComponentView:(UIView *)view {
+    if ([view respondsToSelector:@selector(attributedText)]) {
+        NSAttributedString *attrText = [view performSelector:@selector(attributedText)];
+        return attrText.string;
+    }
+    if ([view respondsToSelector:@selector(text)]) {
+        NSString *text = [view performSelector:@selector(text)];
+        return text;
+    }
+    NSMutableString *result = [NSMutableString string];
+    for (UIView *subview in view.subviews) {
+        NSString *subText = [self extractTextFromParagraphComponentView:subview];
+        if (subText) [result appendString:subText];
+    }
+    return result;
+}
+
+- (NSArray<NSString *> *)getSupportedEventNames
+{
+    NSMutableArray<NSString *> *events = [NSMutableArray array];
+    for (NSString *name in [LifecycleEventUtil allNameStrings]) {
+        if ([name isEqualToString:@"unknown"]) continue;
+        [events addObject:name];
+    }
+    return events;
+}
+
+- (NSDictionary *)normalizePayloadForEvent:(NSString *)eventName
+                                       data:(NSDictionary<NSString *, id> *)data
+{
+    if (![eventName isEqualToString:@"loggingEvent"]) {
+        return data ?: @{};
+    }
+
+    NSString *raw = data[@"message"];
+    NSString *message = @"";
+    if ([raw isKindOfClass:[NSString class]]) {
+        NSString *prefix = @"Sprig: ";
+        message = [raw hasPrefix:prefix] ? [raw substringFromIndex:prefix.length] : raw;
+    }
+
+    return @{
+        @"type": @"loggingEvent",
+        @"message": message,
+        @"level": @"info",
+    };
+}
+
+- (NSString *)jsonStringFromDictionary:(NSDictionary *)dict
+{
+    if (![NSJSONSerialization isValidJSONObject:dict]) {
+        return @"{}";
+    }
+    NSError *error = nil;
+    NSData *data = [NSJSONSerialization dataWithJSONObject:dict options:0 error:&error];
+    if (!data || error) {
+        return @"{}";
+    }
+    return [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding] ?: @"{}";
+}
+
+- (void)subscribeToSdkEvents
+{
+    __weak __typeof(self) weakSelf = self;
+    UserLeap *sdk = [UserLeap shared];
+
+    for (NSNumber *raw in [LifecycleEventUtil all]) {
+        LifecycleEvent eventType = (LifecycleEvent)raw.integerValue;
+        NSString *name = [LifecycleEventUtil stringName:eventType];
+        if ([name isEqualToString:@"unknown"]) continue;
+
+        [sdk registerEventListenerFor:eventType listener:^(NSDictionary<NSString *,id> * _Nonnull data) {
+            __strong __typeof(weakSelf) strongSelf = weakSelf;
+            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];
+
+            // 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}];
+            });
+        }];
+    }
+}
+
+- (void)unsubscribeFromSdkEvents
+{
+    UserLeap *sdk = [UserLeap shared];
+    for (NSNumber *raw in [LifecycleEventUtil all]) {
+        LifecycleEvent eventType = (LifecycleEvent)raw.integerValue;
+        [sdk unregisterAllEventListenersFor:eventType];
+    }
+}
+
+- (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);
+}
+
+@end