react-native-nitro-image-pipeline 1.5.0 → 1.7.0

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

@@ -0,0 +1,103 @@
+package com.margelo.nitro.nitroimagepipeline.transform
+
+import android.graphics.Bitmap
+import android.graphics.BitmapShader
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.RectF
+import android.graphics.Shader
+import coil3.size.Size
+import coil3.transform.Transformation
+import kotlin.math.min
+
+/**
+ * Rounds the corners of the input **at its own size**, in pixels of that bitmap — a port of
+ * `ios/RoundedCornersProcessor.swift`, including its CSS-style clamping of radii that overlap.
+ *
+ * Coil's own `RoundedCornersTransformation` scale-fills and crops its input to the *request* size
+ * as part of its draw. That is right for the default resize (the request size is the output size)
+ * and is why [ResizeTransformation] is skipped for "rounded corners, no blur" there. Under any
+ * other fit the request size is only the box — a `contain` or `center` bitmap is smaller — so
+ * Coil's transformation would scale the result back up to the box. This one leaves the size alone.
+ */
+class PipelineRoundedCornersTransformation(
+    topLeft: Float,
+    topRight: Float,
+    bottomLeft: Float,
+    bottomRight: Float,
+) : Transformation() {
+  // Negative radii would make the path undefined; treat them as square.
+  private val topLeft = topLeft.coerceAtLeast(0f)
+  private val topRight = topRight.coerceAtLeast(0f)
+  private val bottomLeft = bottomLeft.coerceAtLeast(0f)
+  private val bottomRight = bottomRight.coerceAtLeast(0f)
+
+  override val cacheKey =
+      "${PipelineRoundedCornersTransformation::class.java.name}-$topLeft-$topRight-$bottomLeft-$bottomRight"
+
+  override suspend fun transform(input: Bitmap, size: Size): Bitmap {
+    val softwareInput =
+        if (input.config == Bitmap.Config.HARDWARE) input.copy(Bitmap.Config.ARGB_8888, false)
+        else input
+    val width = softwareInput.width
+    val height = softwareInput.height
+    if (width <= 0 || height <= 0) return softwareInput
+
+    // Clamp the way CSS `border-radius` does: if two radii on one edge
+    // overlap, all four scale down proportionally until they fit.
+    var scale = 1f
+    for ((edge, pair) in
+        listOf(
+            width to topLeft + topRight,
+            width to bottomLeft + bottomRight,
+            height to topLeft + bottomLeft,
+            height to topRight + bottomRight,
+        )) {
+      if (pair > edge) scale = min(scale, edge / pair)
+    }
+    val tl = topLeft * scale
+    val tr = topRight * scale
+    val bl = bottomLeft * scale
+    val br = bottomRight * scale
+
+    val path =
+        Path().apply {
+          addRoundRect(
+              RectF(0f, 0f, width.toFloat(), height.toFloat()),
+              // x/y radius pairs, clockwise from the top-left corner.
+              floatArrayOf(tl, tl, tr, tr, br, br, bl, bl),
+              Path.Direction.CW,
+          )
+        }
+    val paint =
+        Paint(Paint.ANTI_ALIAS_FLAG or Paint.FILTER_BITMAP_FLAG).apply {
+          shader = BitmapShader(softwareInput, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP)
+        }
+    // Always ARGB_8888: the corners need an alpha channel whatever the input has.
+    val output = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+    Canvas(output).drawPath(path, paint)
+    return output
+  }
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    return other is PipelineRoundedCornersTransformation &&
+        topLeft == other.topLeft &&
+        topRight == other.topRight &&
+        bottomLeft == other.bottomLeft &&
+        bottomRight == other.bottomRight
+  }
+
+  override fun hashCode(): Int {
+    var result = topLeft.hashCode()
+    result = 31 * result + topRight.hashCode()
+    result = 31 * result + bottomLeft.hashCode()
+    result = 31 * result + bottomRight.hashCode()
+    return result
+  }
+
+  override fun toString() =
+      "PipelineRoundedCornersTransformation(topLeft=$topLeft, topRight=$topRight, " +
+          "bottomLeft=$bottomLeft, bottomRight=$bottomRight)"
+}

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

@@ -6,53 +6,106 @@ import android.graphics.Matrix
 import android.graphics.Paint
 import coil3.size.Size
 import coil3.transform.Transformation
+import com.margelo.nitro.nitroimagepipeline.ResizeFit
 import kotlin.math.max
 
 /**
- * Scales the input to fill exactly [width] × [height] pixels and center-crops the overflow (CSS
- * `object-fit: cover`), upscaling smaller sources. It runs before [BlurTransformation] and rounded
- * corners so their pixel units refer to the final bitmap — matching Nuke's
- * `ImageProcessors.Resize(contentMode: .aspectFill, crop: true)` on iOS.
+ * Resizes the input into a [width] × [height] pixel box under [fit] (see [FitGeometry] for the size
+ * each mode produces). The default — [ResizeFit.COVER] with [allowUpscale] — scales the input to
+ * fill the box exactly and center-crops the overflow (CSS `object-fit: cover`), upscaling smaller
+ * sources, on the very same code path (and cache key) it had before `fit` existed, matching Nuke's
+ * `ImageProcessors.Resize(contentMode: .aspectFill, crop: true)` on iOS. Every other fit runs
+ * through [FitGeometry], matching iOS's `FitResizeProcessor`.
+ *
+ * It runs before [BlurTransformation] and rounded corners so their pixel units refer to the final
+ * bitmap.
  */
 class ResizeTransformation(
     private val width: Int,
     private val height: Int,
+    private val fit: ResizeFit = ResizeFit.COVER,
+    private val allowUpscale: Boolean = true,
 ) : Transformation() {
 
   init {
     require(width > 0 && height > 0) { "width and height must be > 0." }
   }
 
-  override val cacheKey = "${ResizeTransformation::class.java.name}-$width-$height"
+  private val isDefaultFit: Boolean
+    get() = fit == ResizeFit.COVER && allowUpscale
+
+  // The default keeps its original key so results cached by earlier versions stay valid.
+  override val cacheKey = buildString {
+    append(ResizeTransformation::class.java.name)
+        .append('-')
+        .append(width)
+        .append('-')
+        .append(height)
+    if (fit != ResizeFit.COVER) append('-').append(fit.name.lowercase())
+    if (!allowUpscale) append("-noupscale")
+  }
 
   override suspend fun transform(input: Bitmap, size: Size): Bitmap {
     val softwareInput =
         if (input.config == Bitmap.Config.HARDWARE) input.copy(Bitmap.Config.ARGB_8888, false)
         else input
-    if (softwareInput.width == width && softwareInput.height == height) return softwareInput
+    return if (isDefaultFit) cover(softwareInput) else fitted(softwareInput)
+  }
+
+  private fun cover(input: Bitmap): Bitmap {
+    if (input.width == width && input.height == height) return input
 
-    val scale = max(width.toFloat() / softwareInput.width, height.toFloat() / softwareInput.height)
+    val scale = max(width.toFloat() / input.width, height.toFloat() / input.height)
     val matrix =
         Matrix().apply {
           setScale(scale, scale)
-          postTranslate(
-              (width - softwareInput.width * scale) / 2f,
-              (height - softwareInput.height * scale) / 2f,
+          postTranslate((width - input.width * scale) / 2f, (height - input.height * scale) / 2f)
+        }
+    return draw(input, width, height, matrix)
+  }
+
+  private fun fitted(input: Bitmap): Bitmap {
+    val geometry = FitGeometry.of(input.width, input.height, width, height, fit, allowUpscale)
+    // `center` of a source that fits the box, or `contain` without upscaling
+    // of a small source: the bitmap is already the output.
+    if (geometry.isIdentity) return input
+
+    val matrix =
+        Matrix().apply {
+          // Scale to the rounded size exactly, so the drawn extent is whole pixels.
+          setScale(
+              geometry.scaledWidth.toFloat() / input.width,
+              geometry.scaledHeight.toFloat() / input.height,
           )
+          postTranslate(geometry.originX.toFloat(), geometry.originY.toFloat())
         }
-    val config = softwareInput.config ?: Bitmap.Config.ARGB_8888
-    val output = Bitmap.createBitmap(width, height, config)
+    return draw(input, geometry.outputWidth, geometry.outputHeight, matrix)
+  }
+
+  private fun draw(input: Bitmap, outputWidth: Int, outputHeight: Int, matrix: Matrix): Bitmap {
+    val config = input.config ?: Bitmap.Config.ARGB_8888
+    val output = Bitmap.createBitmap(outputWidth, outputHeight, config)
     Canvas(output)
-        .drawBitmap(softwareInput, matrix, Paint(Paint.ANTI_ALIAS_FLAG or Paint.FILTER_BITMAP_FLAG))
+        .drawBitmap(input, matrix, Paint(Paint.ANTI_ALIAS_FLAG or Paint.FILTER_BITMAP_FLAG))
     return output
   }
 
   override fun equals(other: Any?): Boolean {
     if (this === other) return true
-    return other is ResizeTransformation && width == other.width && height == other.height
+    return other is ResizeTransformation &&
+        width == other.width &&
+        height == other.height &&
+        fit == other.fit &&
+        allowUpscale == other.allowUpscale
   }
 
-  override fun hashCode(): Int = 31 * width + height
+  override fun hashCode(): Int {
+    var result = 31 * width + height
+    result = 31 * result + fit.hashCode()
+    result = 31 * result + allowUpscale.hashCode()
+    return result
+  }
 
-  override fun toString() = "ResizeTransformation(width=$width, height=$height)"
+  override fun toString() =
+      "ResizeTransformation(width=$width, height=$height, fit=$fit, allowUpscale=$allowUpscale)"
 }

package/ios/FitResizeProcessor.swift

@@ -0,0 +1,127 @@
+//
+//  FitResizeProcessor.swift
+//  NitroImagePipeline
+//
+//  Resizes into the `ResizeOptions` box under any `fit` other than the
+//  default. The default — `cover` with upscaling — stays on Nuke's own
+//  `ImageProcessors.Resize(.aspectFill, crop: true)`, so its output bytes and
+//  cache keys are exactly what they were before `fit` existed.
+//
+
+import CoreGraphics
+import Foundation
+import Nuke
+import UIKit
+
+/// The resize geometry both platforms implement — Android's port is
+/// `transform/FitGeometry.kt`, and `example/__tests__/fit-geometry.ts` is the
+/// copy the harness checks both against. With a `w` × `h` source and a
+/// `W` × `H` box:
+///
+/// ```
+/// cover   : sx = sy = max(W/w, H/h)
+/// contain : sx = sy = min(W/w, H/h)
+/// stretch : sx = W/w ; sy = H/h
+/// center  : sx = sy = 1
+/// if !allowUpscale: sx = min(sx, 1) ; sy = min(sy, 1)
+/// scaled  = (round(w·sx), round(h·sy))
+/// output  = (min(W, scaled.w), min(H, scaled.h))
+/// origin  = trunc((output − scaled) / 2)        — a centred, whole-pixel crop
+/// ```
+///
+/// The source is drawn scaled to `scaled` at `origin` on an `output`-sized
+/// canvas. Rounding is half-away-from-zero (`.rounded()` here,
+/// `roundToInt()` in Kotlin — identical for the positive values involved).
+struct FitGeometry: Equatable {
+    let source: CGSize
+    let scaled: CGSize
+    let output: CGSize
+    let origin: CGPoint
+
+    init(source: CGSize, box: CGSize, fit: ResizeFit, allowUpscale: Bool) {
+        let boxWidth = box.width.rounded()
+        let boxHeight = box.height.rounded()
+        var scaleX: CGFloat
+        var scaleY: CGFloat
+        switch fit {
+        case .cover:
+            let scale = max(boxWidth / source.width, boxHeight / source.height)
+            scaleX = scale
+            scaleY = scale
+        case .contain:
+            let scale = min(boxWidth / source.width, boxHeight / source.height)
+            scaleX = scale
+            scaleY = scale
+        case .stretch:
+            scaleX = boxWidth / source.width
+            scaleY = boxHeight / source.height
+        case .center:
+            scaleX = 1
+            scaleY = 1
+        }
+        if !allowUpscale {
+            scaleX = min(scaleX, 1)
+            scaleY = min(scaleY, 1)
+        }
+        let scaledWidth = max((source.width * scaleX).rounded(), 1)
+        let scaledHeight = max((source.height * scaleY).rounded(), 1)
+        let outputWidth = min(boxWidth, scaledWidth)
+        let outputHeight = min(boxHeight, scaledHeight)
+        self.source = source
+        scaled = CGSize(width: scaledWidth, height: scaledHeight)
+        output = CGSize(width: outputWidth, height: outputHeight)
+        origin = CGPoint(
+            x: ((outputWidth - scaledWidth) / 2).rounded(.towardZero),
+            y: ((outputHeight - scaledHeight) / 2).rounded(.towardZero)
+        )
+    }
+
+    /// Whether the source is already the output — nothing to draw. Both
+    /// sizes are compared with the *source*: `scaled == output` alone also
+    /// holds for every plain downscale (nothing is cropped), which is not an
+    /// identity.
+    var isIdentity: Bool { scaled == source && output == source }
+}
+
+/// Nuke processor for the non-default fits. Runs before the blur and corner
+/// processors, like `ImageProcessors.Resize`, so their pixel units refer to
+/// the produced bitmap. Sizes are in points of the image, which the pipeline
+/// decodes at scale 1 (1 pt = 1 px) — the same convention as
+/// `RoundedCornersProcessor`.
+struct FitResizeProcessor: ImageProcessing {
+    let width: Double
+    let height: Double
+    let fit: ResizeFit
+    let allowUpscale: Bool
+
+    var identifier: String {
+        "com.nitroimagepipeline.resize?w=\(width),h=\(height),fit=\(fit.stringValue),upscale=\(allowUpscale)"
+    }
+
+    var hashableIdentifier: AnyHashable { identifier }
+
+    func process(_ image: PlatformImage) -> PlatformImage? {
+        let source = image.size
+        guard source.width > 0, source.height > 0 else { return image }
+        let geometry = FitGeometry(
+            source: source,
+            box: CGSize(width: width, height: height),
+            fit: fit,
+            allowUpscale: allowUpscale
+        )
+        // `center` of a source that fits the box, or `contain` without
+        // upscaling of a small source: the bitmap is already the output.
+        if geometry.isIdentity { return image }
+
+        let format = UIGraphicsImageRendererFormat()
+        format.scale = image.scale
+        format.opaque = false
+        // See RoundedCornersProcessor: the extended range doubles the bytes
+        // of an 8-bit source for nothing.
+        format.preferredRange = .standard
+
+        return UIGraphicsImageRenderer(size: geometry.output, format: format).image { _ in
+            image.draw(in: CGRect(origin: geometry.origin, size: geometry.scaled))
+        }
+    }
+}

package/ios/HybridNitroImagePipeline.swift

@@ -138,13 +138,43 @@ class HybridNitroImagePipeline: HybridNitroImagePipelineSpec {
     private var pipeline: ImagePipeline { Self.sharedPipeline }
     private var prefetcher: ImagePrefetcher { Self.sharedPrefetcher }
 
-    private static func cacheOptions(for cache: CacheOption?) -> ImageRequest.Options {
-        switch cache {
+    /// The `URL` for a `url` string as the JS API accepts it: a URL with a
+    /// scheme (`https://`, `file://`, …), or a plain absolute file-system
+    /// path — the form react-native-nitro-image's `saveToTemporaryFileAsync`
+    /// returns — which becomes a `file://` URL.
+    static func url(from string: String) -> URL? {
+        if string.hasPrefix("/") {
+            return URL(fileURLWithPath: string)
+        }
+        return URL(string: string)
+    }
+
+    /// Whether `url` is fetched over the network, as opposed to read from the
+    /// file system (`file://`, incl. `require()`d assets in release builds)
+    /// or decoded inline (`data:`).
+    static func isNetworkURL(_ url: URL) -> Bool {
+        switch url.scheme?.lowercased() {
+        case "http", "https": true
+        default: false
+        }
+    }
+
+    private static func cacheOptions(for cache: CacheOption?, url: URL) -> ImageRequest.Options {
+        var options: ImageRequest.Options = switch cache {
         case .memory: [.disableDiskCache]
         case .disk:   [.disableMemoryCache]
         case .none?:  [.disableDiskCache, .disableMemoryCache]
         default:      []
         }
+        // A local source has nothing to gain from the disk cache: the
+        // pipeline's `.storeAll` policy would copy the file's bytes into the
+        // data cache next to the original. Keep local images in memory only —
+        // Coil does the same on Android, where only network fetches are
+        // written to disk — so `cache: 'disk'` on a local URL means no cache.
+        if !isNetworkURL(url) {
+            options.insert(.disableDiskCache)
+        }
+        return options
     }
 
     /// The processor that bakes `cornerRadius` into the bitmap, or `nil` when
@@ -168,26 +198,46 @@ class HybridNitroImagePipeline: HybridNitroImagePipelineSpec {
         }
     }
 
-    /// The target size in pixels, or `nil` when no (valid) resize was requested.
-    private static func resizeSize(for options: Options?) -> CGSize? {
+    /// The requested resize, or `nil` when there is no (valid) one.
+    private static func requestedResize(for options: Options?) -> ResizeOptions? {
         guard let resize = options?.resize, resize.width > 0, resize.height > 0 else {
             return nil
         }
-        return CGSize(width: resize.width, height: resize.height)
+        return resize
+    }
+
+    private static func fit(of resize: ResizeOptions) -> ResizeFit { resize.fit ?? .cover }
+
+    private static func allowsUpscale(_ resize: ResizeOptions) -> Bool { resize.allowUpscale ?? true }
+
+    /// The resize as it behaved before `fit` existed — aspect-fill, crop,
+    /// upscale — which keeps Nuke's own processor (and its cache keys).
+    private static func isDefaultFit(_ resize: ResizeOptions) -> Bool {
+        fit(of: resize) == .cover && allowsUpscale(resize)
     }
 
     private static func processors(for options: Options?) -> [any ImageProcessing] {
         var processors: [any ImageProcessing] = []
         // Resize first: blur sigma and corner radii are defined in pixels
         // of the bitmap they run on, so they must see the final size.
-        if let size = resizeSize(for: options) {
-            processors.append(ImageProcessors.Resize(
-                size: size,
-                unit: .pixels,
-                contentMode: .aspectFill,
-                crop: true,
-                upscale: true
-            ))
+        if let resize = requestedResize(for: options) {
+            let size = CGSize(width: resize.width, height: resize.height)
+            if isDefaultFit(resize) {
+                processors.append(ImageProcessors.Resize(
+                    size: size,
+                    unit: .pixels,
+                    contentMode: .aspectFill,
+                    crop: true,
+                    upscale: true
+                ))
+            } else {
+                processors.append(FitResizeProcessor(
+                    width: size.width,
+                    height: size.height,
+                    fit: fit(of: resize),
+                    allowUpscale: allowsUpscale(resize)
+                ))
+            }
         }
         if let blur = options?.blur, blur > 0 {
             processors.append(GaussianBlurProcessor(sigma: blur))
@@ -205,19 +255,25 @@ class HybridNitroImagePipeline: HybridNitroImagePipelineSpec {
         var imgRequest = ImageRequest(
             url: url,
             processors: processors(for: options),
-            options: cacheOptions(for: options?.cache)
+            options: cacheOptions(for: options?.cache, url: url)
         )
         // With a target size known, decode near it (aspect-fill, so the
         // decoded image always covers the target) instead of at full
         // resolution — a 48 MP photo displayed as a 300 pt card would
         // otherwise decompress to ~190 MB before Resize shrinks it.
         // Matches Android, where the request's size() drives subsampling;
-        // the exact size and crop still come from the Resize processor.
-        if let size = resizeSize(for: options) {
+        // the exact size and crop still come from the resize processor.
+        // `contain` decodes aspect-fit: its output follows the smaller scale,
+        // and an aspect-fill decode of a wide panorama into a small box would
+        // be near the source's full width before the processor shrinks it.
+        // Android's Scale.FIT subsampling bounds the decode the same way.
+        // `center` never scales, so it must see the source's own pixels: a
+        // subsampled decode would crop the wrong ones.
+        if let resize = requestedResize(for: options), fit(of: resize) != .center {
             imgRequest.thumbnail = ImageRequest.ThumbnailOptions(
-                size: size,
+                size: CGSize(width: resize.width, height: resize.height),
                 unit: .pixels,
-                contentMode: .aspectFill
+                contentMode: fit(of: resize) == .contain ? .aspectFit : .aspectFill
             )
         }
         return imgRequest
@@ -225,7 +281,7 @@ class HybridNitroImagePipeline: HybridNitroImagePipelineSpec {
 
     func loadImage(url: String, options: Options?) throws -> Promise<any HybridImageSpec> {
         return Promise.async {
-            guard let imageUrl = URL(string: url) else {
+            guard let imageUrl = Self.url(from: url) else {
                 throw RuntimeError.error(withMessage: "Invalid URL: \(url)")
             }
 
@@ -243,21 +299,29 @@ class HybridNitroImagePipeline: HybridNitroImagePipelineSpec {
 
     func preLoadImage(url: String) throws -> Promise<Void> {
         return Promise.async {
-            guard let imageUrl = URL(string: url) else {
+            guard let imageUrl = Self.url(from: url) else {
                 throw RuntimeError.error(withMessage: "Invalid URL: \(url)")
             }
-
-            self.prefetcher.startPrefetching(with: [imageUrl])
+            self.prefetch([imageUrl])
         }
     }
 
     func preLoadImages(urls: [String]) throws -> Promise<Void> {
         return Promise.async {
-            let imageUrls = urls.compactMap { URL(string: $0) }
-            self.prefetcher.startPrefetching(with: imageUrls)
+            self.prefetch(urls.compactMap { Self.url(from: $0) })
         }
     }
 
+    /// Prefetching warms the disk cache with a download; a local source has no
+    /// download to warm it with, so those are a no-op (as on Android, where
+    /// Coil never writes non-network sources to disk) rather than a copy of
+    /// the file into the data cache.
+    private func prefetch(_ urls: [URL]) {
+        let networkUrls = urls.filter(Self.isNetworkURL)
+        guard !networkUrls.isEmpty else { return }
+        prefetcher.startPrefetching(with: networkUrls)
+    }
+
     func setMemoryCacheLimit(bytes: Double) throws {
         guard bytes >= 0, bytes.isFinite else {
             throw RuntimeError.error(