react-native-nitro-fetch 0.1.2 → 0.1.4

package/src/fetch.ts

@@ -5,6 +5,7 @@ import type {
   NitroResponse,
 } from './NitroFetch.nitro';
 import { NitroFetch as NitroFetchSingleton } from './NitroInstances';
+import { NativeStorage as NativeStorageSingleton } from './NitroInstances';
 
 // No base64: pass strings/ArrayBuffers directly
 
@@ -21,7 +22,12 @@ function headersToPairs(headers?: HeadersInit): NitroHeader[] | undefined {
     for (const entry of headers as any[]) {
       if (Array.isArray(entry) && entry.length >= 2) {
         pairs.push({ key: String(entry[0]), value: String(entry[1]) });
-      } else if (entry && typeof entry === 'object' && 'key' in entry && 'value' in entry) {
+      } else if (
+        entry &&
+        typeof entry === 'object' &&
+        'key' in entry &&
+        'value' in entry
+      ) {
         pairs.push(entry as NitroHeader);
       }
     }
@@ -34,30 +40,30 @@ function headersToPairs(headers?: HeadersInit): NitroHeader[] | undefined {
   return pairs;
 }
 
-function normalizeBody(body: BodyInit | null | undefined): { bodyString?: string; bodyBytes?: ArrayBuffer } | undefined {
+function normalizeBody(
+  body: BodyInit | null | undefined
+): { bodyString?: string; bodyBytes?: ArrayBuffer } | undefined {
   'worklet';
   if (body == null) return undefined;
   if (typeof body === 'string') return { bodyString: body };
   if (body instanceof URLSearchParams) return { bodyString: body.toString() };
-  if (typeof ArrayBuffer !== 'undefined' && body instanceof ArrayBuffer) return { bodyBytes: body };
+  if (typeof ArrayBuffer !== 'undefined' && body instanceof ArrayBuffer)
+    return { bodyBytes: body };
   if (ArrayBuffer.isView(body)) {
     const view = body as ArrayBufferView;
     // Pass a copy/slice of the underlying bytes without base64
-    //@ts-ignore
-    return { bodyBytes: view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength) };
+    return {
+      //@ts-ignore
+      bodyBytes: view.buffer.slice(
+        view.byteOffset,
+        view.byteOffset + view.byteLength
+      ),
+    };
   }
   // TODO: Blob/FormData support can be added later
   throw new Error('Unsupported body type for nitro fetch');
 }
 
-// @ts-ignore
-function pairsToHeaders(pairs: NitroHeader[]): Headers {
-  'worklet';
-  const h = new Headers();
-  for (const { key, value } of pairs) h.append(key, value);
-  return h;
-}
-
 const NitroFetchHybrid: NitroFetchModule = NitroFetchSingleton;
 
 let client: ReturnType<NitroFetchModule['createClient']> | undefined;
@@ -73,7 +79,10 @@ function ensureClient() {
   return client;
 }
 
-function buildNitroRequest(input: RequestInfo | URL, init?: RequestInit): NitroRequest {
+function buildNitroRequest(
+  input: RequestInfo | URL,
+  init?: RequestInit
+): NitroRequest {
   'worklet';
   let url: string;
   let method: string | undefined;
@@ -102,14 +111,19 @@ function buildNitroRequest(input: RequestInfo | URL, init?: RequestInit): NitroR
     method: (method?.toUpperCase() as any) ?? 'GET',
     headers,
     bodyString: normalized?.bodyString,
-    bodyBytes: "",//normalized?.bodyBytes,
+    // Only include bodyBytes when provided to avoid signaling upload data unintentionally
+    bodyBytes: undefined as any,
     followRedirects: true,
   };
 }
 
-async function nitroFetchRaw(input: RequestInfo | URL, init?: RequestInit): Promise<NitroResponse> {
+async function nitroFetchRaw(
+  input: RequestInfo | URL,
+  init?: RequestInit
+): Promise<NitroResponse> {
   'worklet';
-  const hasNative = typeof (NitroFetchHybrid as any)?.createClient === 'function';
+  const hasNative =
+    typeof (NitroFetchHybrid as any)?.createClient === 'function';
   if (!hasNative) {
     // Fallback path not supported for raw; use global fetch and synthesize minimal shape
     // @ts-ignore: global fetch exists in RN
@@ -132,59 +146,105 @@ async function nitroFetchRaw(input: RequestInfo | URL, init?: RequestInit): Prom
 
   const req = buildNitroRequest(input, init);
   ensureClient();
-  if (!client || typeof (client as any).request !== 'function') throw new Error('NitroFetch client not available');
+  if (!client || typeof (client as any).request !== 'function')
+    throw new Error('NitroFetch client not available');
   const res: NitroResponse = await client.request(req);
   return res;
 }
 
-export async function nitroFetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
-  'worklet';
-  // If native implementation is not present yet, fallback to global fetch
-  const hasNative = typeof (NitroFetchHybrid as any)?.createClient === 'function';
-  if (!hasNative) {
-    // @ts-ignore: global fetch exists in RN
-    return fetch(input as any, init);
+// Simple Headers-like class that supports get() method
+class NitroHeaders {
+  private _headers: Map<string, string>;
+
+  constructor(headers: NitroHeader[]) {
+    this._headers = new Map();
+    for (const { key, value } of headers) {
+      // Headers are case-insensitive, normalize to lowercase
+      this._headers.set(key.toLowerCase(), value);
+    }
+  }
+
+  get(name: string): string | null {
+    return this._headers.get(name.toLowerCase()) ?? null;
+  }
+
+  has(name: string): boolean {
+    return this._headers.has(name.toLowerCase());
+  }
+
+  forEach(callback: (value: string, key: string) => void): void {
+    this._headers.forEach(callback);
+  }
+
+  entries(): IterableIterator<[string, string]> {
+    return this._headers.entries();
+  }
+
+  keys(): IterableIterator<string> {
+    return this._headers.keys();
   }
 
+  values(): IterableIterator<string> {
+    return this._headers.values();
+  }
+}
+
+export async function nitroFetch(
+  input: RequestInfo | URL,
+  init?: RequestInit
+): Promise<Response> {
+  'worklet';
+
   const res = await nitroFetchRaw(input, init);
 
-  // Fallback lightweight Response-like object (minimal methods)
-  const headersObj = res.headers.reduce((acc, { key, value }) => {
-        acc[key] = value;
-        return acc;
-      }, {} as Record<string, string>);
+  const headersObj = new NitroHeaders(res.headers);
 
-  const light: any = {
+  const bodyBytes = res.bodyBytes;
+  const bodyString = res.bodyString;
+
+  const makeLight = (): any => ({
     url: res.url,
     ok: res.ok,
     status: res.status,
     statusText: res.statusText,
     redirected: res.redirected,
     headers: headersObj,
-    arrayBuffer: async () => res.bodyBytes,
-    text: async () => res.bodyString,
-    json: async () => JSON.parse(res.bodyString ?? '{}'),
-  };
+    arrayBuffer: async () => bodyBytes,
+    text: async () => bodyString,
+    json: async () => JSON.parse(bodyString ?? '{}'),
+    clone: () => makeLight(),
+  });
+
+  const light: any = makeLight();
   return light as Response;
 }
 
 // Start a native prefetch. Requires a `prefetchKey` header on the request.
-export async function prefetch(input: RequestInfo | URL, init?: RequestInit): Promise<void> {
+export async function prefetch(
+  input: RequestInfo | URL,
+  init?: RequestInit
+): Promise<void> {
   // If native implementation is not present yet, do nothing
-  const hasNative = typeof (NitroFetchHybrid as any)?.createClient === 'function';
+  const hasNative =
+    typeof (NitroFetchHybrid as any)?.createClient === 'function';
   if (!hasNative) return;
 
   // Build NitroRequest and ensure prefetchKey header exists
   const req = buildNitroRequest(input, init);
-  const hasKey = req.headers?.some(h => h.key.toLowerCase() === 'prefetchkey') ?? false;
+  const hasKey =
+    req.headers?.some((h) => h.key.toLowerCase() === 'prefetchkey') ?? false;
   // Also support passing prefetchKey via non-standard field on init
   const fromInit = (init as any)?.prefetchKey as string | undefined;
   if (!hasKey && fromInit) {
-    req.headers = (req.headers ?? []).concat([{ key: 'prefetchKey', value: fromInit }]);
+    req.headers = (req.headers ?? []).concat([
+      { key: 'prefetchKey', value: fromInit },
+    ]);
   }
-  const finalHasKey = req.headers?.some(h => h.key.toLowerCase() === 'prefetchkey');
+  const finalHasKey = req.headers?.some(
+    (h) => h.key.toLowerCase() === 'prefetchkey'
+  );
   if (!finalHasKey) {
-    throw new Error('prefetch requires a \"prefetchKey\" header');
+    throw new Error('prefetch requires a "prefetchKey" header');
   }
 
   // Ensure client and call native prefetch
@@ -193,26 +253,32 @@ export async function prefetch(input: RequestInfo | URL, init?: RequestInit): Pr
   await client.prefetch(req);
 }
 
-// Persist a request to MMKV so native can prefetch it on app start.
-// Stores an array of entries under the same key Android reads: "nitrofetch_autoprefetch_queue".
+// Persist a request to storage so native can prefetch it on app start.
 export async function prefetchOnAppStart(
   input: RequestInfo | URL,
   init?: RequestInit & { prefetchKey?: string }
 ): Promise<void> {
   // Resolve request and prefetchKey
   const req = buildNitroRequest(input, init);
-  const fromHeader = req.headers?.find(h => h.key.toLowerCase() === 'prefetchkey')?.value;
+  const fromHeader = req.headers?.find(
+    (h) => h.key.toLowerCase() === 'prefetchkey'
+  )?.value;
   const fromInit = (init as any)?.prefetchKey as string | undefined;
   const prefetchKey = fromHeader ?? fromInit;
   if (!prefetchKey) {
-    throw new Error('prefetchOnAppStart requires a "prefetchKey" (header or init.prefetchKey)');
+    throw new Error(
+      'prefetchOnAppStart requires a "prefetchKey" (header or init.prefetchKey)'
+    );
   }
 
   // Convert headers to a plain object for storage
-  const headersObj = (req.headers ?? []).reduce((acc, { key, value }) => {
-    acc[String(key)] = String(value);
-    return acc;
-  }, {} as Record<string, string>);
+  const headersObj = (req.headers ?? []).reduce(
+    (acc, { key, value }) => {
+      acc[String(key)] = String(value);
+      return acc;
+    },
+    {} as Record<string, string>
+  );
 
   const entry = {
     url: req.url,
@@ -220,39 +286,40 @@ export async function prefetchOnAppStart(
     headers: headersObj,
   } as const;
 
-  // Write or append to MMKV queue
+  // Write or append to storage queue
   try {
-    // Dynamically require to keep it optional for consumers
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const { MMKV } = require('react-native-mmkv');
-    const storage = new MMKV(); // default instance matches Android's defaultMMKV
     const KEY = 'nitrofetch_autoprefetch_queue';
     let arr: any[] = [];
     try {
-      const raw = storage.getString(KEY);
+      const raw = NativeStorageSingleton.getString(
+        'nitrofetch_autoprefetch_queue'
+      );
       if (raw) arr = JSON.parse(raw);
       if (!Array.isArray(arr)) arr = [];
     } catch {
       arr = [];
     }
+    if (arr.some((e) => e && e.prefetchKey === prefetchKey)) {
+      arr = arr.filter((e) => e && e.prefetchKey !== prefetchKey);
+    }
     arr.push(entry);
-    storage.set(KEY, JSON.stringify(arr));
+    NativeStorageSingleton.setString(KEY, JSON.stringify(arr));
   } catch (e) {
-    console.warn('react-native-mmkv not available; prefetchOnAppStart is a no-op', e);
+    console.warn('Failed to persist prefetch queue', e);
   }
 }
 
-// Remove one entry (by prefetchKey) from the auto-prefetch queue in MMKV.
-export async function removeFromAutoPrefetch(prefetchKey: string): Promise<void> {
-  // No-op on iOS
+// Remove one entry (by prefetchKey) from the auto-prefetch queue.
+export async function removeFromAutoPrefetch(
+  prefetchKey: string
+): Promise<void> {
   try {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const { MMKV } = require('react-native-mmkv');
-    const storage = new MMKV();
     const KEY = 'nitrofetch_autoprefetch_queue';
     let arr: any[] = [];
     try {
-      const raw = storage.getString(KEY);
+      const raw = NativeStorageSingleton.getString(
+        'nitrofetch_autoprefetch_queue'
+      );
       if (raw) arr = JSON.parse(raw);
       if (!Array.isArray(arr)) arr = [];
     } catch {
@@ -260,34 +327,19 @@ export async function removeFromAutoPrefetch(prefetchKey: string): Promise<void>
     }
     const next = arr.filter((e) => e && e.prefetchKey !== prefetchKey);
     if (next.length === 0) {
-      if (typeof (storage as any).delete === 'function') {
-        (storage as any).delete(KEY);
-      } else {
-        storage.set(KEY, JSON.stringify([]));
-      }
+      NativeStorageSingleton.removeString(KEY);
     } else if (next.length !== arr.length) {
-      storage.set(KEY, JSON.stringify(next));
+      NativeStorageSingleton.setString(KEY, JSON.stringify(next));
     }
   } catch (e) {
-    console.warn('react-native-mmkv not available; removeFromAutoPrefetch is a no-op', e);
+    console.warn('Failed to remove from prefetch queue', e);
   }
 }
 
-// Remove all entries from the auto-prefetch queue in MMKV.
+// Remove all entries from the auto-prefetch queue.
 export async function removeAllFromAutoprefetch(): Promise<void> {
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const { MMKV } = require('react-native-mmkv');
-    const storage = new MMKV();
-    const KEY = 'nitrofetch_autoprefetch_queue';
-    if (typeof (storage as any).delete === 'function') {
-      (storage as any).delete(KEY);
-    } else {
-      storage.set(KEY, JSON.stringify([]));
-    }
-  } catch (e) {
-    console.warn('react-native-mmkv not available; removeAllFromAutoprefetch is a no-op', e);
-  }
+  const KEY = 'nitrofetch_autoprefetch_queue';
+  NativeStorageSingleton.setString(KEY, JSON.stringify([]));
 }
 
 // Optional off-thread processing using react-native-worklets-core
@@ -307,7 +359,6 @@ let WorkletsRef: any | undefined;
 function ensureWorkletRuntime(name = 'nitro-fetch'): any | undefined {
   console.log('ensuring worklet runtime');
   try {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
     const { Worklets } = require('react-native-worklets-core');
     nitroRuntime = nitroRuntime ?? Worklets.createRuntime(name);
     console.log('nitroRuntime:', !!nitroRuntime);
@@ -321,7 +372,7 @@ function ensureWorkletRuntime(name = 'nitro-fetch'): any | undefined {
 function getWorklets(): any | undefined {
   try {
     if (WorkletsRef) return WorkletsRef;
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
+
     const { Worklets } = require('react-native-worklets-core');
     WorkletsRef = Worklets;
     return WorkletsRef;
@@ -384,8 +435,19 @@ export async function nitroFetchOnWorklet<T>(
           const redirected = res.redirected;
           const headersPairs: NitroHeader[] = res.headers;
           const bodyBytes: ArrayBuffer | undefined = undefined; // preferBytes ? res.bodyBytes : undefined;
-          const bodyString: string | undefined = preferBytes ? undefined : res.bodyString;
-          const payload = { url, status, statusText, ok, redirected, headers: headersPairs, bodyBytes, bodyString };
+          const bodyString: string | undefined = preferBytes
+            ? undefined
+            : res.bodyString;
+          const payload = {
+            url,
+            status,
+            statusText,
+            ok,
+            redirected,
+            headers: headersPairs,
+            bodyBytes,
+            bodyString,
+          };
           const out = map(payload);
           // Resolve back on JS thread
           Worklets.runOnJS(resolve)(out as any);

package/LICENSE

@@ -1,20 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Szymon Kapala
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/README.md

@@ -1,144 +0,0 @@
-<p align="center">
-  <img src="./assets/logo.png" alt="Nitro Fetch Logo" width="200" />
-</p>
-
-# react-native-nitro-fetch
-
-Nitro-powered fetch for React Native. Android uses Chromium Cronet (via `org.chromium.net:cronet-embedded`); iOS currently falls back to the built-in fetch. Includes helpers for background prefetching and off-thread parsing with worklets.
-
-## Project Status
-
-This library is currently in alpha. You can adopt it in production, but you may face counter-intuitive api, poor docs or bugs.
-
-## Installation
-
-```sh
-npm install react-native-nitro-fetch react-native-nitro-modules
-```
-
-- `react-native-nitro-modules` is required as this library relies on Nitro Modules. Rebuild your app after installing.
-
-## Quick Start
-
-```ts
-import { fetch } from 'react-native-nitro-fetch';
-
-const res = await fetch('https://httpbin.org/get');
-const json = await res.json();
-```
-
-## Features
-
-- Nitro-backed `fetch`: drop-in replacement for global fetch.
-- Android Cronet: fast HTTP stack via `org.chromium.net:cronet-embedded` (already wired in `android/build.gradle`).
-- Prefetch: start a background request tied to a `prefetchKey` and serve it later.
-- Android auto-prefetch: enqueue requests to MMKV so they warm up on next app start.
-- Worklets helper: run mapping/parsing off the JS thread with `react-native-worklets-core`.
-
-## Why Prefetch
-
-- Faster first paint of data: Prefetching lets you move network I/O earlier on the critical path so the screen can render with data sooner.
-- App start wins: With auto‑prefetch + MMKV, we can begin fetching immediately at process start. In our measurements on mid‑range Android devices (e.g., Samsung A16), this starts at least ~220 ms earlier than initiating the same request from JS after React is up.
-- UX hooks: Kick off prefetch on navigation intent (button press) and serve the result when the destination screen mounts.
-
-See `docs/prefetch.md` for patterns and examples.
-
-## Why Cronet
-
-- Performance: Enables HTTP/2 multiplexing and QUIC/HTTP/3, reducing latency and avoiding head‑of‑line blocking.
-- Efficiency: Advanced connection management, TLS/ALPN, Brotli, and robust on‑disk caching.
-- Battle‑tested: Built on Chromium’s networking stack (the same tech behind Chrome) and widely adopted across the ecosystem, including the Flutter community.
-
-## Philosophy
-
-- Nitro Fetch often outperforms built‑in fetch thanks to Cronet’s optimizations, but raw speed is not the primary goal.
-- The main goals are:
-  - High‑quality prefetching (including auto‑prefetch on app start)
-  - Enabling a multi‑threaded React Native architecture (e.g., off‑thread mapping with worklets)
-- Performance is a nice side‑effect.
-
-## Usage Examples
-
-- Basic fetch (drop-in replacement):
-
-```ts
-import { fetch } from 'react-native-nitro-fetch';
-const res = await fetch('https://jsonplaceholder.typicode.com/todos/1');
-console.log(await res.json());
-```
-
-- Prefetch and consume (Android or JS fallback):
-
-```ts
-import { fetch, prefetch } from 'react-native-nitro-fetch';
-
-await prefetch('https://httpbin.org/uuid', { headers: { prefetchKey: 'uuid' } });
-const res = await fetch('https://httpbin.org/uuid', { headers: { prefetchKey: 'uuid' } });
-console.log('prefetched header:', res.headers.get('nitroPrefetched'));
-```
-
-- Schedule auto-prefetch on Android (requires `react-native-mmkv` in your app):
-
-```ts
-import { prefetchOnAppStart } from 'react-native-nitro-fetch';
-await prefetchOnAppStart('https://httpbin.org/uuid', { prefetchKey: 'uuid' });
-```
-
-- Off-thread parsing with worklets:
-
-```ts
-import { nitroFetchOnWorklet } from 'react-native-nitro-fetch';
-
-const map = (payload: { bodyString?: string }) => {
-  'worklet';
-  return JSON.parse(payload.bodyString ?? '{}');
-};
-
-const data = await nitroFetchOnWorklet('https://httpbin.org/get', undefined, map);
-```
-
-## Platform Notes
-
-- Android: Uses Cronet Java API; no extra setup needed beyond install and rebuild. Cronet engine is initialized once and enables HTTP/2, QUIC, Brotli, and disk cache.
-- iOS: Uses a native `URLSession` client for requests and prefetch (in‑memory cache). Cronet integration is still planned for future releases.
-
-## Limitations & Alternatives
-
-- HTTP streaming: Not supported yet. For streaming responses today, use Expo’s `expo-fetch`. Streaming is on the roadmap.
-- WebSockets: Not supported. For high‑performance sockets and binary streams, consider `react-native-fast-io`.
-
-## Documentation
-
-- Getting Started: `docs/getting-started.md`
-- API Reference: `docs/api.md`
-- Android Details: `docs/android.md`
-- iOS Details: `docs/ios.md`
-- Prefetch & Auto-Prefetch: `docs/prefetch.md`
-- Worklets: `docs/worklets.md`
-- Troubleshooting: `docs/troubleshooting.md`
-- Cronet (Android) notes: `docs/cronet-android.md`
-- Cronet (iOS) notes: `docs/cronet-ios.md`
-
-## Work With Margelo
-
-Need top‑notch React Native help or custom networking solutions? Reach out to Margelo: hello@margelo.com
-
-## Contributing
-
-- Development workflow: `CONTRIBUTING.md#development-workflow`
-- Sending a pull request: `CONTRIBUTING.md#sending-a-pull-request`
-- Code of conduct: `CODE_OF_CONDUCT.md`
-
-## Authors
-
-- [Szymon Kapala](https://x.com/Turbo_Szymon)
-- [Alex Shumihin](https://x.com/pioner_dev)
-- [Ronald Goedeke](https://x.com/BubbleTroubl_rg)
-
-## License
-
-MIT
-
----
-
-Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/src/NitroFetch.nitro.js

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

package/src/NitroInstances.js

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