@dreamhorizonorg/pulse-react-native 0.0.1

package/android/build.gradle

@@ -0,0 +1,97 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['PulseReactNativeOtel_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["PulseReactNativeOtel_" + name]).toInteger()
+}
+
+android {
+  namespace "com.pulsereactnativeotel"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+      consumerProguardFiles 'proguard-rules.pro'
+    }
+    debug {
+      consumerProguardFiles 'proguard-rules.pro'
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation("com.facebook.react:react-android")
+  implementation("org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version")
+
+  api("org.dreamhorizon:pulse-android-sdk:0.0.1-alpha") {
+    exclude group: "com.squareup.okhttp3", module: "okhttp-jvm"
+  }
+  api("com.squareup.okhttp3:okhttp:5.0.0-alpha.14")
+}
+
+configurations.all {
+  resolutionStrategy {
+    eachDependency {
+      if (requested.group == "com.squareup.okhttp3" && requested.name == "okhttp-jvm") {
+        useTarget("com.squareup.okhttp3:okhttp:${requested.version}")
+        because("Resolving okhttp-jvm to okhttp for Android compatibility")
+      }
+    }
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+PulseReactNativeOtel_kotlinVersion=2.0.21
+PulseReactNativeOtel_minSdkVersion=24
+PulseReactNativeOtel_targetSdkVersion=35
+PulseReactNativeOtel_compileSdkVersion=35
+PulseReactNativeOtel_ndkVersion=27.1.12297006

package/android/proguard-rules.pro

@@ -0,0 +1,108 @@
+# Pulse React Native OpenTelemetry - Consumer ProGuard Rules
+# These rules are automatically applied to consuming applications
+
+# ===== OpenTelemetry ProGuard Rules =====
+# OpenTelemetry is heavily reflection-based and needs these classes preserved
+
+# Keep all OpenTelemetry classes
+-keep class io.opentelemetry.** { *; }
+-dontwarn io.opentelemetry.**
+
+# Keep OpenTelemetry API
+-keep class io.opentelemetry.api.** { *; }
+-keep interface io.opentelemetry.api.** { *; }
+
+# Keep OpenTelemetry SDK
+-keep class io.opentelemetry.sdk.** { *; }
+
+# Keep OpenTelemetry Context (critical for span propagation)
+-keep class io.opentelemetry.context.** { *; }
+-keep class io.opentelemetry.context.Context { *; }
+-keep class io.opentelemetry.context.Scope { *; }
+-keep class io.opentelemetry.context.ImplicitContextKeyed { *; }
+-keep interface io.opentelemetry.context.** { *; }
+
+# ===== Missing Compile-Time Annotations =====
+# These annotations are compile-time only and not needed at runtime
+# R8/ProGuard should ignore them when missing
+
+-dontwarn com.google.errorprone.annotations.**
+-dontwarn javax.annotation.**
+-dontwarn org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement
+-dontwarn edu.umd.cs.findbugs.annotations.**
+-dontwarn org.checkerframework.checker.**
+-dontwarn com.google.j2objc.annotations.**
+
+# Specifically ignore the MustBeClosed annotation that R8 complains about
+-dontwarn com.google.errorprone.annotations.MustBeClosed
+-dontwarn com.google.errorprone.annotations.CanIgnoreReturnValue
+-dontwarn com.google.errorprone.annotations.CheckReturnValue
+-dontwarn com.google.errorprone.annotations.concurrent.**
+
+# ===== Missing Java SE Classes (not available in Android) =====
+# java.beans package is part of Java SE but not Android
+# These are referenced by libraries like SnakeYAML and Jackson but not used at runtime
+
+-dontwarn java.beans.**
+-dontwarn java.beans.BeanInfo
+-dontwarn java.beans.ConstructorProperties
+-dontwarn java.beans.FeatureDescriptor
+-dontwarn java.beans.IntrospectionException
+-dontwarn java.beans.Introspector
+-dontwarn java.beans.PropertyDescriptor
+-dontwarn java.beans.Transient
+
+# SnakeYAML uses java.beans for reflection but has fallbacks
+-dontwarn org.yaml.snakeyaml.introspector.MethodProperty
+
+# Jackson uses java.beans for annotations but has fallbacks
+-dontwarn com.fasterxml.jackson.databind.ext.Java7SupportImpl
+
+# ===== Pulse React Native OTEL =====
+# Keep our library classes
+-keep class com.pulsereactnativeotel.** { *; }
+-keepclassmembers class com.pulsereactnativeotel.** { *; }
+
+# Keep Kotlin metadata
+-keep class kotlin.Metadata { *; }
+
+# ===== General Rules =====
+# Keep attributes needed for proper functioning
+-keepattributes Signature
+-keepattributes *Annotation*
+-keepattributes InnerClasses
+-keepattributes EnclosingMethod
+-keepattributes Exceptions
+-keepattributes SourceFile
+-keepattributes LineNumberTable
+
+# Keep generic signatures for proper type checking
+-keepattributes Signature
+
+# ===== React Native Specific =====
+# Keep native method names
+-keepclasseswithmembernames class * {
+    native <methods>;
+}
+
+# Keep React Native annotations
+-keep,allowobfuscation @interface com.facebook.proguard.annotations.DoNotStrip
+-keep,allowobfuscation @interface com.facebook.proguard.annotations.KeepGettersAndSetters
+-keep,allowobfuscation @interface com.facebook.common.internal.DoNotStrip
+-keep,allowobfuscation @interface com.facebook.jni.annotations.DoNotStrip
+
+-keep @com.facebook.proguard.annotations.DoNotStrip class *
+-keep @com.facebook.common.internal.DoNotStrip class *
+-keep @com.facebook.jni.annotations.DoNotStrip class *
+
+-keepclassmembers class * {
+    @com.facebook.proguard.annotations.DoNotStrip *;
+    @com.facebook.common.internal.DoNotStrip *;
+    @com.facebook.jni.annotations.DoNotStrip *;
+}
+
+-keepclassmembers @com.facebook.proguard.annotations.KeepGettersAndSetters class * {
+  void set*(***);
+  *** get*();
+}
+

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/pulsereactnativeotel/PulseOtelConstants.kt

@@ -0,0 +1,20 @@
+package com.pulsereactnativeotel
+
+object PulseOtelConstants {
+  const val INSTRUMENTATION_SCOPE = "com.pulsereactnativeotel"
+
+  const val ATTR_ERROR_FATAL = "error.fatal"
+  const val ATTR_ERROR_TYPE = "exception.type"
+  const val ATTR_ERROR_MESSAGE = "exception.message"
+  const val ATTR_ERROR_STACK = "exception.stacktrace"
+  const val ATTR_ERROR_SOURCE = "error.source"
+
+  const val ATTR_THREAD_ID = "thread.id"
+  const val ATTR_THREAD_NAME = "thread.name"
+
+  const val PLATFORM_REACT_NATIVE = "react-native"
+  const val DEFAULT_ERROR_TYPE = "javascript"
+  const val ERROR_SOURCE_JS = "js"
+}
+
+

package/android/src/main/java/com/pulsereactnativeotel/PulseReactNativeOtelLogger.kt

@@ -0,0 +1,73 @@
+package com.pulsereactnativeotel
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.pulse.android.sdk.PulseSDK
+
+object PulseReactNativeOtelLogger {
+
+    fun trackEvent(
+        event: String,
+        observedTimeMs: Long,
+        properties: ReadableMap?
+    ) {
+        val params = buildMap {
+            properties?.let { putAll(it.toMap()) }
+        }
+
+        PulseSDK.INSTANCE.trackEvent(event, observedTimeMs, params)
+    }
+
+    fun reportException(
+        errorMessage: String,
+        observedTimeMs: Long,
+        stackTrace: String,
+        isFatal: Boolean,
+        errorType: String,
+        attributes: ReadableMap?
+    ) {
+        val params = buildMap {
+            put(PulseOtelConstants.ATTR_ERROR_TYPE, errorType.ifEmpty { PulseOtelConstants.DEFAULT_ERROR_TYPE })
+            put(PulseOtelConstants.ATTR_ERROR_FATAL, isFatal)
+            put(PulseOtelConstants.ATTR_ERROR_MESSAGE, errorMessage)
+            put(PulseOtelConstants.ATTR_ERROR_STACK, stackTrace)
+            put(PulseOtelConstants.ATTR_THREAD_ID, getCurrentThreadId())
+            put(PulseOtelConstants.ATTR_THREAD_NAME, Thread.currentThread().name)
+            put(PulseOtelConstants.ATTR_ERROR_SOURCE, PulseOtelConstants.ERROR_SOURCE_JS)
+            attributes?.let { putAll(it.toMap()) }
+        }
+
+        PulseSDK.INSTANCE.trackNonFatal(errorMessage, observedTimeMs, params)
+    }
+
+    private fun getCurrentThreadId(): String {
+        @Suppress("DEPRECATION")
+        return Thread.currentThread().id.toString()
+    }
+
+    private fun ReadableMap.toMap(): Map<String, Any?> = buildMap {
+        entryIterator.forEach { (key, value) ->
+            put(key, value?.toAny())
+        }
+    }
+
+    private fun Any.toAny(): Any = when (this) {
+        is String -> this
+        is Number -> this
+        is Boolean -> this
+        is ReadableArray -> this.toList()
+        else -> this.toString()
+    }
+
+    private fun ReadableArray.toList(): List<Any?> {
+        if (size() == 0) return emptyList()
+
+        return when (getType(0)) {
+            ReadableType.String -> toArrayList()
+            ReadableType.Number -> toArrayList()
+            ReadableType.Boolean -> toArrayList()
+            else -> emptyList()
+        }
+    }
+}

package/android/src/main/java/com/pulsereactnativeotel/PulseReactNativeOtelModule.kt

@@ -0,0 +1,85 @@
+package com.pulsereactnativeotel
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.pulse.android.sdk.PulseSDK
+import android.os.Looper
+import android.util.Log
+import android.os.Handler
+
+@ReactModule(name = PulseReactNativeOtelModule.NAME)
+class PulseReactNativeOtelModule(reactContext: ReactApplicationContext) :
+  NativePulseReactNativeOtelSpec(reactContext) {
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  override fun isInitialized(): Boolean {
+    return PulseSDK.INSTANCE.isInitialized()
+  }
+
+  override fun trackEvent(event: String, observedTimeMs: Double, properties: ReadableMap?): Boolean {
+    PulseReactNativeOtelLogger.trackEvent(event, observedTimeMs.toLong(), properties)
+    return true
+  }
+
+  override fun reportException(errorMessage: String, observedTimeMs: Double, stackTrace: String, isFatal: Boolean, errorType: String, attributes: ReadableMap?): Boolean {
+    PulseReactNativeOtelLogger.reportException(errorMessage, observedTimeMs.toLong(), stackTrace, isFatal, errorType, attributes)
+    return true
+  }
+
+  override fun startSpan(name: String, attributes: ReadableMap?): String {
+    return PulseReactNativeOtelTracer.startSpan(name, attributes)
+  }
+
+  override fun endSpan(spanId: String, statusCode: String?): Boolean {
+    PulseReactNativeOtelTracer.endSpan(spanId, statusCode)
+    return true
+  }
+
+  override fun addSpanEvent(spanId: String, name: String, attributes: ReadableMap?): Boolean {
+    PulseReactNativeOtelTracer.addEvent(spanId, name, attributes)
+    return true
+  }
+
+  override fun setSpanAttributes(spanId: String, attributes: ReadableMap?): Boolean {
+    PulseReactNativeOtelTracer.setAttributes(spanId, attributes)
+    return true
+  }
+
+  override fun recordSpanException(spanId: String, errorMessage: String, stackTrace: String?): Boolean {
+    PulseReactNativeOtelTracer.recordException(spanId, errorMessage, stackTrace)
+    return  true
+  }
+
+  override fun setUserId(id: String?) {
+    PulseSDK.INSTANCE.setUserId(id)
+  }
+
+  override fun setUserProperty(name: String, value: String?) {
+    PulseSDK.INSTANCE.setUserProperty(name, value)
+  }
+
+  override fun setUserProperties(properties: ReadableMap?) {
+    properties?.let { props ->
+      PulseSDK.INSTANCE.setUserProperties {
+        props.entryIterator.forEach { (key, value) ->
+          put(key, value)
+        }
+      }
+    }
+  }
+
+  override fun triggerAnr() {
+    Handler(Looper.getMainLooper()).postAtFrontOfQueue {
+      Log.d("[Pulse]", "Now running PostAtFrontQueue: ${Thread.currentThread().name}")
+      Thread.sleep(10_000)
+    }
+  }
+
+  companion object {
+    const val NAME = "PulseReactNativeOtel"
+  }
+}

package/android/src/main/java/com/pulsereactnativeotel/PulseReactNativeOtelPackage.kt

@@ -0,0 +1,33 @@
+package com.pulsereactnativeotel
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class PulseReactNativeOtelPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == PulseReactNativeOtelModule.NAME) {
+      PulseReactNativeOtelModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[PulseReactNativeOtelModule.NAME] = ReactModuleInfo(
+        PulseReactNativeOtelModule.NAME,
+        PulseReactNativeOtelModule.NAME,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        false,  // isCxxModule
+        true // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+}

package/android/src/main/java/com/pulsereactnativeotel/PulseReactNativeOtelTracer.kt

@@ -0,0 +1,127 @@
+package com.pulsereactnativeotel
+
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableType
+import com.pulse.android.sdk.PulseSDK
+import io.opentelemetry.api.common.AttributeKey
+import io.opentelemetry.api.trace.Span
+import io.opentelemetry.api.trace.SpanKind
+import io.opentelemetry.api.trace.StatusCode
+import io.opentelemetry.api.trace.Tracer
+import io.opentelemetry.context.Scope
+import java.util.UUID
+import java.util.concurrent.ConcurrentHashMap
+
+object PulseReactNativeOtelTracer {
+
+    private val tracer: Tracer by lazy {
+        PulseSDK.INSTANCE.getOtelOrThrow()
+            .getOpenTelemetry()
+            .tracerProvider
+            .tracerBuilder(PulseOtelConstants.INSTRUMENTATION_SCOPE)
+            .build()
+    }
+
+    private val idToSpan = ConcurrentHashMap<String, Span>()
+    private val idToScope = ConcurrentHashMap<String, Scope>()
+
+    fun startSpan(name: String, attributes: ReadableMap?): String {
+        val span = tracer.spanBuilder(name)
+            .setSpanKind(SpanKind.INTERNAL)
+            .startSpan()
+
+        val scope = span.makeCurrent()
+
+        attributes?.applyTo(span)
+
+        val id = UUID.randomUUID().toString()
+        idToSpan[id] = span
+        idToScope[id] = scope
+
+        return id
+    }
+
+    fun addEvent(spanId: String, name: String, attributes: ReadableMap?) {
+        idToSpan[spanId]?.let { span ->
+            attributes?.applyTo(span)
+            span.addEvent(name)
+        }
+    }
+
+    fun setAttributes(spanId: String, attributes: ReadableMap?) {
+        idToSpan[spanId]?.let { span ->
+            attributes?.applyTo(span)
+        }
+    }
+
+    fun recordException(spanId: String, errorMessage: String, stackTrace: String?) {
+        idToSpan[spanId]?.let { span ->
+            val throwable = RuntimeException(errorMessage)
+            span.recordException(throwable)
+            span.setAttribute(
+                AttributeKey.stringKey(PulseOtelConstants.ATTR_ERROR_MESSAGE),
+                errorMessage
+            )
+
+            stackTrace?.takeIf { it.isNotEmpty() }?.let {
+                span.setAttribute(
+                    AttributeKey.stringKey(PulseOtelConstants.ATTR_ERROR_STACK),
+                    it
+                )
+            }
+        }
+    }
+
+    fun endSpan(spanId: String, statusCode: String?) {
+        idToSpan.remove(spanId)?.let { span ->
+            when (statusCode?.uppercase()) {
+                "OK" -> span.setStatus(StatusCode.OK)
+                "ERROR" -> span.setStatus(StatusCode.ERROR)
+                else -> span.setStatus(StatusCode.UNSET)
+            }
+            span.end()
+        }
+        idToScope.remove(spanId)?.close()
+    }
+
+    private fun ReadableMap.applyTo(span: Span) {
+        entryIterator.forEach { (key, value) ->
+            when (value) {
+                is String -> span.setAttribute(AttributeKey.stringKey(key), value)
+                is Boolean -> span.setAttribute(AttributeKey.booleanKey(key), value)
+                is Number -> span.setAttribute(AttributeKey.doubleKey(key), value.toDouble())
+                is ReadableArray -> {
+                    applyArrayAttribute(span, key, value)
+                }
+                else -> {
+                    span.setAttribute(AttributeKey.stringKey(key), value.toString())
+                }
+            }
+        }
+    }
+
+    private fun applyArrayAttribute(span: Span, key: String, array: ReadableArray) {
+        if (array.size() == 0) {
+            span.setAttribute(AttributeKey.stringArrayKey(key), emptyList())
+            return
+        }
+
+        when (array.getType(0)) {
+            ReadableType.String -> {
+                span.setAttribute(AttributeKey.stringArrayKey(key), array.toArrayList() as List<String>)
+            }
+            ReadableType.Number -> {
+                span.setAttribute(AttributeKey.doubleArrayKey(key), array.toArrayList() as List<Double>)
+            }
+            ReadableType.Boolean -> {
+                span.setAttribute(AttributeKey.booleanArrayKey(key), array.toArrayList() as List<Boolean>)
+            }
+            else -> {
+                span.setAttribute(AttributeKey.stringKey(key), array.toString())
+            }
+        }
+    }
+}
+
+

package/ios/PulseReactNativeOtel.h

@@ -0,0 +1,5 @@
+#import <PulseReactNativeOtelSpec/PulseReactNativeOtelSpec.h>
+
+@interface PulseReactNativeOtel : NSObject <NativePulseReactNativeOtelSpec>
+
+@end

package/ios/PulseReactNativeOtel.mm

@@ -0,0 +1,100 @@
+#import "PulseReactNativeOtel.h"
+
+@implementation PulseReactNativeOtel
+
+RCT_EXPORT_MODULE()
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+- (instancetype)init
+{
+  self = [super init];
+  if (self) {
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+      NSLog(@"[Pulse] iOS support coming soon. All operations will be no-ops.");
+    });
+  }
+  return self;
+}
+
+// Check if native SDK is initialized (always false on iOS)
+- (NSNumber *)isInitialized
+{
+  return @NO;
+}
+
+// Track event (no-op)
+- (NSNumber *)trackEvent:(NSString *)event
+          observedTimeMs:(double)observedTimeMs
+              properties:(NSDictionary *)properties
+{
+  return @NO;
+}
+
+// Start span (returns no-op span ID)
+- (NSString *)startSpan:(NSString *)name
+             attributes:(NSDictionary *)attributes
+{
+  return [NSString stringWithFormat:@"noop-ios-%@", [[NSUUID UUID] UUIDString]];
+}
+
+// End span (no-op)
+- (NSNumber *)endSpan:(NSString *)spanId
+{
+  return @NO;
+}
+
+// Add span event (no-op)
+- (NSNumber *)addSpanEvent:(NSString *)spanId
+                name:(NSString *)name
+          attributes:(NSDictionary *)attributes
+{
+  return @NO;
+}
+
+// Set span attributes (no-op)
+- (NSNumber *)setSpanAttributes:(NSString *)spanId
+               attributes:(NSDictionary *)attributes
+{
+  return @NO;
+}
+
+// Record span exception (no-op)
+- (NSNumber *)recordSpanException:(NSString *)spanId
+               errorMessage:(NSString *)errorMessage
+                 stackTrace:(NSString *)stackTrace
+{
+  return @NO;
+}
+
+- (nonnull NSNumber *)reportException:(nonnull NSString *)errorMessage observedTimeMs:(double)observedTimeMs stackTrace:(nonnull NSString *)stackTrace isFatal:(BOOL)isFatal errorType:(nonnull NSString *)errorType attributes:(nonnull NSDictionary *)attributes { 
+  return @NO;
+}
+
+
+- (void)setUserId:(NSString * _Nullable)id { 
+  // No op
+}
+
+
+- (void)setUserProperties:(nonnull NSDictionary *)properties { 
+  // No op
+}
+
+
+- (void)setUserProperty:(nonnull NSString *)name value:(NSString * _Nullable)value { 
+  // No op
+}
+
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativePulseReactNativeOtelSpecJSI>(params);
+}
+
+@end

package/lib/module/NativePulseReactNativeOtel.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('PulseReactNativeOtel');
+//# sourceMappingURL=NativePulseReactNativeOtel.js.map

package/lib/module/NativePulseReactNativeOtel.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativePulseReactNativeOtel.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAA0B,cAAc;AAwDpE,eAAeA,mBAAmB,CAACC,YAAY,CAAO,sBAAsB,CAAC","ignoreList":[]}