react-native-nitro-fetch 0.1.1

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

@@ -0,0 +1,256 @@
+package com.margelo.nitro.nitrofetch
+
+import android.util.Log
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.ArrayBuffer
+import com.margelo.nitro.core.Promise
+import org.chromium.net.CronetEngine
+import org.chromium.net.CronetException
+import org.chromium.net.UrlRequest
+import org.chromium.net.UrlResponseInfo
+import java.nio.ByteBuffer
+import java.util.concurrent.Executor
+
+fun ByteBuffer.toByteArray(): ByteArray {
+  // duplicate to avoid modifying the original buffer's position
+  val dup = this.duplicate()
+  dup.clear() // sets position=0, limit=capacity
+  val arr = ByteArray(dup.remaining())
+  dup.get(arr)
+  return arr
+}
+
+@DoNotStrip
+class NitroFetchClient(private val engine: CronetEngine, private val executor: Executor) : HybridNitroFetchClientSpec() {
+
+  private fun findPrefetchKey(req: NitroRequest): String? {
+    val h = req.headers ?: return null
+    for (pair in h) {
+      val k = pair.key
+      val v = pair.value
+      if (k.equals("prefetchKey", ignoreCase = true)) return v
+    }
+    return null
+  }
+
+  companion object {
+    @JvmStatic
+    fun fetch(
+      req: NitroRequest,
+      onSuccess: (NitroResponse) -> Unit,
+      onFail: (Throwable) -> Unit
+    ) {
+      try {
+        val engine = NitroFetch.getEngine()
+        val executor = NitroFetch.ioExecutor
+        startCronet(engine, executor, req, onSuccess, onFail)
+      } catch (t: Throwable) {
+        onFail(t)
+      }
+    }
+
+    private fun startCronet(
+      engine: CronetEngine,
+      executor: Executor,
+      req: NitroRequest,
+      onSuccess: (NitroResponse) -> Unit,
+      onFail: (Throwable) -> Unit
+    ) {
+      val url = req.url
+      val callback = object : UrlRequest.Callback() {
+        private val buffer = ByteBuffer.allocateDirect(16 * 1024)
+        private val out = java.io.ByteArrayOutputStream()
+
+        override fun onRedirectReceived(request: UrlRequest, info: UrlResponseInfo, newLocationUrl: String) {
+          request.followRedirect()
+        }
+
+        override fun onResponseStarted(request: UrlRequest, info: UrlResponseInfo) {
+          buffer.clear()
+          request.read(buffer)
+        }
+
+        override fun onReadCompleted(request: UrlRequest, info: UrlResponseInfo, byteBuffer: ByteBuffer) {
+          byteBuffer.flip()
+          val bytes = ByteArray(byteBuffer.remaining())
+          byteBuffer.get(bytes)
+          out.write(bytes)
+          byteBuffer.clear()
+          request.read(byteBuffer)
+        }
+
+        override fun onSucceeded(request: UrlRequest, info: UrlResponseInfo) {
+          try {
+            val headersArr: Array<NitroHeader> =
+              info.allHeadersAsList.map { NitroHeader(it.key, it.value) }.toTypedArray()
+            val status = info.httpStatusCode
+            val bytes = out.toByteArray()
+            val contentType = info.allHeaders["Content-Type"] ?: info.allHeaders["content-type"]
+            val charset = run {
+              val ct = contentType ?: ""
+              val m = Regex("charset=([A-Za-z0-9_\\-:.]+)", RegexOption.IGNORE_CASE).find(ct.toString())
+              try {
+                if (m != null) java.nio.charset.Charset.forName(m.groupValues[1]) else Charsets.UTF_8
+              } catch (_: Throwable) {
+                Charsets.UTF_8
+              }
+            }
+            val bodyStr = try { String(bytes, charset) } catch (_: Throwable) { String(bytes, Charsets.UTF_8) }
+            val res = NitroResponse(
+              url = info.url,
+              status = status.toDouble(),
+              statusText = info.httpStatusText ?: "",
+              ok = status in 200..299,
+              redirected = info.url != url,
+              headers = headersArr,
+              bodyString = bodyStr,
+              bodyBytes = null
+            )
+            onSuccess(res)
+          } catch (t: Throwable) {
+            onFail(t)
+          }
+        }
+
+        override fun onFailed(request: UrlRequest, info: UrlResponseInfo?, error: CronetException) {
+          onFail(RuntimeException("Cronet failed: ${error.message}", error))
+        }
+
+        override fun onCanceled(request: UrlRequest, info: UrlResponseInfo?) {
+          onFail(RuntimeException("Cronet canceled"))
+        }
+      }
+
+      val builder = engine.newUrlRequestBuilder(url, callback, executor)
+      val method = req.method?.name ?: "GET"
+      builder.setHttpMethod(method)
+      req.headers?.forEach { (k, v) -> builder.addHeader(k, v) }
+      val bodyBytes = req.bodyBytes
+      val bodyStr = req.bodyString
+      if ((bodyBytes != null) || !bodyStr.isNullOrEmpty()) {
+        val body: ByteArray = when {
+          bodyBytes != null -> bodyBytes.getBuffer(true).toByteArray()
+          !bodyStr.isNullOrEmpty() -> bodyStr!!.toByteArray(Charsets.UTF_8)
+          else -> ByteArray(0)
+        }
+        val provider = object : org.chromium.net.UploadDataProvider() {
+          private var pos = 0
+          override fun getLength(): Long = body.size.toLong()
+          override fun read(uploadDataSink: org.chromium.net.UploadDataSink, byteBuffer: ByteBuffer) {
+            val remaining = body.size - pos
+            val toWrite = minOf(byteBuffer.remaining(), remaining)
+            byteBuffer.put(body, pos, toWrite)
+            pos += toWrite
+            uploadDataSink.onReadSucceeded(false)
+          }
+          override fun rewind(uploadDataSink: org.chromium.net.UploadDataSink) {
+            pos = 0
+            uploadDataSink.onRewindSucceeded()
+          }
+        }
+        builder.setUploadDataProvider(provider, executor)
+      }
+      val request = builder.build()
+      request.start()
+    }
+  }
+
+  override fun request(req: NitroRequest): Promise<NitroResponse> {
+    val promise = Promise<NitroResponse>()
+    // Try to serve from prefetch cache/pending first
+    val key = findPrefetchKey(req)
+    if (key != null) {
+      // If a prefetch is currently pending, wait for it
+      FetchCache.getPending(key)?.let { fut ->
+        fun withPrefetchedHeader(res: NitroResponse): NitroResponse {
+          val newHeaders = (res.headers?.toMutableList() ?: mutableListOf())
+          newHeaders.add(NitroHeader("nitroPrefetched", "true"))
+          return NitroResponse(
+            url = res.url,
+            status = res.status,
+            statusText = res.statusText,
+            ok = res.ok,
+            redirected = res.redirected,
+            headers = newHeaders.toTypedArray(),
+            bodyString = res.bodyString,
+            bodyBytes = res.bodyBytes
+          )
+        }
+        fut.whenComplete { res, err ->
+          if (err != null) {
+            promise.reject(err)
+          } else if (res != null) {
+            promise.resolve(withPrefetchedHeader(res))
+          } else {
+            promise.reject(IllegalStateException("Prefetch pending returned null result"))
+          }
+        }
+        return promise
+      }
+      // If a fresh prefetched result exists (<=5s old), return it immediately
+      FetchCache.getResultIfFresh(key, 5_000L)?.let { cached ->
+        val newHeaders = (cached.headers?.toMutableList() ?: mutableListOf())
+        newHeaders.add(NitroHeader("nitroPrefetched", "true"))
+        val wrapped = NitroResponse(
+          url = cached.url,
+          status = cached.status,
+          statusText = cached.statusText,
+          ok = cached.ok,
+          redirected = cached.redirected,
+          headers = newHeaders.toTypedArray(),
+          bodyString = cached.bodyString,
+          bodyBytes = cached.bodyBytes
+        )
+        promise.resolve(wrapped)
+        return promise
+      }
+    }
+    fetch(
+      req,
+      onSuccess = { promise.resolve(it) },
+      onFail = { promise.reject(it) }
+    )
+    return promise
+  }
+
+  override fun prefetch(req: NitroRequest): Promise<Unit> {
+    val promise = Promise<Unit>()
+    val key = findPrefetchKey(req)
+    if (key.isNullOrEmpty()) {
+      promise.reject(IllegalArgumentException("prefetch: missing 'prefetchKey' header"))
+      return promise
+    }
+    // If already have a fresh result, resolve immediately
+    FetchCache.getResultIfFresh(key, 5_000L)?.let {
+      promise.resolve(Unit)
+      return promise
+    }
+    // If already pending, resolve when it's done
+    FetchCache.getPending(key)?.let { fut ->
+      fut.whenComplete { _, err -> if (err != null) promise.reject(err) else promise.resolve(Unit) }
+      return promise
+    }
+    // Start new prefetch
+    val future = java.util.concurrent.CompletableFuture<NitroResponse>()
+    FetchCache.setPending(key, future)
+    fetch(
+      req,
+      onSuccess = { res ->
+        try {
+          FetchCache.complete(key, res)
+          promise.resolve(Unit)
+        } catch (t: Throwable) {
+          FetchCache.completeExceptionally(key, t)
+          promise.reject(t)
+        }
+      },
+      onFail = { err ->
+        FetchCache.completeExceptionally(key, err)
+        promise.reject(err)
+      }
+    )
+    return promise
+  }
+
+
+}

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

@@ -0,0 +1,22 @@
+package com.margelo.nitro.nitrofetch
+
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class NitroFetchPackage : TurboReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return null
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider { HashMap() }
+    }
+
+    companion object {
+        init {
+            System.loadLibrary("nitrofetch")
+        }
+    }
+}

package/ios/FetchCache.swift

@@ -0,0 +1,56 @@
+import Foundation
+
+final class FetchCache {
+  struct CachedEntry {
+    let response: NitroResponse
+    let timestampMs: Int64
+  }
+
+  private static let queue = DispatchQueue(label: "nitrofetch.cache", attributes: .concurrent)
+  private static var pending: [String: [(Result<NitroResponse, Error>) -> Void]] = [:]
+  private static var results: [String: CachedEntry] = [:]
+
+  static func getPending(_ key: String) -> Bool {
+    var has = false
+    queue.sync { has = pending[key] != nil }
+    return has
+  }
+
+  static func addPending(_ key: String, completion: @escaping (Result<NitroResponse, Error>) -> Void) {
+    queue.async(flags: .barrier) {
+      var arr = pending[key] ?? []
+      arr.append(completion)
+      pending[key] = arr
+    }
+  }
+
+  static func complete(_ key: String, with result: Result<NitroResponse, Error>) {
+    var callbacks: [(Result<NitroResponse, Error>) -> Void] = []
+    queue.sync {
+      callbacks = pending[key] ?? []
+    }
+    queue.async(flags: .barrier) {
+      pending.removeValue(forKey: key)
+      if case let .success(resp) = result {
+        results[key] = CachedEntry(response: resp, timestampMs: Int64(Date().timeIntervalSince1970 * 1000))
+      }
+    }
+    callbacks.forEach { $0(result) }
+  }
+
+  static func getResultIfFresh(_ key: String, maxAgeMs: Int64) -> NitroResponse? {
+    var out: NitroResponse?
+    queue.sync {
+      if let entry = results[key] {
+        let age = Int64(Date().timeIntervalSince1970 * 1000) - entry.timestampMs
+        if age <= maxAgeMs {
+          out = entry.response
+        } else {
+          results.removeValue(forKey: key)
+        }
+      }
+    }
+    return out
+  }
+}
+

package/ios/NitroAutoPrefetcher.swift

@@ -0,0 +1,81 @@
+import Foundation
+
+@objc(NitroAutoPrefetcher)
+public final class NitroAutoPrefetcher: NSObject {
+  private static var initialized = false
+  private static let queueKey = "nitrofetch_autoprefetch_queue"
+
+  @objc
+  public static func prefetchOnStart() {
+    if initialized { return }
+    initialized = true
+    guard let raw = readMMKVString(forKey: queueKey), !raw.isEmpty else { return }
+    guard let data = raw.data(using: .utf8) else { return }
+    guard let arr = try? JSONSerialization.jsonObject(with: data, options: []) as? [Any] else { return }
+
+    for item in arr {
+      guard let obj = item as? [String: Any] else { continue }
+      guard let url = obj["url"] as? String, !url.isEmpty else { continue }
+      guard let prefetchKey = obj["prefetchKey"] as? String, !prefetchKey.isEmpty else { continue }
+      let headersDict = (obj["headers"] as? [String: Any]) ?? [:]
+      var headers: [NitroHeader] = headersDict.map { (k, v) in NitroHeader(key: String(describing: k), value: String(describing: v)) }
+      headers.append(NitroHeader(key: "prefetchKey", value: prefetchKey))
+      let req = NitroRequest(url: url,
+                             method: nil,
+                             headers: headers,
+                             bodyString: nil,
+                             bodyBytes: nil,
+                             timeoutMs: nil,
+                             followRedirects: true)
+      Task {
+        do { try await NitroFetchClient.prefetchStatic(req) } catch { /* ignore – best effort */ }
+      }
+    }
+  }
+
+  // MARK: - MMKV dynamic access (optional)
+
+  private static func readMMKVString(forKey key: String) -> String? {
+    guard let mmkvClass = NSClassFromString("MMKV") as? NSObject.Type else { return nil }
+    // Try to initialize if needed (ignore failures)
+    let initSelectors = [
+      NSSelectorFromString("initializeMMKV:"),
+      NSSelectorFromString("initialize:")
+    ]
+    for sel in initSelectors where mmkvClass.responds(to: sel) {
+      _ = mmkvClass.perform(sel, with: nil)
+      break
+    }
+    guard let mmkvObjUnretained = mmkvClass.perform(NSSelectorFromString("defaultMMKV"))?.takeUnretainedValue() else { return nil }
+    let mmkv = mmkvObjUnretained as AnyObject
+    // Try common selectors
+    let candidates = [
+      NSSelectorFromString("decodeStringForKey:"),
+      NSSelectorFromString("stringForKey:"),
+      NSSelectorFromString("getStringForKey:"),
+    ]
+    for sel in candidates where mmkv.responds(to: sel) {
+      if let val = mmkv.perform(sel, with: key)?.takeUnretainedValue() as? String {
+        return val
+      }
+    }
+    // Some APIs have (forKey: defaultValue:) signatures
+    let twoArgCandidates = [
+      NSSelectorFromString("decodeStringForKey:defaultValue:"),
+      NSSelectorFromString("stringForKey:defaultValue:"),
+      NSSelectorFromString("getStringForKey:defaultValue:"),
+    ]
+    for sel in twoArgCandidates where mmkv.responds(to: sel) {
+      // NSInvocation is cumbersome in Swift; best-effort fallthrough without it
+      // Prefer single-arg variants above.
+      break
+    }
+    return nil
+  }
+}
+
+// Expose a C-ABI symbol the ObjC++ file can call
+@_cdecl("NitroStartSwift")
+public func NitroStartSwift() {
+  NitroAutoPrefetcher.prefetchOnStart()
+}

package/ios/NitroBootstrap.mm

@@ -0,0 +1,27 @@
+#import <Foundation/Foundation.h>
+#if __has_include(<UIKit/UIKit.h>)
+#import <UIKit/UIKit.h>
+#endif
+
+// No need to import the Swift header if you don’t want to.
+// Just declare the C entry point:
+extern "C" void NitroStartSwift(void);
+
+@interface NitroFetchBootstrapper : NSObject @end
+@implementation NitroFetchBootstrapper
+
++ (void)load {
+#if __has_include(<UIKit/UIKit.h>)
+  if (NSClassFromString(@"UIApplication")) {
+    [[NSNotificationCenter defaultCenter] addObserverForName:UIApplicationDidFinishLaunchingNotification
+                                                      object:nil queue:nil
+                                                  usingBlock:^(__unused NSNotification *note) {
+      NitroStartSwift(); // <-- call the C symbol
+    }];
+    dispatch_async(dispatch_get_main_queue(), ^{
+      NitroStartSwift();
+    });
+  }
+#endif
+}
+@end

package/ios/NitroFetch.swift

@@ -0,0 +1,9 @@
+import Foundation
+
+final class NitroFetch: HybridNitroFetchSpec {
+  func createClient() throws -> (any HybridNitroFetchClientSpec) {
+    return NitroFetchClient()
+  }
+  
+}
+

package/ios/NitroFetchClient.swift

@@ -0,0 +1,205 @@
+import Foundation
+import NitroModules
+
+final class NitroFetchClient: HybridNitroFetchClientSpec {
+  func request(req: NitroRequest) throws -> Promise<NitroResponse> {
+    let promise = Promise<NitroResponse>.init()
+    Task {
+      do {
+        let response = try await NitroFetchClient.requestStatic(req)
+        promise.resolve(withResult: response)
+      } catch {
+        promise.reject(withError: error)
+      }
+    }
+    return promise
+  }
+  
+  func prefetch(req: NitroRequest) throws -> Promise<Void> {
+    let promise = Promise<Void>.init()
+    Task {
+      do {
+        try await NitroFetchClient.prefetchStatic(req)
+        promise.resolve(withResult: ())
+      } catch {
+        promise.reject(withError: error)
+      }
+      
+    }
+    return promise
+  }
+  
+  // Shared URLSession for static operations
+  private static let session: URLSession = {
+    let config = URLSessionConfiguration.default
+    config.requestCachePolicy = .useProtocolCachePolicy
+    config.urlCache = URLCache(memoryCapacity: 32 * 1024 * 1024,
+                               diskCapacity: 100 * 1024 * 1024,
+                               diskPath: "nitrofetch_urlcache")
+    return URLSession(configuration: config)
+  }()
+
+  private static func findPrefetchKey(_ req: NitroRequest) -> String? {
+    guard let headers = req.headers else { return nil }
+    for h in headers {
+      if h.key.caseInsensitiveCompare("prefetchKey") == .orderedSame {
+        return h.value
+      }
+    }
+    return nil
+  }
+
+  // MARK: - Static API usable from native bootstrap
+
+
+  public class func requestStatic(_ req: NitroRequest) async throws -> NitroResponse {
+    if let key = findPrefetchKey(req) {
+      // If a prefetched result is fresh, return immediately
+      if let cached = FetchCache.getResultIfFresh(key, maxAgeMs: 5_000) {
+        var headers = cached.headers ?? []
+        headers.append(NitroHeader(key: "nitroPrefetched", value: "true"))
+        return NitroResponse(url: cached.url,
+                             status: cached.status,
+                             statusText: cached.statusText,
+                             ok: cached.ok,
+                             redirected: cached.redirected,
+                             headers: headers,
+                             bodyString: cached.bodyString,
+                             bodyBytes: cached.bodyBytes)
+      }
+
+      // If a prefetch is already pending, await and reuse its result
+      if FetchCache.getPending(key) {
+        return try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<NitroResponse, Error>) in
+          FetchCache.addPending(key) { result in
+            switch result {
+            case .success(let res):
+              // Mirror Android: mark response as coming from prefetch
+              var headers = res.headers ?? []
+              headers.append(NitroHeader(key: "nitroPrefetched", value: "true"))
+              let wrapped = NitroResponse(url: res.url,
+                                          status: res.status,
+                                          statusText: res.statusText,
+                                          ok: res.ok,
+                                          redirected: res.redirected,
+                                          headers: headers,
+                                          bodyString: res.bodyString,
+                                          bodyBytes: res.bodyBytes)
+              continuation.resume(returning: wrapped)
+            case .failure(let err):
+              continuation.resume(throwing: err)
+            }
+          }
+        }
+      }
+    }
+
+    let (urlRequest, finalURL) = try buildURLRequest(req)
+    let (data, response) = try await session.data(for: urlRequest)
+    guard let http = response as? HTTPURLResponse else {
+      throw NSError(domain: "NitroFetch", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid response"])
+    }
+
+    let headersPairs: [NitroHeader] = http.allHeaderFields.compactMap { k, v in
+      guard let key = k as? String else { return nil }
+      return NitroHeader(key: key, value: String(describing: v))
+    }
+
+    // Choose bodyString by default (matching Android’s first pass)
+    let charset = NitroFetchClient.detectCharset(from: http) ?? String.Encoding.utf8
+    let bodyStr = String(data: data, encoding: charset) ?? String(data: data, encoding: .utf8)
+
+    let res = NitroResponse(
+      url: finalURL?.absoluteString ?? http.url?.absoluteString ?? req.url,
+      status: Double(http.statusCode),
+      statusText: HTTPURLResponse.localizedString(forStatusCode: http.statusCode),
+      ok: (200...299).contains(http.statusCode),
+      redirected: (finalURL?.absoluteString ?? http.url?.absoluteString ?? req.url) != req.url,
+      headers: headersPairs,
+      bodyString: bodyStr,
+      bodyBytes: nil
+    )
+
+    // Do not write to cache here; only prefetch should populate the cache
+
+    return res
+  }
+
+  public class func prefetchStatic(_ req: NitroRequest) async throws {
+    guard let key = findPrefetchKey(req) else {
+      throw NSError(domain: "NitroFetch", code: -2, userInfo: [NSLocalizedDescriptionKey: "prefetch: missing 'prefetchKey' header"])
+    }
+
+    if FetchCache.getResultIfFresh(key, maxAgeMs: 5_000) != nil {
+      return // already have a fresh result
+    }
+
+    if FetchCache.getPending(key) {
+      return // already pending
+    }
+
+    // Mark pending and start the request
+    FetchCache.addPending(key) { _ in /* ignored here */ }
+    Task.detached {
+      do {
+        let (urlRequest, finalURL) = try buildURLRequest(req)
+        let (data, response) = try await session.data(for: urlRequest)
+        guard let http = response as? HTTPURLResponse else {
+          throw NSError(domain: "NitroFetch", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid response"])
+        }
+        let headersPairs: [NitroHeader] = http.allHeaderFields.compactMap { k, v in
+          guard let key = k as? String else { return nil }
+          return NitroHeader(key: key, value: String(describing: v))
+        }
+        let charset = NitroFetchClient.detectCharset(from: http) ?? .utf8
+        let bodyStr = String(data: data, encoding: charset) ?? String(data: data, encoding: .utf8)
+        let res = NitroResponse(
+          url: finalURL?.absoluteString ?? http.url?.absoluteString ?? req.url,
+          status: Double(http.statusCode),
+          statusText: HTTPURLResponse.localizedString(forStatusCode: http.statusCode),
+          ok: (200...299).contains(http.statusCode),
+          redirected: (finalURL?.absoluteString ?? http.url?.absoluteString ?? req.url) != req.url,
+          headers: headersPairs,
+          bodyString: bodyStr,
+          bodyBytes: nil
+        )
+        FetchCache.complete(key, with: .success(res))
+      } catch {
+        FetchCache.complete(key, with: .failure(error))
+      }
+    }
+  }
+  
+  private static func reqToHttpMethod(_ req: NitroRequest) -> String? {
+    return req.method?.stringValue
+  }
+
+  private static func buildURLRequest(_ req: NitroRequest) throws -> (URLRequest, URL?) {
+    guard let url = URL(string: req.url) else {
+      throw NSError(domain: "NitroFetch", code: -3, userInfo: [NSLocalizedDescriptionKey: "Invalid URL: \(req.url)"])
+    }
+    var r = URLRequest(url: url)
+    if let m = req.method?.rawValue { r.httpMethod = reqToHttpMethod(req) }
+    if let headers = req.headers {
+      for h in headers { r.addValue(h.value, forHTTPHeaderField: h.key) }
+    }
+    if let s = req.bodyString {
+      r.httpBody = s.data(using: .utf8)
+    }
+    if let t = req.timeoutMs, t > 0 { r.timeoutInterval = TimeInterval(t) / 1000.0 }
+    return (r, nil)
+  }
+
+  private static func detectCharset(from http: HTTPURLResponse) -> String.Encoding? {
+    if let ct = http.value(forHTTPHeaderField: "Content-Type")?.lowercased() {
+      if let range = ct.range(of: "charset=") {
+        let charset = String(ct[range.upperBound...]).trimmingCharacters(in: .whitespaces)
+        let mapped = CFStringConvertIANACharSetNameToEncoding(charset as CFString)
+        if mapped != kCFStringEncodingInvalidId {
+          return String.Encoding(rawValue: CFStringConvertEncodingToNSStringEncoding(mapped))
+        }
+      }
+    }
+    return nil
+  }
+}

package/lib/module/NitroFetch.nitro.js

@@ -0,0 +1,7 @@
+"use strict";
+
+// Minimal request/response types to model WHATWG fetch without streaming.
+
+;
+export {};
+//# sourceMappingURL=NitroFetch.nitro.js.map

package/lib/module/NitroFetch.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["NitroFetch.nitro.ts"],"mappings":";;AAEA;;AAaC;AAAC","ignoreList":[]}

package/lib/module/NitroInstances.js

@@ -0,0 +1,6 @@
+"use strict";
+
+import { NitroModules } from 'react-native-nitro-modules';
+// Create singletons once per JS runtime
+export const NitroFetch = NitroModules.createHybridObject('NitroFetch');
+//# sourceMappingURL=NitroInstances.js.map

package/lib/module/NitroInstances.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","NitroFetch","createHybridObject"],"sourceRoot":"../../src","sources":["NitroInstances.ts"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAGzD;AACA,OAAO,MAAMC,UAA0B,GACrCD,YAAY,CAACE,kBAAkB,CAAiB,YAAY,CAAC","ignoreList":[]}