react-native-nitro-fetch 1.2.1 → 1.3.1

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;
 }
@@ -47,9 +50,8 @@ export interface NitroResponse {
   ok: boolean;
   redirected: boolean;
   headers: NitroHeader[];
-  // Body as either UTF-8 string or raw bytes (first implementation target)
   bodyString?: string;
-  bodyBytes?: string; //will be ArrayBuffer in future
+  bodyBytes?: ArrayBuffer;
 }
 
 export interface NitroFetchClient extends HybridObject<{

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');
+    }
+}

package/src/Response.js

@@ -0,0 +1,258 @@
+import { NitroHeaders } from './Headers';
+import { stringToUTF8, utf8ToString } from './utf8';
+function isNitroResponseInit(arg) {
+    return (arg != null &&
+        typeof arg === 'object' &&
+        'url' in arg &&
+        'status' in arg &&
+        'ok' in arg);
+}
+export class NitroResponse {
+    url;
+    ok;
+    status;
+    statusText;
+    redirected;
+    headers;
+    type;
+    _bodyBytes;
+    _bodyString;
+    _bodyStream;
+    _bodyUsed = false;
+    constructor(bodyOrInit, init) {
+        if (isNitroResponseInit(bodyOrInit)) {
+            // Internal constructor path
+            const nitroInit = bodyOrInit;
+            this.url = nitroInit.url;
+            this.ok = nitroInit.ok;
+            this.status = nitroInit.status;
+            this.statusText = nitroInit.statusText;
+            this.redirected = nitroInit.redirected;
+            this.type = nitroInit.type ?? 'basic';
+            if (nitroInit.headers instanceof NitroHeaders) {
+                this.headers = nitroInit.headers;
+            }
+            else {
+                this.headers = new NitroHeaders(nitroInit.headers);
+            }
+            this._bodyBytes = nitroInit.bodyBytes;
+            this._bodyString = nitroInit.bodyString;
+            this._bodyStream = nitroInit.body;
+        }
+        else {
+            // Public constructor: new Response(body?, init?)
+            const body = bodyOrInit;
+            this.status = init?.status ?? 200;
+            this.statusText = init?.statusText ?? '';
+            this.ok = this.status >= 200 && this.status < 300;
+            this.url = '';
+            this.redirected = false;
+            this.type = 'default';
+            this.headers = new NitroHeaders(init?.headers);
+            if (body == null) {
+                // no body
+            }
+            else if (typeof body === 'string') {
+                this._bodyString = body;
+            }
+            else if (body instanceof ArrayBuffer) {
+                this._bodyBytes = body;
+            }
+            else if (ArrayBuffer.isView(body)) {
+                const view = body;
+                this._bodyBytes = view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
+            }
+            else if (typeof ReadableStream !== 'undefined' &&
+                body instanceof ReadableStream) {
+                this._bodyStream = body;
+            }
+            else if (typeof URLSearchParams !== 'undefined' &&
+                body instanceof URLSearchParams) {
+                this._bodyString = body.toString();
+                if (!this.headers.has('content-type')) {
+                    this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
+                }
+            }
+            else if (typeof Blob !== 'undefined' && body instanceof Blob) {
+                // Store as string — RN Blobs are string-backed
+                this._bodyString = '';
+                this._bodyStream = body.stream?.();
+            }
+        }
+    }
+    get bodyUsed() {
+        return this._bodyUsed;
+    }
+    get body() {
+        if (this._bodyStream)
+            return this._bodyStream;
+        const bytes = this._getBodyBytes();
+        if (!bytes)
+            return null;
+        return new ReadableStream({
+            start(controller) {
+                controller.enqueue(new Uint8Array(bytes));
+                controller.close();
+            },
+        });
+    }
+    _throwIfBodyUsed() {
+        if (this._bodyUsed) {
+            throw new TypeError('Body has already been consumed.');
+        }
+    }
+    _getBodyBytes() {
+        // TODO: copy buffer to avoid clone being modifying res
+        if (this._bodyBytes != null)
+            return this._bodyBytes;
+        if (this._bodyString != null) {
+            const encoded = stringToUTF8(this._bodyString);
+            return encoded.buffer.slice(encoded.byteOffset, encoded.byteOffset + encoded.byteLength);
+        }
+        return undefined;
+    }
+    _getBodyString() {
+        if (this._bodyString != null)
+            return this._bodyString;
+        if (this._bodyBytes) {
+            return utf8ToString(new Uint8Array(this._bodyBytes));
+        }
+        return '';
+    }
+    async text() {
+        this._throwIfBodyUsed();
+        this._bodyUsed = true;
+        if (this._bodyStream && !this._bodyBytes && this._bodyString == null) {
+            const reader = this._bodyStream.getReader();
+            const chunks = [];
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                if (value)
+                    chunks.push(value);
+            }
+            // Concatenate chunks
+            let totalLen = 0;
+            for (const c of chunks)
+                totalLen += c.byteLength;
+            const merged = new Uint8Array(totalLen);
+            let offset = 0;
+            for (const c of chunks) {
+                merged.set(c, offset);
+                offset += c.byteLength;
+            }
+            return utf8ToString(merged);
+        }
+        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;
+        if (this._bodyStream && !this._bodyBytes && this._bodyString == null) {
+            const reader = this._bodyStream.getReader();
+            const chunks = [];
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                if (value)
+                    chunks.push(value);
+            }
+            let totalLen = 0;
+            for (const c of chunks)
+                totalLen += c.byteLength;
+            const merged = new Uint8Array(totalLen);
+            let offset = 0;
+            for (const c of chunks) {
+                merged.set(c, offset);
+                offset += c.byteLength;
+            }
+            return merged.buffer.slice(merged.byteOffset, merged.byteOffset + merged.byteLength);
+        }
+        return this._getBodyBytes() ?? new ArrayBuffer(0);
+    }
+    async blob() {
+        this._throwIfBodyUsed();
+        this._bodyUsed = true;
+        // RN's Blob doesn't support ArrayBuffer/ArrayBufferView — use string body
+        const bodyStr = this._getBodyString();
+        const contentType = this.headers.get('content-type') ?? '';
+        return new Blob([bodyStr], { 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 Response whose body has been used.');
+        }
+        return new NitroResponse({
+            url: this.url,
+            status: this.status,
+            statusText: this.statusText,
+            ok: this.ok,
+            redirected: this.redirected,
+            headers: this.headers,
+            bodyBytes: this._bodyBytes,
+            bodyString: this._bodyString,
+            type: this.type,
+        });
+    }
+    async formData() {
+        throw new TypeError('formData() is not supported in NitroResponse');
+    }
+    // --- Static methods ---
+    static error() {
+        return new NitroResponse({
+            url: '',
+            status: 0,
+            statusText: '',
+            ok: false,
+            redirected: false,
+            headers: [],
+            type: 'error',
+        });
+    }
+    static json(data, init) {
+        const body = JSON.stringify(data);
+        const headers = new NitroHeaders(init?.headers);
+        if (!headers.has('content-type')) {
+            headers.set('content-type', 'application/json');
+        }
+        return new NitroResponse({
+            url: '',
+            status: init?.status ?? 200,
+            statusText: init?.statusText ?? '',
+            ok: (init?.status ?? 200) >= 200 && (init?.status ?? 200) < 300,
+            redirected: false,
+            headers,
+            bodyString: body,
+        });
+    }
+    static redirect(url, status = 302) {
+        const validStatuses = [301, 302, 303, 307, 308];
+        if (!validStatuses.includes(status)) {
+            throw new RangeError(`Invalid redirect status: ${status}. Must be one of ${validStatuses.join(', ')}`);
+        }
+        const headers = new NitroHeaders();
+        headers.set('location', url);
+        return new NitroResponse({
+            url: '',
+            status,
+            statusText: '',
+            ok: false,
+            redirected: false,
+            headers,
+        });
+    }
+}

package/src/Response.ts

@@ -144,7 +144,8 @@ export class NitroResponse {
   }
 
   private _getBodyBytes(): ArrayBuffer | undefined {
-    if (this._bodyBytes) return this._bodyBytes;
+    // TODO: copy buffer to avoid clone being modifying res
+    if (this._bodyBytes != null) return this._bodyBytes;
     if (this._bodyString != null) {
       const encoded = stringToUTF8(this._bodyString);
       return (encoded.buffer as ArrayBuffer).slice(