react-native-nitro-image-pipeline 0.1.1 → 0.2.0

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

@@ -8,6 +8,7 @@ import coil3.ImageLoader
 import coil3.disk.DiskCache
 import coil3.memory.MemoryCache
 import coil3.network.okhttp.OkHttpNetworkFetcherFactory
+import coil3.request.CachePolicy
 import coil3.request.ErrorResult
 import coil3.request.ImageRequest
 import coil3.request.SuccessResult
@@ -53,55 +54,68 @@ class HybridNitroImagePipeline : HybridNitroImagePipelineSpec() {
         .build()
   }
 
-  override fun loadImage(url: String, options: Options?): Promise<HybridImageSpec> =
-      Promise.async {
-        val blur = options?.blur?.toFloat() ?: 0f
-        val cornerRadius = options?.cornerRadius?.toFloat() ?: 0f
-        val transformations = buildList {
-          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)
-                .allowHardware(true)
-                .memoryCacheKey(memoryCacheKey)
-                .transformations(transformations)
-                .build()
-
-        val result = imageLoader.execute(request)
-        when (result) {
-          is ErrorResult -> throw result.throwable
-          is SuccessResult -> {
-            val bitmap =
-                when (val img = result.image) {
-                  is BitmapImage -> img.bitmap
-                  is DrawableImage -> img.drawable.toBitmap()
-                  else -> throw Error("Unsupported image type: ${img.javaClass.simpleName}")
+  override fun loadImage(url: String, options: Options?): Promise<HybridImageSpec> = Promise.async {
+    val blur = options?.blur?.toFloat() ?: 0f
+    val cornerRadius = options?.cornerRadius?.toFloat() ?: 0f
+    val transformations = buildList {
+      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)
+            .apply {
+              when (options?.cache) {
+                CacheOption.MEMORY -> {
+                  memoryCachePolicy(CachePolicy.ENABLED)
+                  diskCachePolicy(CachePolicy.DISABLED)
                 }
-            HybridImage(bitmap)
-          }
-        }
-      }
+                CacheOption.DISK -> {
+                  memoryCachePolicy(CachePolicy.DISABLED)
+                  diskCachePolicy(CachePolicy.ENABLED)
+                }
+                CacheOption.NONE -> {
+                  memoryCachePolicy(CachePolicy.DISABLED)
+                  diskCachePolicy(CachePolicy.DISABLED)
+                }
+                null -> Unit // Coil defaults: both enabled
+              }
+            }
+            .allowHardware(true)
+            .memoryCacheKey(memoryCacheKey)
+            .transformations(transformations)
+            .build()
 
-  override fun preLoadImage(url: String): Promise<Unit> =
-      Promise.async {
-        val request = ImageRequest.Builder(context).data(url).build()
-        imageLoader.execute(request)
+    when (val result = imageLoader.execute(request)) {
+      is ErrorResult -> throw result.throwable
+      is SuccessResult -> {
+        val bitmap =
+            when (val img = result.image) {
+              is BitmapImage -> img.bitmap
+              is DrawableImage -> img.drawable.toBitmap()
+              else -> throw Error("Unsupported image type: ${img.javaClass.simpleName}")
+            }
+        HybridImage(bitmap)
       }
+    }
+  }
 
-  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)
-        }
-      }
+  override fun preLoadImage(url: String): Promise<Unit> = Promise.async {
+    val request = ImageRequest.Builder(context).data(url).build()
+    imageLoader.execute(request)
+  }
+
+  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)
+    }
+  }
 
   override fun gaussianBlur(image: HybridImageSpec, radius: Double): Promise<HybridImageSpec> =
       Promise.async {

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

@@ -8,12 +8,13 @@ import com.facebook.react.module.model.ReactModuleInfoProvider
 public class NitroImagePipelinePackage : BaseReactPackage() {
   override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null
 
-  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
-      ReactModuleInfoProvider { emptyMap() }
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider {
+    emptyMap()
+  }
 
   companion object {
     init {
-      NitroImagePipelineOnLoad.initializeNative();
+      NitroImagePipelineOnLoad.initializeNative()
     }
   }
-}
+}

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

@@ -20,65 +20,71 @@ class BlurTransformation(
     private val sampling: Float = 1f,
 ) : Transformation() {
 
-    init {
-        require(radius in 0.01..25.0) { "radius must be in (0, 25]." }
-        require(sampling >= 1f) { "sampling must be >= 1." }
-    }
-
-    override val cacheKey = "${BlurTransformation::class.java.name}-$radius-$sampling"
-
-    override suspend fun transform(input: Bitmap, size: Size): Bitmap {
-        val paint = Paint(Paint.ANTI_ALIAS_FLAG or Paint.FILTER_BITMAP_FLAG)
-        // Auto-scale so the blurred image is at most 512px on the longest side.
-        // Blur is a low-pass filter so blurring at lower resolution is identical in quality.
-        val autoSampling = (maxOf(input.width, input.height) / 512f).coerceAtLeast(sampling)
-        val scaledWidth = (input.width / autoSampling).toInt().coerceAtLeast(1)
-        val scaledHeight = (input.height / autoSampling).toInt().coerceAtLeast(1)
-        val config = input.config ?: Bitmap.Config.ARGB_8888
+  init {
+    require(radius in 0.01..25.0) { "radius must be in (0, 25]." }
+    require(sampling >= 1f) { "sampling must be >= 1." }
+  }
 
-        val output = Bitmap.createBitmap(scaledWidth, scaledHeight, config)
-        output.applyCanvas {
-            scale(1 / autoSampling, 1 / autoSampling)
-            drawBitmap(input, 0f, 0f, paint)
-        }
+  override val cacheKey = "${BlurTransformation::class.java.name}-$radius-$sampling"
 
-        var script: RenderScript? = null
-        var tmpIn: Allocation? = null
-        var tmpOut: Allocation? = null
-        var blur: ScriptIntrinsicBlur? = null
-        try {
-            script = RenderScript.create(context)
-            tmpIn = Allocation.createFromBitmap(script, output, Allocation.MipmapControl.MIPMAP_NONE, Allocation.USAGE_SCRIPT)
-            tmpOut = Allocation.createTyped(script, tmpIn.type)
-            blur = ScriptIntrinsicBlur.create(script, Element.U8_4(script))
-            blur.setRadius(radius)
-            blur.setInput(tmpIn)
-            blur.forEach(tmpOut)
-            tmpOut.copyTo(output)
-        } finally {
-            script?.destroy()
-            tmpIn?.destroy()
-            tmpOut?.destroy()
-            blur?.destroy()
-        }
+  override suspend fun transform(input: Bitmap, size: Size): Bitmap {
+    val paint = Paint(Paint.ANTI_ALIAS_FLAG or Paint.FILTER_BITMAP_FLAG)
+    // Auto-scale so the blurred image is at most 512px on the longest side.
+    // Blur is a low-pass filter so blurring at lower resolution is identical in quality.
+    val autoSampling = (maxOf(input.width, input.height) / 512f).coerceAtLeast(sampling)
+    val scaledWidth = (input.width / autoSampling).toInt().coerceAtLeast(1)
+    val scaledHeight = (input.height / autoSampling).toInt().coerceAtLeast(1)
+    val config = input.config ?: Bitmap.Config.ARGB_8888
 
-        return output.scale(input.width, input.height)
+    val output = Bitmap.createBitmap(scaledWidth, scaledHeight, config)
+    output.applyCanvas {
+      scale(1 / autoSampling, 1 / autoSampling)
+      drawBitmap(input, 0f, 0f, paint)
     }
 
-    override fun equals(other: Any?): Boolean {
-        if (this === other) return true
-        return other is BlurTransformation &&
-            context == other.context &&
-            radius == other.radius &&
-            sampling == other.sampling
+    var script: RenderScript? = null
+    var tmpIn: Allocation? = null
+    var tmpOut: Allocation? = null
+    var blur: ScriptIntrinsicBlur? = null
+    try {
+      script = RenderScript.create(context)
+      tmpIn =
+          Allocation.createFromBitmap(
+              script,
+              output,
+              Allocation.MipmapControl.MIPMAP_NONE,
+              Allocation.USAGE_SCRIPT,
+          )
+      tmpOut = Allocation.createTyped(script, tmpIn.type)
+      blur = ScriptIntrinsicBlur.create(script, Element.U8_4(script))
+      blur.setRadius(radius)
+      blur.setInput(tmpIn)
+      blur.forEach(tmpOut)
+      tmpOut.copyTo(output)
+    } finally {
+      script?.destroy()
+      tmpIn?.destroy()
+      tmpOut?.destroy()
+      blur?.destroy()
     }
 
-    override fun hashCode(): Int {
-        var result = context.hashCode()
-        result = 31 * result + radius.hashCode()
-        result = 31 * result + sampling.hashCode()
-        return result
-    }
+    return output.scale(input.width, input.height)
+  }
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    return other is BlurTransformation &&
+        context == other.context &&
+        radius == other.radius &&
+        sampling == other.sampling
+  }
+
+  override fun hashCode(): Int {
+    var result = context.hashCode()
+    result = 31 * result + radius.hashCode()
+    result = 31 * result + sampling.hashCode()
+    return result
+  }
 
-    override fun toString() = "BlurTransformation(radius=$radius, sampling=$sampling)"
+  override fun toString() = "BlurTransformation(radius=$radius, sampling=$sampling)"
 }

package/ios/HybridNitroImagePipeline.swift

@@ -58,11 +58,21 @@ class HybridNitroImagePipeline: HybridNitroImagePipelineSpec {
 
     func loadImage(url: String, options: Options?) throws -> Promise<any HybridImageSpec> {
         return Promise.async {
-            let imgRequest = ImageRequest(url: URL(string: url), processors: [
-                .gaussianBlur(radius: Int(options?.blur ?? 0)),
-                .roundedCorners(radius: options?.cornerRadius ?? 0)
+            let cacheOptions: ImageRequest.Options = switch options?.cache {
+            case .memory: [.disableDiskCache]
+            case .disk:   [.disableMemoryCache]
+            case .none?:  [.disableDiskCache, .disableMemoryCache]
+            default:      []
+            }
+
+            let imgRequest = ImageRequest(
+                url: URL(string: url),
+                processors: [
+                    .gaussianBlur(radius: Int(options?.blur ?? 0)),
+                    .roundedCorners(radius: options?.cornerRadius ?? 0)
+                ], options: cacheOptions
+            )
 
-            ])
             let image = try await ImagePipeline.shared.image(for: imgRequest)
             return HybridImage(uiImage: image)
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-image-pipeline",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "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",
@@ -62,7 +62,7 @@
     "@biomejs/biome": "^2.4.10",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
-    "@types/jest": "^29.5.12",
+    "@types/jest": "^30.0.0",
     "@types/react": "19.2.0",
     "conventional-changelog-conventionalcommits": "^9.1.0",
     "nitrogen": "0.35.2",