react-native-nitro-image-pipeline 0.3.3 → 0.3.5

package/README.md

@@ -85,7 +85,7 @@ await NitroImagePipeline.preLoadImages([
 const blurred = await NitroImagePipeline.gaussianBlur(image, 10);
 
 // Clear the image cache
-NitroImagePipeline.clearCache();
+await NitroImagePipeline.clearCache();
 ```
 
 ## API Reference
@@ -114,7 +114,7 @@ Applies a Gaussian blur to an existing `Image` object. Returns `Promise<Image>`.
 
 ### `clearCache()`
 
-Removes all cached images from memory and disk.
+Removes all cached images from memory and disk. Returns `Promise<void>` that resolves once both caches are cleared.
 
 ## Credits
 

package/android/src/main/java/com/margelo/nitro/nitroimagepipeline/HybridNitroImagePipeline.kt

@@ -22,6 +22,11 @@ import com.margelo.nitro.core.Promise
 import com.margelo.nitro.image.HybridImage
 import com.margelo.nitro.image.HybridImageSpec
 import com.margelo.nitro.nitroimagepipeline.transform.BlurTransformation
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.withContext
 import okhttp3.OkHttpClient
 import okio.Path.Companion.toOkioPath
 import org.chromium.net.CronetEngine
@@ -30,29 +35,8 @@ class HybridNitroImagePipeline : HybridNitroImagePipelineSpec() {
   private val context
     get() = NitroModules.applicationContext as Context
 
-  private val okHttpClient: OkHttpClient by lazy {
-    val builder = OkHttpClient.Builder()
-    try {
-      val cronetEngine = CronetEngine.Builder(context).build()
-      builder.addInterceptor(CronetInterceptor.newBuilder(cronetEngine).build())
-    } catch (_: Exception) {
-      // Cronet unavailable (no GMS or unsupported device) — use plain OkHttp
-    }
-    builder.build()
-  }
-
-  private val imageLoader: ImageLoader by lazy {
-    ImageLoader.Builder(context)
-        .components { add(OkHttpNetworkFetcherFactory(callFactory = okHttpClient)) }
-        .memoryCache { MemoryCache.Builder().maxSizePercent(context, 0.25).build() }
-        .diskCache {
-          DiskCache.Builder()
-              .directory(context.cacheDir.resolve("nitro_image_cache").toOkioPath())
-              .maxSizeBytes(256L * 1024 * 1024)
-              .build()
-        }
-        .build()
-  }
+  private val imageLoader: ImageLoader
+    get() = getOrCreateImageLoader(context)
 
   override fun loadImage(url: String, options: Options?): Promise<HybridImageSpec> = Promise.async {
     val blur = options?.blur?.toFloat() ?: 0f
@@ -61,11 +45,6 @@ class HybridNitroImagePipeline : HybridNitroImagePipelineSpec() {
       if (blur > 0f) add(BlurTransformation(context, blur))
       if (cornerRadius > 0f) add(RoundedCornersTransformation(cornerRadius))
     }
-    val memoryCacheKey = buildString {
-      append(url)
-      if (blur > 0f) append("_blur$blur")
-      if (cornerRadius > 0f) append("_corner$cornerRadius")
-    }
     val request =
         ImageRequest.Builder(context)
             .data(url)
@@ -87,7 +66,6 @@ class HybridNitroImagePipeline : HybridNitroImagePipelineSpec() {
               }
             }
             .allowHardware(true)
-            .memoryCacheKey(memoryCacheKey)
             .transformations(transformations)
             .build()
 
@@ -111,10 +89,17 @@ class HybridNitroImagePipeline : HybridNitroImagePipelineSpec() {
   }
 
   override fun preLoadImages(urls: Array<String>): Promise<Unit> = Promise.async {
-    for (url in urls) {
-      val request = ImageRequest.Builder(context).data(url).build()
-      imageLoader.execute(request)
+    coroutineScope {
+      urls
+          .map { url ->
+            async {
+              val request = ImageRequest.Builder(context).data(url).build()
+              imageLoader.execute(request)
+            }
+          }
+          .awaitAll()
     }
+    Unit
   }
 
   override fun gaussianBlur(image: HybridImageSpec, radius: Double): Promise<HybridImageSpec> =
@@ -126,8 +111,48 @@ class HybridNitroImagePipeline : HybridNitroImagePipelineSpec() {
         HybridImage(blurred)
       }
 
-  override fun clearCache() {
+  override fun clearCache(): Promise<Unit> = Promise.async {
     imageLoader.memoryCache?.clear()
-    imageLoader.diskCache?.clear()
+    // DiskCache.clear() does file I/O; keep it off the JS thread but await
+    // completion so callers can rely on the cache being empty, and so an
+    // IOException rejects the promise instead of crashing the process.
+    withContext(Dispatchers.IO) { imageLoader.diskCache?.clear() }
+  }
+
+  companion object {
+    // Coil requires a single DiskCache instance per directory, so the loader
+    // must be shared across all HybridNitroImagePipeline instances.
+    @Volatile private var sharedImageLoader: ImageLoader? = null
+
+    private fun getOrCreateImageLoader(context: Context): ImageLoader =
+        sharedImageLoader
+            ?: synchronized(this) {
+              sharedImageLoader ?: createImageLoader(context).also { sharedImageLoader = it }
+            }
+
+    private fun createImageLoader(context: Context): ImageLoader {
+      val okHttpClient =
+          OkHttpClient.Builder()
+              .apply {
+                try {
+                  val cronetEngine = CronetEngine.Builder(context).build()
+                  addInterceptor(CronetInterceptor.newBuilder(cronetEngine).build())
+                } catch (_: Exception) {
+                  // Cronet unavailable (no GMS or unsupported device) — use plain OkHttp
+                }
+              }
+              .build()
+
+      return ImageLoader.Builder(context)
+          .components { add(OkHttpNetworkFetcherFactory(callFactory = okHttpClient)) }
+          .memoryCache { MemoryCache.Builder().maxSizePercent(context, 0.25).build() }
+          .diskCache {
+            DiskCache.Builder()
+                .directory(context.cacheDir.resolve("nitro_image_cache").toOkioPath())
+                .maxSizeBytes(256L * 1024 * 1024)
+                .build()
+          }
+          .build()
+    }
   }
 }

package/ios/HybridNitroImagePipeline.swift

@@ -16,9 +16,44 @@ import CoreImage
 private class HybridImage: HybridImageSpec, NativeImage {
     let uiImage: UIImage
 
+    // PNG encoding is expensive; encode once and reuse for both
+    // toArrayBuffer() and toBase64(). Guarded by a lock (lazy var is not
+    // thread-safe) and dropped on memory pressure so a JS-retained image
+    // doesn't pin its encoding forever.
+    private let pngLock = NSLock()
+    private var cachedPngData: Data?
+    private var memoryWarningObserver: (any NSObjectProtocol)?
+
     init(uiImage: UIImage) {
         self.uiImage = uiImage
         super.init()
+        memoryWarningObserver = NotificationCenter.default.addObserver(
+            forName: UIApplication.didReceiveMemoryWarningNotification,
+            object: nil,
+            queue: nil
+        ) { [weak self] _ in
+            guard let self else { return }
+            self.pngLock.lock()
+            self.cachedPngData = nil
+            self.pngLock.unlock()
+        }
+    }
+
+    deinit {
+        if let memoryWarningObserver {
+            NotificationCenter.default.removeObserver(memoryWarningObserver)
+        }
+    }
+
+    private func pngData() -> Data? {
+        pngLock.lock()
+        defer { pngLock.unlock() }
+        if let cachedPngData {
+            return cachedPngData
+        }
+        let data = uiImage.pngData()
+        cachedPngData = data
+        return data
     }
 
     var width: Double {
@@ -30,14 +65,14 @@ private class HybridImage: HybridImageSpec, NativeImage {
     }
 
     func toArrayBuffer() throws -> ArrayBuffer {
-        guard let data = uiImage.pngData() else {
+        guard let data = pngData() else {
             throw RuntimeError.error(withMessage: "Failed to encode image to PNG")
         }
         return try ArrayBuffer.copy(data: data)
     }
 
     func toBase64() throws -> String {
-        guard let data = uiImage.pngData() else {
+        guard let data = pngData() else {
             throw RuntimeError.error(withMessage: "Failed to encode image")
         }
 
@@ -50,14 +85,34 @@ private class HybridImage: HybridImageSpec, NativeImage {
 }
 
 class HybridNitroImagePipeline: HybridNitroImagePipelineSpec {
-    private let prefetcher = ImagePrefetcher()
-
-    override init() {
-        ImagePipeline.shared = ImagePipeline(configuration: .withDataCache)
-    }
+    // One shared pipeline (instead of mutating ImagePipeline.shared) so the
+    // prefetcher and loadImage read/write the exact same caches, other Nuke
+    // users in the host app are left untouched, and repeated instantiation
+    // (e.g. Metro reloads) never puts two DataCache instances on the same
+    // directory.
+    private static let sharedPipeline: ImagePipeline = {
+        var configuration = ImagePipeline.Configuration.withDataCache
+        // Store processed (blurred/rounded) variants on disk in addition to
+        // the original download, so they survive memory eviction and
+        // restarts without dropping the original for other variants.
+        configuration.dataCachePolicy = .storeAll
+        return ImagePipeline(configuration: configuration)
+    }()
+
+    private static let sharedPrefetcher = ImagePrefetcher(pipeline: sharedPipeline)
+
+    // CIContext is expensive to create; Apple recommends reusing one.
+    private static let ciContext = CIContext()
+
+    private var pipeline: ImagePipeline { Self.sharedPipeline }
+    private var prefetcher: ImagePrefetcher { Self.sharedPrefetcher }
 
     func loadImage(url: String, options: Options?) throws -> Promise<any HybridImageSpec> {
         return Promise.async {
+            guard let imageUrl = URL(string: url) else {
+                throw RuntimeError.error(withMessage: "Invalid URL: \(url)")
+            }
+
             let cacheOptions: ImageRequest.Options = switch options?.cache {
             case .memory: [.disableDiskCache]
             case .disk:   [.disableMemoryCache]
@@ -74,12 +129,12 @@ class HybridNitroImagePipeline: HybridNitroImagePipelineSpec {
             }
 
             let imgRequest = ImageRequest(
-                url: URL(string: url),
+                url: imageUrl,
                 processors: processors,
                 options: cacheOptions
             )
 
-            let image = try await ImagePipeline.shared.image(for: imgRequest)
+            let image = try await self.pipeline.image(for: imgRequest)
             return HybridImage(uiImage: image)
         }
     }
@@ -101,8 +156,10 @@ class HybridNitroImagePipeline: HybridNitroImagePipelineSpec {
         }
     }
 
-    func clearCache() throws {
-        ImagePipeline.shared.cache.removeAll()
+    func clearCache() throws -> Promise<Void> {
+        return Promise.async {
+            self.pipeline.cache.removeAll()
+        }
     }
 
     func gaussianBlur(image: any HybridImageSpec, radius: Double) throws -> Promise<any HybridImageSpec> {
@@ -113,17 +170,20 @@ class HybridNitroImagePipeline: HybridNitroImagePipelineSpec {
 
             let uiImage = nativeImage.uiImage
 
-            let ciImage = CIImage(image: uiImage)
+            guard let ciImage = CIImage(image: uiImage) else {
+                throw RuntimeError.error(withMessage: "Failed to read image data")
+            }
 
             let filter = CIFilter(name: "CIGaussianBlur")!
             filter.setValue(ciImage, forKey: kCIInputImageKey)
             filter.setValue(radius, forKey: kCIInputRadiusKey)
 
-            let context = CIContext()
-            let output = filter.outputImage
-            let cgImage = context.createCGImage(output!, from: ciImage!.extent)
+            guard let output = filter.outputImage,
+                  let cgImage = Self.ciContext.createCGImage(output, from: ciImage.extent) else {
+                throw RuntimeError.error(withMessage: "Failed to apply gaussian blur")
+            }
 
-            return HybridImage(uiImage: UIImage(cgImage: cgImage!))
+            return HybridImage(uiImage: UIImage(cgImage: cgImage))
         }
     }
 

package/lib/commonjs/index.js

@@ -19,32 +19,53 @@ const NitroImagePipeline = exports.NitroImagePipeline = _reactNativeNitroModules
 function useImage({
   url,
   blur = 0,
-  cornerRadius = 0
+  cornerRadius = 0,
+  cache
 }) {
   const [image, setImage] = (0, _react.useState)({
     image: undefined,
     error: undefined
   });
+  const loadedUrlRef = (0, _react.useRef)(url);
   (0, _react.useEffect)(() => {
+    let cancelled = false;
+    // Only reset to the loading state when the URL changes; for same-URL
+    // param tweaks (blur/cornerRadius/cache) keep showing the current image
+    // until the new variant resolves, to avoid flashing empty.
+    if (loadedUrlRef.current !== url) {
+      loadedUrlRef.current = url;
+      setImage({
+        image: undefined,
+        error: undefined
+      });
+    }
     (async () => {
       try {
         const result = await NitroImagePipeline.loadImage(url, {
           blur,
-          cornerRadius
-        });
-        setImage({
-          image: result,
-          error: undefined
+          cornerRadius,
+          cache
         });
+        if (!cancelled) {
+          setImage({
+            image: result,
+            error: undefined
+          });
+        }
       } catch (e) {
         const error = e instanceof Error ? e : new Error(`${e}`);
-        setImage({
-          image: undefined,
-          error: error
-        });
+        if (!cancelled) {
+          setImage({
+            image: undefined,
+            error: error
+          });
+        }
       }
     })();
-  }, [url, blur]);
+    return () => {
+      cancelled = true;
+    };
+  }, [url, blur, cornerRadius, cache]);
   return image;
 }
 //# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_react","require","_reactNativeNitroModules","NitroImagePipeline","exports","NitroModules","createHybridObject","useImage","url","blur","cornerRadius","image","setImage","useState","undefined","error","useEffect","result","loadImage","e","Error"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,wBAAA,GAAAD,OAAA;AAIO,MAAME,kBAAkB,GAAAC,OAAA,CAAAD,kBAAA,GAC7BE,qCAAY,CAACC,kBAAkB,CAAyB,oBAAoB,CAAC;AAmB/E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,QAAQA,CAAC;EACvBC,GAAG;EACHC,IAAI,GAAG,CAAC;EACRC,YAAY,GAAG;AAKjB,CAAC,EAAU;EACT,MAAM,CAACC,KAAK,EAAEC,QAAQ,CAAC,GAAG,IAAAC,eAAQ,EAAS;IACzCF,KAAK,EAAEG,SAAS;IAChBC,KAAK,EAAED;EACT,CAAC,CAAC;EAEF,IAAAE,gBAAS,EAAC,MAAM;IACd,CAAC,YAAY;MACX,IAAI;QACF,MAAMC,MAAM,GAAG,MAAMd,kBAAkB,CAACe,SAAS,CAACV,GAAG,EAAE;UACrDC,IAAI;UACJC;QACF,CAAC,CAAC;QAEFE,QAAQ,CAAC;UAAED,KAAK,EAAEM,MAAM;UAAEF,KAAK,EAAED;QAAU,CAAC,CAAC;MAC/C,CAAC,CAAC,OAAOK,CAAC,EAAE;QACV,MAAMJ,KAAK,GAAGI,CAAC,YAAYC,KAAK,GAAGD,CAAC,GAAG,IAAIC,KAAK,CAAC,GAAGD,CAAC,EAAE,CAAC;QACxDP,QAAQ,CAAC;UAAED,KAAK,EAAEG,SAAS;UAAEC,KAAK,EAAEA;QAAM,CAAC,CAAC;MAC9C;IACF,CAAC,EAAE,CAAC;EACN,CAAC,EAAE,CAACP,GAAG,EAAEC,IAAI,CAAC,CAAC;EAEf,OAAOE,KAAK;AACd","ignoreList":[]}
+{"version":3,"names":["_react","require","_reactNativeNitroModules","NitroImagePipeline","exports","NitroModules","createHybridObject","useImage","url","blur","cornerRadius","cache","image","setImage","useState","undefined","error","loadedUrlRef","useRef","useEffect","cancelled","current","result","loadImage","e","Error"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,wBAAA,GAAAD,OAAA;AAUO,MAAME,kBAAkB,GAAAC,OAAA,CAAAD,kBAAA,GAC7BE,qCAAY,CAACC,kBAAkB,CAAyB,oBAAoB,CAAC;AAmB/E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,QAAQA,CAAC;EACvBC,GAAG;EACHC,IAAI,GAAG,CAAC;EACRC,YAAY,GAAG,CAAC;EAChBC;AAMF,CAAC,EAAU;EACT,MAAM,CAACC,KAAK,EAAEC,QAAQ,CAAC,GAAG,IAAAC,eAAQ,EAAS;IACzCF,KAAK,EAAEG,SAAS;IAChBC,KAAK,EAAED;EACT,CAAC,CAAC;EACF,MAAME,YAAY,GAAG,IAAAC,aAAM,EAACV,GAAG,CAAC;EAEhC,IAAAW,gBAAS,EAAC,MAAM;IACd,IAAIC,SAAS,GAAG,KAAK;IACrB;IACA;IACA;IACA,IAAIH,YAAY,CAACI,OAAO,KAAKb,GAAG,EAAE;MAChCS,YAAY,CAACI,OAAO,GAAGb,GAAG;MAC1BK,QAAQ,CAAC;QAAED,KAAK,EAAEG,SAAS;QAAEC,KAAK,EAAED;MAAU,CAAC,CAAC;IAClD;IAEA,CAAC,YAAY;MACX,IAAI;QACF,MAAMO,MAAM,GAAG,MAAMnB,kBAAkB,CAACoB,SAAS,CAACf,GAAG,EAAE;UACrDC,IAAI;UACJC,YAAY;UACZC;QACF,CAAC,CAAC;QAEF,IAAI,CAACS,SAAS,EAAE;UACdP,QAAQ,CAAC;YAAED,KAAK,EAAEU,MAAM;YAAEN,KAAK,EAAED;UAAU,CAAC,CAAC;QAC/C;MACF,CAAC,CAAC,OAAOS,CAAC,EAAE;QACV,MAAMR,KAAK,GAAGQ,CAAC,YAAYC,KAAK,GAAGD,CAAC,GAAG,IAAIC,KAAK,CAAC,GAAGD,CAAC,EAAE,CAAC;QACxD,IAAI,CAACJ,SAAS,EAAE;UACdP,QAAQ,CAAC;YAAED,KAAK,EAAEG,SAAS;YAAEC,KAAK,EAAEA;UAAM,CAAC,CAAC;QAC9C;MACF;IACF,CAAC,EAAE,CAAC;IAEJ,OAAO,MAAM;MACXI,SAAS,GAAG,IAAI;IAClB,CAAC;EACH,CAAC,EAAE,CAACZ,GAAG,EAAEC,IAAI,EAAEC,YAAY,EAAEC,KAAK,CAAC,CAAC;EAEpC,OAAOC,KAAK;AACd","ignoreList":[]}

package/lib/module/index.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { useEffect, useState } from 'react';
+import { useEffect, useRef, useState } from 'react';
 import { NitroModules } from 'react-native-nitro-modules';
 export const NitroImagePipeline = NitroModules.createHybridObject('NitroImagePipeline');
 /**
@@ -14,32 +14,53 @@ export const NitroImagePipeline = NitroModules.createHybridObject('NitroImagePip
 export function useImage({
   url,
   blur = 0,
-  cornerRadius = 0
+  cornerRadius = 0,
+  cache
 }) {
   const [image, setImage] = useState({
     image: undefined,
     error: undefined
   });
+  const loadedUrlRef = useRef(url);
   useEffect(() => {
+    let cancelled = false;
+    // Only reset to the loading state when the URL changes; for same-URL
+    // param tweaks (blur/cornerRadius/cache) keep showing the current image
+    // until the new variant resolves, to avoid flashing empty.
+    if (loadedUrlRef.current !== url) {
+      loadedUrlRef.current = url;
+      setImage({
+        image: undefined,
+        error: undefined
+      });
+    }
     (async () => {
       try {
         const result = await NitroImagePipeline.loadImage(url, {
           blur,
-          cornerRadius
-        });
-        setImage({
-          image: result,
-          error: undefined
+          cornerRadius,
+          cache
         });
+        if (!cancelled) {
+          setImage({
+            image: result,
+            error: undefined
+          });
+        }
       } catch (e) {
         const error = e instanceof Error ? e : new Error(`${e}`);
-        setImage({
-          image: undefined,
-          error: error
-        });
+        if (!cancelled) {
+          setImage({
+            image: undefined,
+            error: error
+          });
+        }
       }
     })();
-  }, [url, blur]);
+    return () => {
+      cancelled = true;
+    };
+  }, [url, blur, cornerRadius, cache]);
   return image;
 }
 //# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["useEffect","useState","NitroModules","NitroImagePipeline","createHybridObject","useImage","url","blur","cornerRadius","image","setImage","undefined","error","result","loadImage","e","Error"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA,SAASA,SAAS,EAAEC,QAAQ,QAAQ,OAAO;AAE3C,SAASC,YAAY,QAAQ,4BAA4B;AAIzD,OAAO,MAAMC,kBAAkB,GAC7BD,YAAY,CAACE,kBAAkB,CAAyB,oBAAoB,CAAC;AAmB/E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,QAAQA,CAAC;EACvBC,GAAG;EACHC,IAAI,GAAG,CAAC;EACRC,YAAY,GAAG;AAKjB,CAAC,EAAU;EACT,MAAM,CAACC,KAAK,EAAEC,QAAQ,CAAC,GAAGT,QAAQ,CAAS;IACzCQ,KAAK,EAAEE,SAAS;IAChBC,KAAK,EAAED;EACT,CAAC,CAAC;EAEFX,SAAS,CAAC,MAAM;IACd,CAAC,YAAY;MACX,IAAI;QACF,MAAMa,MAAM,GAAG,MAAMV,kBAAkB,CAACW,SAAS,CAACR,GAAG,EAAE;UACrDC,IAAI;UACJC;QACF,CAAC,CAAC;QAEFE,QAAQ,CAAC;UAAED,KAAK,EAAEI,MAAM;UAAED,KAAK,EAAED;QAAU,CAAC,CAAC;MAC/C,CAAC,CAAC,OAAOI,CAAC,EAAE;QACV,MAAMH,KAAK,GAAGG,CAAC,YAAYC,KAAK,GAAGD,CAAC,GAAG,IAAIC,KAAK,CAAC,GAAGD,CAAC,EAAE,CAAC;QACxDL,QAAQ,CAAC;UAAED,KAAK,EAAEE,SAAS;UAAEC,KAAK,EAAEA;QAAM,CAAC,CAAC;MAC9C;IACF,CAAC,EAAE,CAAC;EACN,CAAC,EAAE,CAACN,GAAG,EAAEC,IAAI,CAAC,CAAC;EAEf,OAAOE,KAAK;AACd","ignoreList":[]}
+{"version":3,"names":["useEffect","useRef","useState","NitroModules","NitroImagePipeline","createHybridObject","useImage","url","blur","cornerRadius","cache","image","setImage","undefined","error","loadedUrlRef","cancelled","current","result","loadImage","e","Error"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA,SAASA,SAAS,EAAEC,MAAM,EAAEC,QAAQ,QAAQ,OAAO;AAEnD,SAASC,YAAY,QAAQ,4BAA4B;AAUzD,OAAO,MAAMC,kBAAkB,GAC7BD,YAAY,CAACE,kBAAkB,CAAyB,oBAAoB,CAAC;AAmB/E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,QAAQA,CAAC;EACvBC,GAAG;EACHC,IAAI,GAAG,CAAC;EACRC,YAAY,GAAG,CAAC;EAChBC;AAMF,CAAC,EAAU;EACT,MAAM,CAACC,KAAK,EAAEC,QAAQ,CAAC,GAAGV,QAAQ,CAAS;IACzCS,KAAK,EAAEE,SAAS;IAChBC,KAAK,EAAED;EACT,CAAC,CAAC;EACF,MAAME,YAAY,GAAGd,MAAM,CAACM,GAAG,CAAC;EAEhCP,SAAS,CAAC,MAAM;IACd,IAAIgB,SAAS,GAAG,KAAK;IACrB;IACA;IACA;IACA,IAAID,YAAY,CAACE,OAAO,KAAKV,GAAG,EAAE;MAChCQ,YAAY,CAACE,OAAO,GAAGV,GAAG;MAC1BK,QAAQ,CAAC;QAAED,KAAK,EAAEE,SAAS;QAAEC,KAAK,EAAED;MAAU,CAAC,CAAC;IAClD;IAEA,CAAC,YAAY;MACX,IAAI;QACF,MAAMK,MAAM,GAAG,MAAMd,kBAAkB,CAACe,SAAS,CAACZ,GAAG,EAAE;UACrDC,IAAI;UACJC,YAAY;UACZC;QACF,CAAC,CAAC;QAEF,IAAI,CAACM,SAAS,EAAE;UACdJ,QAAQ,CAAC;YAAED,KAAK,EAAEO,MAAM;YAAEJ,KAAK,EAAED;UAAU,CAAC,CAAC;QAC/C;MACF,CAAC,CAAC,OAAOO,CAAC,EAAE;QACV,MAAMN,KAAK,GAAGM,CAAC,YAAYC,KAAK,GAAGD,CAAC,GAAG,IAAIC,KAAK,CAAC,GAAGD,CAAC,EAAE,CAAC;QACxD,IAAI,CAACJ,SAAS,EAAE;UACdJ,QAAQ,CAAC;YAAED,KAAK,EAAEE,SAAS;YAAEC,KAAK,EAAEA;UAAM,CAAC,CAAC;QAC9C;MACF;IACF,CAAC,EAAE,CAAC;IAEJ,OAAO,MAAM;MACXE,SAAS,GAAG,IAAI;IAClB,CAAC;EACH,CAAC,EAAE,CAACT,GAAG,EAAEC,IAAI,EAAEC,YAAY,EAAEC,KAAK,CAAC,CAAC;EAEpC,OAAOC,KAAK;AACd","ignoreList":[]}

package/lib/typescript/src/index.d.ts

@@ -1,5 +1,6 @@
 import type { Image } from 'react-native-nitro-image';
-import type { NitroImagePipeline as NitroImagePipelineSpec } from './specs/nitro-image-toolkit.nitro';
+import type { CacheOption, NitroImagePipeline as NitroImagePipelineSpec, Options } from './specs/nitro-image-toolkit.nitro';
+export type { CacheOption, Options };
 export declare const NitroImagePipeline: NitroImagePipelineSpec;
 type Result = {
     image: undefined;
@@ -19,10 +20,10 @@ type Result = {
  * const { image, error } = useImage({ filePath: '/tmp/image.jpg' })
  * ```
  */
-export declare function useImage({ url, blur, cornerRadius, }: {
+export declare function useImage({ url, blur, cornerRadius, cache, }: {
     url: string;
     blur?: number;
     cornerRadius?: number;
+    cache?: CacheOption;
 }): Result;
-export {};
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAGtD,OAAO,KAAK,EAAE,kBAAkB,IAAI,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAEtG,eAAO,MAAM,kBAAkB,wBACgD,CAAC;AAEhF,KAAK,MAAM,GAEP;IACE,KAAK,EAAE,SAAS,CAAC;IACjB,KAAK,EAAE,SAAS,CAAC;CAClB,GAED;IACE,KAAK,EAAE,KAAK,CAAC;IACb,KAAK,EAAE,SAAS,CAAC;CAClB,GAED;IACE,KAAK,EAAE,SAAS,CAAC;IACjB,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEN;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,EACvB,GAAG,EACH,IAAQ,EACR,YAAgB,GACjB,EAAE;IACD,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,GAAG,MAAM,CAuBT"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAGtD,OAAO,KAAK,EACV,WAAW,EACX,kBAAkB,IAAI,sBAAsB,EAC5C,OAAO,EACR,MAAM,mCAAmC,CAAC;AAE3C,YAAY,EAAE,WAAW,EAAE,OAAO,EAAE,CAAC;AAErC,eAAO,MAAM,kBAAkB,wBACgD,CAAC;AAEhF,KAAK,MAAM,GAEP;IACE,KAAK,EAAE,SAAS,CAAC;IACjB,KAAK,EAAE,SAAS,CAAC;CAClB,GAED;IACE,KAAK,EAAE,KAAK,CAAC;IACb,KAAK,EAAE,SAAS,CAAC;CAClB,GAED;IACE,KAAK,EAAE,SAAS,CAAC;IACjB,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEN;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,EACvB,GAAG,EACH,IAAQ,EACR,YAAgB,EAChB,KAAK,GACN,EAAE;IACD,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,WAAW,CAAC;CACrB,GAAG,MAAM,CA0CT"}

package/lib/typescript/src/specs/nitro-image-toolkit.nitro.d.ts

@@ -1,7 +1,7 @@
 import type { Image } from 'react-native-nitro-image';
 import type { HybridObject } from 'react-native-nitro-modules';
-type CacheOption = 'memory' | 'disk' | 'none';
-type Options = {
+export type CacheOption = 'memory' | 'disk' | 'none';
+export type Options = {
     blur?: number;
     cache?: CacheOption;
     cornerRadius?: number;
@@ -14,7 +14,6 @@ export interface NitroImagePipeline extends HybridObject<{
     preLoadImage(url: string): Promise<void>;
     preLoadImages(urls: string[]): Promise<void>;
     gaussianBlur(image: Image, radius: number): Promise<Image>;
-    clearCache(): void;
+    clearCache(): Promise<void>;
 }
-export {};
 //# sourceMappingURL=nitro-image-toolkit.nitro.d.ts.map

package/lib/typescript/src/specs/nitro-image-toolkit.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nitro-image-toolkit.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/nitro-image-toolkit.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D,KAAK,WAAW,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC;AAC9C,KAAK,OAAO,GAAG;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,WAAW,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7E,MAAM,WAAW,kBACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACzD,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAC1D,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAG3D,UAAU,IAAI,IAAI,CAAC;CACpB"}
+{"version":3,"file":"nitro-image-toolkit.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/nitro-image-toolkit.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC;AACrD,MAAM,MAAM,OAAO,GAAG;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,WAAW,kBACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACzD,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAC1D,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAG3D,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7B"}

package/nitrogen/generated/android/c++/JCacheOption.hpp

@@ -15,7 +15,7 @@ namespace margelo::nitro::nitroimagepipeline {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ enum "CacheOption" and the the Kotlin enum "CacheOption".
+   * The C++ JNI bridge between the C++ enum "CacheOption" and the Kotlin enum "CacheOption".
    */
   struct JCacheOption final: public jni::JavaClass<JCacheOption> {
   public:

package/nitrogen/generated/android/c++/JHybridNitroImagePipelineSpec.cpp

@@ -94,16 +94,16 @@ namespace margelo::nitro::nitroimagepipeline {
   }
   std::shared_ptr<Promise<void>> JHybridNitroImagePipelineSpec::preLoadImages(const std::vector<std::string>& urls) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JArrayClass<jni::JString>> /* urls */)>("preLoadImages");
-    auto __result = method(_javaPart, [&]() {
-      size_t __size = urls.size();
+    auto __result = method(_javaPart, [&](auto&& __input) {
+      size_t __size = __input.size();
       jni::local_ref<jni::JArrayClass<jni::JString>> __array = jni::JArrayClass<jni::JString>::newArray(__size);
       for (size_t __i = 0; __i < __size; __i++) {
-        const auto& __element = urls[__i];
+        const auto& __element = __input[__i];
         auto __elementJni = jni::make_jstring(__element);
         __array->setElement(__i, *__elementJni);
       }
       return __array;
-    }());
+    }(urls));
     return [&]() {
       auto __promise = Promise<void>::create();
       __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
@@ -132,9 +132,20 @@ namespace margelo::nitro::nitroimagepipeline {
       return __promise;
     }();
   }
-  void JHybridNitroImagePipelineSpec::clearCache() {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("clearCache");
-    method(_javaPart);
+  std::shared_ptr<Promise<void>> JHybridNitroImagePipelineSpec::clearCache() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("clearCache");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
 
 } // namespace margelo::nitro::nitroimagepipeline

package/nitrogen/generated/android/c++/JHybridNitroImagePipelineSpec.hpp

@@ -58,7 +58,7 @@ namespace margelo::nitro::nitroimagepipeline {
     std::shared_ptr<Promise<void>> preLoadImage(const std::string& url) override;
     std::shared_ptr<Promise<void>> preLoadImages(const std::vector<std::string>& urls) override;
     std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::image::HybridImageSpec>>> gaussianBlur(const std::shared_ptr<margelo::nitro::image::HybridImageSpec>& image, double radius) override;
-    void clearCache() override;
+    std::shared_ptr<Promise<void>> clearCache() override;
 
   private:
     jni::global_ref<JHybridNitroImagePipelineSpec::JavaPart> _javaPart;

package/nitrogen/generated/android/c++/JOptions.hpp

@@ -19,7 +19,7 @@ namespace margelo::nitro::nitroimagepipeline {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ struct "Options" and the the Kotlin data class "Options".
+   * The C++ JNI bridge between the C++ struct "Options" and the Kotlin data class "Options".
    */
   struct JOptions final: public jni::JavaClass<JOptions> {
   public:

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroimagepipeline/HybridNitroImagePipelineSpec.kt

@@ -10,6 +10,7 @@ package com.margelo.nitro.nitroimagepipeline
 import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
 import com.margelo.nitro.image.HybridImageSpec
 import com.margelo.nitro.core.Promise
 import com.margelo.nitro.core.HybridObject
@@ -48,7 +49,7 @@ abstract class HybridNitroImagePipelineSpec: HybridObject() {
   
   @DoNotStrip
   @Keep
-  abstract fun clearCache(): Unit
+  abstract fun clearCache(): Promise<Unit>
 
   // Default implementation of `HybridObject.toString()`
   override fun toString(): String {
@@ -60,6 +61,7 @@ abstract class HybridNitroImagePipelineSpec: HybridObject() {
   @Keep
   protected open class CxxPart(javaPart: HybridNitroImagePipelineSpec): HybridObject.CxxPart(javaPart) {
     // C++ JHybridNitroImagePipelineSpec::CxxPart::initHybrid(...)
+    @FastNative
     external override fun initHybrid(): HybridData
   }
   override fun createCxxPart(): CxxPart {

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroimagepipeline/Options.kt

@@ -9,6 +9,7 @@ package com.margelo.nitro.nitroimagepipeline
 
 import androidx.annotation.Keep
 import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
 
 
 /**
@@ -29,6 +30,22 @@ data class Options(
 ) {
   /* primary constructor */
 
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is Options) return false
+    return Objects.deepEquals(this.blur, other.blur)
+      && Objects.deepEquals(this.cache, other.cache)
+      && Objects.deepEquals(this.cornerRadius, other.cornerRadius)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf<Any?>(
+      blur,
+      cache,
+      cornerRadius
+    ).contentDeepHashCode()
+  }
+
   companion object {
     /**
      * Constructor called from C++

package/nitrogen/generated/ios/NitroImagePipeline-Swift-Cxx-Bridge.hpp

@@ -231,14 +231,5 @@ namespace margelo::nitro::nitroimagepipeline::bridge::swift {
   inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<Promise<void>>>::withError(error);
   }
-  
-  // pragma MARK: Result<void>
-  using Result_void_ = Result<void>;
-  inline Result_void_ create_Result_void_() noexcept {
-    return Result<void>::withValue();
-  }
-  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
-    return Result<void>::withError(error);
-  }
 
 } // namespace margelo::nitro::nitroimagepipeline::bridge::swift

package/nitrogen/generated/ios/c++/HybridNitroImagePipelineSpecSwift.hpp

@@ -110,11 +110,13 @@ namespace margelo::nitro::nitroimagepipeline {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline void clearCache() override {
+    inline std::shared_ptr<Promise<void>> clearCache() override {
       auto __result = _swiftPart.clearCache();
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
+      auto __value = std::move(__result.value());
+      return __value;
     }
 
   private:

package/nitrogen/generated/ios/swift/HybridNitroImagePipelineSpec.swift

@@ -18,7 +18,7 @@ public protocol HybridNitroImagePipelineSpec_protocol: HybridObject {
   func preLoadImage(url: String) throws -> Promise<Void>
   func preLoadImages(urls: [String]) throws -> Promise<Void>
   func gaussianBlur(image: (any HybridImageSpec), radius: Double) throws -> Promise<(any HybridImageSpec)>
-  func clearCache() throws -> Void
+  func clearCache() throws -> Promise<Void>
 }
 
 public extension HybridNitroImagePipelineSpec_protocol {

package/nitrogen/generated/ios/swift/HybridNitroImagePipelineSpec_cxx.swift

@@ -212,13 +212,21 @@ open class HybridNitroImagePipelineSpec_cxx {
   }
   
   @inline(__always)
-  public final func clearCache() -> bridge.Result_void_ {
+  public final func clearCache() -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
-      try self.__implementation.clearCache()
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.clearCache()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
 }

package/nitrogen/generated/shared/c++/HybridNitroImagePipelineSpec.hpp

@@ -61,7 +61,7 @@ namespace margelo::nitro::nitroimagepipeline {
       virtual std::shared_ptr<Promise<void>> preLoadImage(const std::string& url) = 0;
       virtual std::shared_ptr<Promise<void>> preLoadImages(const std::vector<std::string>& urls) = 0;
       virtual std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::image::HybridImageSpec>>> gaussianBlur(const std::shared_ptr<margelo::nitro::image::HybridImageSpec>& image, double radius) = 0;
-      virtual void clearCache() = 0;
+      virtual std::shared_ptr<Promise<void>> clearCache() = 0;
 
     protected:
       // Hybrid Setup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-image-pipeline",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "High-performance image loading, caching, and processing for React Native, built with Nitro Modules",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",
@@ -59,19 +59,19 @@
     "registry": "https://registry.npmjs.org/"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.4.10",
-    "@semantic-release/changelog": "^6.0.3",
-    "@semantic-release/git": "^10.0.1",
-    "@types/bun": "^1.3.12",
+    "@biomejs/biome": "^2.5.6",
+    "@semantic-release/changelog": "^7.0.0",
+    "@semantic-release/git": "^11.0.1",
+    "@types/bun": "^1.3.14",
     "@types/jest": "^30.0.0",
-    "@types/react": "19.2.0",
-    "conventional-changelog-conventionalcommits": "^9.1.0",
-    "nitrogen": "0.36.1",
+    "@types/react": "19.2.18",
+    "conventional-changelog-conventionalcommits": "^10.2.1",
+    "nitrogen": "0.36.5",
     "react": "19.2.3",
     "react-native": "0.84.1",
     "react-native-builder-bob": "^0.43.0",
-    "react-native-nitro-modules": "0.36.1",
-    "semantic-release": "^25.0.5",
+    "react-native-nitro-modules": "0.36.5",
+    "semantic-release": "^25.0.8",
     "typescript": "^5.8.3"
   },
   "peerDependencies": {

package/src/index.ts

@@ -1,8 +1,14 @@
-import { useEffect, useState } from 'react';
+import { useEffect, useRef, useState } from 'react';
 import type { Image } from 'react-native-nitro-image';
 import { NitroModules } from 'react-native-nitro-modules';
 
-import type { NitroImagePipeline as NitroImagePipelineSpec } from './specs/nitro-image-toolkit.nitro';
+import type {
+  CacheOption,
+  NitroImagePipeline as NitroImagePipelineSpec,
+  Options,
+} from './specs/nitro-image-toolkit.nitro';
+
+export type { CacheOption, Options };
 
 export const NitroImagePipeline =
   NitroModules.createHybridObject<NitroImagePipelineSpec>('NitroImagePipeline');
@@ -36,31 +42,52 @@ export function useImage({
   url,
   blur = 0,
   cornerRadius = 0,
+  cache,
 }: {
   url: string;
   blur?: number;
   cornerRadius?: number;
+  cache?: CacheOption;
 }): Result {
   const [image, setImage] = useState<Result>({
     image: undefined,
     error: undefined,
   });
+  const loadedUrlRef = useRef(url);
 
   useEffect(() => {
+    let cancelled = false;
+    // Only reset to the loading state when the URL changes; for same-URL
+    // param tweaks (blur/cornerRadius/cache) keep showing the current image
+    // until the new variant resolves, to avoid flashing empty.
+    if (loadedUrlRef.current !== url) {
+      loadedUrlRef.current = url;
+      setImage({ image: undefined, error: undefined });
+    }
+
     (async () => {
       try {
         const result = await NitroImagePipeline.loadImage(url, {
           blur,
           cornerRadius,
+          cache,
         });
 
-        setImage({ image: result, error: undefined });
+        if (!cancelled) {
+          setImage({ image: result, error: undefined });
+        }
       } catch (e) {
         const error = e instanceof Error ? e : new Error(`${e}`);
-        setImage({ image: undefined, error: error });
+        if (!cancelled) {
+          setImage({ image: undefined, error: error });
+        }
       }
     })();
-  }, [url, blur]);
+
+    return () => {
+      cancelled = true;
+    };
+  }, [url, blur, cornerRadius, cache]);
 
   return image;
 }

package/src/specs/nitro-image-toolkit.nitro.ts

@@ -1,8 +1,12 @@
 import type { Image } from 'react-native-nitro-image';
 import type { HybridObject } from 'react-native-nitro-modules';
 
-type CacheOption = 'memory' | 'disk' | 'none';
-type Options = { blur?: number; cache?: CacheOption; cornerRadius?: number };
+export type CacheOption = 'memory' | 'disk' | 'none';
+export type Options = {
+  blur?: number;
+  cache?: CacheOption;
+  cornerRadius?: number;
+};
 
 export interface NitroImagePipeline
   extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
@@ -12,5 +16,5 @@ export interface NitroImagePipeline
   gaussianBlur(image: Image, radius: number): Promise<Image>;
   // Future: brightness, saturation, tint, etc.
 
-  clearCache(): void;
+  clearCache(): Promise<void>;
 }