react-native-nitro-fetch 1.3.1 → 1.3.3

package/src/Headers.js

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

@@ -1,22 +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();
+  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 {
-        const result = await fn();
-        return { result, profilePath: path };
-    }
-    finally {
-        hermes.disableSamplingProfiler();
-        try {
-            hermes.dumpSamplingProfiler(path);
-        }
-        catch {
-            // Profile dump may fail on some platforms
-        }
+      hermes.dumpSamplingProfiler(path);
+    } catch {
+      // Profile dump may fail on some platforms
     }
+  }
 }

package/src/NetworkInspector.js

@@ -1,183 +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);
-    }
+  _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,4 +3,5 @@ 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');