react-native-nitro-fetch 1.1.0 → 1.1.1

package/android/src/main/java/com/margelo/nitro/nitrofetch/DevToolsReporter.kt

@@ -1,111 +1,106 @@
 package com.margelo.nitro.nitrofetch
 
 /**
- * Thin facade over React Native's [com.facebook.react.modules.network.InspectorNetworkReporter].
- * All methods are no-ops when the modern CDP debugger is not attached (guarded by
- * `isDebuggingEnabled()` inside RN), so they are safe to call in release builds.
+ * Thin facade over React Native's `com.facebook.react.modules.network.InspectorNetworkReporter`.
  *
- * The underlying reporter is marked `internal` in RN but is the officially documented
- * Kotlin entry point for third-party networking libraries to surface requests in the
- * Fusebox / RN DevTools Network tab. We intentionally bypass the visibility modifier
- * rather than duplicating the JNI bindings, matching the pattern used by other
- * community HTTP clients. If the class isn't present (RN < 0.76 or a trimmed
- * distribution), every call becomes a no-op.
+ * The reporter is `internal` in RN and may be missing entirely on older versions or stripped
+ * distributions. To stay both safe (no [NoClassDefFoundError]) and fast (no per-call reflection
+ * once the class is known to exist), we use the **isolation-class pattern**:
+ *
+ *  - This facade has *no* compile-time reference to `InspectorNetworkReporter`. It can always
+ *    be loaded and verified by ART, even when the reporter is absent.
+ *  - All direct calls live in [DevToolsReporterImpl], which is loaded reflectively *once* via
+ *    `Class.forName`. If verification fails (missing class), we catch and stay in no-op mode.
+ *  - On success, we hold an [Impl] interface reference and dispatch through it on every call —
+ *    a single null check + a virtual call (likely devirtualized by the JIT). No reflection,
+ *    no boxing, no method-handle lookups on the hot path.
  */
-@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
 internal object DevToolsReporter {
-  private val available: Boolean = try {
-    Class.forName("com.facebook.react.modules.network.InspectorNetworkReporter")
-    true
-  } catch (_: Throwable) {
-    false
+
+  /** Stable interface in *our* package — Impl implements it; no foreign types here. */
+  internal interface Impl {
+    fun isDebuggingEnabled(): Boolean
+    fun reportRequestStart(
+      requestId: String, url: String, method: String,
+      headers: Map<String, String>, body: String, encodedDataLength: Long
+    )
+    fun reportResponseStart(
+      requestId: String, url: String, statusCode: Int,
+      headers: Map<String, String>, expectedDataLength: Long
+    )
+    fun reportDataReceived(requestId: String, length: Int)
+    fun reportResponseEnd(requestId: String, encodedDataLength: Long)
+    fun reportRequestFailed(requestId: String, cancelled: Boolean)
+    fun storeResponseBody(requestId: String, body: String, base64Encoded: Boolean)
+    fun storeResponseBodyIncremental(requestId: String, data: String)
   }
 
-  fun isDebuggingEnabled(): Boolean {
-    if (!available) return false
+  @Volatile private var impl: Impl? = null
+  // We deliberately do NOT latch failure: cold-start prefetch can run before
+  // RN classes are realized, and we want a later request to recover. The
+  // probe is cheap (Class.forName has its own internal cache).
+  private fun resolve(): Impl? {
+    val cached = impl
+    if (cached != null) return cached
+
+    if (!isSoLoaderInitialized()) return null
     return try {
-      com.facebook.react.modules.network.InspectorNetworkReporter.isDebuggingEnabled()
+      val cls = Class.forName("com.margelo.nitro.nitrofetch.DevToolsReporterImpl")
+  
+      val created = cls.getDeclaredConstructor().newInstance() as Impl
+      impl = created
+      created
     } catch (_: Throwable) {
-      false
+      null
     }
   }
 
+  private fun isSoLoaderInitialized(): Boolean = try {
+    com.facebook.soloader.SoLoader.isInitialized()
+  } catch (_: Throwable) {
+    false
+  }
+
+  // --- Hot path: one null check + interface call. JIT will devirtualize. ---
+
+  fun isDebuggingEnabled(): Boolean = resolve()?.isDebuggingEnabled() ?: false
+
   fun reportRequestStart(
-    requestId: String,
-    url: String,
-    method: String,
-    headers: Map<String, String>,
-    body: String,
-    encodedDataLength: Long
+    requestId: String, url: String, method: String,
+    headers: Map<String, String>, body: String, encodedDataLength: Long
   ) {
-    if (!available) return
-    try {
-      com.facebook.react.modules.network.InspectorNetworkReporter.reportRequestStart(
-        requestId, url, method, headers, body, encodedDataLength
-      )
-      com.facebook.react.modules.network.InspectorNetworkReporter.reportConnectionTiming(requestId, headers)
-    } catch (_: Throwable) {
-    }
+    impl?.reportRequestStart(requestId, url, method, headers, body, encodedDataLength)
   }
 
   fun reportResponseStart(
-    requestId: String,
-    url: String,
-    statusCode: Int,
-    headers: Map<String, String>,
-    expectedDataLength: Long
+    requestId: String, url: String, statusCode: Int,
+    headers: Map<String, String>, expectedDataLength: Long
   ) {
-    if (!available) return
-    try {
-      com.facebook.react.modules.network.InspectorNetworkReporter.reportResponseStart(
-        requestId, url, statusCode, headers, expectedDataLength
-      )
-    } catch (_: Throwable) {
-    }
+    impl?.reportResponseStart(requestId, url, statusCode, headers, expectedDataLength)
   }
 
   fun reportDataReceived(requestId: String, length: Int) {
-    if (!available) return
-    try {
-      com.facebook.react.modules.network.InspectorNetworkReporter.reportDataReceivedImpl(requestId, length)
-    } catch (_: Throwable) {
-    }
+    impl?.reportDataReceived(requestId, length)
   }
 
   fun reportResponseEnd(requestId: String, encodedDataLength: Long) {
-    if (!available) return
-    try {
-      com.facebook.react.modules.network.InspectorNetworkReporter.reportResponseEnd(requestId, encodedDataLength)
-    } catch (_: Throwable) {
-    }
+    impl?.reportResponseEnd(requestId, encodedDataLength)
   }
 
   fun reportRequestFailed(requestId: String, cancelled: Boolean) {
-    if (!available) return
-    try {
-      com.facebook.react.modules.network.InspectorNetworkReporter.reportRequestFailed(requestId, cancelled)
-    } catch (_: Throwable) {
-    }
+    impl?.reportRequestFailed(requestId, cancelled)
   }
 
   fun storeResponseBody(requestId: String, body: String, base64Encoded: Boolean) {
-    if (!available) return
-    try {
-      com.facebook.react.modules.network.InspectorNetworkReporter.maybeStoreResponseBody(
-        requestId, body, base64Encoded
-      )
-    } catch (_: Throwable) {
-    }
+    impl?.storeResponseBody(requestId, body, base64Encoded)
   }
 
   fun storeResponseBodyIncremental(requestId: String, data: String) {
-    if (!available) return
-    try {
-      com.facebook.react.modules.network.InspectorNetworkReporter.maybeStoreResponseBodyIncremental(requestId, data)
-    } catch (_: Throwable) {
-    }
+    impl?.storeResponseBodyIncremental(requestId, data)
   }
 
+  // --- Pure helpers, no reporter dependency. ---
+
   fun isTextualContentType(contentType: String?): Boolean {
     if (contentType == null) return false
     val ct = contentType.lowercase()

package/android/src/main/java/com/margelo/nitro/nitrofetch/DevToolsReporterImpl.kt

@@ -0,0 +1,67 @@
+package com.margelo.nitro.nitrofetch
+
+/**
+ * Direct-dispatch backend for [DevToolsReporter]. Loaded reflectively from the facade
+ * via `Class.forName`, so a missing `InspectorNetworkReporter` only prevents *this* class
+ * from loading — the facade itself stays intact and degrades to a no-op.
+ *
+ * Once loaded, every call here is a plain JVM static invoke. No reflection, no boxing,
+ * no method-handle lookups. The `@Suppress` annotations bypass RN's `internal` visibility
+ * (RN has no public surface here) — this is the documented integration point.
+ */
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+internal class DevToolsReporterImpl : DevToolsReporter.Impl {
+  override fun isDebuggingEnabled(): Boolean =
+    com.facebook.react.modules.network.InspectorNetworkReporter.isDebuggingEnabled()
+
+  override fun reportRequestStart(
+    requestId: String, url: String, method: String,
+    headers: Map<String, String>, body: String, encodedDataLength: Long
+  ) {
+    com.facebook.react.modules.network.InspectorNetworkReporter.reportRequestStart(
+      requestId, url, method, headers, body, encodedDataLength
+    )
+    com.facebook.react.modules.network.InspectorNetworkReporter.reportConnectionTiming(
+      requestId, headers
+    )
+  }
+
+  override fun reportResponseStart(
+    requestId: String, url: String, statusCode: Int,
+    headers: Map<String, String>, expectedDataLength: Long
+  ) {
+    com.facebook.react.modules.network.InspectorNetworkReporter.reportResponseStart(
+      requestId, url, statusCode, headers, expectedDataLength
+    )
+  }
+
+  override fun reportDataReceived(requestId: String, length: Int) {
+    com.facebook.react.modules.network.InspectorNetworkReporter.reportDataReceivedImpl(
+      requestId, length
+    )
+  }
+
+  override fun reportResponseEnd(requestId: String, encodedDataLength: Long) {
+    com.facebook.react.modules.network.InspectorNetworkReporter.reportResponseEnd(
+      requestId, encodedDataLength
+    )
+  }
+
+  override fun reportRequestFailed(requestId: String, cancelled: Boolean) {
+    com.facebook.react.modules.network.InspectorNetworkReporter.reportRequestFailed(
+      requestId, cancelled
+    )
+  }
+
+  override fun storeResponseBody(requestId: String, body: String, base64Encoded: Boolean) {
+    com.facebook.react.modules.network.InspectorNetworkReporter.maybeStoreResponseBody(
+      requestId, body, base64Encoded
+    )
+  }
+
+  override fun storeResponseBodyIncremental(requestId: String, data: String) {
+    com.facebook.react.modules.network.InspectorNetworkReporter.maybeStoreResponseBodyIncremental(
+      requestId, data
+    )
+  }
+}

package/android/src/main/java/com/margelo/nitro/nitrofetch/NitroFetchClient.kt

@@ -80,8 +80,12 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
       if (BuildConfig.NITRO_FETCH_TRACING) {
         Trace.beginAsyncSection(traceLabel, traceCookie)
       }
-      val devToolsRequestId = req.requestId ?: UUID.randomUUID().toString()
-      val devToolsEnabled = DevToolsReporter.isDebuggingEnabled()
+      // BuildConfig.DEBUG short-circuits in release: R8 constant-folds the
+      // && so every `if (devToolsEnabled)` block below becomes dead code and
+      // the DevToolsReporter classes drop out of the release APK entirely.
+      // The UUID generation is gated too so SecureRandom isn't touched in release.
+      val devToolsEnabled = BuildConfig.DEBUG && DevToolsReporter.isDebuggingEnabled()
+      val devToolsRequestId = if (devToolsEnabled) (req.requestId ?: UUID.randomUUID().toString()) else ""
       val callback = object : UrlRequest.Callback() {
         private val buffer = ByteBuffer.allocateDirect(16 * 1024)
         private val out = java.io.ByteArrayOutputStream()

package/android/src/main/java/com/margelo/nitro/nitrofetch/NitroUrlRequestBuilder.kt

@@ -27,8 +27,10 @@ class NitroUrlRequestBuilder(
 
   private val builder: CronetUrlRequest.Builder
   private val byteBuffer: ByteBuffer
-  private val devToolsRequestId: String = UUID.randomUUID().toString()
-  private val devToolsEnabled: Boolean = DevToolsReporter.isDebuggingEnabled()
+  // BuildConfig.DEBUG short-circuits in release so R8 strips DevTools paths.
+  // UUID generation is gated too so SecureRandom isn't touched in release.
+  private val devToolsEnabled: Boolean = BuildConfig.DEBUG && DevToolsReporter.isDebuggingEnabled()
+  private val devToolsRequestId: String = if (devToolsEnabled) UUID.randomUUID().toString() else ""
   private var devToolsBytes: Int = 0
   private var devToolsTextual: Boolean = false
   private var httpMethod: String = "GET"

package/ios/HybridUrlRequestBuilder.swift

@@ -16,7 +16,13 @@ class HybridUrlRequestBuilder: HybridUrlRequestBuilderSpec {
 
   private var urlRequest: URLRequest
   private var priority: Float = 0.5
-  private let devToolsRequestId: String = UUID().uuidString
+  private let devToolsRequestId: String = {
+    #if DEBUG
+    return UUID().uuidString
+    #else
+    return ""
+    #endif
+  }()
 
   init(
     url: String,
@@ -109,9 +115,11 @@ class HybridUrlRequestBuilder: HybridUrlRequestBuilderSpec {
     task.priority = priority
     delegate.task = task
 
+    #if DEBUG
     if NitroDevToolsReporter.isDebuggingEnabled() {
       NitroDevToolsReporter.reportRequestStart(withRequest: devToolsRequestId, request: urlRequest)
     }
+    #endif
 
     let request = HybridUrlRequest(task: task, delegate: delegate)
     delegate.hybridRequest = request
@@ -192,17 +200,21 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
       if let error = error {
         let nsError = error as NSError
         if nsError.code == NSURLErrorCancelled {
+          #if DEBUG
           if NitroDevToolsReporter.isDebuggingEnabled() {
             NitroDevToolsReporter.reportRequestFailed(self.devToolsRequestId, cancelled: true)
           }
+          #endif
           if let callback = self.onCanceled {
             let nitroInfo = self.response?.toNitro()
             callback(nitroInfo)
           }
         } else {
+          #if DEBUG
           if NitroDevToolsReporter.isDebuggingEnabled() {
             NitroDevToolsReporter.reportRequestFailed(self.devToolsRequestId, cancelled: false)
           }
+          #endif
           if let callback = self.onFailed {
             let nitroError = error.toNitro()
             let nitroInfo = self.response?.toNitro()
@@ -210,9 +222,11 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
           }
         }
       } else if let response = self.response {
+        #if DEBUG
         if NitroDevToolsReporter.isDebuggingEnabled() {
           NitroDevToolsReporter.reportResponseEnd(self.devToolsRequestId, encodedDataLength: self.devToolsBytes)
         }
+        #endif
         if let callback = self.onSucceeded {
           let info = response.toNitro()
           callback(info)
@@ -236,6 +250,7 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
 
     executor.sync { [weak self] in
       guard let self = self else { return }
+      #if DEBUG
       if NitroDevToolsReporter.isDebuggingEnabled() {
         var headerDict: [String: String] = [:]
         httpResponse.allHeaderFields.forEach { k, v in
@@ -250,6 +265,7 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
         let ct = headerDict["Content-Type"] ?? headerDict["content-type"]
         self.devToolsTextual = NitroDevToolsReporter.isTextualContentType(ct)
       }
+      #endif
       if let callback = self.onResponseStarted {
         let info = httpResponse.toNitro()
         callback(info)
@@ -268,6 +284,7 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
       executor.sync { [weak self] in
         guard let self = self, let response = self.response else { return }
 
+        #if DEBUG
         if NitroDevToolsReporter.isDebuggingEnabled() {
           self.devToolsBytes += data.count
           NitroDevToolsReporter.reportDataReceived(self.devToolsRequestId, length: data.count)
@@ -275,6 +292,7 @@ private class URLSessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSe
             NitroDevToolsReporter.storeResponseBodyIncremental(self.devToolsRequestId, text: text)
           }
         }
+        #endif
 
         let arrayBuffer: ArrayBuffer
         do {

package/ios/NitroDevToolsReporter.mm

@@ -10,29 +10,39 @@
 #define NITRO_HAS_NETWORK_REPORTER 0
 #endif
 
-// The Objective-C wrapper does not expose -isDebuggingEnabled publicly,
-// but the underlying C++ NetworkReporter does. We avoid depending on the
-// C++ header and instead rely on RN guarding every report call internally.
-// For our own body-capture short-circuit we assume enabled when the class
-// exists; the underlying calls are still no-ops when no debugger attached.
+// During cold-start prefetch, RN's RCTInspectorNetworkReporter class may not
+// be realized yet (its underlying C++ NetworkReporter singleton is brought up
+// when the bridge initializes). Every entry point goes through +reporterClass,
+// which uses NSClassFromString so a missing class becomes a clean no-op
+// instead of crashing on a not-yet-initialized C++ singleton.
 
 @implementation NitroDevToolsReporter
 
-+ (BOOL)isDebuggingEnabled {
++ (Class _Nullable)reporterClass {
 #if NITRO_HAS_NETWORK_REPORTER
-  return YES;
+  static Class cached = Nil;
+  if (cached == Nil) {
+    cached = NSClassFromString(@"RCTInspectorNetworkReporter");
+  }
+  return cached;
 #else
-  return NO;
+  return Nil;
 #endif
 }
 
++ (BOOL)isDebuggingEnabled {
+  return [self reporterClass] != Nil;
+}
+
 + (void)reportRequestStartWithRequest:(NSString *)requestId
                               request:(NSURLRequest *)request {
 #if NITRO_HAS_NETWORK_REPORTER
   if (request == nil) return;
+  Class cls = [self reporterClass];
+  if (cls == Nil) return;
   int encoded = (int)(request.HTTPBody.length);
-  [RCTInspectorNetworkReporter reportRequestStart:requestId request:request encodedDataLength:encoded];
-  [RCTInspectorNetworkReporter reportConnectionTiming:requestId request:request];
+  [cls reportRequestStart:requestId request:request encodedDataLength:encoded];
+  [cls reportConnectionTiming:requestId request:request];
 #endif
 }
 
@@ -42,6 +52,8 @@
                    headers:(NSDictionary<NSString *, NSString *> *)headers
                 bodyString:(NSString *)bodyString {
 #if NITRO_HAS_NETWORK_REPORTER
+  Class cls = [self reporterClass];
+  if (cls == Nil) return;
   NSURL *u = [NSURL URLWithString:url];
   if (u == nil) return;
   NSMutableURLRequest *req = [NSMutableURLRequest requestWithURL:u];
@@ -53,8 +65,8 @@
     req.HTTPBody = [bodyString dataUsingEncoding:NSUTF8StringEncoding];
   }
   NSInteger encoded = bodyString ? (NSInteger)[bodyString lengthOfBytesUsingEncoding:NSUTF8StringEncoding] : 0;
-  [RCTInspectorNetworkReporter reportRequestStart:requestId request:req encodedDataLength:(int)encoded];
-  [RCTInspectorNetworkReporter reportConnectionTiming:requestId request:req];
+  [cls reportRequestStart:requestId request:req encodedDataLength:(int)encoded];
+  [cls reportConnectionTiming:requestId request:req];
 #endif
 }
 
@@ -63,40 +75,48 @@
                  statusCode:(NSInteger)statusCode
                     headers:(NSDictionary<NSString *, NSString *> *)headers {
 #if NITRO_HAS_NETWORK_REPORTER
+  Class cls = [self reporterClass];
+  if (cls == Nil) return;
   NSURL *u = [NSURL URLWithString:url];
   if (u == nil) return;
   NSHTTPURLResponse *resp = [[NSHTTPURLResponse alloc] initWithURL:u
                                                          statusCode:statusCode
                                                         HTTPVersion:@"HTTP/1.1"
                                                        headerFields:headers];
-  [RCTInspectorNetworkReporter reportResponseStart:requestId
-                                           response:resp
-                                         statusCode:(int)statusCode
-                                            headers:headers];
+  [cls reportResponseStart:requestId
+                  response:resp
+                statusCode:(int)statusCode
+                   headers:headers];
 #endif
 }
 
 + (void)reportDataReceived:(NSString *)requestId length:(NSInteger)length {
 #if NITRO_HAS_NETWORK_REPORTER
   if (length <= 0) return;
+  Class cls = [self reporterClass];
+  if (cls == Nil) return;
   // Only data.length is read by the underlying reporter. Avoid allocating a
   // zero-filled buffer by handing NSData a non-owned byte pointer and the
   // intended length.
   static uint8_t sentinel;
   NSData *sized = [NSData dataWithBytesNoCopy:&sentinel length:(NSUInteger)length freeWhenDone:NO];
-  [RCTInspectorNetworkReporter reportDataReceived:requestId data:sized];
+  [cls reportDataReceived:requestId data:sized];
 #endif
 }
 
 + (void)reportResponseEnd:(NSString *)requestId encodedDataLength:(NSInteger)length {
 #if NITRO_HAS_NETWORK_REPORTER
-  [RCTInspectorNetworkReporter reportResponseEnd:requestId encodedDataLength:(int)length];
+  Class cls = [self reporterClass];
+  if (cls == Nil) return;
+  [cls reportResponseEnd:requestId encodedDataLength:(int)length];
 #endif
 }
 
 + (void)reportRequestFailed:(NSString *)requestId cancelled:(BOOL)cancelled {
 #if NITRO_HAS_NETWORK_REPORTER
-  [RCTInspectorNetworkReporter reportRequestFailed:requestId cancelled:cancelled];
+  Class cls = [self reporterClass];
+  if (cls == Nil) return;
+  [cls reportRequestFailed:requestId cancelled:cancelled];
 #endif
 }
 
@@ -104,13 +124,17 @@
                      data:(NSData *)data
             base64Encoded:(BOOL)base64Encoded {
 #if NITRO_HAS_NETWORK_REPORTER
-  [RCTInspectorNetworkReporter maybeStoreResponseBody:requestId data:data base64Encoded:base64Encoded];
+  Class cls = [self reporterClass];
+  if (cls == Nil) return;
+  [cls maybeStoreResponseBody:requestId data:data base64Encoded:base64Encoded];
 #endif
 }
 
 + (void)storeResponseBodyIncremental:(NSString *)requestId text:(NSString *)text {
 #if NITRO_HAS_NETWORK_REPORTER
-  [RCTInspectorNetworkReporter maybeStoreResponseBodyIncremental:requestId data:text];
+  Class cls = [self reporterClass];
+  if (cls == Nil) return;
+  [cls maybeStoreResponseBodyIncremental:requestId data:text];
 #endif
 }
 

package/ios/NitroFetchClient.swift

@@ -170,26 +170,34 @@ final class NitroFetchClient: HybridNitroFetchClientSpec {
                 "%{public}s %{public}s", traceMethod, tracePath)
     #endif
 
+    // DevTools/CDP reporting is gated on `#if DEBUG` so the entire block is
+    // compiled out of release builds — no runtime cost, no symbol references.
+    #if DEBUG
     let devToolsId = req.requestId ?? UUID().uuidString
     if NitroDevToolsReporter.isDebuggingEnabled() {
       NitroDevToolsReporter.reportRequestStart(withRequest: devToolsId, request: urlRequest)
     }
+    #endif
 
     let data: Data
     let response: URLResponse
     do {
       (data, response) = try await session.data(for: urlRequest, delegate: delegate)
     } catch {
+      #if DEBUG
       if NitroDevToolsReporter.isDebuggingEnabled() {
         let cancelled = (error as NSError).code == NSURLErrorCancelled
         NitroDevToolsReporter.reportRequestFailed(devToolsId, cancelled: cancelled)
       }
+      #endif
       throw error
     }
     guard let http = response as? HTTPURLResponse else {
+      #if DEBUG
       if NitroDevToolsReporter.isDebuggingEnabled() {
         NitroDevToolsReporter.reportRequestFailed(devToolsId, cancelled: false)
       }
+      #endif
       throw NSError(domain: "NitroFetch", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid response"])
     }
 
@@ -198,6 +206,7 @@ final class NitroFetchClient: HybridNitroFetchClientSpec {
       return NitroHeader(key: key, value: String(describing: v))
     }
 
+    #if DEBUG
     if NitroDevToolsReporter.isDebuggingEnabled() {
       var headerDict: [String: String] = [:]
       for h in headersPairs { headerDict[h.key] = h.value }
@@ -217,6 +226,7 @@ final class NitroFetchClient: HybridNitroFetchClientSpec {
       }
       NitroDevToolsReporter.reportResponseEnd(devToolsId, encodedDataLength: data.count)
     }
+    #endif
 
     // Choose bodyString by default (matching Android’s first pass)
     let charset = NitroFetchClient.detectCharset(from: http) ?? String.Encoding.utf8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-fetch",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Awesome Fetch :)",
   "main": "./lib/module/index.js",
   "module": "./lib/module/index.js",