@pulseboard/react-native 0.1.0

package/PulseBoardSDK.podspec

@@ -0,0 +1,24 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name            = "PulseBoardSDK"
+  s.version         = package["version"]
+  s.summary         = package["description"]
+  s.homepage        = "https://github.com/yourusername/pulseboard"
+  s.license         = package["license"]
+  s.authors         = { "PulseBoard" => "hello@pulseboard.dev" }
+  s.platforms       = { :ios => "15.1" }
+  s.source          = { :git => "https://github.com/yourusername/pulseboard.git", :tag => "#{s.version}" }
+  s.source_files    = "ios/**/*.{swift,h,m,mm}"
+  s.requires_arc    = true
+
+  s.dependency "React-Core"
+  s.dependency "ReactCommon/turbomodule/core"
+
+  s.pod_target_xcconfig = {
+    "SWIFT_VERSION"        => "5.9",
+    "CLANG_ENABLE_MODULES" => "YES",
+  }
+end

package/README.md

@@ -0,0 +1,27 @@
+# @pulseboard/react-native
+
+> Official PulseBoard SDK for React Native. Built exclusively for iOS and Android using native React Native APIs.
+
+## Installation
+
+```bash
+npm install @pulseboard/react-native
+```
+
+## iOS
+
+```bash
+npx pod-install
+```
+
+## Android Permissions
+
+Add the following to your `AndroidManifest.xml`:
+
+```xml
+<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+<uses-permission android:name="android.permission.READ_PHONE_STATE" />
+```
+
+`READ_PHONE_STATE` is only required for carrier name detection.
+If you prefer not to request it, carrier will return `"unknown"`.

package/android/build.gradle

@@ -0,0 +1,46 @@
+buildscript {
+  ext.safeExtGet = { prop, fallback ->
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath("com.android.tools.build:gradle:8.1.0")
+    classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.0")
+  }
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+android {
+  compileSdkVersion safeExtGet("compileSdkVersion", 34)
+  namespace "com.pulseboard"
+
+  defaultConfig {
+    minSdkVersion safeExtGet("minSdkVersion", 24)
+    targetSdkVersion safeExtGet("targetSdkVersion", 34)
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = "17"
+  }
+}
+
+repositories {
+  google()
+  mavenCentral()
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.READ_PHONE_STATE" />
+</manifest>

package/android/src/main/java/com/pulseboard/PulseBoardDeviceModule.kt

@@ -0,0 +1,81 @@
+package com.pulseboard
+
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import android.util.DisplayMetrics
+import android.view.WindowManager
+import com.facebook.react.bridge.*
+
+class PulseBoardDeviceModule(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  override fun getName() = "PulseBoardDevice"
+
+  @ReactMethod
+  fun getDeviceInfo(promise: Promise) {
+    try {
+      val context     = reactContext
+      val packageInfo = context.packageManager.getPackageInfo(context.packageName, 0)
+      val metrics     = DisplayMetrics()
+
+      @Suppress("DEPRECATION")
+      val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+        val windowMetrics = windowManager.currentWindowMetrics
+        metrics.widthPixels  = windowMetrics.bounds.width()
+        metrics.heightPixels = windowMetrics.bounds.height()
+      } else {
+        @Suppress("DEPRECATION")
+        windowManager.defaultDisplay.getMetrics(metrics)
+      }
+
+      val result = Arguments.createMap().apply {
+        putString("model",        Build.MODEL)
+        putString("manufacturer", Build.MANUFACTURER)
+        putString("brand",        Build.BRAND)
+        putString("os",           "Android")
+        putString("osVersion",    Build.VERSION.RELEASE)
+        putString("appVersion",   packageInfo.versionName ?: "unknown")
+        putString("buildNumber",  getBuildNumber(packageInfo))
+        putString("bundleId",     context.packageName)
+        putDouble("screenWidth",  metrics.widthPixels.toDouble())
+        putDouble("screenHeight", metrics.heightPixels.toDouble())
+        putBoolean("isTablet",    isTablet(context))
+        putBoolean("isEmulator",  isEmulator())
+      }
+
+      promise.resolve(result)
+    } catch (e: Exception) {
+      promise.reject("DEVICE_INFO_ERROR", e.message, e)
+    }
+  }
+
+  private fun getBuildNumber(packageInfo: android.content.pm.PackageInfo): String {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+      packageInfo.longVersionCode.toString()
+    } else {
+      @Suppress("DEPRECATION")
+      packageInfo.versionCode.toString()
+    }
+  }
+
+  private fun isTablet(context: Context): Boolean {
+    val metrics = context.resources.displayMetrics
+    val widthDp  = metrics.widthPixels  / metrics.density
+    val heightDp = metrics.heightPixels / metrics.density
+    return minOf(widthDp, heightDp) >= 600f
+  }
+
+  private fun isEmulator(): Boolean {
+    return (Build.FINGERPRINT.startsWith("generic")
+      || Build.FINGERPRINT.startsWith("unknown")
+      || Build.MODEL.contains("Emulator")
+      || Build.MODEL.contains("Android SDK built for x86")
+      || Build.MANUFACTURER.contains("Genymotion")
+      || Build.BRAND.startsWith("generic")
+      || Build.DEVICE.startsWith("generic")
+      || Build.PRODUCT == "google_sdk")
+  }
+}

package/android/src/main/java/com/pulseboard/PulseBoardDevicePackage.kt

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

package/android/src/main/java/com/pulseboard/PulseBoardNetworkModule.kt

@@ -0,0 +1,81 @@
+package com.pulseboard
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.NetworkCapabilities
+import android.os.Build
+import android.telephony.TelephonyManager
+import com.facebook.react.bridge.*
+import java.net.NetworkInterface
+
+class PulseBoardNetworkModule(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  override fun getName() = "PulseBoardNetwork"
+
+  @ReactMethod
+  fun getNetworkInfo(promise: Promise) {
+    try {
+      val connectivityManager = reactContext
+        .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+
+      val result = Arguments.createMap().apply {
+        putString("type",          getConnectionType(connectivityManager))
+        putBoolean("isConnected",  isConnected(connectivityManager))
+        putBoolean("isWifiEnabled", isWifi(connectivityManager))
+        putString("carrier",       getCarrier())
+        putString("ipAddress",     getIPAddress() ?: "unknown")
+      }
+
+      promise.resolve(result)
+    } catch (e: Exception) {
+      promise.reject("NETWORK_INFO_ERROR", e.message, e)
+    }
+  }
+
+  private fun getConnectionType(cm: ConnectivityManager): String {
+    val network = cm.activeNetwork ?: return "offline"
+    val caps    = cm.getNetworkCapabilities(network) ?: return "unknown"
+
+    return when {
+      caps.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)     -> "wifi"
+      caps.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> "cellular"
+      caps.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET) -> "ethernet"
+      else                                                       -> "unknown"
+    }
+  }
+
+  private fun isConnected(cm: ConnectivityManager): Boolean {
+    val network = cm.activeNetwork ?: return false
+    val caps    = cm.getNetworkCapabilities(network) ?: return false
+    return caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+  }
+
+  private fun isWifi(cm: ConnectivityManager): Boolean {
+    val network = cm.activeNetwork ?: return false
+    val caps    = cm.getNetworkCapabilities(network) ?: return false
+    return caps.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
+  }
+
+  private fun getCarrier(): String {
+    return try {
+      val telephonyManager = reactContext
+        .getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager
+      telephonyManager.networkOperatorName.takeIf { it.isNotEmpty() } ?: "unknown"
+    } catch (e: Exception) {
+      "unknown"
+    }
+  }
+
+  private fun getIPAddress(): String? {
+    return try {
+      NetworkInterface.getNetworkInterfaces()
+        .asSequence()
+        .flatMap { it.inetAddresses.asSequence() }
+        .firstOrNull { !it.isLoopbackAddress && it.hostAddress?.contains(':') == false }
+        ?.hostAddress
+    } catch (e: Exception) {
+      null
+    }
+  }
+}

package/android/src/main/java/com/pulseboard/PulseBoardNetworkPackage.kt

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

package/android/src/main/java/com/pulseboard/PulseBoardPackage.kt

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

package/dist/index.d.mts

@@ -0,0 +1,103 @@
+type EventType = "error" | "event" | "metric";
+type Platform = "ios" | "android" | "unknown";
+type NetworkType = "wifi" | "cellular" | "offline" | "unknown";
+type AppContext = {
+    appVersion?: string;
+    buildNumber?: string;
+    environment?: "production" | "staging" | "development";
+};
+type UserContext = {
+    userId?: string;
+    email?: string;
+    username?: string;
+};
+type DeviceContext = {
+    platform: Platform;
+    os: string;
+    osVersion: string | number;
+    model: string;
+    manufacturer: string;
+    brand: string;
+    isTablet: boolean;
+    appVersion: string;
+    buildNumber: string;
+    bundleId: string;
+    screenWidth: number;
+    screenHeight: number;
+    fontScale: number;
+    isEmulator: boolean;
+    language: string;
+    timezone: string;
+};
+type NetworkContext = {
+    type: NetworkType;
+    isConnected: boolean;
+    isWifiEnabled: boolean;
+    carrier: string;
+    ipAddress: string;
+};
+type SessionContext = {
+    sessionId: string;
+    startedAt: string;
+};
+type EnrichedContext = {
+    app: AppContext;
+    device: DeviceContext;
+    network: NetworkContext;
+    session: SessionContext;
+    user: UserContext;
+};
+type PulseEvent = {
+    apiKey: string;
+    type: EventType;
+    name: string;
+    payload: Record<string, unknown>;
+    timestamp: string;
+    context?: EnrichedContext;
+};
+type SDKConfig = {
+    apiKey: string;
+    host: string;
+    app?: AppContext;
+    autoCapture?: boolean;
+    debug?: boolean;
+    flushInterval?: number;
+    maxQueueSize?: number;
+};
+type TrackOptions = {
+    payload?: Record<string, unknown>;
+    timestamp?: string;
+};
+type CaptureErrorOptions = {
+    payload?: Record<string, unknown>;
+};
+
+declare class PulseBoardSDK {
+    private config;
+    private client;
+    private queue;
+    private autoCapture;
+    private contextCollector;
+    private flushTimer;
+    private initialized;
+    init(config: SDKConfig): void;
+    getContext(): Promise<EnrichedContext>;
+    identify(user: UserContext): void;
+    clearUser(): void;
+    track(name: string, options?: TrackOptions): void;
+    metric(name: string, value: number, options?: TrackOptions): void;
+    captureError(error: Error, options?: CaptureErrorOptions): void;
+    startSession(): void;
+    endSession(duration?: number): void;
+    trackScreen(screenName: string, loadTime?: number): void;
+    trackApiCall(endpoint: string, httpMethod: string, statusCode: number, duration: number, payloadSize?: number): void;
+    trackCrash(error: Error, isFatal?: boolean): void;
+    flush(): Promise<void>;
+    destroy(): void;
+    private buildAndEnqueue;
+    private assertInitialized;
+    private log;
+}
+declare const PulseBoard: PulseBoardSDK;
+
+export { type AppContext, type CaptureErrorOptions, type DeviceContext, type EnrichedContext, type EventType, type NetworkContext, PulseBoard, type PulseEvent, type SDKConfig, type SessionContext, type TrackOptions, type UserContext };

package/dist/index.d.ts

@@ -0,0 +1,103 @@
+type EventType = "error" | "event" | "metric";
+type Platform = "ios" | "android" | "unknown";
+type NetworkType = "wifi" | "cellular" | "offline" | "unknown";
+type AppContext = {
+    appVersion?: string;
+    buildNumber?: string;
+    environment?: "production" | "staging" | "development";
+};
+type UserContext = {
+    userId?: string;
+    email?: string;
+    username?: string;
+};
+type DeviceContext = {
+    platform: Platform;
+    os: string;
+    osVersion: string | number;
+    model: string;
+    manufacturer: string;
+    brand: string;
+    isTablet: boolean;
+    appVersion: string;
+    buildNumber: string;
+    bundleId: string;
+    screenWidth: number;
+    screenHeight: number;
+    fontScale: number;
+    isEmulator: boolean;
+    language: string;
+    timezone: string;
+};
+type NetworkContext = {
+    type: NetworkType;
+    isConnected: boolean;
+    isWifiEnabled: boolean;
+    carrier: string;
+    ipAddress: string;
+};
+type SessionContext = {
+    sessionId: string;
+    startedAt: string;
+};
+type EnrichedContext = {
+    app: AppContext;
+    device: DeviceContext;
+    network: NetworkContext;
+    session: SessionContext;
+    user: UserContext;
+};
+type PulseEvent = {
+    apiKey: string;
+    type: EventType;
+    name: string;
+    payload: Record<string, unknown>;
+    timestamp: string;
+    context?: EnrichedContext;
+};
+type SDKConfig = {
+    apiKey: string;
+    host: string;
+    app?: AppContext;
+    autoCapture?: boolean;
+    debug?: boolean;
+    flushInterval?: number;
+    maxQueueSize?: number;
+};
+type TrackOptions = {
+    payload?: Record<string, unknown>;
+    timestamp?: string;
+};
+type CaptureErrorOptions = {
+    payload?: Record<string, unknown>;
+};
+
+declare class PulseBoardSDK {
+    private config;
+    private client;
+    private queue;
+    private autoCapture;
+    private contextCollector;
+    private flushTimer;
+    private initialized;
+    init(config: SDKConfig): void;
+    getContext(): Promise<EnrichedContext>;
+    identify(user: UserContext): void;
+    clearUser(): void;
+    track(name: string, options?: TrackOptions): void;
+    metric(name: string, value: number, options?: TrackOptions): void;
+    captureError(error: Error, options?: CaptureErrorOptions): void;
+    startSession(): void;
+    endSession(duration?: number): void;
+    trackScreen(screenName: string, loadTime?: number): void;
+    trackApiCall(endpoint: string, httpMethod: string, statusCode: number, duration: number, payloadSize?: number): void;
+    trackCrash(error: Error, isFatal?: boolean): void;
+    flush(): Promise<void>;
+    destroy(): void;
+    private buildAndEnqueue;
+    private assertInitialized;
+    private log;
+}
+declare const PulseBoard: PulseBoardSDK;
+
+export { type AppContext, type CaptureErrorOptions, type DeviceContext, type EnrichedContext, type EventType, type NetworkContext, PulseBoard, type PulseEvent, type SDKConfig, type SessionContext, type TrackOptions, type UserContext };