react-native-nitro-fetch 0.1.3 → 0.1.5

package/src/fetch.ts

@@ -4,7 +4,11 @@ import type {
   NitroRequest,
   NitroResponse,
 } from './NitroFetch.nitro';
-import { NitroFetch as NitroFetchSingleton } from './NitroInstances';
+import {
+  boxedNitroFetch,
+  NitroFetch as NitroFetchSingleton,
+} from './NitroInstances';
+import { NativeStorage as NativeStorageSingleton } from './NitroInstances';
 
 // No base64: pass strings/ArrayBuffers directly
 
@@ -21,7 +25,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 +43,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 +82,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 +114,18 @@ 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> {
-  'worklet';
-  const hasNative = typeof (NitroFetchHybrid as any)?.createClient === 'function';
+async function nitroFetchRaw(
+  input: RequestInfo | URL,
+  init?: RequestInit
+): Promise<NitroResponse> {
+  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 +148,103 @@ 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> {
   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 bodyBytes = res.bodyBytes;
+  const bodyString = res.bodyString;
 
-  const light: any = {
+  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,42 +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);
+    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 {
@@ -263,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
@@ -310,9 +359,8 @@ 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);
+    nitroRuntime = nitroRuntime ?? Worklets.createContext(name);
     console.log('nitroRuntime:', !!nitroRuntime);
     return nitroRuntime;
   } catch {
@@ -324,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;
@@ -355,7 +403,7 @@ export async function nitroFetchOnWorklet<T>(
   }
 
   // Fallback: if runtime is not available, do the work on JS
-  if (!rt || !Worklets || typeof rt.run !== 'function') {
+  if (!rt || !Worklets || typeof rt.runAsync !== 'function') {
     console.warn('nitroFetchOnWorklet: no runtime, mapping on JS thread');
     const res = await nitroFetchRaw(input, init);
     const payload = {
@@ -370,36 +418,24 @@ export async function nitroFetchOnWorklet<T>(
     } as const;
     return mapWorklet(payload as any);
   }
+  console.log('nitroFetchOnWorklet: running on worklet thread');
+  return await rt.runAsync(() => {
+    'worklet';
+    const unboxedNitroFetch = boxedNitroFetch.unbox();
+    const unboxedClient = unboxedNitroFetch.createClient();
+    const res = unboxedClient.requestSync(buildNitroRequest(input, init));
+    const payload = {
+      url: res.url,
+      status: res.status,
+      statusText: res.statusText,
+      ok: res.ok,
+      redirected: res.redirected,
+      headers: res.headers,
+      bodyBytes: preferBytes ? res.bodyBytes : undefined,
+      bodyString: preferBytes ? undefined : res.bodyString,
+    } as const;
 
-  return await new Promise<T>((resolve, reject) => {
-    try {
-      console.log('nitroFetchOnWorklet: about to call rt.run');
-      rt.run(async (map: NitroWorkletMapper<T>) => {
-        'worklet';
-        try {
-          console.log('nitroFetchOnWorklet: running fetch on worklet thread');
-          const res = await nitroFetchRaw(input, init);
-          console.log('nitroFetchOnWorklet: fetch completed');
-          const url = res.url;
-          const status = res.status;
-          const statusText = res.statusText;
-          const ok = res.ok;
-          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 out = map(payload);
-          // Resolve back on JS thread
-          Worklets.runOnJS(resolve)(out as any);
-        } catch (e) {
-          Worklets.runOnJS(reject)(e as any);
-        }
-      }, mapWorklet as any);
-    } catch (e) {
-      console.error('nitroFetchOnWorklet: rt.run failed', e);
-      reject(e);
-    }
+    return mapWorklet(payload 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,151 +0,0 @@
-<a href="https://margelo.com">
-  <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="./docs/static/img/banner-nitro-modules-dark.png" />
-    <source media="(prefers-color-scheme: light)" srcset="./docs/static/img/banner-nitro-modules-light.png" />
-    <img alt="Nitro Modules" src="./docs/static/img/banner-nitro-modules-light.png" />
-  </picture>
-</a>
-
-<br />
-
-**react-native-nitro-fetch** is a general purpose network fetching library for React Native. It can be used as a drop-in replacement for the built-in `fetch(...)` method, as well as provide additional features like prefetching and workletized mappers.
-
-## Features
-
-- 🔧 Drop-in replacement for the built-in `fetch(...)` method
-- ⚡️ Fast HTTP stack using [Cronet](https://chromium.googlesource.com/chromium/src/+/lkgr/components/cronet/README.md) on Android, and [URLSession](https://developer.apple.com/documentation/Foundation/URLSession) on iOS
-- 💪 Supports [HTTP/2](https://en.wikipedia.org/wiki/HTTP/2), [QUIC](https://www.chromium.org/quic/), [Brotli](https://github.com/google/brotli), and disk cache
-- ⏰ Prefetching on app-startup for even faster initialization
-- 🧵 Worklet support for parallel data mapping without blocking the JS Thread
-- 🔥 Powered by [Nitro Modules](https://github.com/mrousavy/nitro)
-
-## Installation
-
-```sh
-npm i react-native-nitro-fetch react-native-nitro-modules
-```
-
-> [Nitro Modules](https://github.com/mrousavy/nitro) requires react-native 0.75+ or higher
-
-## Usage
-
-To simply fetch data, import the `fetch(...)` method from `react-native-nitro-fetch`:
-
-```ts
-import { fetch } from 'react-native-nitro-fetch'
-
-const res = await fetch('https://httpbin.org/get')
-const json = await res.json()
-```
-
-This can be used as a drop-in-replacement for the built-in `fetch(...)` method.
-
-### Prefetching in JS
-
-You can prefetch a URL in JS, which keeps the result cached for the next actual `fetch(...)` call - this can be used shortly before navigating to a new screen to have results hot & ready:
-
-```ts
-import { prefetch } from 'react-native-nitro-fetch'
-
-await prefetch('https://httpbin.org/uuid', {
-  headers: { prefetchKey: 'uuid' }
-})
-```
-
-Then, on the new screen that was navigated to:
-
-```ts
-import { fetch } from 'react-native-nitro-fetch'
-
-const res = await fetch('https://httpbin.org/uuid', {
-  headers: { prefetchKey: 'uuid' }
-})
-console.log('prefetched header:', res.headers.get('nitroPrefetched'))
-```
-
-### Prefetching for the next app launch
-
-Prefetching data on app launch (or _process start_) will make it hot & ready once your JS code actually runs. Call `prefetchOnAppStart(...)` to enqueue a prefetch for the **next** app start:
-
-```ts
-import { prefetchOnAppStart } from 'react-native-nitro-fetch'
-
-await prefetchOnAppStart('https://httpbin.org/uuid', {
-  prefetchKey: 'uuid'
-})
-```
-
-Then, once the app opens the next time, a call to `fetch(...)` might resolve faster since it will contain already cached results:
-
-```ts
-import { fetch } from 'react-native-nitro-fetch'
-
-const res = await fetch('https://httpbin.org/uuid', {
-  headers: { prefetchKey: 'uuid' }
-})
-console.log('prefetched header:', res.headers.get('nitroPrefetched'))
-```
-
-In our tests, prefetching alone yielded a **~220 ms** faster TTI (time-to-interactive) time! 🤯
-
-### Worklet Mapping
-
-Since Nitro Fetch is a [Nitro Module](https://nitro.margelo.com), it can be used from Worklets.
-This can be useful to parse data without blocking the main JS-Thread:
-
-```ts
-import { nitroFetchOnWorklet } from 'react-native-nitro-fetch'
-
-const data = await nitroFetchOnWorklet(
-  'https://httpbin.org/get',
-  undefined,
-  (payload) => {
-    'worklet'
-    return JSON.parse(payload.bodyString ?? '{}')
-  }
-)
-```
-
-## Project Status
-
-Nitro Fetch is currently in an alpha stage. You can adopt it in production, but keep in mind that the library and it's API is subject to change.
-
-## Limitations & Alternatives
-
-- [HTTP streaming](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API) is not yet supported. As an alternative, use Expo's [expo-fetch](https://docs.expo.dev/versions/latest/sdk/expo/). Streaming is on the roadmap.
-- [WebSockets](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) are not supported. For high‑performance sockets and binary streams, consider using [react-native-fast-io](https://github.com/callstackincubator/react-native-fast-io) by our friends at Callstack.
-
-## 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)
-
-## Margelo
-
-Nitro Fetch is built with ❤️ by Margelo.
-We build fast and beautiful apps. Contact us at [margelo.com](https://margelo.com) for high-end consultancy services.
-
-## 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://github.com/Szymon20000)
-- [Alex Shumihin](https://github.com/pioner92)
-- [Ronald Goedeke](https://github.com/ronickg)
-- [Marc Rousavy](https://github.com/mrousavy)
-
-## License
-
-MIT
-