@posthog/react-native-plugin 0.0.1 → 2.0.1

package/android/src/main/java/com/posthogreactnativeplugin/PosthogReactNativePluginModule.kt

@@ -0,0 +1,317 @@
+package com.posthogreactnativeplugin
+
+import android.util.Log
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.UiThreadUtil
+import com.posthog.PostHog
+import com.posthog.PostHogConfig
+import com.posthog.PostHogEvent
+import com.posthog.android.PostHogAndroid
+import com.posthog.android.PostHogAndroidConfig
+import com.posthog.internal.PostHogPreferences
+import com.posthog.internal.PostHogPreferences.Companion.ANONYMOUS_ID
+import com.posthog.internal.PostHogPreferences.Companion.DISTINCT_ID
+import com.posthog.internal.PostHogSessionManager
+import java.util.UUID
+
+class PosthogReactNativePluginModule(
+  reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext) {
+  override fun getName(): String = NAME
+
+  @ReactMethod
+  fun setup(
+    sessionId: String,
+    sdkOptions: ReadableMap,
+    pluginConfig: ReadableMap,
+    promise: Promise,
+  ) {
+    val sessionReplayConfig = getMap(pluginConfig, "sessionReplay")
+    val errorTrackingConfig = getMap(pluginConfig, "errorTracking")
+
+    setupNativeSdk(
+      method = "setup",
+      sessionId = sessionId,
+      sdkOptions = sdkOptions,
+      sessionReplayEnabled = getBoolean(sessionReplayConfig, "enabled", false),
+      sdkReplayConfig = getMap(sessionReplayConfig, "sdkReplayConfig"),
+      decideReplayConfig = getMap(sessionReplayConfig, "decideReplayConfig"),
+      nativeErrorTrackingAutocapture = getBoolean(errorTrackingConfig, "nativeAutocapture", false),
+      promise = promise,
+    )
+  }
+
+  @ReactMethod
+  fun start(
+    sessionId: String,
+    sdkOptions: ReadableMap,
+    sdkReplayConfig: ReadableMap,
+    decideReplayConfig: ReadableMap,
+    promise: Promise,
+  ) {
+    setupNativeSdk(
+      method = "start",
+      sessionId = sessionId,
+      sdkOptions = sdkOptions,
+      sessionReplayEnabled = true,
+      sdkReplayConfig = sdkReplayConfig,
+      decideReplayConfig = decideReplayConfig,
+      nativeErrorTrackingAutocapture = false,
+      promise = promise,
+    )
+  }
+
+  private fun setupNativeSdk(
+    method: String,
+    sessionId: String,
+    sdkOptions: ReadableMap,
+    sessionReplayEnabled: Boolean,
+    sdkReplayConfig: ReadableMap?,
+    decideReplayConfig: ReadableMap?,
+    nativeErrorTrackingAutocapture: Boolean,
+    promise: Promise,
+  ) {
+    val initRunnable =
+      Runnable {
+        try {
+          val uuid = UUID.fromString(sessionId)
+          PostHogSessionManager.setSessionId(uuid)
+
+          val context = this.reactApplicationContext
+          val apiKey = getString(sdkOptions, "apiKey", "")
+          val host = getString(sdkOptions, "host", PostHogConfig.DEFAULT_HOST)
+          val debugValue = getBoolean(sdkOptions, "debug", false)
+          val distinctId = getString(sdkOptions, "distinctId", "")
+          val anonymousId = getString(sdkOptions, "anonymousId", "")
+          val theSdkVersion = getString(sdkOptions, "sdkVersion", "")
+          val theFlushAt = getInt(sdkOptions, "flushAt", DEFAULT_FLUSH_AT)
+
+          val config =
+            PostHogAndroidConfig(apiKey, host).apply {
+              debug = debugValue
+              captureDeepLinks = false
+              captureApplicationLifecycleEvents = false
+              captureScreenViews = false
+              flushAt = theFlushAt
+              errorTrackingConfig.autoCapture = nativeErrorTrackingAutocapture
+
+              // React Native rethrows fatal JS errors natively as JavascriptException.
+              // The JS layer already captured them, so drop the native duplicate.
+              addBeforeSend { event -> if (isReactNativeFatalJsError(event)) null else event }
+
+              // Always apply the session replay configuration so that recording started later
+              // (e.g. startRecording or a linked feature flag) uses the right mode and masking;
+              // sessionReplayEnabled only controls whether recording starts at setup.
+              val maskAllTextInputs = getBoolean(sdkReplayConfig, "maskAllTextInputs", DEFAULT_MASK_ALL_TEXT_INPUTS)
+              val maskAllImages = getBoolean(sdkReplayConfig, "maskAllImages", DEFAULT_MASK_ALL_IMAGES)
+              val captureLog = getBoolean(sdkReplayConfig, "captureLog", DEFAULT_CAPTURE_LOG)
+
+              // read throttleDelayMs and use androidDebouncerDelayMs as a fallback for back compatibility
+              val throttleDelayMs =
+                when {
+                  hasKey(sdkReplayConfig, "throttleDelayMs") -> getInt(sdkReplayConfig, "throttleDelayMs", DEFAULT_THROTTLE_DELAY_MS)
+                  hasKey(sdkReplayConfig, "androidDebouncerDelayMs") -> getInt(sdkReplayConfig, "androidDebouncerDelayMs", DEFAULT_THROTTLE_DELAY_MS)
+                  else -> DEFAULT_THROTTLE_DELAY_MS
+                }
+
+              sessionReplay = sessionReplayEnabled
+              sessionReplayConfig.screenshot = true
+              sessionReplayConfig.captureLogcat = captureLog
+              sessionReplayConfig.throttleDelayMs = throttleDelayMs.toLong()
+              sessionReplayConfig.maskAllImages = maskAllImages
+              sessionReplayConfig.maskAllTextInputs = maskAllTextInputs
+              sessionReplayConfig.sampleRate = getDoubleOrNull(sdkReplayConfig, "sampleRate")
+
+              val endpoint = getString(decideReplayConfig, "endpoint", "")
+              if (endpoint.isNotEmpty()) {
+                snapshotEndpoint = endpoint
+              }
+
+              if (theSdkVersion.isNotEmpty()) {
+                sdkName = "posthog-react-native"
+                sdkVersion = theSdkVersion
+              }
+            }
+          PostHogAndroid.setup(context, config)
+
+          setIdentify(config.cachePreferences, distinctId, anonymousId)
+        } catch (e: Throwable) {
+          logError(method, e)
+        } finally {
+          promise.resolve(null)
+        }
+      }
+
+    // forces the SDK to be initialized on the main thread
+    if (UiThreadUtil.isOnUiThread()) {
+      initRunnable.run()
+    } else {
+      UiThreadUtil.runOnUiThread(initRunnable)
+    }
+  }
+
+  @ReactMethod
+  fun startSession(
+    sessionId: String,
+    promise: Promise,
+  ) {
+    try {
+      val uuid = UUID.fromString(sessionId)
+      PostHogSessionManager.setSessionId(uuid)
+      PostHog.startSession()
+    } catch (e: Throwable) {
+      logError("startSession", e)
+    } finally {
+      promise.resolve(null)
+    }
+  }
+
+  @ReactMethod
+  fun isEnabled(promise: Promise) {
+    try {
+      promise.resolve(PostHog.isSessionReplayActive())
+    } catch (e: Throwable) {
+      logError("isEnabled", e)
+      promise.resolve(false)
+    }
+  }
+
+  @ReactMethod
+  fun endSession(promise: Promise) {
+    try {
+      PostHog.endSession()
+    } catch (e: Throwable) {
+      logError("endSession", e)
+    } finally {
+      promise.resolve(null)
+    }
+  }
+
+  @ReactMethod
+  fun identify(
+    distinctId: String,
+    anonymousId: String,
+    promise: Promise,
+  ) {
+    try {
+      setIdentify(PostHog.getConfig<PostHogConfig>()?.cachePreferences, distinctId, anonymousId)
+    } catch (e: Throwable) {
+      logError("identify", e)
+    } finally {
+      promise.resolve(null)
+    }
+  }
+
+  private fun setIdentify(
+    cachePreferences: PostHogPreferences?,
+    distinctId: String,
+    anonymousId: String,
+  ) {
+    cachePreferences?.let { preferences ->
+      if (anonymousId.isNotEmpty()) {
+        preferences.setValue(ANONYMOUS_ID, anonymousId)
+      }
+      if (distinctId.isNotEmpty()) {
+        preferences.setValue(DISTINCT_ID, distinctId)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun startRecording(
+    resumeCurrent: Boolean,
+    promise: Promise,
+  ) {
+    try {
+      PostHog.startSessionReplay(resumeCurrent)
+    } catch (e: Throwable) {
+      logError("startRecording", e)
+    } finally {
+      promise.resolve(null)
+    }
+  }
+
+  @ReactMethod
+  fun stopRecording(promise: Promise) {
+    try {
+      PostHog.stopSessionReplay()
+    } catch (e: Throwable) {
+      logError("stopRecording", e)
+    } finally {
+      promise.resolve(null)
+    }
+  }
+
+  private fun getMap(
+    map: ReadableMap?,
+    key: String,
+  ): ReadableMap? =
+    runCatching {
+      if (map != null && map.hasKey(key) && !map.isNull(key)) {
+        map.getMap(key)
+      } else {
+        null
+      }
+    }.getOrNull()
+
+  private fun hasKey(
+    map: ReadableMap?,
+    key: String,
+  ): Boolean = runCatching { map != null && map.hasKey(key) && !map.isNull(key) }.getOrDefault(false)
+
+  private fun getBoolean(
+    map: ReadableMap?,
+    key: String,
+    default: Boolean,
+  ): Boolean = runCatching { if (hasKey(map, key)) map?.getBoolean(key) ?: default else default }.getOrDefault(default)
+
+  private fun getString(
+    map: ReadableMap?,
+    key: String,
+    default: String,
+  ): String = runCatching { if (hasKey(map, key)) map?.getString(key) ?: default else default }.getOrDefault(default)
+
+  private fun getInt(
+    map: ReadableMap?,
+    key: String,
+    default: Int,
+  ): Int = runCatching { if (hasKey(map, key)) map?.getInt(key) ?: default else default }.getOrDefault(default)
+
+  private fun getDoubleOrNull(
+    map: ReadableMap?,
+    key: String,
+  ): Double? = runCatching { if (hasKey(map, key)) map?.getDouble(key) else null }.getOrNull()
+
+  private fun isReactNativeFatalJsError(event: PostHogEvent): Boolean {
+    if (event.event != "\$exception") return false
+    val exceptionList = event.properties?.get("\$exception_list") as? List<*> ?: return false
+    return exceptionList.any { item ->
+      val exception = item as? Map<*, *> ?: return@any false
+      exception["type"] == "JavascriptException" &&
+        (exception["module"] as? String)?.startsWith("com.facebook.react") == true
+    }
+  }
+
+  private fun logError(
+    method: String,
+    error: Throwable,
+  ) {
+    Log.println(Log.ERROR, POSTHOG_TAG, "Method $method, error: $error")
+  }
+
+  companion object {
+    const val NAME = "PosthogReactNativePlugin"
+    const val POSTHOG_TAG = "PostHog"
+
+    // Default session replay configuration values
+    const val DEFAULT_MASK_ALL_TEXT_INPUTS = true
+    const val DEFAULT_MASK_ALL_IMAGES = true
+    const val DEFAULT_CAPTURE_LOG = true
+    const val DEFAULT_FLUSH_AT = 20
+    const val DEFAULT_THROTTLE_DELAY_MS = 1000
+  }
+}

package/android/src/main/java/com/posthogreactnativeplugin/PosthogReactNativePluginPackage.kt

@@ -0,0 +1,13 @@
+package com.posthogreactnativeplugin
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class PosthogReactNativePluginPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
+    listOf(PosthogReactNativePluginModule(reactContext))
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> = emptyList()
+}

package/ios/PosthogReactNativePlugin-Bridging-Header.h

@@ -0,0 +1,2 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>

package/ios/PosthogReactNativePlugin.mm

@@ -0,0 +1,45 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(PosthogReactNativePlugin, NSObject)
+
+RCT_EXTERN_METHOD(setup:(NSString)sessionId
+                 withSdkOptions:(NSDictionary)sdkOptions
+                 withPluginConfig:(NSDictionary)pluginConfig
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(start:(NSString)sessionId
+                 withSdkOptions:(NSDictionary)sdkOptions
+                 withSdkReplayConfig:(NSDictionary)sdkReplayConfig
+                 withDecideReplayConfig:(NSDictionary)decideReplayConfig
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(startSession:(NSString)sessionId
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(isEnabled:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(endSession:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(identify:(NSString)distinctId
+                  withAnonymousId:(NSString)anonymousId
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(startRecording:(BOOL)resumeCurrent
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(stopRecording:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+@end

package/ios/PosthogReactNativePlugin.swift

@@ -0,0 +1,254 @@
+import PostHog
+
+/// Meant for internally logging PostHog related things
+private func hedgeLog(_ message: String) {
+    print("[PostHog] \(message)")
+}
+
+// Deduplication works on Android (both architectures) and iOS (old architecture only).
+// On the iOS new architecture, fatal JS exception events surface as a generic SIGABRT
+// crash event with no JS-error text in any field, so they currently cannot be filtered.
+private let fatalJsErrorMarkers = ["Unhandled JS Exception", "ExceptionsManager.reportException", "facebook::jsi::JSError"]
+
+private func containsFatalJsErrorMarker(_ text: String?) -> Bool {
+    guard let text else { return false }
+    return fatalJsErrorMarkers.contains { text.contains($0) }
+}
+
+private func isReactNativeFatalJsError(_ event: PostHogEvent) -> Bool {
+    guard event.event == "$exception",
+          let exceptionList = event.properties["$exception_list"] as? [[String: Any]]
+    else { return false }
+    return exceptionList.contains { exception in
+        if containsFatalJsErrorMarker(exception["type"] as? String) {
+            return true
+        }
+        if containsFatalJsErrorMarker(exception["value"] as? String) {
+            return true
+        }
+        // New-architecture RN rethrows fatal JS errors as a C++ jsi::JSError (SIGABRT);
+        // the JS-error text only survives in the signal's crash-info message.
+        let mechanism = exception["mechanism"] as? [String: Any]
+        let meta = mechanism?["meta"] as? [String: Any]
+        let signal = meta?["signal"] as? [String: Any]
+        return containsFatalJsErrorMarker(signal?["crash_info_message"] as? String)
+    }
+}
+
+@objc(PosthogReactNativePlugin)
+class PosthogReactNativePlugin: NSObject {
+    private var config: PostHogConfig?
+
+    @objc(setup:withSdkOptions:withPluginConfig:withResolver:withRejecter:)
+    func setup(
+        sessionId: String, sdkOptions: [String: Any], pluginConfig: [String: Any],
+        resolve: RCTPromiseResolveBlock, reject _: RCTPromiseRejectBlock
+    ) {
+        let sessionReplayConfig = pluginConfig["sessionReplay"] as? [String: Any] ?? [:]
+        let errorTrackingConfig = pluginConfig["errorTracking"] as? [String: Any] ?? [:]
+
+        setupNativeSdk(
+            method: "setup",
+            sessionId: sessionId,
+            sdkOptions: sdkOptions,
+            sessionReplayEnabled: sessionReplayConfig["enabled"] as? Bool ?? false,
+            sdkReplayConfig: sessionReplayConfig["sdkReplayConfig"] as? [String: Any] ?? [:],
+            decideReplayConfig: sessionReplayConfig["decideReplayConfig"] as? [String: Any] ?? [:],
+            nativeErrorTrackingAutocapture: errorTrackingConfig["nativeAutocapture"] as? Bool ?? false,
+            resolve: resolve
+        )
+    }
+
+    @objc(start:withSdkOptions:withSdkReplayConfig:withDecideReplayConfig:withResolver:withRejecter:)
+    func start(
+        sessionId: String, sdkOptions: [String: Any], sdkReplayConfig: [String: Any],
+        decideReplayConfig: [String: Any], resolve: RCTPromiseResolveBlock,
+        reject _: RCTPromiseRejectBlock
+    ) {
+        setupNativeSdk(
+            method: "start",
+            sessionId: sessionId,
+            sdkOptions: sdkOptions,
+            sessionReplayEnabled: true,
+            sdkReplayConfig: sdkReplayConfig,
+            decideReplayConfig: decideReplayConfig,
+            nativeErrorTrackingAutocapture: false,
+            resolve: resolve
+        )
+    }
+
+    private func setupNativeSdk(
+        method _: String,
+        sessionId: String,
+        sdkOptions: [String: Any],
+        sessionReplayEnabled: Bool,
+        sdkReplayConfig: [String: Any],
+        decideReplayConfig: [String: Any],
+        nativeErrorTrackingAutocapture: Bool,
+        resolve: RCTPromiseResolveBlock
+    ) {
+        if sessionId.isEmpty {
+            hedgeLog("Invalid empty sessionId provided.")
+            resolve(nil)
+            return
+        }
+
+        let projectToken =
+            (sdkOptions["projectToken"] as? String)
+                ?? (sdkOptions["apiKey"] as? String)
+                ?? ""
+        let host = sdkOptions["host"] as? String ?? PostHogConfig.defaultHost
+        let debug = sdkOptions["debug"] as? Bool ?? false
+
+        PostHogSessionManager.shared.setSessionId(sessionId)
+
+        let config = PostHogConfig(projectToken: projectToken, host: host)
+        config.captureApplicationLifecycleEvents = false
+        config.captureScreenViews = false
+        config.debug = debug
+        config.errorTrackingConfig.autoCapture = nativeErrorTrackingAutocapture
+
+        // React Native rethrows fatal JS errors natively (RCTFatalException / ExceptionsManager).
+        // The JS layer already captured them, so drop the native duplicate.
+        config.setBeforeSend { event in
+            isReactNativeFatalJsError(event) ? nil : event
+        }
+
+        if #available(iOS 15.0, *) {
+            config.surveys = false
+        }
+
+        // Always apply the session replay configuration so that recording started later
+        // (e.g. startRecording or a linked feature flag) uses the right mode and masking;
+        // sessionReplayEnabled only controls whether recording starts at setup.
+        config.sessionReplay = sessionReplayEnabled
+        config.sessionReplayConfig.screenshotMode = true
+
+        let maskAllTextInputs = sdkReplayConfig["maskAllTextInputs"] as? Bool ?? true
+        config.sessionReplayConfig.maskAllTextInputs = maskAllTextInputs
+
+        let maskAllImages = sdkReplayConfig["maskAllImages"] as? Bool ?? true
+        config.sessionReplayConfig.maskAllImages = maskAllImages
+
+        let maskAllSandboxedViews = sdkReplayConfig["maskAllSandboxedViews"] as? Bool ?? true
+        config.sessionReplayConfig.maskAllSandboxedViews = maskAllSandboxedViews
+
+        // read throttleDelayMs and use iOSdebouncerDelayMs as a fallback for back compatibility
+        let throttleDelayMs =
+            (sdkReplayConfig["throttleDelayMs"] as? Int)
+                ?? (sdkReplayConfig["iOSdebouncerDelayMs"] as? Int)
+                ?? 1000
+
+        let timeInterval: TimeInterval = Double(throttleDelayMs) / 1000.0
+        config.sessionReplayConfig.throttleDelay = timeInterval
+
+        let captureNetworkTelemetry = sdkReplayConfig["captureNetworkTelemetry"] as? Bool ?? true
+        config.sessionReplayConfig.captureNetworkTelemetry = captureNetworkTelemetry
+
+        let captureLog = sdkReplayConfig["captureLog"] as? Bool ?? true
+        config.sessionReplayConfig.captureLogs = captureLog
+
+        config.sessionReplayConfig.sampleRate = sdkReplayConfig["sampleRate"] as? NSNumber
+
+        let screenshotModeBackgroundCapture = sdkReplayConfig["screenshotModeBackgroundCapture"] as? Bool ?? false
+        config.sessionReplayConfig.screenshotModeBackgroundCapture = screenshotModeBackgroundCapture
+
+        let endpoint = decideReplayConfig["endpoint"] as? String ?? ""
+        if !endpoint.isEmpty {
+            config.snapshotEndpoint = endpoint
+        }
+
+        let distinctId = sdkOptions["distinctId"] as? String ?? ""
+        let anonymousId = sdkOptions["anonymousId"] as? String ?? ""
+
+        let sdkVersion = sdkOptions["sdkVersion"] as? String ?? ""
+
+        let flushAt = sdkOptions["flushAt"] as? Int ?? 20
+        config.flushAt = flushAt
+
+        if !sdkVersion.isEmpty {
+            postHogSdkName = "posthog-react-native"
+            postHogVersion = sdkVersion
+        }
+
+        PostHogSDK.shared.setup(config)
+
+        self.config = config
+
+        guard let storageManager = self.config?.storageManager else {
+            hedgeLog("Storage manager is not available in the config.")
+            resolve(nil)
+            return
+        }
+
+        setIdentify(storageManager, distinctId: distinctId, anonymousId: anonymousId)
+
+        resolve(nil)
+    }
+
+    @objc(startSession:withResolver:withRejecter:)
+    func startSession(
+        sessionId: String, resolve: RCTPromiseResolveBlock, reject _: RCTPromiseRejectBlock
+    ) {
+        if sessionId.isEmpty {
+            hedgeLog("Invalid empty sessionId provided.")
+            resolve(nil)
+            return
+        }
+        PostHogSessionManager.shared.setSessionId(sessionId)
+        PostHogSDK.shared.startSession()
+        resolve(nil)
+    }
+
+    @objc(isEnabled:withRejecter:)
+    func isEnabled(resolve: RCTPromiseResolveBlock, reject _: RCTPromiseRejectBlock) {
+        let isEnabled = PostHogSDK.shared.isSessionReplayActive()
+        resolve(isEnabled)
+    }
+
+    @objc(endSession:withRejecter:)
+    func endSession(resolve: RCTPromiseResolveBlock, reject _: RCTPromiseRejectBlock) {
+        PostHogSDK.shared.endSession()
+        resolve(nil)
+    }
+
+    @objc(identify:withAnonymousId:withResolver:withRejecter:)
+    func identify(
+        distinctId: String, anonymousId: String, resolve: RCTPromiseResolveBlock,
+        reject _: RCTPromiseRejectBlock
+    ) {
+        guard let storageManager = config?.storageManager else {
+            hedgeLog("Storage manager is not available in the config.")
+            resolve(nil)
+            return
+        }
+        setIdentify(storageManager, distinctId: distinctId, anonymousId: anonymousId)
+
+        resolve(nil)
+    }
+
+    private func setIdentify(
+        _ storageManager: PostHogStorageManager, distinctId: String, anonymousId: String
+    ) {
+        if !anonymousId.isEmpty {
+            storageManager.setAnonymousId(anonymousId)
+        }
+        if !distinctId.isEmpty {
+            storageManager.setDistinctId(distinctId)
+        }
+    }
+
+    @objc(startRecording:withResolver:withRejecter:)
+    func startRecording(
+        resumeCurrent: Bool, resolve: RCTPromiseResolveBlock, reject _: RCTPromiseRejectBlock
+    ) {
+        PostHogSDK.shared.startSessionRecording(resumeCurrent: resumeCurrent)
+        resolve(nil)
+    }
+
+    @objc(stopRecording:withRejecter:)
+    func stopRecording(resolve: RCTPromiseResolveBlock, reject _: RCTPromiseRejectBlock) {
+        PostHogSDK.shared.stopSessionRecording()
+        resolve(nil)
+    }
+}

package/lib/commonjs/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.endSession = endSession;
+exports.identify = identify;
+exports.isEnabled = isEnabled;
+exports.setup = setup;
+exports.start = start;
+exports.startRecording = startRecording;
+exports.startSession = startSession;
+exports.stopRecording = stopRecording;
+var _reactNative = require("react-native");
+const LINKING_ERROR = `The package '@posthog/react-native-plugin' doesn't seem to be linked. Make sure: \n\n` + _reactNative.Platform.select({
+  ios: "- You have run 'pod install'\n",
+  default: ''
+}) + '- You rebuilt the app after installing the package\n' + '- You are not using Expo Go\n';
+const PosthogReactNativePlugin = _reactNative.NativeModules.PosthogReactNativePlugin ? _reactNative.NativeModules.PosthogReactNativePlugin : new Proxy({}, {
+  get() {
+    throw new Error(LINKING_ERROR);
+  }
+});
+function setup(sessionId, sdkOptions, pluginConfig = {}) {
+  return PosthogReactNativePlugin.setup(sessionId, sdkOptions, pluginConfig);
+}
+function start(sessionId, sdkOptions, sdkReplayConfig, decideReplayConfig) {
+  return PosthogReactNativePlugin.start(sessionId, sdkOptions, sdkReplayConfig, decideReplayConfig);
+}
+function startSession(sessionId) {
+  return PosthogReactNativePlugin.startSession(sessionId);
+}
+function endSession() {
+  return PosthogReactNativePlugin.endSession();
+}
+function isEnabled() {
+  return PosthogReactNativePlugin.isEnabled();
+}
+function identify(distinctId, anonymousId) {
+  return PosthogReactNativePlugin.identify(distinctId, anonymousId);
+}
+function startRecording(resumeCurrent) {
+  return PosthogReactNativePlugin.startRecording(resumeCurrent);
+}
+function stopRecording() {
+  return PosthogReactNativePlugin.stopRecording();
+}
+const PostHogReactNativePlugin = {
+  setup,
+  start,
+  startSession,
+  endSession,
+  isEnabled,
+  identify,
+  startRecording,
+  stopRecording
+};
+var _default = exports.default = PostHogReactNativePlugin;
+//# sourceMappingURL=index.js.map