react-native-nitro-fetch 1.2.1 → 1.3.1

package/src/fetch.ts

@@ -7,7 +7,6 @@ import type {
   NitroResponse as NitroResponseNative,
 } from './NitroFetch.nitro';
 import {
-  boxedNitroFetch,
   NitroFetch as NitroFetchSingleton,
   NitroCronetSingleton,
 } from './NitroInstances';
@@ -168,7 +167,11 @@ function ensureClient() {
 
 function buildNitroRequest(
   input: RequestInfo | URL,
-  init?: RequestInit & { redirect?: RequestRedirect; cache?: RequestCache }
+  init?: RequestInit & {
+    redirect?: RequestRedirect;
+    cache?: RequestCache;
+    prefetchCacheTtlMs?: number;
+  }
 ): NitroRequestNative {
   'worklet';
   let url: string;
@@ -217,6 +220,11 @@ function buildNitroRequest(
   // Determine followRedirects based on redirect option
   const followRedirects = redirectOption === 'follow';
 
+  const prefetchCacheTtlMs =
+    typeof init?.prefetchCacheTtlMs === 'number'
+      ? init.prefetchCacheTtlMs
+      : undefined;
+
   return {
     url,
     method: (method?.toUpperCase() as any) ?? 'GET',
@@ -225,6 +233,7 @@ function buildNitroRequest(
     bodyBytes: undefined as any,
     bodyFormData: normalized?.bodyFormData,
     followRedirects,
+    prefetchCacheTtlMs,
   };
 }
 
@@ -325,7 +334,7 @@ function normalizeBodyPure(
 // Pure JS version of buildNitroRequest that doesnt use anything that breaks worklets
 export function buildNitroRequestPure(
   input: RequestInfo | URL,
-  init?: RequestInit
+  init?: RequestInit & { prefetchCacheTtlMs?: number }
 ): NitroRequestNative {
   'worklet';
   let url: string;
@@ -357,6 +366,11 @@ export function buildNitroRequestPure(
   const headers = headersToPairsPure(headersInit);
   const normalized = normalizeBodyPure(body);
 
+  const prefetchCacheTtlMs =
+    typeof init?.prefetchCacheTtlMs === 'number'
+      ? init.prefetchCacheTtlMs
+      : undefined;
+
   return {
     url,
     method: (method?.toUpperCase() as any) ?? 'GET',
@@ -365,6 +379,7 @@ export function buildNitroRequestPure(
     // Only include bodyBytes when provided to avoid signaling upload data unintentionally
     bodyBytes: undefined as any,
     followRedirects: true,
+    prefetchCacheTtlMs,
   };
 }
 
@@ -703,7 +718,7 @@ export async function nitroFetch(
     ok: res.ok,
     redirected: res.redirected,
     headers: res.headers,
-    bodyBytes: res.bodyBytes as unknown as ArrayBuffer | undefined,
+    bodyBytes: res.bodyBytes,
     bodyString: res.bodyString,
   });
   return response as unknown as Response;
@@ -770,11 +785,21 @@ export async function prefetchOnAppStart(
     {} as Record<string, string>
   );
 
-  const entry = {
+  const entry: Record<string, any> = {
     url: req.url,
     prefetchKey,
     headers: headersObj,
-  } as const;
+  };
+  if (req.method && req.method !== 'GET') entry.method = req.method;
+  if (req.bodyString !== undefined) entry.bodyString = req.bodyString;
+  if (typeof req.bodyBytes === 'string' && req.bodyBytes.length > 0)
+    entry.bodyBytes = req.bodyBytes;
+  if (req.bodyFormData && req.bodyFormData.length > 0)
+    entry.bodyFormData = req.bodyFormData;
+  if (typeof req.timeoutMs === 'number') entry.timeoutMs = req.timeoutMs;
+  if (req.followRedirects === false) entry.followRedirects = false;
+  if (typeof req.prefetchCacheTtlMs === 'number')
+    entry.prefetchCacheTtlMs = req.prefetchCacheTtlMs;
 
   // Write or append to storage queue
   try {
@@ -832,6 +857,19 @@ export async function removeAllFromAutoprefetch(): Promise<void> {
   NativeStorageSingleton.setString(KEY, JSON.stringify([]));
 }
 
+export function __readAutoPrefetchQueue(): Array<Record<string, any>> {
+  try {
+    const raw = NativeStorageSingleton.getString(
+      'nitrofetch_autoprefetch_queue'
+    );
+    if (!raw) return [];
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
 // Optional off-thread processing using react-native-worklets
 
 export type NitroWorkletMapper<T> = (payload: {
@@ -891,10 +929,9 @@ export async function nitroFetchOnWorklet<T>(
   }
   return await runOnRuntimeAsync(rt, () => {
     'worklet';
-    const unboxedNitroFetch = boxedNitroFetch.unbox();
-    const unboxedClient = unboxedNitroFetch.createClient();
+    const nitroFetchClient = NitroFetchHybrid.createClient();
     const request = buildNitroRequestPure(input, init);
-    const res = unboxedClient.requestSync(request);
+    const res = nitroFetchClient.requestSync(request);
     const payload = {
       url: res.url,
       status: res.status,

package/src/index.js

@@ -0,0 +1,10 @@
+export { nitroFetch as fetch, nitroFetchOnWorklet, prefetch, prefetchOnAppStart, removeFromAutoPrefetch, removeAllFromAutoprefetch, __readAutoPrefetchQueue, } from './fetch';
+export { NitroHeaders as Headers } from './Headers';
+export { NitroResponse as Response } from './Response';
+export { NitroRequest as Request } from './Request';
+export { NitroFetch } from './NitroInstances';
+export { registerTokenRefresh, clearTokenRefresh, callRefreshEndpoint, getStoredTokenRefreshConfig, getNestedField, applyTemplate, } from './tokenRefresh';
+export { NetworkInspector } from './NetworkInspector';
+export { generateCurl } from './CurlGenerator';
+export { profileFetch } from './HermesProfiler';
+import './fetch';

package/src/index.tsx

@@ -5,6 +5,7 @@ export {
   prefetchOnAppStart,
   removeFromAutoPrefetch,
   removeAllFromAutoprefetch,
+  __readAutoPrefetchQueue,
 } from './fetch';
 export type { NitroFormDataPart } from './fetch';
 export type {

package/src/index.web.js

@@ -0,0 +1,104 @@
+// 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';
+export { NitroHeaders as Headers } from './Headers';
+export { NitroResponse as Response } from './Response';
+export { NitroRequest as Request } from './Request';
+export { NetworkInspector } from './NetworkInspector';
+export { generateCurl } from './CurlGenerator';
+export { profileFetch } from './HermesProfiler';
+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);
+}

package/src/tokenRefresh.js

@@ -0,0 +1,104 @@
+import { NativeStorage as NativeStorageSingleton } from './NitroInstances';
+// Storage keys
+const KEY_WS = 'nitro_token_refresh_websocket';
+const KEY_FETCH = 'nitro_token_refresh_fetch';
+const KEY_WS_CACHE = 'nitro_token_refresh_ws_cache';
+const KEY_FETCH_CACHE = 'nitro_token_refresh_fetch_cache';
+// — Helpers —
+/**
+ * Resolve a dot-notation path inside a parsed JSON object.
+ */
+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);
+}
+function applyCompositeTemplate(template, values) {
+    return template.replace(/\{\{(\w+)\}\}/g, (_, key) => values[key] ?? '');
+}
+export async function callRefreshEndpoint(config) {
+    const method = config.method ?? 'POST';
+    const response = await fetch(config.url, {
+        method,
+        headers: config.headers,
+        body: config.body,
+    });
+    if (!response.ok) {
+        throw new Error(`Token refresh failed: ${response.status} ${response.statusText}`);
+    }
+    const headers = {};
+    if (config.responseType === 'text') {
+        const text = await response.text();
+        if (config.textHeader) {
+            headers[config.textHeader] = config.textTemplate
+                ? applyTemplate(config.textTemplate, text)
+                : text;
+        }
+        return headers;
+    }
+    // Default: json
+    const json = await response.json();
+    if (config.mappings) {
+        for (const mapping of config.mappings) {
+            const value = getNestedField(json, mapping.jsonPath);
+            if (value != null) {
+                headers[mapping.header] = mapping.valueTemplate
+                    ? applyTemplate(mapping.valueTemplate, value)
+                    : value;
+            }
+        }
+    }
+    if (config.compositeHeaders) {
+        for (const comp of config.compositeHeaders) {
+            const values = {};
+            for (const [placeholder, jsonPath] of Object.entries(comp.paths)) {
+                const val = getNestedField(json, jsonPath);
+                if (val != null)
+                    values[placeholder] = val;
+            }
+            headers[comp.header] = applyCompositeTemplate(comp.template, values);
+        }
+    }
+    return headers;
+}
+export function registerTokenRefresh(options) {
+    const { target, ...config } = options;
+    const raw = JSON.stringify(config);
+    if (target === 'websocket' || target === 'all') {
+        NativeStorageSingleton.setSecureString(KEY_WS, raw);
+    }
+    if (target === 'fetch' || target === 'all') {
+        NativeStorageSingleton.setSecureString(KEY_FETCH, raw);
+    }
+}
+export function clearTokenRefresh(target) {
+    const t = target ?? 'all';
+    if (t === 'websocket' || t === 'all') {
+        NativeStorageSingleton.removeSecureString(KEY_WS);
+        NativeStorageSingleton.removeSecureString(KEY_WS_CACHE);
+    }
+    if (t === 'fetch' || t === 'all') {
+        NativeStorageSingleton.removeSecureString(KEY_FETCH);
+        NativeStorageSingleton.removeSecureString(KEY_FETCH_CACHE);
+    }
+}
+export function getStoredTokenRefreshConfig(target) {
+    const key = target === 'websocket' ? KEY_WS : KEY_FETCH;
+    try {
+        const raw = NativeStorageSingleton.getSecureString(key);
+        if (!raw)
+            return null;
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}

package/src/utf8.js

@@ -0,0 +1,40 @@
+let _TextEncoder;
+let _TextDecoder;
+const NITRO_TEXT_DECODER_PKG = 'react-native-nitro-text-decoder';
+function loadOptionalTextCodec() {
+    try {
+        // Hide require from the bundler so the package stays truly optional.
+        // eslint-disable-next-line no-new-func
+        const dynamicRequire = new Function('mod', 'return require(mod);');
+        return dynamicRequire(NITRO_TEXT_DECODER_PKG);
+    }
+    catch {
+        return {};
+    }
+}
+if (typeof TextEncoder !== 'undefined') {
+    _TextEncoder = TextEncoder;
+}
+else {
+    _TextEncoder = loadOptionalTextCodec().TextEncoder;
+}
+if (typeof TextDecoder !== 'undefined') {
+    _TextDecoder = TextDecoder;
+}
+else {
+    _TextDecoder = loadOptionalTextCodec().TextDecoder;
+}
+export function stringToUTF8(str) {
+    if (!_TextEncoder) {
+        console.warn('stringToUTF8: TextEncoder not available. Install react-native-nitro-text-decoder.');
+        return new Uint8Array(0);
+    }
+    return new _TextEncoder().encode(str);
+}
+export function utf8ToString(bytes) {
+    if (!_TextDecoder) {
+        console.warn('utf8ToString: TextDecoder not available. Install react-native-nitro-text-decoder.');
+        return '';
+    }
+    return new _TextDecoder().decode(bytes);
+}

package/src/utf8.ts

@@ -1,22 +1,37 @@
 let _TextEncoder: typeof TextEncoder | undefined;
 let _TextDecoder: typeof TextDecoder | undefined;
 
-try {
-  _TextEncoder =
-    typeof TextEncoder !== 'undefined'
-      ? TextEncoder
-      : require('react-native-nitro-text-decoder').TextEncoder;
-} catch {
-  /* resolved at first use */
+const NITRO_TEXT_DECODER_PKG = 'react-native-nitro-text-decoder';
+
+function loadOptionalTextCodec(): {
+  TextEncoder?: typeof TextEncoder;
+  TextDecoder?: typeof TextDecoder;
+} {
+  try {
+    // Hide require from the bundler so the package stays truly optional.
+    // eslint-disable-next-line no-new-func
+    const dynamicRequire = new Function('mod', 'return require(mod);') as (
+      m: string
+    ) => unknown;
+    return dynamicRequire(NITRO_TEXT_DECODER_PKG) as {
+      TextEncoder?: typeof TextEncoder;
+      TextDecoder?: typeof TextDecoder;
+    };
+  } catch {
+    return {};
+  }
+}
+
+if (typeof TextEncoder !== 'undefined') {
+  _TextEncoder = TextEncoder;
+} else {
+  _TextEncoder = loadOptionalTextCodec().TextEncoder;
 }
 
-try {
-  _TextDecoder =
-    typeof TextDecoder !== 'undefined'
-      ? TextDecoder
-      : require('react-native-nitro-text-decoder').TextDecoder;
-} catch {
-  /* resolved at first use */
+if (typeof TextDecoder !== 'undefined') {
+  _TextDecoder = TextDecoder;
+} else {
+  _TextDecoder = loadOptionalTextCodec().TextDecoder;
 }
 
 export function stringToUTF8(str: string): Uint8Array {