@posthog/react-native-plugin 0.0.1 → 2.0.0

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

@@ -0,0 +1,301 @@
+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.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
+
+              if (sessionReplayEnabled) {
+                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 = true
+                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 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,217 @@
+import PostHog
+
+/// Meant for internally logging PostHog related things
+private func hedgeLog(_ message: String) {
+    print("[PostHog] \(message)")
+}
+
+@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
+
+        if #available(iOS 15.0, *) {
+            config.surveys = false
+        }
+
+        if sessionReplayEnabled {
+            config.sessionReplay = true
+            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

package/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","LINKING_ERROR","Platform","select","ios","default","PosthogReactNativePlugin","NativeModules","Proxy","get","Error","setup","sessionId","sdkOptions","pluginConfig","start","sdkReplayConfig","decideReplayConfig","startSession","endSession","isEnabled","identify","distinctId","anonymousId","startRecording","resumeCurrent","stopRecording","PostHogReactNativePlugin","_default","exports"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAEA,MAAMC,aAAa,GACjB,uFAAuF,GACvFC,qBAAQ,CAACC,MAAM,CAAC;EAAEC,GAAG,EAAE,gCAAgC;EAAEC,OAAO,EAAE;AAAG,CAAC,CAAC,GACvE,sDAAsD,GACtD,+BAA+B;AAEjC,MAAMC,wBAAwB,GAAGC,0BAAa,CAACD,wBAAwB,GACnEC,0BAAa,CAACD,wBAAwB,GACtC,IAAIE,KAAK,CACP,CAAC,CAAC,EACF;EACEC,GAAGA,CAAA,EAAG;IACJ,MAAM,IAAIC,KAAK,CAACT,aAAa,CAAC;EAChC;AACF,CACF,CAAC;AAmBE,SAASU,KAAKA,CACnBC,SAAiB,EACjBC,UAAuC,EACvCC,YAA4C,GAAG,CAAC,CAAC,EAClC;EACf,OAAOR,wBAAwB,CAACK,KAAK,CAACC,SAAS,EAAEC,UAAU,EAAEC,YAAY,CAAC;AAC5E;AAEO,SAASC,KAAKA,CACnBH,SAAiB,EACjBC,UAAuC,EACvCG,eAA4C,EAC5CC,kBAA+C,EAChC;EACf,OAAOX,wBAAwB,CAACS,KAAK,CAACH,SAAS,EAAEC,UAAU,EAAEG,eAAe,EAAEC,kBAAkB,CAAC;AACnG;AAEO,SAASC,YAAYA,CAACN,SAAiB,EAAiB;EAC7D,OAAON,wBAAwB,CAACY,YAAY,CAACN,SAAS,CAAC;AACzD;AAEO,SAASO,UAAUA,CAAA,EAAkB;EAC1C,OAAOb,wBAAwB,CAACa,UAAU,CAAC,CAAC;AAC9C;AAEO,SAASC,SAASA,CAAA,EAAqB;EAC5C,OAAOd,wBAAwB,CAACc,SAAS,CAAC,CAAC;AAC7C;AAEO,SAASC,QAAQA,CAACC,UAAkB,EAAEC,WAAmB,EAAiB;EAC/E,OAAOjB,wBAAwB,CAACe,QAAQ,CAACC,UAAU,EAAEC,WAAW,CAAC;AACnE;AAEO,SAASC,cAAcA,CAACC,aAAsB,EAAiB;EACpE,OAAOnB,wBAAwB,CAACkB,cAAc,CAACC,aAAa,CAAC;AAC/D;AAEO,SAASC,aAAaA,CAAA,EAAkB;EAC7C,OAAOpB,wBAAwB,CAACoB,aAAa,CAAC,CAAC;AACjD;AAgCA,MAAMC,wBAAwD,GAAG;EAC/DhB,KAAK;EACLI,KAAK;EACLG,YAAY;EACZC,UAAU;EACVC,SAAS;EACTC,QAAQ;EACRG,cAAc;EACdE;AACF,CAAC;AAAA,IAAAE,QAAA,GAAAC,OAAA,CAAAxB,OAAA,GAEcsB,wBAAwB","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,48 @@
+"use strict";
+
+import { NativeModules, Platform } from 'react-native';
+const LINKING_ERROR = `The package '@posthog/react-native-plugin' doesn't seem to be linked. Make sure: \n\n` + 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 = NativeModules.PosthogReactNativePlugin ? NativeModules.PosthogReactNativePlugin : new Proxy({}, {
+  get() {
+    throw new Error(LINKING_ERROR);
+  }
+});
+export function setup(sessionId, sdkOptions, pluginConfig = {}) {
+  return PosthogReactNativePlugin.setup(sessionId, sdkOptions, pluginConfig);
+}
+export function start(sessionId, sdkOptions, sdkReplayConfig, decideReplayConfig) {
+  return PosthogReactNativePlugin.start(sessionId, sdkOptions, sdkReplayConfig, decideReplayConfig);
+}
+export function startSession(sessionId) {
+  return PosthogReactNativePlugin.startSession(sessionId);
+}
+export function endSession() {
+  return PosthogReactNativePlugin.endSession();
+}
+export function isEnabled() {
+  return PosthogReactNativePlugin.isEnabled();
+}
+export function identify(distinctId, anonymousId) {
+  return PosthogReactNativePlugin.identify(distinctId, anonymousId);
+}
+export function startRecording(resumeCurrent) {
+  return PosthogReactNativePlugin.startRecording(resumeCurrent);
+}
+export function stopRecording() {
+  return PosthogReactNativePlugin.stopRecording();
+}
+const PostHogReactNativePlugin = {
+  setup,
+  start,
+  startSession,
+  endSession,
+  isEnabled,
+  identify,
+  startRecording,
+  stopRecording
+};
+export default PostHogReactNativePlugin;
+//# sourceMappingURL=index.js.map