react-native-nitro-fetch 1.3.2 → 1.4.0

package/src/fetch.ts

@@ -438,6 +438,169 @@ async function resolveBlobBody(
   return init;
 }
 
+// http(s) -> native client; anything else is a local resource (hot path).
+function isHttpUrl(url: string): boolean {
+  if (url.startsWith('http://') || url.startsWith('https://')) return true;
+  const c = url.charCodeAt(0);
+  if (c !== 104 && c !== 72) return false; // not 'h'/'H'
+  return /^https?:/i.test(url);
+}
+
+function getUrlString(input: RequestInfo | URL): string {
+  if (typeof input === 'string') return input;
+  if (input instanceof URL) return input.toString();
+  const u = (input as { url?: unknown } | null)?.url;
+  return typeof u === 'string' ? u : String(input);
+}
+
+function base64ToBytes(b64: string): Uint8Array {
+  const decode = (globalThis as { atob?: (s: string) => string }).atob;
+  if (typeof decode === 'function') {
+    const bin = decode(b64);
+    const out = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+    return out;
+  }
+  // base64 fallback for runtimes without a global atob.
+  /* eslint-disable no-bitwise */
+  const chars =
+    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+  const clean = b64.replace(/[^A-Za-z0-9+/]/g, '');
+  const out = new Uint8Array(Math.floor((clean.length * 3) / 4));
+  let p = 0;
+  let buf = 0;
+  let bits = 0;
+  for (let i = 0; i < clean.length; i++) {
+    buf = (buf << 6) | chars.indexOf(clean[i]!);
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out[p++] = (buf >> bits) & 0xff;
+    }
+  }
+  return out;
+  /* eslint-enable no-bitwise */
+}
+
+type MinimalTextDecoder = {
+  decode(input: ArrayBufferView): string;
+};
+type TextDecoderCtor = new (
+  label?: string,
+  options?: { fatal?: boolean }
+) => MinimalTextDecoder;
+
+// Cached: our nitro-text-decoder if the app bundles it (aliased require keeps it optional, not a dep), else a global TextDecoder.
+let _decoder: MinimalTextDecoder | null | undefined;
+function resolveTextDecoder(): MinimalTextDecoder | null {
+  if (_decoder !== undefined) return _decoder;
+  try {
+    const dynamicRequire = require;
+    const mod = dynamicRequire('react-native-nitro-text-decoder') as {
+      TextDecoder?: TextDecoderCtor;
+    };
+    if (mod && typeof mod.TextDecoder === 'function') {
+      _decoder = new mod.TextDecoder('utf-8', { fatal: true });
+      return _decoder;
+    }
+  } catch {
+    // optional, not bundled
+  }
+  const GlobalTextDecoder = (globalThis as { TextDecoder?: TextDecoderCtor })
+    .TextDecoder;
+  if (typeof GlobalTextDecoder === 'function') {
+    _decoder = new GlobalTextDecoder('utf-8', { fatal: true });
+    return _decoder;
+  }
+  _decoder = null;
+  return _decoder;
+}
+
+// data: text via a TextDecoder; null (bytes-only) + a one-time warn if none.
+let _warnedNoTextDecoder = false;
+function decodeUtf8(bytes: Uint8Array): string | null {
+  const decoder = resolveTextDecoder();
+  if (decoder) {
+    try {
+      return decoder.decode(bytes);
+    } catch {
+      return null; // invalid UTF-8 -> keep bytes only
+    }
+  }
+  if (!_warnedNoTextDecoder) {
+    _warnedNoTextDecoder = true;
+    console.warn(
+      '[nitro-fetch] Reading a data: URL as text needs a TextDecoder. Install ' +
+        'react-native-nitro-text-decoder or expose a global TextDecoder. The ' +
+        'body is still available via response.arrayBuffer()/bytes().'
+    );
+  }
+  return null;
+}
+
+// Decode a data: URL into a synthetic 200 response, entirely in JS.
+function decodeDataUrl(url: string): NitroResponseNative {
+  const comma = url.indexOf(',');
+  if (comma < 0) throw new TypeError('Failed to fetch: invalid data: URL');
+  const meta = url.slice(5, comma); // strip leading "data:"
+  const rawData = url.slice(comma + 1);
+  const isBase64 = /;base64\s*$/i.test(meta);
+  const mediaType =
+    (isBase64 ? meta.replace(/;base64\s*$/i, '') : meta).trim() ||
+    'text/plain;charset=US-ASCII';
+
+  let bodyString: string | undefined;
+  let bodyBytes: ArrayBuffer | undefined;
+  let length: number;
+  if (isBase64) {
+    const bytes = base64ToBytes(rawData);
+    length = bytes.byteLength;
+    // bytes for arrayBuffer/bytes; string for text/json when a decoder exists.
+    bodyBytes = bytes.buffer as ArrayBuffer;
+    const decoded = decodeUtf8(bytes);
+    if (decoded != null) bodyString = decoded;
+  } else {
+    bodyString = decodeURIComponent(rawData);
+    length =
+      typeof TextEncoder !== 'undefined'
+        ? new TextEncoder().encode(bodyString).length
+        : bodyString.length;
+  }
+
+  return {
+    url,
+    status: 200,
+    statusText: 'OK',
+    ok: true,
+    redirected: false,
+    headers: [
+      { key: 'Content-Type', value: mediaType },
+      { key: 'Content-Length', value: String(length) },
+    ],
+    bodyString,
+    bodyBytes,
+  } as NitroResponseNative;
+}
+
+// Non-http(s): decode data: in JS, reject blob:, read file/content/path natively.
+async function fetchLocalResource(
+  req: NitroRequestNative
+): Promise<NitroResponseNative> {
+  const url = req.url;
+  if (url.startsWith('data:')) return decodeDataUrl(url);
+  if (url.startsWith('blob:')) {
+    throw new TypeError(
+      'nitro-fetch cannot read blob: URLs (the React Native blob registry is not ' +
+        'reachable from native). Read blobs with the platform fetch/FileReader instead.'
+    );
+  }
+  ensureClient();
+  if (!client || typeof client.request !== 'function') {
+    throw new Error('NitroFetch client not available');
+  }
+  return client.request(req);
+}
+
 async function nitroFetchRaw(
   input: RequestInfo | URL,
   init?: RequestInit
@@ -478,6 +641,11 @@ async function nitroFetchRaw(
 
   const req = buildNitroRequest(input, init);
 
+  // Route non-http(s) (data:/file://content://scheme-less) off the HTTP client.
+  if (!isHttpUrl(req.url)) {
+    return fetchLocalResource(req);
+  }
+
   // Inspector: record start (zero cost when disabled — single boolean check)
   let inspectorId: string | undefined;
   if (NetworkInspector.isEnabled()) {
@@ -696,7 +864,8 @@ export async function nitroFetch(
     } as any;
   }
 
-  if ((init as any)?.stream === true) {
+  // Streaming is http(s)-only; local URLs fall through to nitroFetchRaw (check runs only when streaming).
+  if ((init as any)?.stream === true && isHttpUrl(getUrlString(input))) {
     return nitroStreamFetch(input, init);
   }
 

package/src/index.js

@@ -1,24 +1,9 @@
-export {
-  nitroFetch as fetch,
-  nitroFetchOnWorklet,
-  prefetch,
-  prefetchOnAppStart,
-  removeFromAutoPrefetch,
-  removeAllFromAutoprefetch,
-  __readAutoPrefetchQueue,
-} from './fetch';
+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 { registerTokenRefresh, clearTokenRefresh, callRefreshEndpoint, getStoredTokenRefreshConfig, getNestedField, applyTemplate, } from './tokenRefresh';
 export { NetworkInspector } from './NetworkInspector';
 export { generateCurl } from './CurlGenerator';
 export { profileFetch } from './HermesProfiler';

package/src/index.web.js

@@ -9,98 +9,96 @@ 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;
+    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,
+        };
     }
-    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);
+    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,
-  });
+    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');
+    console.warn('prefetch is not available on web');
 }
 export async function prefetchOnAppStart(_input, _init) {
-  console.warn('prefetchOnAppStart is not available on web');
+    console.warn('prefetchOnAppStart is not available on web');
 }
 export async function removeFromAutoPrefetch(_prefetchKey) {
-  console.warn('removeFromAutoPrefetch is not available on web');
+    console.warn('removeFromAutoPrefetch is not available on web');
 }
 export async function removeAllFromAutoprefetch() {
-  console.warn('removeAllFromAutoprefetch is not available on web');
+    console.warn('removeAllFromAutoprefetch is not available on web');
 }
-export const NitroFetch = new Proxy(
-  {},
-  {
+export const NitroFetch = new Proxy({}, {
     get(_target, prop) {
-      console.warn(`NitroFetch.${String(prop)} is not available on web`);
-      return undefined;
+        console.warn(`NitroFetch.${String(prop)} is not available on web`);
+        return undefined;
     },
-  }
-);
+});
 export function registerTokenRefresh(_options) {
-  console.warn('registerTokenRefresh is not available on web');
+    console.warn('registerTokenRefresh is not available on web');
 }
 export function clearTokenRefresh(_target) {
-  console.warn('clearTokenRefresh is not available on web');
+    console.warn('clearTokenRefresh is not available on web');
 }
 export async function callRefreshEndpoint(_config) {
-  console.warn('callRefreshEndpoint is not available on web');
-  return {};
+    console.warn('callRefreshEndpoint is not available on web');
+    return {};
 }
 export function getStoredTokenRefreshConfig(_target) {
-  console.warn('getStoredTokenRefreshConfig is not available on web');
-  return null;
+    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;
+    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);
+    return template.replace(/\{\{value\}\}/g, value);
 }

package/src/tokenRefresh.js

@@ -9,94 +9,96 @@ const KEY_FETCH_CACHE = 'nitro_token_refresh_fetch_cache';
  * 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;
+    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);
+    return template.replace(/\{\{value\}\}/g, value);
 }
 function applyCompositeTemplate(template, values) {
-  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => values[key] ?? '');
+    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;
+    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}`);
     }
-    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;
-      }
+    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);
+    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;
+    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);
-  }
+    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);
-  }
+    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;
-  }
+    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

@@ -2,40 +2,39 @@ 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 {};
-  }
+    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;
+    _TextEncoder = TextEncoder;
+}
+else {
+    _TextEncoder = loadOptionalTextCodec().TextEncoder;
 }
 if (typeof TextDecoder !== 'undefined') {
-  _TextDecoder = TextDecoder;
-} else {
-  _TextDecoder = loadOptionalTextCodec().TextDecoder;
+    _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);
+    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);
+    if (!_TextDecoder) {
+        console.warn('utf8ToString: TextDecoder not available. Install react-native-nitro-text-decoder.');
+        return '';
+    }
+    return new _TextDecoder().decode(bytes);
 }