react-native-nitro-fetch 1.3.0 → 1.3.1

package/src/Headers.js

@@ -0,0 +1,127 @@
+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,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();
+        try {
+            hermes.dumpSamplingProfiler(path);
+        }
+        catch {
+            // Profile dump may fail on some platforms
+        }
+    }
+}

package/src/NetworkInspector.js

@@ -0,0 +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);
+    }
+}
+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,6 @@
+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,173 @@
+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');
+    }
+}