react-native-nitro-fetch 1.1.2 → 1.2.0

package/NitroFetch.podspec

@@ -25,7 +25,10 @@ Pod::Spec.new do |s|
   s.dependency 'React-RCTNetwork'
 
   # Expose the DevTools reporter Obj-C facade to Swift via the pod's umbrella module.
-  s.public_header_files = ["ios/NitroDevToolsReporter.h"]
+  s.public_header_files = [
+    "ios/NitroDevToolsReporter.h",
+    "ios/NitroAutoPrefetcher.h",
+  ]
 
   load 'nitrogen/generated/ios/NitroFetch+autolinking.rb'
   add_nitrogen_files(s)

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

@@ -16,6 +16,77 @@ object AutoPrefetcher {
   private const val KEY_TOKEN_CACHE = "nitro_token_refresh_fetch_cache"
   private const val PREFS_NAME = NitroFetchSecureAtRest.PREFS_NAME
 
+  /**
+   * Register a URL to prefetch on app start. Call from `Application.onCreate()`
+   * BEFORE `prefetchOnStart(this)`. Writes to the same persistent queue used by
+   * the JS `prefetchOnAppStart` API; entries are deduped by `prefetchKey`.
+   *
+   * If called after `prefetchOnStart` already ran (late registration), the
+   * entry is also kicked immediately via `NitroFetchClient.fetch` so the
+   * current session benefits without waiting for the next cold launch.
+   */
+  @JvmStatic
+  @JvmOverloads
+  fun registerPrefetch(
+    context: Context,
+    url: String,
+    prefetchKey: String,
+    headers: Map<String, String> = emptyMap()
+  ) {
+    if (url.isEmpty() || prefetchKey.isEmpty()) return
+    try {
+      val prefs = context.applicationContext
+        .getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+      val raw = prefs.getString(KEY_QUEUE, null) ?: ""
+      val arr = if (raw.isEmpty()) JSONArray() else try { JSONArray(raw) } catch (_: Throwable) { JSONArray() }
+
+      val next = JSONArray()
+      for (i in 0 until arr.length()) {
+        val o = arr.optJSONObject(i) ?: continue
+        if (o.optString("prefetchKey", "") == prefetchKey) continue
+        next.put(o)
+      }
+
+      val headersObj = JSONObject()
+      headers.forEach { (k, v) -> headersObj.put(k, v) }
+      val entry = JSONObject().apply {
+        put("url", url)
+        put("prefetchKey", prefetchKey)
+        put("headers", headersObj)
+      }
+      next.put(entry)
+      prefs.edit().putString(KEY_QUEUE, next.toString()).apply()
+    } catch (_: Throwable) {
+      // best-effort
+    }
+
+    if (initialized) {
+      // late path — kick a single immediate prefetch with cached token headers
+      try {
+        val prefs = context.applicationContext
+          .getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+        val cacheRaw = NitroFetchSecureAtRest.getDecryptedForPrefs(prefs, KEY_TOKEN_CACHE)
+        val tokenHeaders: Map<String, String> = if (!cacheRaw.isNullOrEmpty()) {
+          try {
+            val co = JSONObject(cacheRaw)
+            co.keys().asSequence().associateWith { k -> co.optString(k, "") }
+          } catch (_: Throwable) { emptyMap() }
+        } else emptyMap()
+
+        val single = JSONArray().apply {
+          val headersObj = JSONObject()
+          headers.forEach { (k, v) -> headersObj.put(k, v) }
+          put(JSONObject().apply {
+            put("url", url)
+            put("prefetchKey", prefetchKey)
+            put("headers", headersObj)
+          })
+        }
+        startPrefetches(single, tokenHeaders)
+      } catch (_: Throwable) {}
+    }
+  }
+
   fun prefetchOnStart(app: Application) {
     if (initialized) return
     initialized = true
@@ -155,12 +226,22 @@ object AutoPrefetcher {
         conn.setRequestProperty(k, reqHeaders.optString(k, ""))
       }
 
+      NitroCookieSync.attachCookieFromManagerIfMissing(
+        urlStr,
+        NitroCookieSync.hasCookieHeaderInJson(reqHeaders)
+      ) { key, value -> conn.setRequestProperty(key, value) }
+
       if (body != null) {
         conn.outputStream.use { it.write(body.toByteArray(Charsets.UTF_8)) }
       }
 
       val status = conn.responseCode
-      if (status !in 200..299) return null
+      if (status !in 200..299) {
+        android.util.Log.d("NitroFetch", "[TokenRefresh] Refresh endpoint returned HTTP $status")
+        return null
+      }
+
+      NitroCookieSync.storeSetCookieFromHttpURLConnection(conn.url.toString(), conn, flush = true)
 
       val responseBody = conn.inputStream.use { it.bufferedReader(Charsets.UTF_8).readText() }
 

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

@@ -0,0 +1,138 @@
+package com.margelo.nitro.nitrofetch
+
+import android.util.Log
+import android.webkit.CookieManager
+import org.json.JSONObject
+import org.chromium.net.UrlResponseInfo
+import java.net.HttpURLConnection
+
+/**
+ * Shared [CookieManager] bridging for Cronet and [HttpURLConnection] token refresh.
+ * - Attaches `Cookie` from the jar when the request has no `Cookie` header.
+ * - Persists `Set-Cookie` responses; [flush] is applied only when at least one cookie was stored.
+ *
+ * **Opt-in:** Cookie sync is disabled by default to avoid changing behaviour for consumers
+ * that do not rely on the WebView cookie jar. Call [enableCookieSync] before any requests.
+ */
+object NitroCookieSync {
+  private const val LOG_TAG = "NitroCookieSync"
+
+  @Volatile
+  private var enabled = false
+
+  /**
+   * Enable cookie synchronisation between Cronet / HttpURLConnection and the system
+   * [CookieManager]. Call once (e.g. from `Application.onCreate`) before any fetch or
+   * autoprefetch work. Has no effect when called multiple times.
+   */
+  @JvmStatic
+  fun enableCookieSync() {
+    enabled = true
+  }
+
+  @JvmStatic
+  fun isCookieSyncEnabled(): Boolean = enabled
+
+  fun hasCookieHeaderInNitroRequest(headers: Array<NitroHeader>?): Boolean {
+    return headers?.any { it.key.equals("Cookie", ignoreCase = true) } == true
+  }
+
+  fun hasCookieHeaderInJson(reqHeaders: JSONObject?): Boolean {
+    if (reqHeaders == null) return false
+    return reqHeaders.keys().asSequence().any { it.equals("Cookie", ignoreCase = true) }
+  }
+
+  /**
+   * If [hasCookieHeader] is false, adds `Cookie` from [CookieManager] for [url] via [addHeader].
+   * No-op when cookie sync is [disabled][enableCookieSync].
+   */
+  fun attachCookieFromManagerIfMissing(
+    url: String,
+    hasCookieHeader: Boolean,
+    addHeader: (String, String) -> Unit
+  ) {
+    if (!enabled) return
+    if (hasCookieHeader) return
+    try {
+      val jar = CookieManager.getInstance()
+      val cookieHeader = jar.getCookie(url)
+      if (!cookieHeader.isNullOrEmpty()) {
+        addHeader("Cookie", cookieHeader)
+      }
+    } catch (exception: Exception) {
+      Log.w(LOG_TAG, "Failed to attach cookie header", exception)
+    }
+  }
+
+  /**
+   * Applies `Set-Cookie` headers from a Cronet [UrlResponseInfo] into [CookieManager].
+   * @param flush If true, [CookieManager.flush] runs only when at least one cookie was applied.
+   * Use `flush = false` on redirects so persistence happens once on the final response.
+   * @return true if at least one `Set-Cookie` was stored.
+   */
+  fun storeSetCookieFromUrlResponseInfo(
+    responseUrl: String,
+    info: UrlResponseInfo,
+    flush: Boolean
+  ): Boolean {
+    if (!enabled) return false
+    return try {
+      val cookieManager = CookieManager.getInstance()
+      val setCookieHeaders = info.allHeadersAsList.filter {
+        it.key.equals("Set-Cookie", ignoreCase = true)
+      }
+      if (setCookieHeaders.isEmpty()) return false
+      for (header in setCookieHeaders) {
+        cookieManager.setCookie(responseUrl, header.value)
+      }
+      if (flush) {
+        cookieManager.flush()
+      }
+      true
+    } catch (exception: Exception) {
+      Log.w(LOG_TAG, "Failed to store response cookies", exception)
+      false
+    }
+  }
+
+  /**
+   * Applies `Set-Cookie` from an [HttpURLConnection] response into [CookieManager].
+   * @param flush If true, [CookieManager.flush] runs only when at least one cookie was applied.
+   */
+  fun storeSetCookieFromHttpURLConnection(
+    urlStr: String,
+    conn: HttpURLConnection,
+    flush: Boolean
+  ): Boolean {
+    if (!enabled) return false
+    return try {
+      val cookieManager = CookieManager.getInstance()
+      var anySet = false
+      conn.headerFields?.forEach { (key, values) ->
+        if (key?.equals("Set-Cookie", ignoreCase = true) == true) {
+          values.forEach { cookieValue ->
+            cookieManager.setCookie(urlStr, cookieValue)
+            anySet = true
+          }
+        }
+      }
+      if (anySet && flush) {
+        cookieManager.flush()
+      }
+      anySet
+    } catch (exception: Exception) {
+      Log.w(LOG_TAG, "Failed to store response cookies (HttpURLConnection)", exception)
+      false
+    }
+  }
+
+  /** Persists in-memory cookie updates to disk (call after a successful request when any `Set-Cookie` was applied). */
+  fun flushCookieManager() {
+    if (!enabled) return
+    try {
+      CookieManager.getInstance().flush()
+    } catch (exception: Exception) {
+      Log.w(LOG_TAG, "Failed to flush CookieManager", exception)
+    }
+  }
+}

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

@@ -90,11 +90,17 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
         private val buffer = ByteBuffer.allocateDirect(16 * 1024)
         private val out = java.io.ByteArrayOutputStream()
         private var redirectStopped = false
+        /** True if a redirect response applied at least one `Set-Cookie` (in memory, not yet flushed). */
+        private var setCookieAppliedOnRedirect = false
         private var devToolsBytes = 0
         private var devToolsTextual = false
 
         override fun onRedirectReceived(request: UrlRequest, info: UrlResponseInfo, newLocationUrl: String) {
           if (shouldFollowRedirects) {
+            // Apply Set-Cookie in-memory; flush once in onSucceeded (avoid flush per hop).
+            if (NitroCookieSync.storeSetCookieFromUrlResponseInfo(info.url, info, flush = false)) {
+              setCookieAppliedOnRedirect = true
+            }
             request.followRedirect()
           } else {
             // Return the redirect response as-is without following
@@ -162,6 +168,11 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
             DevToolsReporter.reportResponseEnd(devToolsRequestId, devToolsBytes.toLong())
           }
           try {
+            val storedOnFinal =
+              NitroCookieSync.storeSetCookieFromUrlResponseInfo(info.url, info, flush = false)
+            if (storedOnFinal || setCookieAppliedOnRedirect) {
+              NitroCookieSync.flushCookieManager()
+            }
             val headersArr: Array<NitroHeader> =
               info.allHeadersAsList.map { NitroHeader(it.key, it.value) }.toTypedArray()
             val status = info.httpStatusCode
@@ -221,6 +232,11 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
       builder.setHttpMethod(method)
       req.headers?.forEach { (k, v) -> builder.addHeader(k, v) }
 
+      NitroCookieSync.attachCookieFromManagerIfMissing(
+        url,
+        NitroCookieSync.hasCookieHeaderInNitroRequest(req.headers)
+      ) { key, value -> builder.addHeader(key, value) }
+
       val formParts = req.bodyFormData
       if (formParts != null && formParts.isNotEmpty()) {
         val (multipartBody, contentType) = buildMultipartBody(formParts)

package/ios/NitroAutoPrefetcher.h

@@ -0,0 +1,25 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Native-side prefetch registration. Call from `application:didFinishLaunchingWithOptions:`
+ * to declare URLs that should be prefetched on the very first cold launch (and every
+ * cold launch thereafter). Writes to the same persistent queue used by the JS
+ * `prefetchOnAppStart` API; entries are deduped by `prefetchKey`.
+ *
+ * This header is the Obj-C facade for the Swift `NitroAutoPrefetcher` class so that
+ * Swift host apps can `#import <NitroFetch/NitroAutoPrefetcher.h>` from a bridging
+ * header without pulling in the pod's C++ surface.
+ */
+@interface NitroAutoPrefetcher : NSObject
+
++ (void)prefetchOnStart;
+
++ (void)registerPrefetchWithUrl:(NSString *)url
+                    prefetchKey:(NSString *)prefetchKey
+                        headers:(NSDictionary<NSString *, NSString *> *)headers;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/NitroAutoPrefetcher.swift

@@ -8,6 +8,70 @@ public final class NitroAutoPrefetcher: NSObject {
   private static let tokenRefreshKey = "nitro_token_refresh_fetch"
   private static let tokenCacheKey = "nitro_token_refresh_fetch_cache"
 
+  /// Register a URL to prefetch on app start. Call from
+  /// `application(_:didFinishLaunchingWithOptions:)`. Writes to the same
+  /// persistent queue used by the JS `prefetchOnAppStart` API; entries are
+  /// deduped by `prefetchKey`.
+  ///
+  /// If called after `prefetchOnStart` already ran (late registration), the
+  /// entry is also kicked immediately via `NitroFetchClient.prefetchStatic`.
+  @objc
+  public static func registerPrefetch(
+    url: String,
+    prefetchKey: String,
+    headers: [String: String]
+  ) {
+    if url.isEmpty || prefetchKey.isEmpty { return }
+    let userDefaults = UserDefaults(suiteName: suiteName) ?? UserDefaults.standard
+
+    var arr: [[String: Any]] = []
+    if let raw = userDefaults.string(forKey: queueKey),
+       !raw.isEmpty,
+       let data = raw.data(using: .utf8),
+       let parsed = try? JSONSerialization.jsonObject(with: data) as? [[String: Any]] {
+      arr = parsed
+    }
+    arr.removeAll { ($0["prefetchKey"] as? String) == prefetchKey }
+    arr.append([
+      "url": url,
+      "prefetchKey": prefetchKey,
+      "headers": headers,
+    ])
+    if let data = try? JSONSerialization.data(withJSONObject: arr),
+       let str = String(data: data, encoding: .utf8) {
+      userDefaults.set(str, forKey: queueKey)
+    }
+
+    if initialized {
+      // Late path — apply cached token headers + kick immediate prefetch
+      var tokenHeaders: [String: String] = [:]
+      if let cacheRaw = NitroFetchSecureAtRest.decryptedString(forKey: tokenCacheKey, defaults: userDefaults),
+         !cacheRaw.isEmpty,
+         let cacheData = cacheRaw.data(using: .utf8),
+         let cacheObj = try? JSONSerialization.jsonObject(with: cacheData) as? [String: String] {
+        tokenHeaders = cacheObj
+      }
+      var merged: [String: String] = headers
+      for (k, v) in tokenHeaders { merged[k] = v }
+      var hdrs: [NitroHeader] = merged.map { NitroHeader(key: $0.key, value: $0.value) }
+      hdrs.append(NitroHeader(key: "prefetchKey", value: prefetchKey))
+      let req = NitroRequest(
+        url: url,
+        method: nil,
+        headers: hdrs,
+        bodyString: nil,
+        bodyBytes: nil,
+        bodyFormData: nil,
+        timeoutMs: nil,
+        followRedirects: true,
+        requestId: nil
+      )
+      Task {
+        do { try await NitroFetchClient.prefetchStatic(req) } catch { /* best-effort */ }
+      }
+    }
+  }
+
   @objc
   public static func prefetchOnStart() {
     if initialized { return }

package/lib/module/index.web.js

@@ -0,0 +1,108 @@
+"use strict";
+
+// Web entry for react-native-nitro-fetch.
+// Native (Cronet/URLSession) is unavailable on the web, so we delegate to the
+// browser's built-in fetch and stub native-only APIs with console.warn.
+
+import { NitroRequest as NitroRequestClass } from "./Request.js";
+export { NitroHeaders as Headers } from "./Headers.js";
+export { NitroResponse as Response } from "./Response.js";
+export { NitroRequest as Request } from "./Request.js";
+export { NetworkInspector } from "./NetworkInspector.js";
+export { generateCurl } from "./CurlGenerator.js";
+export { profileFetch } from "./HermesProfiler.js";
+export async function fetch(input, init) {
+  let resolvedInput = input;
+  let resolvedInit = init;
+  if (input instanceof NitroRequestClass) {
+    const method = (init?.method ?? input.method).toUpperCase();
+    const hasBodyMethod = method !== 'GET' && method !== 'HEAD';
+    let body = init?.body;
+    if (body === undefined && hasBodyMethod) {
+      const bytes = await input.arrayBuffer().catch(() => undefined);
+      body = bytes && bytes.byteLength > 0 ? bytes : null;
+    }
+    resolvedInput = input.url;
+    resolvedInit = {
+      ...init,
+      method,
+      headers: init?.headers ?? input.headers,
+      body,
+      redirect: init?.redirect ?? input.redirect,
+      cache: init?.cache ?? input.cache,
+      signal: init?.signal ?? input.signal
+    };
+  }
+  return globalThis.fetch(resolvedInput, resolvedInit);
+}
+export async function nitroFetchOnWorklet(input, init, mapWorklet, _options) {
+  console.warn('nitroFetchOnWorklet: worklets are not available on web; running on the JS thread');
+  const res = await globalThis.fetch(input, init);
+  const bodyBytes = await res.clone().arrayBuffer();
+  let bodyString;
+  try {
+    bodyString = await res.clone().text();
+  } catch {
+    bodyString = undefined;
+  }
+  const headers = [];
+  res.headers.forEach((v, k) => headers.push({
+    key: k,
+    value: v
+  }));
+  return mapWorklet({
+    url: res.url,
+    status: res.status,
+    statusText: res.statusText,
+    ok: res.ok,
+    redirected: res.redirected ?? false,
+    headers,
+    bodyBytes,
+    bodyString
+  });
+}
+export async function prefetch(_input, _init) {
+  console.warn('prefetch is not available on web');
+}
+export async function prefetchOnAppStart(_input, _init) {
+  console.warn('prefetchOnAppStart is not available on web');
+}
+export async function removeFromAutoPrefetch(_prefetchKey) {
+  console.warn('removeFromAutoPrefetch is not available on web');
+}
+export async function removeAllFromAutoprefetch() {
+  console.warn('removeAllFromAutoprefetch is not available on web');
+}
+export const NitroFetch = new Proxy({}, {
+  get(_target, prop) {
+    console.warn(`NitroFetch.${String(prop)} is not available on web`);
+    return undefined;
+  }
+});
+export function registerTokenRefresh(_options) {
+  console.warn('registerTokenRefresh is not available on web');
+}
+export function clearTokenRefresh(_target) {
+  console.warn('clearTokenRefresh is not available on web');
+}
+export async function callRefreshEndpoint(_config) {
+  console.warn('callRefreshEndpoint is not available on web');
+  return {};
+}
+export function getStoredTokenRefreshConfig(_target) {
+  console.warn('getStoredTokenRefreshConfig is not available on web');
+  return null;
+}
+export function getNestedField(obj, dotPath) {
+  const parts = dotPath.split('.');
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== 'object') return undefined;
+    current = current[part];
+  }
+  return current != null ? String(current) : undefined;
+}
+export function applyTemplate(template, value) {
+  return template.replace(/\{\{value\}\}/g, value);
+}
+//# sourceMappingURL=index.web.js.map

package/lib/module/index.web.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroRequest","NitroRequestClass","NitroHeaders","Headers","NitroResponse","Response","Request","NetworkInspector","generateCurl","profileFetch","fetch","input","init","resolvedInput","resolvedInit","method","toUpperCase","hasBodyMethod","body","undefined","bytes","arrayBuffer","catch","byteLength","url","headers","redirect","cache","signal","globalThis","nitroFetchOnWorklet","mapWorklet","_options","console","warn","res","bodyBytes","clone","bodyString","text","forEach","v","k","push","key","value","status","statusText","ok","redirected","prefetch","_input","_init","prefetchOnAppStart","removeFromAutoPrefetch","_prefetchKey","removeAllFromAutoprefetch","NitroFetch","Proxy","get","_target","prop","String","registerTokenRefresh","clearTokenRefresh","callRefreshEndpoint","_config","getStoredTokenRefreshConfig","getNestedField","obj","dotPath","parts","split","current","part","applyTemplate","template","replace"],"sourceRoot":"../../src","sources":["index.web.tsx"],"mappings":"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","ignoreList":[]}

package/lib/typescript/src/index.web.d.ts

@@ -0,0 +1,68 @@
+import type { RequestRedirect, RequestCache } from './Request';
+export { NitroHeaders as Headers } from './Headers';
+export { NitroResponse as Response } from './Response';
+export { NitroRequest as Request } from './Request';
+export type { RequestRedirect, RequestCache } from './Request';
+export { NetworkInspector } from './NetworkInspector';
+export type { NetworkEntry, NetworkEntryCallback, WebSocketEntry, WebSocketMessage, InspectorEntry, } from './NetworkInspector';
+export { generateCurl } from './CurlGenerator';
+export type { CurlOptions } from './CurlGenerator';
+export { profileFetch } from './HermesProfiler';
+export type { ProfileResult } from './HermesProfiler';
+export type { NitroFormDataPart } from './NitroFetch.nitro';
+export type { NitroRequest as NitroRequest, NitroResponse as NitroResponse, } from './NitroFetch.nitro';
+export type TokenRefreshConfig = {
+    url: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH';
+    headers?: Record<string, string>;
+    body?: string;
+    responseType?: 'json' | 'text';
+    mappings?: {
+        jsonPath: string;
+        header: string;
+        valueTemplate?: string;
+    }[];
+    compositeHeaders?: {
+        header: string;
+        template: string;
+        paths: Record<string, string>;
+    }[];
+};
+export declare function fetch(input: RequestInfo | URL, init?: RequestInit & {
+    stream?: boolean;
+    redirect?: RequestRedirect;
+    cache?: RequestCache;
+}): Promise<Response>;
+export type NitroWorkletMapper<T> = (payload: {
+    url: string;
+    status: number;
+    statusText: string;
+    ok: boolean;
+    redirected: boolean;
+    headers: {
+        key: string;
+        value: string;
+    }[];
+    bodyBytes?: ArrayBuffer;
+    bodyString?: string;
+}) => T;
+export declare function nitroFetchOnWorklet<T>(input: RequestInfo | URL, init: RequestInit | undefined, mapWorklet: NitroWorkletMapper<T>, _options?: {
+    preferBytes?: boolean;
+    runtimeName?: string;
+}): Promise<T>;
+export declare function prefetch(_input: RequestInfo | URL, _init?: RequestInit): Promise<void>;
+export declare function prefetchOnAppStart(_input: RequestInfo | URL, _init?: RequestInit & {
+    prefetchKey?: string;
+}): Promise<void>;
+export declare function removeFromAutoPrefetch(_prefetchKey: string): Promise<void>;
+export declare function removeAllFromAutoprefetch(): Promise<void>;
+export declare const NitroFetch: unknown;
+export declare function registerTokenRefresh(_options: {
+    target: 'websocket' | 'fetch' | 'all';
+} & TokenRefreshConfig): void;
+export declare function clearTokenRefresh(_target?: 'websocket' | 'fetch' | 'all'): void;
+export declare function callRefreshEndpoint(_config: TokenRefreshConfig): Promise<Record<string, string>>;
+export declare function getStoredTokenRefreshConfig(_target: 'websocket' | 'fetch'): TokenRefreshConfig | null;
+export declare function getNestedField(obj: unknown, dotPath: string): string | undefined;
+export declare function applyTemplate(template: string, value: string): string;
+//# sourceMappingURL=index.web.d.ts.map

package/lib/typescript/src/index.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.web.d.ts","sourceRoot":"","sources":["../../../src/index.web.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE/D,OAAO,EAAE,YAAY,IAAI,OAAO,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAE,aAAa,IAAI,QAAQ,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,EAAE,YAAY,IAAI,OAAO,EAAE,MAAM,WAAW,CAAC;AACpD,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,YAAY,EACV,YAAY,EACZ,oBAAoB,EACpB,cAAc,EACd,gBAAgB,EAChB,cAAc,GACf,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,YAAY,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,YAAY,EACV,YAAY,IAAI,YAAY,EAC5B,aAAa,IAAI,aAAa,GAC/B,MAAM,oBAAoB,CAAC;AAE5B,MAAM,MAAM,kBAAkB,GAAG;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,CAAC;IAC1C,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC/B,QAAQ,CAAC,EAAE;QACT,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,EAAE,CAAC;IACJ,gBAAgB,CAAC,EAAE;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;QACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KAC/B,EAAE,CAAC;CACL,CAAC;AAEF,wBAAsB,KAAK,CACzB,KAAK,EAAE,WAAW,GAAG,GAAG,EACxB,IAAI,CAAC,EAAE,WAAW,GAAG;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB,GACA,OAAO,CAAC,QAAQ,CAAC,CAwBnB;AAED,MAAM,MAAM,kBAAkB,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE;IAC5C,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,EAAE,EAAE,OAAO,CAAC;IACZ,UAAU,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC1C,SAAS,CAAC,EAAE,WAAW,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,KAAK,CAAC,CAAC;AAER,wBAAsB,mBAAmB,CAAC,CAAC,EACzC,KAAK,EAAE,WAAW,GAAG,GAAG,EACxB,IAAI,EAAE,WAAW,GAAG,SAAS,EAC7B,UAAU,EAAE,kBAAkB,CAAC,CAAC,CAAC,EACjC,QAAQ,CAAC,EAAE;IAAE,WAAW,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GACzD,OAAO,CAAC,CAAC,CAAC,CAwBZ;AAED,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,WAAW,GAAG,GAAG,EACzB,KAAK,CAAC,EAAE,WAAW,GAClB,OAAO,CAAC,IAAI,CAAC,CAEf;AAED,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,WAAW,GAAG,GAAG,EACzB,KAAK,CAAC,EAAE,WAAW,GAAG;IAAE,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7C,OAAO,CAAC,IAAI,CAAC,CAEf;AAED,wBAAsB,sBAAsB,CAC1C,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC,CAEf;AAED,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,IAAI,CAAC,CAE/D;AAED,eAAO,MAAM,UAAU,EAAE,OAQxB,CAAC;AAEF,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE;IAAE,MAAM,EAAE,WAAW,GAAG,OAAO,GAAG,KAAK,CAAA;CAAE,GAAG,kBAAkB,GACvE,IAAI,CAEN;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,GAAG,KAAK,GACtC,IAAI,CAEN;AAED,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAGjC;AAED,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,WAAW,GAAG,OAAO,GAC7B,kBAAkB,GAAG,IAAI,CAG3B;AAED,wBAAgB,cAAc,CAC5B,GAAG,EAAE,OAAO,EACZ,OAAO,EAAE,MAAM,GACd,MAAM,GAAG,SAAS,CAQpB;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAErE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-fetch",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "Awesome Fetch :)",
   "main": "./lib/module/index.js",
   "module": "./lib/module/index.js",
@@ -11,6 +11,7 @@
     ".": {
       "source": "./src/index.tsx",
       "types": "./lib/typescript/src/index.d.ts",
+      "browser": "./lib/module/index.web.js",
       "default": "./lib/module/index.js"
     },
     "./package.json": "./package.json",

package/src/index.web.tsx

@@ -0,0 +1,200 @@
+// Web entry for react-native-nitro-fetch.
+// Native (Cronet/URLSession) is unavailable on the web, so we delegate to the
+// browser's built-in fetch and stub native-only APIs with console.warn.
+
+import { NitroRequest as NitroRequestClass } from './Request';
+import type { RequestRedirect, RequestCache } from './Request';
+
+export { NitroHeaders as Headers } from './Headers';
+export { NitroResponse as Response } from './Response';
+export { NitroRequest as Request } from './Request';
+export type { RequestRedirect, RequestCache } from './Request';
+
+export { NetworkInspector } from './NetworkInspector';
+export type {
+  NetworkEntry,
+  NetworkEntryCallback,
+  WebSocketEntry,
+  WebSocketMessage,
+  InspectorEntry,
+} from './NetworkInspector';
+export { generateCurl } from './CurlGenerator';
+export type { CurlOptions } from './CurlGenerator';
+export { profileFetch } from './HermesProfiler';
+export type { ProfileResult } from './HermesProfiler';
+
+export type { NitroFormDataPart } from './NitroFetch.nitro';
+export type {
+  NitroRequest as NitroRequest,
+  NitroResponse as NitroResponse,
+} from './NitroFetch.nitro';
+
+export type TokenRefreshConfig = {
+  url: string;
+  method?: 'GET' | 'POST' | 'PUT' | 'PATCH';
+  headers?: Record<string, string>;
+  body?: string;
+  responseType?: 'json' | 'text';
+  mappings?: {
+    jsonPath: string;
+    header: string;
+    valueTemplate?: string;
+  }[];
+  compositeHeaders?: {
+    header: string;
+    template: string;
+    paths: Record<string, string>;
+  }[];
+};
+
+export async function fetch(
+  input: RequestInfo | URL,
+  init?: RequestInit & {
+    stream?: boolean;
+    redirect?: RequestRedirect;
+    cache?: RequestCache;
+  }
+): Promise<Response> {
+  let resolvedInput: RequestInfo | URL = input;
+  let resolvedInit = init;
+  if (input instanceof NitroRequestClass) {
+    const method = (init?.method ?? input.method).toUpperCase();
+    const hasBodyMethod = method !== 'GET' && method !== 'HEAD';
+    let body: BodyInit | null | undefined = init?.body;
+    if (body === undefined && hasBodyMethod) {
+      const bytes = await input.arrayBuffer().catch(() => undefined);
+      body = bytes && bytes.byteLength > 0 ? bytes : null;
+    }
+    resolvedInput = input.url;
+    resolvedInit = {
+      ...init,
+      method,
+      headers: (init?.headers ??
+        (input.headers as unknown as HeadersInit)) as HeadersInit,
+      body,
+      redirect: init?.redirect ?? input.redirect,
+      cache: init?.cache ?? input.cache,
+      signal: init?.signal ?? input.signal,
+    };
+  }
+  return globalThis.fetch(resolvedInput as RequestInfo, resolvedInit);
+}
+
+export type NitroWorkletMapper<T> = (payload: {
+  url: string;
+  status: number;
+  statusText: string;
+  ok: boolean;
+  redirected: boolean;
+  headers: { key: string; value: string }[];
+  bodyBytes?: ArrayBuffer;
+  bodyString?: string;
+}) => T;
+
+export async function nitroFetchOnWorklet<T>(
+  input: RequestInfo | URL,
+  init: RequestInit | undefined,
+  mapWorklet: NitroWorkletMapper<T>,
+  _options?: { preferBytes?: boolean; runtimeName?: string }
+): Promise<T> {
+  console.warn(
+    'nitroFetchOnWorklet: worklets are not available on web; running on the JS thread'
+  );
+  const res = await globalThis.fetch(input as RequestInfo, init);
+  const bodyBytes = await res.clone().arrayBuffer();
+  let bodyString: string | undefined;
+  try {
+    bodyString = await res.clone().text();
+  } catch {
+    bodyString = undefined;
+  }
+  const headers: { key: string; value: string }[] = [];
+  res.headers.forEach((v, k) => headers.push({ key: k, value: v }));
+  return mapWorklet({
+    url: res.url,
+    status: res.status,
+    statusText: res.statusText,
+    ok: res.ok,
+    redirected: (res as { redirected?: boolean }).redirected ?? false,
+    headers,
+    bodyBytes,
+    bodyString,
+  });
+}
+
+export async function prefetch(
+  _input: RequestInfo | URL,
+  _init?: RequestInit
+): Promise<void> {
+  console.warn('prefetch is not available on web');
+}
+
+export async function prefetchOnAppStart(
+  _input: RequestInfo | URL,
+  _init?: RequestInit & { prefetchKey?: string }
+): Promise<void> {
+  console.warn('prefetchOnAppStart is not available on web');
+}
+
+export async function removeFromAutoPrefetch(
+  _prefetchKey: string
+): Promise<void> {
+  console.warn('removeFromAutoPrefetch is not available on web');
+}
+
+export async function removeAllFromAutoprefetch(): Promise<void> {
+  console.warn('removeAllFromAutoprefetch is not available on web');
+}
+
+export const NitroFetch: unknown = new Proxy(
+  {},
+  {
+    get(_target, prop) {
+      console.warn(`NitroFetch.${String(prop)} is not available on web`);
+      return undefined;
+    },
+  }
+);
+
+export function registerTokenRefresh(
+  _options: { target: 'websocket' | 'fetch' | 'all' } & TokenRefreshConfig
+): void {
+  console.warn('registerTokenRefresh is not available on web');
+}
+
+export function clearTokenRefresh(
+  _target?: 'websocket' | 'fetch' | 'all'
+): void {
+  console.warn('clearTokenRefresh is not available on web');
+}
+
+export async function callRefreshEndpoint(
+  _config: TokenRefreshConfig
+): Promise<Record<string, string>> {
+  console.warn('callRefreshEndpoint is not available on web');
+  return {};
+}
+
+export function getStoredTokenRefreshConfig(
+  _target: 'websocket' | 'fetch'
+): TokenRefreshConfig | null {
+  console.warn('getStoredTokenRefreshConfig is not available on web');
+  return null;
+}
+
+export function getNestedField(
+  obj: unknown,
+  dotPath: string
+): string | undefined {
+  const parts = dotPath.split('.');
+  let current: unknown = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== 'object') return undefined;
+    current = (current as Record<string, unknown>)[part];
+  }
+  return current != null ? String(current) : undefined;
+}
+
+export function applyTemplate(template: string, value: string): string {
+  return template.replace(/\{\{value\}\}/g, value);
+}