@pigeonmal/react-native-nitro-fetch 0.1.6

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

@@ -0,0 +1,331 @@
+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.io.InterruptedIOException
+import java.nio.ByteBuffer
+import java.util.concurrent.Executor
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicBoolean
+import okio.AsyncTimeout
+
+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) {
+      if (pair.key.equals("prefetchKey", ignoreCase = true)) return pair.value
+    }
+    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 completed = AtomicBoolean(false)
+      var urlRequest: UrlRequest? = null
+
+      // Create timeout handler
+      val timeout = object : AsyncTimeout() {
+        override fun timedOut() {
+          if (completed.compareAndSet(false, true)) {
+            urlRequest?.cancel()
+          }
+        }
+      }
+
+      // Configure timeout from request
+      req.timeoutMs?.let { timeoutMs ->
+        if (timeoutMs > 0) {
+          timeout.timeout(timeoutMs.toLong(), TimeUnit.MILLISECONDS)
+        }
+      }
+
+      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) {
+          if (!completed.compareAndSet(false, true)) return
+          timeout.exit()
+          
+          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) {
+          if (!completed.compareAndSet(false, true)) return
+          val timedOut = timeout.exit()
+          
+          val exception = if (timedOut) {
+            InterruptedIOException("Request timeout after ${req.timeoutMs}ms").apply {
+              initCause(error)
+            }
+          } else {
+            RuntimeException("Cronet failed: ${error.message}", error)
+          }
+          onFail(exception)
+        }
+
+        override fun onCanceled(request: UrlRequest, info: UrlResponseInfo?) {
+          if (!completed.compareAndSet(false, true)) return
+          val timedOut = timeout.exit()
+          
+          val exception = if (timedOut) {
+            InterruptedIOException("Request timeout after ${req.timeoutMs}ms")
+          } else {
+            RuntimeException("Cronet canceled")
+          }
+          onFail(exception)
+        }
+      }
+
+      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 -> ByteArray(1);//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)
+      }
+      
+      urlRequest = builder.build()
+      timeout.enter()
+      urlRequest.start()
+    }
+  }
+
+  // Helper function to add prefetch header to response (reused by both sync/async)
+  private 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
+    )
+  }
+
+  override fun requestSync(req: NitroRequest): NitroResponse {
+    val key = findPrefetchKey(req)
+    if (key != null) {
+      FetchCache.getPending(key)?.let { fut ->
+        return try {
+          withPrefetchedHeader(fut.get()) // blocks until complete
+        } catch (e: Exception) {
+          throw e.cause ?: e
+        }
+      }
+      FetchCache.getResultIfFresh(key, 5_000L)?.let { cached ->
+        return withPrefetchedHeader(cached)
+      }
+    }
+    val latch = java.util.concurrent.CountDownLatch(1)
+    var result: NitroResponse? = null
+    var error: Throwable? = null
+    
+    fetch(
+      req,
+      onSuccess = { 
+        result = it
+        latch.countDown()
+      },
+      onFail = { 
+        error = it
+        latch.countDown()
+      }
+    )
+    latch.await()
+    error?.let { throw it }
+    return result!!
+  }
+
+  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 ->
+        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 ->
+        promise.resolve(withPrefetchedHeader(cached))
+        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 (NON-DESTRUCTIVE CHECK)
+    if (FetchCache.hasFreshResult(key, 5_000L)) {
+      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/NativeStorage.swift

@@ -0,0 +1,61 @@
+//
+//  NativeStorage.swift
+//  Pods
+//
+//  Created by Ritesh Shukla on 08/11/25.
+//
+
+import Foundation
+
+
+final class NativeStorage: HybridNativeStorageSpec {
+  
+  private static let suiteName = "nitro_fetch_storage"
+  
+  private let userDefaults: UserDefaults
+  
+  public override init() {
+    // Use a named suite for better isolation, fallback to standard if creation fails
+    if let suite = UserDefaults(suiteName: NativeStorage.suiteName) {
+      self.userDefaults = suite
+    } else {
+      self.userDefaults = UserDefaults.standard
+    }
+    super.init()
+  }
+  
+  /// Retrieves a string value for the given key.
+  ///
+  /// - Parameter key: The key to look up in storage
+  /// - Returns: The stored string value, or empty string if key doesn't exist
+  /// - Throws: RuntimeError if the operation fails
+  func getString(key: String) throws -> String {
+    guard let value = userDefaults.string(forKey: key) else {
+      return ""
+    }
+    return value
+  }
+  
+  /// Stores a string value with the given key.
+  ///
+  /// - Parameters:
+  ///   - key: The key to store the value under
+  ///   - value: The string value to store
+  /// - Throws: RuntimeError if the write operation fails
+  func setString(key: String, value: String) throws {
+    userDefaults.set(value, forKey: key)
+    // Synchronize to ensure immediate persistence
+    userDefaults.synchronize()
+  }
+  
+  /// Deletes the value associated with the given key.
+  /// If the key doesn't exist, this is a no-op.
+  ///
+  /// - Parameter key: The key to delete from storage
+  /// - Throws: RuntimeError if the delete operation fails
+  func removeString(key: String) throws {
+    userDefaults.removeObject(forKey: key)
+    // Synchronize to ensure immediate persistence
+    userDefaults.synchronize()
+  }
+}

package/ios/NitroAutoPrefetcher.swift

@@ -0,0 +1,45 @@
+import Foundation
+
+@objc(NitroAutoPrefetcher)
+public final class NitroAutoPrefetcher: NSObject {
+  private static var initialized = false
+  private static let queueKey = "nitrofetch_autoprefetch_queue"
+  private static let suiteName = "nitro_fetch_storage"
+
+  @objc
+  public static func prefetchOnStart() {
+    if initialized { return }
+    initialized = true
+    
+    // Read from UserDefaults
+    let userDefaults = UserDefaults(suiteName: suiteName) ?? UserDefaults.standard
+    guard let raw = userDefaults.string(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 */ }
+      }
+    }
+  }
+}
+
+// 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()
+  }
+  
+}
+