react-native-nitro-fetch 0.1.3 → 0.1.4

package/android/build.gradle

@@ -117,11 +117,11 @@ dependencies {
   implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation project(":react-native-nitro-modules")
-  implementation("com.tencent:mmkv:1.3.14")// or latest
   // Provide org.chromium.net Java API for CronetEngine in Kotlin
   // Cronet
   api "org.chromium.net:cronet-embedded:${cronetVersion}"
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0"
+
 }
 
 configurations {

package/android/src/main/java/com/margelo/nitro/nitrofetch/AutoPrefetcher.kt

@@ -1,21 +1,23 @@
 package com.margelo.nitro.nitrofetch
 
 import android.app.Application
+import android.content.Context
 import org.json.JSONArray
 import org.json.JSONObject
 import java.util.concurrent.CompletableFuture
-import com.tencent.mmkv.MMKV;
 
 
 object AutoPrefetcher {
   @Volatile private var initialized = false
+  private const val KEY_QUEUE = "nitrofetch_autoprefetch_queue"
+  private const val PREFS_NAME = "nitro_fetch_storage"
 
   fun prefetchOnStart(app: Application) {
     if (initialized) return
     initialized = true
     try {
-      val mmkv = getMMKV(app) ?: return
-      val raw = invokeMMKVDecodeString(mmkv, KEY_QUEUE) ?: return
+      val prefs = app.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+      val raw = prefs.getString(KEY_QUEUE, null) ?: ""
       if (raw.isEmpty()) return
       val arr = JSONArray(raw)
       for (i in 0 until arr.length()) {
@@ -42,12 +44,8 @@ object AutoPrefetcher {
         )
 
         // If already pending or fresh, skip starting a new one
-        if (FetchCache.getPending(prefetchKey) != null) {
-          continue
-        }
-        if (FetchCache.getResultIfFresh(prefetchKey, 5_000L) != null) {
-          continue
-        }
+        if (FetchCache.getPending(prefetchKey) != null) continue
+        if (FetchCache.hasFreshResult(prefetchKey, 5_000L)) continue
 
         val future = CompletableFuture<NitroResponse>()
         FetchCache.setPending(prefetchKey, future)
@@ -71,23 +69,4 @@ object AutoPrefetcher {
       // ignore – prefetch-on-start is best-effort
     }
   }
-
-  private const val KEY_QUEUE = "nitrofetch_autoprefetch_queue"
-
-  private fun getMMKV(app: Application): Any? {
-    return try {
-      MMKV.initialize(app);
-
-      return MMKV.defaultMMKV()
-    } catch (_: Throwable) {
-      null
-    }
-  }
-
-  private fun invokeMMKVDecodeString(mmkv: Any, key: String): String? {
-    return try {
-      val m = mmkv.javaClass.getMethod("decodeString", String::class.java, String::class.java)
-      m.invoke(mmkv, key, null) as? String
-    } catch (_: Throwable) { null }
-  }
 }

package/android/src/main/java/com/margelo/nitro/nitrofetch/FetchCache.kt

@@ -41,8 +41,18 @@ object FetchCache {
     return if (age <= maxAgeMs) entry.response else null
   }
 
+  /**
+   * Check if a fresh result exists WITHOUT consuming it.
+   * Used to check if we should skip starting a new prefetch.
+   */
+  fun hasFreshResult(key: String, maxAgeMs: Long): Boolean {
+    val entry = results[key] ?: return false
+    val age = System.currentTimeMillis() - entry.timestampMs
+    return age <= maxAgeMs
+  }
+
   fun clear() {
     pending.clear()
     results.clear()
   }
-}
+}

package/android/src/main/java/com/margelo/nitro/nitrofetch/NativeStorage.kt

@@ -0,0 +1,102 @@
+package com.margelo.nitro.nitrofetch
+
+import android.app.Application
+import android.content.Context
+import android.content.SharedPreferences
+import android.util.Log
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.NitroModules
+
+
+
+@DoNotStrip
+class NativeStorage : HybridNativeStorageSpec() {
+
+    companion object {
+        private const val TAG = "HybridNativeStorage"
+        private const val PREFS_NAME = "nitro_fetch_storage"
+
+       
+        private val sharedPreferences: SharedPreferences by lazy {
+            val context = NitroModules.applicationContext ?: throw Error("Cannot get Android Context - No Context available!")
+            context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+        }
+
+
+    }
+
+    /**
+     * Retrieves a string value for the given key.
+     *
+     * @param key The key to look up in storage
+     * @return The stored string value, or empty string if key doesn't exist
+     * @throws IllegalStateException if SharedPreferences is not available
+     */
+    override fun getString(key: String): String {
+        return try {
+            val value = sharedPreferences.getString(key, null)
+            if (value != null) {
+                Log.d(TAG, "Retrieved value for key: $key")
+                value
+            } else {
+                Log.d(TAG, "Key not found: $key, returning empty string")
+                ""
+            }
+        } catch (t: Throwable) {
+            Log.e(TAG, "Error getting string for key: $key", t)
+            throw RuntimeException("Failed to get string for key: $key", t)
+        }
+    }
+
+    /**
+     * Stores a string value with the given key.
+     *
+     * @param key The key to store the value under
+     * @param value The string value to store
+     * @throws IllegalStateException if SharedPreferences is not available
+     * @throws RuntimeException if the write operation fails
+     */
+    override fun setString(key: String, value: String) {
+        try {
+            val editor = sharedPreferences.edit()
+            editor.putString(key, value)
+            val success = editor.commit() // commit() is synchronous and returns boolean
+            if (success) {
+                Log.d(TAG, "Successfully stored value for key: $key")
+            } else {
+                Log.e(TAG, "Failed to commit value for key: $key")
+                throw RuntimeException("Failed to store value for key: $key")
+            }
+        } catch (t: Throwable) {
+            Log.e(TAG, "Error setting string for key: $key", t)
+            throw RuntimeException("Failed to set string for key: $key", t)
+        }
+    }
+
+    /**
+     * Deletes the value associated with the given key.
+     * If the key doesn't exist, this is a no-op.
+     *
+     * @param key The key to delete from storage
+     * @throws IllegalStateException if SharedPreferences is not available
+     * @throws RuntimeException if the delete operation fails
+     */
+    override fun removeString(key: String) {
+        try {
+            val editor = sharedPreferences.edit()
+            editor.remove(key)
+            val success = editor.commit() // commit() is synchronous and returns boolean
+            if (success) {
+                Log.d(TAG, "Successfully deleted key: $key")
+            } else {
+                Log.e(TAG, "Failed to commit deletion for key: $key")
+                throw RuntimeException("Failed to delete key: $key")
+            }
+        } catch (t: Throwable) {
+            Log.e(TAG, "Error deleting key: $key", t)
+            throw RuntimeException("Failed to delete key: $key", t)
+        }
+    }
+}
+
+

package/android/src/main/java/com/margelo/nitro/nitrofetch/NitroFetchClient.kt

@@ -220,8 +220,8 @@ class NitroFetchClient(private val engine: CronetEngine, private val executor: E
       promise.reject(IllegalArgumentException("prefetch: missing 'prefetchKey' header"))
       return promise
     }
-    // If already have a fresh result, resolve immediately
-    FetchCache.getResultIfFresh(key, 5_000L)?.let {
+    // If already have a fresh result, resolve immediately (NON-DESTRUCTIVE CHECK)
+    if (FetchCache.hasFreshResult(key, 5_000L)) {
       promise.resolve(Unit)
       return promise
     }

package/ios/NativeStorage.swift

@@ -0,0 +1,61 @@
+//
+//  NativeStorage.swift
+//  Pods
+//
+//  Created by Ritesh Shukla on 08/11/25.
+//
+
+import Foundation
+
+
+final class NativeStorage: HybridNativeStorageSpec {
+  
+  private static let suiteName = "nitro_fetch_storage"
+  
+  private let userDefaults: UserDefaults
+  
+  public override init() {
+    // Use a named suite for better isolation, fallback to standard if creation fails
+    if let suite = UserDefaults(suiteName: NativeStorage.suiteName) {
+      self.userDefaults = suite
+    } else {
+      self.userDefaults = UserDefaults.standard
+    }
+    super.init()
+  }
+  
+  /// Retrieves a string value for the given key.
+  ///
+  /// - Parameter key: The key to look up in storage
+  /// - Returns: The stored string value, or empty string if key doesn't exist
+  /// - Throws: RuntimeError if the operation fails
+  func getString(key: String) throws -> String {
+    guard let value = userDefaults.string(forKey: key) else {
+      return ""
+    }
+    return value
+  }
+  
+  /// Stores a string value with the given key.
+  ///
+  /// - Parameters:
+  ///   - key: The key to store the value under
+  ///   - value: The string value to store
+  /// - Throws: RuntimeError if the write operation fails
+  func setString(key: String, value: String) throws {
+    userDefaults.set(value, forKey: key)
+    // Synchronize to ensure immediate persistence
+    userDefaults.synchronize()
+  }
+  
+  /// Deletes the value associated with the given key.
+  /// If the key doesn't exist, this is a no-op.
+  ///
+  /// - Parameter key: The key to delete from storage
+  /// - Throws: RuntimeError if the delete operation fails
+  func removeString(key: String) throws {
+    userDefaults.removeObject(forKey: key)
+    // Synchronize to ensure immediate persistence
+    userDefaults.synchronize()
+  }
+}

package/ios/NitroAutoPrefetcher.swift

@@ -4,12 +4,16 @@ import Foundation
 public final class NitroAutoPrefetcher: NSObject {
   private static var initialized = false
   private static let queueKey = "nitrofetch_autoprefetch_queue"
+  private static let suiteName = "nitro_fetch_storage"
 
   @objc
   public static func prefetchOnStart() {
     if initialized { return }
     initialized = true
-    guard let raw = readMMKVString(forKey: queueKey), !raw.isEmpty else { return }
+    
+    // Read from UserDefaults
+    let userDefaults = UserDefaults(suiteName: suiteName) ?? UserDefaults.standard
+    guard let raw = userDefaults.string(forKey: queueKey), !raw.isEmpty else { return }
     guard let data = raw.data(using: .utf8) else { return }
     guard let arr = try? JSONSerialization.jsonObject(with: data, options: []) as? [Any] else { return }
 
@@ -32,46 +36,6 @@ public final class NitroAutoPrefetcher: NSObject {
       }
     }
   }
-
-  // MARK: - MMKV dynamic access (optional)
-
-  private static func readMMKVString(forKey key: String) -> String? {
-    guard let mmkvClass = NSClassFromString("MMKV") as? NSObject.Type else { return nil }
-    // Try to initialize if needed (ignore failures)
-    let initSelectors = [
-      NSSelectorFromString("initializeMMKV:"),
-      NSSelectorFromString("initialize:")
-    ]
-    for sel in initSelectors where mmkvClass.responds(to: sel) {
-      _ = mmkvClass.perform(sel, with: nil)
-      break
-    }
-    guard let mmkvObjUnretained = mmkvClass.perform(NSSelectorFromString("defaultMMKV"))?.takeUnretainedValue() else { return nil }
-    let mmkv = mmkvObjUnretained as AnyObject
-    // Try common selectors
-    let candidates = [
-      NSSelectorFromString("decodeStringForKey:"),
-      NSSelectorFromString("stringForKey:"),
-      NSSelectorFromString("getStringForKey:"),
-    ]
-    for sel in candidates where mmkv.responds(to: sel) {
-      if let val = mmkv.perform(sel, with: key)?.takeUnretainedValue() as? String {
-        return val
-      }
-    }
-    // Some APIs have (forKey: defaultValue:) signatures
-    let twoArgCandidates = [
-      NSSelectorFromString("decodeStringForKey:defaultValue:"),
-      NSSelectorFromString("stringForKey:defaultValue:"),
-      NSSelectorFromString("getStringForKey:defaultValue:"),
-    ]
-    for sel in twoArgCandidates where mmkv.responds(to: sel) {
-      // NSInvocation is cumbersome in Swift; best-effort fallthrough without it
-      // Prefer single-arg variants above.
-      break
-    }
-    return nil
-  }
 }
 
 // Expose a C-ABI symbol the ObjC++ file can call

package/lib/module/NitroFetch.nitro.js

@@ -1,7 +1,4 @@
 "use strict";
 
-// Minimal request/response types to model WHATWG fetch without streaming.
-
-;
 export {};
 //# sourceMappingURL=NitroFetch.nitro.js.map

package/lib/module/NitroFetch.nitro.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sourceRoot":"../../src","sources":["NitroFetch.nitro.ts"],"mappings":";;AAEA;;AAaC;AAAC","ignoreList":[]}
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["NitroFetch.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/NitroInstances.js

@@ -3,4 +3,5 @@
 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');
 //# sourceMappingURL=NitroInstances.js.map

package/lib/module/NitroInstances.js.map

@@ -1 +1 @@
-{"version":3,"names":["NitroModules","NitroFetch","createHybridObject"],"sourceRoot":"../../src","sources":["NitroInstances.ts"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAGzD;AACA,OAAO,MAAMC,UAA0B,GACrCD,YAAY,CAACE,kBAAkB,CAAiB,YAAY,CAAC","ignoreList":[]}
+{"version":3,"names":["NitroModules","NitroFetch","createHybridObject","NativeStorage"],"sourceRoot":"../../src","sources":["NitroInstances.ts"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAMzD;AACA,OAAO,MAAMC,UAA0B,GACrCD,YAAY,CAACE,kBAAkB,CAAiB,YAAY,CAAC;AAE/D,OAAO,MAAMC,aAAgC,GAC3CH,YAAY,CAACE,kBAAkB,CAAoB,eAAe,CAAC","ignoreList":[]}

package/lib/module/fetch.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import { NitroFetch as NitroFetchSingleton } from "./NitroInstances.js";
+import { NativeStorage as NativeStorageSingleton } from "./NitroInstances.js";
 
 // No base64: pass strings/ArrayBuffers directly
 
@@ -55,26 +56,14 @@ function normalizeBody(body) {
   if (ArrayBuffer.isView(body)) {
     const view = body;
     // Pass a copy/slice of the underlying bytes without base64
-    //@ts-ignore
     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) {
-  'worklet';
-
-  const h = new Headers();
-  for (const {
-    key,
-    value
-  } of pairs) h.append(key, value);
-  return h;
-}
 const NitroFetchHybrid = NitroFetchSingleton;
 let client;
 function ensureClient() {
@@ -114,8 +103,8 @@ function buildNitroRequest(input, init) {
     method: method?.toUpperCase() ?? 'GET',
     headers,
     bodyString: normalized?.bodyString,
-    bodyBytes: "",
-    //normalized?.bodyBytes,
+    // Only include bodyBytes when provided to avoid signaling upload data unintentionally
+    bodyBytes: undefined,
     followRedirects: true
   };
 }
@@ -151,36 +140,58 @@ async function nitroFetchRaw(input, init) {
   const res = await client.request(req);
   return res;
 }
+
+// Simple Headers-like class that supports get() method
+class NitroHeaders {
+  constructor(headers) {
+    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) {
+    return this._headers.get(name.toLowerCase()) ?? null;
+  }
+  has(name) {
+    return this._headers.has(name.toLowerCase());
+  }
+  forEach(callback) {
+    this._headers.forEach(callback);
+  }
+  entries() {
+    return this._headers.entries();
+  }
+  keys() {
+    return this._headers.keys();
+  }
+  values() {
+    return this._headers.values();
+  }
+}
 export async function nitroFetch(input, init) {
   'worklet';
 
-  // If native implementation is not present yet, fallback to global fetch
-  const hasNative = typeof NitroFetchHybrid?.createClient === 'function';
-  if (!hasNative) {
-    // @ts-ignore: global fetch exists in RN
-    return fetch(input, init);
-  }
   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;
-  }, {});
-  const light = {
+  const headersObj = new NitroHeaders(res.headers);
+  const bodyBytes = res.bodyBytes;
+  const bodyString = res.bodyString;
+  const makeLight = () => ({
     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 = makeLight();
   return light;
 }
 
@@ -203,7 +214,7 @@ export async function prefetch(input, init) {
   }
   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
@@ -212,8 +223,7 @@ export async function prefetch(input, init) {
   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, init) {
   // Resolve request and prefetchKey
   const req = buildNitroRequest(input, init);
@@ -238,18 +248,12 @@ export async function prefetchOnAppStart(input, init) {
     headers: headersObj
   };
 
-  // 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 = [];
     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 {
@@ -259,25 +263,19 @@ export async function prefetchOnAppStart(input, init) {
       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.
+// Remove one entry (by prefetchKey) from the auto-prefetch queue.
 export async function removeFromAutoPrefetch(prefetchKey) {
-  // No-op on iOS
   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 = [];
     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 {
@@ -285,36 +283,19 @@ export async function removeFromAutoPrefetch(prefetchKey) {
     }
     const next = arr.filter(e => e && e.prefetchKey !== prefetchKey);
     if (next.length === 0) {
-      if (typeof storage.delete === 'function') {
-        storage.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() {
-  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.delete === 'function') {
-      storage.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
@@ -324,7 +305,6 @@ let WorkletsRef;
 function ensureWorkletRuntime(name = 'nitro-fetch') {
   console.log('ensuring worklet runtime');
   try {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
     const {
       Worklets
     } = require('react-native-worklets-core');
@@ -339,7 +319,6 @@ function ensureWorkletRuntime(name = 'nitro-fetch') {
 function getWorklets() {
   try {
     if (WorkletsRef) return WorkletsRef;
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
     const {
       Worklets
     } = require('react-native-worklets-core');