react-native-nitro-fetch 1.3.2 → 1.4.0

package/src/Headers.js

@@ -1,119 +1,127 @@
 function normalizeName(name) {
-  return name.toLowerCase();
+    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]);
+    _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' && 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)]);
+        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));
     }
-  }
-  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);
+    get(name) {
+        const values = this._map.get(normalizeName(name));
+        if (!values || values.length === 0)
+            return null;
+        return values.join(', ');
     }
-  }
-  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(', ')];
-      }
+    getSetCookie() {
+        return this._map.get('set-cookie') ?? [];
     }
-    return gen();
-  }
-  keys() {
-    const map = this._map;
-    const sortedKeys = Array.from(map.keys()).sort();
-    function* gen() {
-      for (const key of sortedKeys) {
-        yield key;
-      }
+    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();
     }
-    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(', ');
-      }
+    [Symbol.iterator]() {
+        return this.entries();
     }
-    return gen();
-  }
-  [Symbol.iterator]() {
-    return this.entries();
-  }
 }

package/src/HermesProfiler.js

@@ -1,20 +1,22 @@
 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();
+    const hermes = global.HermesInternal;
+    if (!hermes) {
+        const result = await fn();
+        return { result };
+    }
+    const path = outputPath ?? `/tmp/nitrofetch-profile-${Date.now()}.cpuprofile`;
+    hermes.enableSamplingProfiler();
     try {
-      hermes.dumpSamplingProfiler(path);
-    } catch {
-      // Profile dump may fail on some platforms
+        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

@@ -1,175 +1,183 @@
 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);
-  }
+    _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/NitroInstances.js

@@ -3,5 +3,4 @@ import { NitroModules } from 'react-native-nitro-modules';
 export const NitroFetch = NitroModules.createHybridObject('NitroFetch');
 export const NativeStorage = NitroModules.createHybridObject('NativeStorage');
 export const boxedNitroFetch = NitroModules.box(NitroFetch);
-export const NitroCronetSingleton =
-  NitroModules.createHybridObject('NitroCronet');
+export const NitroCronetSingleton = NitroModules.createHybridObject('NitroCronet');