react-native-nitro-fetch 1.3.0 → 1.3.2

package/nitrogen/generated/shared/c++/NitroRequest.hpp

@@ -57,11 +57,12 @@ namespace margelo::nitro::nitrofetch {
     std::optional<std::vector<NitroFormDataPart>> bodyFormData     SWIFT_PRIVATE;
     std::optional<double> timeoutMs     SWIFT_PRIVATE;
     std::optional<bool> followRedirects     SWIFT_PRIVATE;
+    std::optional<double> prefetchCacheTtlMs     SWIFT_PRIVATE;
     std::optional<std::string> requestId     SWIFT_PRIVATE;
 
   public:
     NitroRequest() = default;
-    explicit NitroRequest(std::string url, std::optional<NitroRequestMethod> method, std::optional<std::vector<NitroHeader>> headers, std::optional<std::string> bodyString, std::optional<std::string> bodyBytes, std::optional<std::vector<NitroFormDataPart>> bodyFormData, std::optional<double> timeoutMs, std::optional<bool> followRedirects, std::optional<std::string> requestId): url(url), method(method), headers(headers), bodyString(bodyString), bodyBytes(bodyBytes), bodyFormData(bodyFormData), timeoutMs(timeoutMs), followRedirects(followRedirects), requestId(requestId) {}
+    explicit NitroRequest(std::string url, std::optional<NitroRequestMethod> method, std::optional<std::vector<NitroHeader>> headers, std::optional<std::string> bodyString, std::optional<std::string> bodyBytes, std::optional<std::vector<NitroFormDataPart>> bodyFormData, std::optional<double> timeoutMs, std::optional<bool> followRedirects, std::optional<double> prefetchCacheTtlMs, std::optional<std::string> requestId): url(url), method(method), headers(headers), bodyString(bodyString), bodyBytes(bodyBytes), bodyFormData(bodyFormData), timeoutMs(timeoutMs), followRedirects(followRedirects), prefetchCacheTtlMs(prefetchCacheTtlMs), requestId(requestId) {}
 
   public:
     friend bool operator==(const NitroRequest& lhs, const NitroRequest& rhs) = default;
@@ -85,6 +86,7 @@ namespace margelo::nitro {
         JSIConverter<std::optional<std::vector<margelo::nitro::nitrofetch::NitroFormDataPart>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "bodyFormData"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "timeoutMs"))),
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "followRedirects"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "prefetchCacheTtlMs"))),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "requestId")))
       );
     }
@@ -98,6 +100,7 @@ namespace margelo::nitro {
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "bodyFormData"), JSIConverter<std::optional<std::vector<margelo::nitro::nitrofetch::NitroFormDataPart>>>::toJSI(runtime, arg.bodyFormData));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "timeoutMs"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.timeoutMs));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "followRedirects"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.followRedirects));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "prefetchCacheTtlMs"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.prefetchCacheTtlMs));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "requestId"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.requestId));
       return obj;
     }
@@ -117,6 +120,7 @@ namespace margelo::nitro {
       if (!JSIConverter<std::optional<std::vector<margelo::nitro::nitrofetch::NitroFormDataPart>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "bodyFormData")))) return false;
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "timeoutMs")))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "followRedirects")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "prefetchCacheTtlMs")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "requestId")))) return false;
       return true;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-fetch",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "Awesome Fetch :)",
   "main": "./lib/module/index.js",
   "module": "./lib/module/index.js",

package/src/CurlGenerator.js

@@ -0,0 +1,28 @@
+function shellEscape(str) {
+  if (/^[a-zA-Z0-9._\-/:=@,+]+$/.test(str)) return str;
+  return "'" + str.replace(/'/g, "'\\''") + "'";
+}
+export function generateCurl(options) {
+  const parts = ['curl'];
+  if (options.method && options.method !== 'GET') {
+    parts.push('-X', shellEscape(options.method));
+  }
+  if (options.headers) {
+    for (const h of options.headers) {
+      if (h.key.toLowerCase() === 'prefetchkey') continue;
+      parts.push('-H', shellEscape(`${h.key}: ${h.value}`));
+    }
+  }
+  if (options.body) {
+    const maxLen = 10_000;
+    const truncated =
+      options.body.length > maxLen
+        ? options.body.slice(0, maxLen) + '...[truncated]'
+        : options.body;
+    parts.push('-d', shellEscape(truncated));
+  }
+  if (options.verbose) parts.push('-v');
+  if (options.compressed) parts.push('--compressed');
+  parts.push(shellEscape(options.url));
+  return parts.join(' ');
+}

package/src/Headers.js

@@ -0,0 +1,119 @@
+function normalizeName(name) {
+  return name.toLowerCase();
+}
+export class NitroHeaders {
+  _map;
+  constructor(init) {
+    this._map = new Map();
+    if (!init) return;
+    if (init instanceof NitroHeaders) {
+      init._map.forEach((values, key) => {
+        this._map.set(key, [...values]);
+      });
+    } else if (
+      typeof init === 'object' &&
+      !Array.isArray(init) &&
+      typeof init.forEach === 'function' &&
+      typeof init.get === 'function'
+    ) {
+      // Headers-like object (standard Headers or duck-typed)
+      init.forEach((value, key) => {
+        this._map.set(normalizeName(key), [value]);
+      });
+    } else if (Array.isArray(init)) {
+      for (const entry of init) {
+        if (Array.isArray(entry) && entry.length >= 2) {
+          // [string, string] tuple
+          const key = normalizeName(String(entry[0]));
+          const value = String(entry[1]);
+          const existing = this._map.get(key);
+          if (existing) existing.push(value);
+          else this._map.set(key, [value]);
+        } else if (
+          entry &&
+          typeof entry === 'object' &&
+          'key' in entry &&
+          'value' in entry
+        ) {
+          // NitroHeader object
+          const key = normalizeName(entry.key);
+          const value = entry.value;
+          const existing = this._map.get(key);
+          if (existing) existing.push(value);
+          else this._map.set(key, [value]);
+        }
+      }
+    } else if (typeof init === 'object' && init !== null) {
+      const keys = Object.keys(init);
+      for (let i = 0; i < keys.length; i++) {
+        const k = keys[i];
+        const v = init[k];
+        if (v !== undefined) {
+          this._map.set(normalizeName(k), [String(v)]);
+        }
+      }
+    }
+  }
+  append(name, value) {
+    const key = normalizeName(name);
+    const existing = this._map.get(key);
+    if (existing) existing.push(value);
+    else this._map.set(key, [value]);
+  }
+  delete(name) {
+    this._map.delete(normalizeName(name));
+  }
+  get(name) {
+    const values = this._map.get(normalizeName(name));
+    if (!values || values.length === 0) return null;
+    return values.join(', ');
+  }
+  getSetCookie() {
+    return this._map.get('set-cookie') ?? [];
+  }
+  has(name) {
+    return this._map.has(normalizeName(name));
+  }
+  set(name, value) {
+    this._map.set(normalizeName(name), [value]);
+  }
+  forEach(callback, thisArg) {
+    const sortedKeys = Array.from(this._map.keys()).sort();
+    for (const key of sortedKeys) {
+      callback.call(thisArg, this._map.get(key).join(', '), key, this);
+    }
+  }
+  entries() {
+    const map = this._map;
+    const sortedKeys = Array.from(map.keys()).sort();
+    function* gen() {
+      for (const key of sortedKeys) {
+        yield [key, map.get(key).join(', ')];
+      }
+    }
+    return gen();
+  }
+  keys() {
+    const map = this._map;
+    const sortedKeys = Array.from(map.keys()).sort();
+    function* gen() {
+      for (const key of sortedKeys) {
+        yield key;
+      }
+    }
+    return gen();
+  }
+  values() {
+    const map = this._map;
+    const sortedKeys = Array.from(map.keys()).sort();
+    function* gen() {
+      for (const key of sortedKeys) {
+        yield map.get(key).join(', ');
+      }
+    }
+    return gen();
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+}

package/src/HermesProfiler.js

@@ -0,0 +1,20 @@
+export async function profileFetch(fn, outputPath) {
+  const hermes = global.HermesInternal;
+  if (!hermes) {
+    const result = await fn();
+    return { result };
+  }
+  const path = outputPath ?? `/tmp/nitrofetch-profile-${Date.now()}.cpuprofile`;
+  hermes.enableSamplingProfiler();
+  try {
+    const result = await fn();
+    return { result, profilePath: path };
+  } finally {
+    hermes.disableSamplingProfiler();
+    try {
+      hermes.dumpSamplingProfiler(path);
+    } catch {
+      // Profile dump may fail on some platforms
+    }
+  }
+}

package/src/NetworkInspector.js

@@ -0,0 +1,175 @@
+import { generateCurl } from './CurlGenerator';
+class NetworkInspectorImpl {
+  _enabled = false;
+  _entries = [];
+  _maxEntries = 500;
+  _maxBodyCapture = 4096;
+  _listeners = new Set();
+  enable(options) {
+    this._enabled = true;
+    if (options?.maxEntries != null) this._maxEntries = options.maxEntries;
+    if (options?.maxBodyCapture != null)
+      this._maxBodyCapture = options.maxBodyCapture;
+  }
+  disable() {
+    this._enabled = false;
+  }
+  isEnabled() {
+    return this._enabled;
+  }
+  getEntries() {
+    return this._entries;
+  }
+  getHttpEntries() {
+    return this._entries.filter((e) => e.type === 'http');
+  }
+  getWebSocketEntries() {
+    return this._entries.filter((e) => e.type === 'websocket');
+  }
+  getEntry(id) {
+    return this._entries.find((e) => e.id === id);
+  }
+  clear() {
+    this._entries = [];
+  }
+  onEntry(callback) {
+    this._listeners.add(callback);
+    return () => {
+      this._listeners.delete(callback);
+    };
+  }
+  _notify(entry) {
+    for (const cb of this._listeners) {
+      try {
+        cb(entry);
+      } catch {
+        // swallow listener errors
+      }
+    }
+  }
+  _trimEntries() {
+    if (this._entries.length > this._maxEntries) {
+      this._entries.shift();
+    }
+  }
+  // --- HTTP recording ---
+  _recordStart(id, url, method, headers, body) {
+    if (!this._enabled) return;
+    const bodySize = body ? body.length : 0;
+    const entry = {
+      id,
+      type: 'http',
+      url,
+      method,
+      requestHeaders: headers.map((h) => ({ key: h.key, value: h.value })),
+      requestBody: body ? body.slice(0, this._maxBodyCapture) : undefined,
+      requestBodySize: bodySize,
+      status: 0,
+      statusText: '',
+      responseHeaders: [],
+      responseBodySize: 0,
+      startTime: performance.now(),
+      endTime: 0,
+      duration: 0,
+      curl: generateCurl({ url, method, headers, body }),
+    };
+    this._entries.push(entry);
+    this._trimEntries();
+  }
+  _recordEnd(id, status, statusText, headers, bodySize, error, responseBody) {
+    if (!this._enabled) return;
+    const entry = this._entries.find((e) => e.id === id && e.type === 'http');
+    if (!entry) return;
+    entry.status = status;
+    entry.statusText = statusText;
+    entry.responseHeaders = headers.map((h) => ({
+      key: h.key,
+      value: h.value,
+    }));
+    entry.responseBodySize = bodySize;
+    entry.endTime = performance.now();
+    entry.duration = entry.endTime - entry.startTime;
+    if (error) entry.error = error;
+    if (responseBody != null) {
+      entry.responseBody = responseBody.slice(0, this._maxBodyCapture);
+    }
+    this._notify(entry);
+  }
+  // --- WebSocket recording ---
+  _recordWsOpen(id, url, protocols, headers) {
+    if (!this._enabled) return;
+    const entry = {
+      id,
+      type: 'websocket',
+      url,
+      protocols,
+      requestHeaders: headers.map((h) => ({ key: h.key, value: h.value })),
+      startTime: performance.now(),
+      endTime: 0,
+      duration: 0,
+      readyState: 'CONNECTING',
+      messages: [],
+      messagesSent: 0,
+      messagesReceived: 0,
+      bytesSent: 0,
+      bytesReceived: 0,
+    };
+    this._entries.push(entry);
+    this._trimEntries();
+    this._notify(entry);
+  }
+  _recordWsConnected(id) {
+    if (!this._enabled) return;
+    const entry = this._entries.find(
+      (e) => e.id === id && e.type === 'websocket'
+    );
+    if (!entry) return;
+    entry.readyState = 'OPEN';
+    this._notify(entry);
+  }
+  _recordWsMessage(id, direction, data, size, isBinary) {
+    if (!this._enabled) return;
+    const entry = this._entries.find(
+      (e) => e.id === id && e.type === 'websocket'
+    );
+    if (!entry) return;
+    entry.messages.push({
+      direction,
+      data: data.slice(0, this._maxBodyCapture),
+      size,
+      isBinary,
+      timestamp: performance.now(),
+    });
+    if (direction === 'sent') {
+      entry.messagesSent++;
+      entry.bytesSent += size;
+    } else {
+      entry.messagesReceived++;
+      entry.bytesReceived += size;
+    }
+    this._notify(entry);
+  }
+  _recordWsClose(id, code, reason) {
+    if (!this._enabled) return;
+    const entry = this._entries.find(
+      (e) => e.id === id && e.type === 'websocket'
+    );
+    if (!entry) return;
+    entry.readyState = 'CLOSED';
+    entry.closeCode = code;
+    entry.closeReason = reason;
+    entry.endTime = performance.now();
+    entry.duration = entry.endTime - entry.startTime;
+    this._notify(entry);
+  }
+  _recordWsError(id, error) {
+    if (!this._enabled) return;
+    const entry = this._entries.find(
+      (e) => e.id === id && e.type === 'websocket'
+    );
+    if (!entry) return;
+    entry.error = error;
+    this._notify(entry);
+  }
+}
+export const NetworkInspector = new NetworkInspectorImpl();

package/src/NitroCronet.nitro.js

@@ -0,0 +1 @@
+export {};

package/src/NitroFetch.nitro.js

@@ -0,0 +1 @@
+export {};

package/src/NitroFetch.nitro.ts

@@ -36,6 +36,9 @@ export interface NitroRequest {
   // Controls
   timeoutMs?: number;
   followRedirects?: boolean; // default true
+  // Max age (ms) a prefetch cache entry is considered fresh at read time.
+  // Default 5000 when omitted. <= 0 disables cache hits.
+  prefetchCacheTtlMs?: number;
   // Optional ID used for cancellation via cancelRequest()
   requestId?: string;
 }

package/src/NitroInstances.js

@@ -0,0 +1,7 @@
+import { NitroModules } from 'react-native-nitro-modules';
+// Create singletons once per JS runtime
+export const NitroFetch = NitroModules.createHybridObject('NitroFetch');
+export const NativeStorage = NitroModules.createHybridObject('NativeStorage');
+export const boxedNitroFetch = NitroModules.box(NitroFetch);
+export const NitroCronetSingleton =
+  NitroModules.createHybridObject('NitroCronet');

package/src/Request.js

@@ -0,0 +1,176 @@
+import { NitroHeaders } from './Headers';
+import { stringToUTF8, utf8ToString } from './utf8';
+export class NitroRequest {
+  url;
+  method;
+  headers;
+  redirect;
+  signal;
+  cache;
+  credentials;
+  mode;
+  referrer;
+  referrerPolicy;
+  integrity;
+  keepalive;
+  destination;
+  _body;
+  _bodyUsed = false;
+  constructor(input, init) {
+    if (input instanceof NitroRequest) {
+      // Clone from another NitroRequest
+      this.url = input.url;
+      this.method = (init?.method ?? input.method).toUpperCase();
+      this.headers = new NitroHeaders(
+        init?.headers
+          ? init.headers instanceof NitroHeaders
+            ? init.headers
+            : init.headers
+          : input.headers
+      );
+      this.redirect = init?.redirect ?? input.redirect;
+      this.signal = init?.signal ?? input.signal;
+      this.cache = init?.cache ?? input.cache;
+      this.credentials = init?.credentials ?? input.credentials;
+      this.mode = init?.mode ?? input.mode;
+      this.referrer = init?.referrer ?? input.referrer;
+      this.referrerPolicy = init?.referrerPolicy ?? input.referrerPolicy;
+      this.integrity = init?.integrity ?? input.integrity;
+      this.keepalive = init?.keepalive ?? input.keepalive;
+      this._body = init?.body !== undefined ? (init.body ?? null) : input._body;
+    } else if (
+      typeof input === 'object' &&
+      input !== null &&
+      'url' in input &&
+      'method' in input &&
+      'headers' in input &&
+      !(input instanceof URL)
+    ) {
+      // Construct from a Request-like object (standard Request or duck-typed)
+      this.url = input.url;
+      this.method = (init?.method ?? input.method).toUpperCase();
+      this.headers = new NitroHeaders(
+        init?.headers
+          ? init.headers instanceof NitroHeaders
+            ? init.headers
+            : init.headers
+          : input.headers
+      );
+      this.redirect = init?.redirect ?? input.redirect ?? 'follow';
+      this.signal = init?.signal ?? input.signal;
+      this.cache = init?.cache ?? input.cache ?? 'default';
+      this.credentials =
+        init?.credentials ?? input.credentials ?? 'same-origin';
+      this.mode = init?.mode ?? input.mode ?? 'cors';
+      this.referrer = init?.referrer ?? input.referrer ?? 'about:client';
+      this.referrerPolicy = init?.referrerPolicy ?? input.referrerPolicy ?? '';
+      this.integrity = init?.integrity ?? input.integrity ?? '';
+      this.keepalive = init?.keepalive ?? input.keepalive ?? false;
+      this._body = init?.body ?? null;
+    } else {
+      this.url = String(input);
+      this.method = (init?.method ?? 'GET').toUpperCase();
+      this.headers = new NitroHeaders(
+        init?.headers
+          ? init.headers instanceof NitroHeaders
+            ? init.headers
+            : init.headers
+          : undefined
+      );
+      this.redirect = init?.redirect ?? 'follow';
+      this.signal = init?.signal ?? new AbortController().signal;
+      this.cache = init?.cache ?? 'default';
+      this.credentials = init?.credentials ?? 'same-origin';
+      this.mode = init?.mode ?? 'cors';
+      this.referrer = init?.referrer ?? 'about:client';
+      this.referrerPolicy = init?.referrerPolicy ?? '';
+      this.integrity = init?.integrity ?? '';
+      this.keepalive = init?.keepalive ?? false;
+      this._body = init?.body ?? null;
+    }
+    this.destination = '';
+  }
+  get bodyUsed() {
+    return this._bodyUsed;
+  }
+  get body() {
+    if (this._body == null) return null;
+    const bodyBytes = this._getBodyBytes();
+    if (!bodyBytes) return null;
+    return new ReadableStream({
+      start(controller) {
+        controller.enqueue(new Uint8Array(bodyBytes));
+        controller.close();
+      },
+    });
+  }
+  _throwIfBodyUsed() {
+    if (this._bodyUsed) {
+      throw new TypeError('Body has already been consumed.');
+    }
+  }
+  _getBodyBytes() {
+    if (this._body == null) return undefined;
+    if (typeof this._body === 'string') {
+      const encoded = stringToUTF8(this._body);
+      return encoded.buffer.slice(
+        encoded.byteOffset,
+        encoded.byteOffset + encoded.byteLength
+      );
+    }
+    if (this._body instanceof ArrayBuffer) return this._body;
+    if (ArrayBuffer.isView(this._body)) {
+      const view = this._body;
+      return view.buffer.slice(
+        view.byteOffset,
+        view.byteOffset + view.byteLength
+      );
+    }
+    return undefined;
+  }
+  _getBodyString() {
+    if (this._body == null) return '';
+    if (typeof this._body === 'string') return this._body;
+    const bytes = this._getBodyBytes();
+    if (bytes) return utf8ToString(new Uint8Array(bytes));
+    return '';
+  }
+  async text() {
+    this._throwIfBodyUsed();
+    this._bodyUsed = true;
+    return this._getBodyString();
+  }
+  async json() {
+    this._throwIfBodyUsed();
+    this._bodyUsed = true;
+    const t = this._getBodyString();
+    return JSON.parse(t || '{}');
+  }
+  async arrayBuffer() {
+    this._throwIfBodyUsed();
+    this._bodyUsed = true;
+    return this._getBodyBytes() ?? new ArrayBuffer(0);
+  }
+  async blob() {
+    this._throwIfBodyUsed();
+    this._bodyUsed = true;
+    const buffer = this._getBodyBytes() ?? new ArrayBuffer(0);
+    const contentType = this.headers.get('content-type') ?? '';
+    return new Blob([buffer], { type: contentType });
+  }
+  async bytes() {
+    this._throwIfBodyUsed();
+    this._bodyUsed = true;
+    const buffer = this._getBodyBytes() ?? new ArrayBuffer(0);
+    return new Uint8Array(buffer);
+  }
+  clone() {
+    if (this._bodyUsed) {
+      throw new TypeError('Cannot clone a Request whose body has been used.');
+    }
+    return new NitroRequest(this);
+  }
+  async formData() {
+    throw new TypeError('formData() is not supported in NitroRequest');
+  }
+}