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

package/ios/GaussianBlur.swift

@@ -29,25 +29,30 @@ enum GaussianBlur {
         // Normalise to premultiplied ARGB8888 — vImageBoxConvolve_ARGB8888
         // needs four 8-bit channels, and premultiplied alpha is what keeps
         // transparent edges from bleeding dark halos into the blur.
+        let colorSpace = CGColorSpaceCreateDeviceRGB()
+        let bitmapInfo = CGBitmapInfo(rawValue: CGImageAlphaInfo.premultipliedFirst.rawValue)
         guard var format = vImage_CGImageFormat(
             bitsPerComponent: 8,
             bitsPerPixel: 32,
-            colorSpace: CGColorSpaceCreateDeviceRGB(),
-            bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.premultipliedFirst.rawValue),
+            colorSpace: colorSpace,
+            bitmapInfo: bitmapInfo,
             renderingIntent: .defaultIntent
         ) else { return nil }
 
+        // Both buffers are freed on exit, except the one handed over to the
+        // result CGImage below (`handedOver`), which is freed with the image.
+        var handedOver: UnsafeMutableRawPointer?
         var source = vImage_Buffer()
         guard vImageBuffer_InitWithCGImage(
             &source, &format, nil, cgImage, vImage_Flags(kvImageNoFlags)
         ) == kvImageNoError else { return nil }
-        defer { free(source.data) }
+        defer { if source.data != handedOver { free(source.data) } }
 
         var scratch = vImage_Buffer()
         guard vImageBuffer_Init(
             &scratch, source.height, source.width, 32, vImage_Flags(kvImageNoFlags)
         ) == kvImageNoError else { return nil }
-        defer { free(scratch.data) }
+        defer { if scratch.data != handedOver { free(scratch.data) } }
 
         // kvImageEdgeExtend clamps at the borders instead of sampling
         // transparent black, so the image keeps its edges instead of fading
@@ -75,12 +80,46 @@ enum GaussianBlur {
             swap(&input, &output)
         }
 
-        var error = vImage_Error(kvImageNoError)
-        guard let blurred = vImageCreateCGImageFromBuffer(
-            &input, &format, nil, nil, vImage_Flags(kvImageNoFlags), &error
-        )?.takeRetainedValue(), error == kvImageNoError else { return nil }
+        // Ownership of the result buffer moves to the CGImage (no copy);
+        // `handedOver` keeps the exits above from freeing it a second time.
+        return makeImage(from: input, colorSpace: colorSpace, bitmapInfo: bitmapInfo, handedOver: &handedOver)
+    }
+
+    /// Wraps `buffer` in a CGImage instead of copying it (one full-bitmap
+    /// memcpy less per blur). Ownership is explicit: once the data provider
+    /// exists, it frees the buffer — together with the image, or right away
+    /// if creating the image fails and the provider is released — so
+    /// `handedOver` is set to the buffer's data as soon as that is the case.
+    /// (vImageCreateCGImageFromBuffer with kvImageNoAllocate would do the
+    /// same, but leaves unspecified whether its free callback runs when the
+    /// call fails.)
+    private static func makeImage(
+        from buffer: vImage_Buffer,
+        colorSpace: CGColorSpace,
+        bitmapInfo: CGBitmapInfo,
+        handedOver: inout UnsafeMutableRawPointer?
+    ) -> CGImage? {
+        guard let provider = CGDataProvider(
+            dataInfo: nil,
+            data: buffer.data,
+            size: buffer.rowBytes * Int(buffer.height),
+            releaseData: { _, data, _ in free(UnsafeMutableRawPointer(mutating: data)) }
+        ) else { return nil }
+        handedOver = buffer.data
 
-        return blurred
+        return CGImage(
+            width: Int(buffer.width),
+            height: Int(buffer.height),
+            bitsPerComponent: 8,
+            bitsPerPixel: 32,
+            bytesPerRow: buffer.rowBytes,
+            space: colorSpace,
+            bitmapInfo: bitmapInfo,
+            provider: provider,
+            decode: nil,
+            shouldInterpolate: true,
+            intent: .defaultIntent
+        )
     }
 
     /// Widths for the three box-blur passes that approximate a Gaussian of

package/ios/HybridNitroImagePipeline.swift

@@ -12,7 +12,7 @@ import Nuke
 
 import UIKit
 
-private class HybridImage: HybridImageSpec, NativeImage {
+class HybridImage: HybridImageSpec, NativeImage {
     let uiImage: UIImage
 
     // PNG encoding is expensive; encode once and reuse for both
@@ -21,26 +21,22 @@ private class HybridImage: HybridImageSpec, NativeImage {
     // doesn't pin its encoding forever.
     private let pngLock = NSLock()
     private var cachedPngData: Data?
+    // Registered only once there is encoded data to drop: most images are
+    // only ever displayed, and an observer per image is wasted work in a
+    // list of hundreds. Guarded by `pngLock` like the data it protects.
     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)
+        pngLock.lock()
+        let observer = memoryWarningObserver
+        pngLock.unlock()
+        if let observer {
+            NotificationCenter.default.removeObserver(observer)
         }
     }
 
@@ -52,6 +48,18 @@ private class HybridImage: HybridImageSpec, NativeImage {
         }
         let data = uiImage.pngData()
         cachedPngData = data
+        if data != nil, memoryWarningObserver == nil {
+            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()
+            }
+        }
         return data
     }
 
@@ -89,7 +97,7 @@ class HybridNitroImagePipeline: HybridNitroImagePipelineSpec {
     // 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 = {
+    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
@@ -105,6 +113,15 @@ class HybridNitroImagePipeline: HybridNitroImagePipelineSpec {
         configuration.imageCache = ImageCache(
             costLimit: min(ImageCache.defaultCostLimit, 128 * 1024 * 1024)
         )
+        // Nuke decodes on a serial queue by default, so a screenful of new
+        // list cells is decoded one image at a time however many cores the
+        // device has. Decode in parallel instead — capped so a burst of
+        // full-resolution decodes (no `resize`) can't multiply peak memory
+        // by the core count. Processing stays at Nuke's default of 2: the
+        // blur allocates several full-size buffers per image.
+        configuration.imageDecodingQueue.maxConcurrentOperationCount = min(
+            4, max(1, ProcessInfo.processInfo.activeProcessorCount)
+        )
         return ImagePipeline(configuration: configuration)
     }()
 
@@ -181,36 +198,49 @@ class HybridNitroImagePipeline: HybridNitroImagePipelineSpec {
         return processors
     }
 
+    /// The `ImageRequest` for `url` with `options` applied — shared by
+    /// `loadImage` and `PipelineImageLoader` so both hit the same caches with
+    /// identical cache keys.
+    static func makeRequest(url: URL, options: Options?) -> ImageRequest {
+        var imgRequest = ImageRequest(
+            url: url,
+            processors: processors(for: options),
+            options: cacheOptions(for: options?.cache)
+        )
+        // 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) {
+            imgRequest.thumbnail = ImageRequest.ThumbnailOptions(
+                size: size,
+                unit: .pixels,
+                contentMode: .aspectFill
+            )
+        }
+        return imgRequest
+    }
+
     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)")
             }
 
-            var imgRequest = ImageRequest(
-                url: imageUrl,
-                processors: Self.processors(for: options),
-                options: Self.cacheOptions(for: options?.cache)
-            )
-            // 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 = Self.resizeSize(for: options) {
-                imgRequest.thumbnail = ImageRequest.ThumbnailOptions(
-                    size: size,
-                    unit: .pixels,
-                    contentMode: .aspectFill
-                )
-            }
-
+            let imgRequest = Self.makeRequest(url: imageUrl, options: options)
             let image = try await self.pipeline.image(for: imgRequest)
             return HybridImage(uiImage: image)
         }
     }
 
+    func createImageLoader(url: String, options: ViewOptions?) throws -> any HybridImageLoaderSpec {
+        // An unparseable URL fails at load time, not here — matching Android,
+        // where Coil validates the URL only when the request runs.
+        return PipelineImageLoader(url: url, options: options)
+    }
+
     func preLoadImage(url: String) throws -> Promise<Void> {
         return Promise.async {
             guard let imageUrl = URL(string: url) else {
@@ -228,6 +258,22 @@ class HybridNitroImagePipeline: HybridNitroImagePipelineSpec {
         }
     }
 
+    func setMemoryCacheLimit(bytes: Double) throws {
+        guard bytes >= 0, bytes.isFinite else {
+            throw RuntimeError.error(
+                withMessage: "Memory cache limit must be a non-negative, finite number of bytes (got \(bytes))"
+            )
+        }
+        guard let cache = pipeline.configuration.imageCache as? ImageCache else { return }
+        // Double(Int.max) rounds up to 2^63, so Int(_:) of the clamped value
+        // would trap; branch instead of min-ing.
+        let limit = bytes >= Double(Int.max) ? Int.max : Int(bytes)
+        cache.costLimit = limit
+        // Setting the limit only affects future inserts; evict down to it now
+        // so the call frees memory immediately.
+        cache.trim(toCost: limit)
+    }
+
     func clearCache() throws -> Promise<Void> {
         return Promise.async {
             self.pipeline.cache.removeAll()

package/ios/PipelineImageLoader.swift

@@ -0,0 +1,195 @@
+//
+//  PipelineImageLoader.swift
+//  NitroImagePipeline
+//
+
+import Foundation
+import NitroImage
+import NitroModules
+import Nuke
+import UIKit
+
+/// An `ImageLoader` (react-native-nitro-image) backed by the shared pipeline.
+///
+/// `<NativeNitroImage image={loader} />` drives it entirely natively: the view
+/// calls `requestImage` when it attaches to a window and `dropImage` when it
+/// detaches. The load runs at the view's laid-out size (× screen scale) with
+/// no JS round trips, and detaching cancels the request and releases the
+/// bitmap — the decoded image stays in the shared memory/disk caches, so
+/// re-attaching (list recycling) is instant.
+///
+/// `ViewOptions` values are in points; this class converts them to the
+/// pixel-based `Options` of the shared request builder using the view's
+/// display scale, so cache keys match an equivalent `loadImage` call.
+class PipelineImageLoader: HybridImageLoaderSpec {
+    private let url: String
+    private let options: ViewOptions?
+
+    // Per-view in-flight work, keyed by the view's identity, so a loader
+    // shared between several views cancels only the right request. Confined
+    // to the main thread — every access happens inside a main-queue block.
+    private var tasks: [ObjectIdentifier: Task<Void, Never>] = [:]
+    private var pendingLayouts: [ObjectIdentifier: NSKeyValueObservation] = [:]
+
+    init(url: String, options: ViewOptions?) {
+        self.url = url
+        self.options = options
+    }
+
+    private var pipeline: ImagePipeline { HybridNitroImagePipeline.sharedPipeline }
+
+    /// visionOS has no `UIScreen.main`; there UIKit reports 2.0 as the
+    /// display scale of trait environments.
+    private static var fallbackScale: CGFloat {
+        #if os(visionOS)
+        return 2.0
+        #else
+        return UIScreen.main.scale
+        #endif
+    }
+
+    private static func displayScale(of view: UIView) -> CGFloat {
+        let scale = view.traitCollection.displayScale
+        // 0 means "unspecified" (view not in a hierarchy yet).
+        return scale > 0 ? scale : fallbackScale
+    }
+
+    /// The point-based `ViewOptions` as pixel-based `Options`, resolved
+    /// against `scale` and the target size in pixels.
+    private func pixelOptions(scale: CGFloat, sizePx: CGSize?) -> Options {
+        let cornerRadius = options?.cornerRadius.map { radius -> Variant_Double_CornerRadii in
+            switch radius {
+            case .first(let uniform):
+                return .first(uniform * scale)
+            case .second(let radii):
+                return .second(CornerRadii(
+                    topLeft: radii.topLeft.map { $0 * scale },
+                    topRight: radii.topRight.map { $0 * scale },
+                    bottomLeft: radii.bottomLeft.map { $0 * scale },
+                    bottomRight: radii.bottomRight.map { $0 * scale }
+                ))
+            }
+        }
+        return Options(
+            blur: options?.blur.map { $0 * scale },
+            cache: options?.cache,
+            cornerRadius: cornerRadius,
+            resize: sizePx.map { ResizeOptions(width: Double($0.width), height: Double($0.height)) }
+        )
+    }
+
+    /// An explicit `resize` override (pixels), when set and valid.
+    private var explicitResize: CGSize? {
+        guard let resize = options?.resize, resize.width > 0, resize.height > 0 else {
+            return nil
+        }
+        return CGSize(width: resize.width, height: resize.height)
+    }
+
+    // MARK: - ImageLoader
+
+    func loadImage() throws -> Promise<any HybridImageSpec> {
+        return Promise.async {
+            guard let imageUrl = URL(string: self.url) else {
+                throw RuntimeError.error(withMessage: "Invalid URL: \(self.url)")
+            }
+            // No view to measure here: use the explicit resize if given, and
+            // the main screen's scale for the point-based options.
+            let scale = await MainActor.run { Self.fallbackScale }
+            let request = HybridNitroImagePipeline.makeRequest(
+                url: imageUrl,
+                options: self.pixelOptions(scale: scale, sizePx: self.explicitResize)
+            )
+            let image = try await self.pipeline.image(for: request)
+            return HybridImage(uiImage: image)
+        }
+    }
+
+    func requestImage(forView view: any HybridNitroImageViewSpec) throws {
+        guard let nativeView = view as? NativeImageView else { return }
+        let key = ObjectIdentifier(view)
+        // Always hop (asynchronously) to main: `requestImage` fires while the
+        // view is being mounted, and only after the current mounting
+        // transaction finishes is its final frame guaranteed to be set.
+        DispatchQueue.main.async {
+            self.load(into: nativeView.imageView, key: key)
+        }
+    }
+
+    func dropImage(forView view: any HybridNitroImageViewSpec) throws {
+        guard let nativeView = view as? NativeImageView else { return }
+        let key = ObjectIdentifier(view)
+        // Same queue as `requestImage`, so rapid attach/detach sequences
+        // (list recycling) replay in call order.
+        DispatchQueue.main.async {
+            self.cancel(key: key)
+            nativeView.imageView.image = nil
+        }
+    }
+
+    // MARK: - Main-thread loading
+
+    private func cancel(key: ObjectIdentifier) {
+        tasks[key]?.cancel()
+        tasks[key] = nil
+        // Releasing the observation invalidates it.
+        pendingLayouts[key] = nil
+    }
+
+    private func load(into imageView: UIImageView, key: ObjectIdentifier) {
+        cancel(key: key)
+
+        if let sizePx = explicitResize {
+            start(into: imageView, key: key, sizePx: sizePx)
+            return
+        }
+
+        let bounds = imageView.bounds.size
+        if bounds.width > 0, bounds.height > 0 {
+            let scale = Self.displayScale(of: imageView)
+            start(into: imageView, key: key, sizePx: CGSize(
+                width: bounds.width * scale,
+                height: bounds.height * scale
+            ))
+        } else {
+            // Mounted at zero size (e.g. a flex child before its container
+            // grows): wait for real bounds. Observed on the layer — CALayer
+            // properties are KVO-compliant, UIView's are not.
+            pendingLayouts[key] = imageView.layer.observe(\.bounds) { [weak self, weak imageView] layer, _ in
+                guard layer.bounds.width > 0, layer.bounds.height > 0 else { return }
+                DispatchQueue.main.async {
+                    guard let self, let imageView else { return }
+                    guard self.pendingLayouts[key] != nil else { return }
+                    self.load(into: imageView, key: key)
+                }
+            }
+        }
+    }
+
+    private func start(into imageView: UIImageView, key: ObjectIdentifier, sizePx: CGSize) {
+        guard let imageUrl = URL(string: url) else { return }
+        let scale = Self.displayScale(of: imageView)
+        let request = HybridNitroImagePipeline.makeRequest(
+            url: imageUrl,
+            options: pixelOptions(scale: scale, sizePx: sizePx)
+        )
+        let pipeline = self.pipeline
+        // A memory-cache hit is served synchronously. Going through
+        // `pipeline.image(for:)` would resume on Nuke's queue and then hop
+        // back to the main actor, so a recycled cell (whose image `dropImage`
+        // just cleared) would show empty for a frame or two even though the
+        // bitmap is already in memory. The subscript honours the request's
+        // `.disableMemoryCacheReads`, so `cache: 'disk'`/`'none'` still miss.
+        if !request.options.contains(.disableMemoryCacheReads), let cached = pipeline.cache[request] {
+            imageView.image = cached.image
+            return
+        }
+        // Cancelling the Task cancels Nuke's request; a finished task stays in
+        // the map (cancelling it is a no-op) until `cancel` replaces it.
+        tasks[key] = Task { @MainActor [weak imageView] in
+            guard let image = try? await pipeline.image(for: request) else { return }
+            guard !Task.isCancelled else { return }
+            imageView?.image = image
+        }
+    }
+}

package/ios/RoundedCornersProcessor.swift

@@ -48,6 +48,11 @@ struct RoundedCornersProcessor: ImageProcessing {
         let format = UIGraphicsImageRendererFormat()
         format.scale = image.scale
         format.opaque = false
+        // `.automatic` picks the extended (16-bit-per-channel) range on
+        // wide-gamut displays, which doubles the bytes of this bitmap — the
+        // one that ends up in the memory cache and on screen — for an 8-bit
+        // sRGB source that gains nothing from it.
+        format.preferredRange = .standard
 
         let rect = CGRect(origin: .zero, size: size)
         return UIGraphicsImageRenderer(size: size, format: format).image { context in

package/lib/commonjs/NativePipelineImage.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NativePipelineImage = void 0;
+var _react = require("react");
+var _reactNativeNitroImage = require("react-native-nitro-image");
+var _resizeForStyle = require("./resizeForStyle");
+var _usePipelineImageLoader = require("./usePipelineImageLoader");
+var _jsxRuntime = require("react/jsx-runtime");
+/**
+ * The instance `<NativePipelineImage>` exposes through its `ref` — the
+ * underlying `NativeNitroImage` host view, with the usual native-view
+ * methods (`measure`, …).
+ */
+
+/**
+ * The fully native-driven variant of `PipelineImage`: after the first render
+ * there is **zero JS work per image**. The native view starts the request
+ * when it attaches to the window — at its own laid-out size, so nothing
+ * waits for an `onLayout` round trip — and cancels it (releasing the bitmap)
+ * when it detaches, which makes off-screen list cells free. Loads go through
+ * the same pipeline and caches as `useImage`/`preLoadImage`.
+ *
+ * Compared to `PipelineImage`:
+ * - No `onLoad`/`onError` callbacks — the loaded `Image` never crosses into
+ *   JS. Use `PipelineImage` (or `useImage`) when you need them.
+ * - The bitmap is loaded once at the size the view first has; if the view is
+ *   resized later, the bitmap scales with it instead of reloading.
+ * @example
+ * ```tsx
+ * <NativePipelineImage
+ *   url="https://example.com/photo.jpg"
+ *   style={{ width: 300, height: 200, borderRadius: 24 }}
+ *   blur={4}
+ * />
+ * ```
+ */
+const NativePipelineImage = exports.NativePipelineImage = /*#__PURE__*/(0, _react.forwardRef)(function NativePipelineImage({
+  url,
+  blur,
+  cornerRadius,
+  cache,
+  resize,
+  style,
+  ...viewProps
+}, ref) {
+  // Same precedence as PipelineImage: an explicit prop wins over style.
+  const effectiveCornerRadius = cornerRadius ?? (0, _resizeForStyle.cornerRadiusForStyle)(style);
+  const loader = (0, _usePipelineImageLoader.usePipelineImageLoader)(url, {
+    blur,
+    cornerRadius: effectiveCornerRadius,
+    cache,
+    resize
+  });
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNativeNitroImage.NativeNitroImage
+  // Before the spread so a caller-provided recyclingKey wins.
+  , {
+    recyclingKey: url,
+    ...viewProps,
+    ref: ref,
+    style: style,
+    image: loader
+  });
+});
+
+// Reanimated and DevTools read the display name; the forwardRef wrapper
+// would otherwise report as anonymous.
+NativePipelineImage.displayName = 'NativePipelineImage';
+//# sourceMappingURL=NativePipelineImage.js.map

package/lib/commonjs/NativePipelineImage.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","_reactNativeNitroImage","_resizeForStyle","_usePipelineImageLoader","_jsxRuntime","NativePipelineImage","exports","forwardRef","url","blur","cornerRadius","cache","resize","style","viewProps","ref","effectiveCornerRadius","cornerRadiusForStyle","loader","usePipelineImageLoader","jsx","NativeNitroImage","recyclingKey","image","displayName"],"sourceRoot":"../../src","sources":["NativePipelineImage.tsx"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,sBAAA,GAAAD,OAAA;AAEA,IAAAE,eAAA,GAAAF,OAAA;AAMA,IAAAG,uBAAA,GAAAH,OAAA;AAAkE,IAAAI,WAAA,GAAAJ,OAAA;AAKlE;AACA;AACA;AACA;AACA;;AA+BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMK,mBAAmB,GAAAC,OAAA,CAAAD,mBAAA,gBAAG,IAAAE,iBAAU,EAG3C,SAASF,mBAAmBA,CAC5B;EAAEG,GAAG;EAAEC,IAAI;EAAEC,YAAY;EAAEC,KAAK;EAAEC,MAAM;EAAEC,KAAK;EAAE,GAAGC;AAAU,CAAC,EAC/DC,GAAG,EACH;EACA;EACA,MAAMC,qBAAqB,GAAGN,YAAY,IAAI,IAAAO,oCAAoB,EAACJ,KAAK,CAAC;EACzE,MAAMK,MAAM,GAAG,IAAAC,8CAAsB,EAACX,GAAG,EAAE;IACzCC,IAAI;IACJC,YAAY,EAAEM,qBAAqB;IACnCL,KAAK;IACLC;EACF,CAAC,CAAC;EAEF,oBACE,IAAAR,WAAA,CAAAgB,GAAA,EAACnB,sBAAA,CAAAoB;EACC;EAAA;IACAC,YAAY,EAAEd,GAAI;IAAA,GACdM,SAAS;IACbC,GAAG,EAAEA,GAAI;IACTF,KAAK,EAAEA,KAAM;IACbU,KAAK,EAAEL;EAAO,CACf,CAAC;AAEN,CAAC,CAAC;;AAEF;AACA;AACAb,mBAAmB,CAACmB,WAAW,GAAG,qBAAqB","ignoreList":[]}

package/lib/commonjs/index.js

@@ -3,6 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "NativePipelineImage", {
+  enumerable: true,
+  get: function () {
+    return _NativePipelineImage.NativePipelineImage;
+  }
+});
 Object.defineProperty(exports, "NitroImagePipeline", {
   enumerable: true,
   get: function () {
@@ -39,8 +45,16 @@ Object.defineProperty(exports, "useImage", {
     return _useImage.useImage;
   }
 });
+Object.defineProperty(exports, "usePipelineImageLoader", {
+  enumerable: true,
+  get: function () {
+    return _usePipelineImageLoader.usePipelineImageLoader;
+  }
+});
+var _NativePipelineImage = require("./NativePipelineImage");
 var _NitroImagePipeline = require("./NitroImagePipeline");
 var _PipelineImage = require("./PipelineImage");
 var _resizeForStyle = require("./resizeForStyle");
 var _useImage = require("./useImage");
+var _usePipelineImageLoader = require("./usePipelineImageLoader");
 //# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_NitroImagePipeline","require","_PipelineImage","_resizeForStyle","_useImage"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,mBAAA,GAAAC,OAAA;AACA,IAAAC,cAAA,GAAAD,OAAA;AAKA,IAAAE,eAAA,GAAAF,OAAA;AAWA,IAAAG,SAAA,GAAAH,OAAA","ignoreList":[]}
+{"version":3,"names":["_NativePipelineImage","require","_NitroImagePipeline","_PipelineImage","_resizeForStyle","_useImage","_usePipelineImageLoader"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,oBAAA,GAAAC,OAAA;AAKA,IAAAC,mBAAA,GAAAD,OAAA;AACA,IAAAE,cAAA,GAAAF,OAAA;AAKA,IAAAG,eAAA,GAAAH,OAAA;AAYA,IAAAI,SAAA,GAAAJ,OAAA;AACA,IAAAK,uBAAA,GAAAL,OAAA","ignoreList":[]}

package/lib/commonjs/usePipelineImageLoader.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePipelineImageLoader = usePipelineImageLoader;
+var _react = require("react");
+var _NitroImagePipeline = require("./NitroImagePipeline");
+/**
+ * Creates (and memoizes) an {@linkcode ImageLoader} for `url` to pass to
+ * `<NativeNitroImage image={...} />`. The view drives it entirely natively:
+ * the request starts when the view attaches — at the view's laid-out size,
+ * with no JS round trips — and is cancelled when it detaches. See
+ * {@linkcode NitroImagePipeline.createImageLoader}.
+ *
+ * `blur`/`cornerRadius` are in **points** (unlike `useImage`, where they are
+ * bitmap pixels); the screen scale is applied natively. Inline object
+ * literals are fine — options are compared by value, not identity.
+ */
+function usePipelineImageLoader(url, options) {
+  // Split the options into primitives (like useImage does) so an inline
+  // literal — a new identity every render — doesn't recreate the loader;
+  // recreating it would re-trigger the native load.
+  const blur = options?.blur;
+  const cache = options?.cache;
+  const cornerRadius = options?.cornerRadius;
+  const isUniformRadius = typeof cornerRadius === 'number';
+  const uniformRadius = isUniformRadius ? cornerRadius : 0;
+  const hasCornerObject = !isUniformRadius && cornerRadius !== undefined;
+  const {
+    topLeft = 0,
+    topRight = 0,
+    bottomLeft = 0,
+    bottomRight = 0
+  } = isUniformRadius || cornerRadius === undefined ? {} : cornerRadius;
+  const resizeWidth = options?.resize?.width;
+  const resizeHeight = options?.resize?.height;
+  return (0, _react.useMemo)(() => {
+    const cornerRadiusOption = isUniformRadius ? uniformRadius : hasCornerObject ? {
+      topLeft,
+      topRight,
+      bottomLeft,
+      bottomRight
+    } : undefined;
+    const stableOptions = {
+      blur,
+      cache,
+      cornerRadius: cornerRadiusOption,
+      resize: resizeWidth !== undefined && resizeHeight !== undefined ? {
+        width: resizeWidth,
+        height: resizeHeight
+      } : undefined
+    };
+    const loader = _NitroImagePipeline.NitroImagePipeline.createImageLoader(url, stableOptions);
+    // `NativeNitroImage` needs a way to tell two loader instances apart when
+    // diffing its `image` prop; tag the loader with what it will load (the
+    // same convention react-native-nitro-image's own loaders use).
+    Object.defineProperty(loader, '__source', {
+      enumerable: true,
+      configurable: true,
+      value: {
+        url,
+        options: stableOptions
+      }
+    });
+    return loader;
+  }, [url, blur, cache, isUniformRadius, uniformRadius, hasCornerObject, topLeft, topRight, bottomLeft, bottomRight, resizeWidth, resizeHeight]);
+}
+//# sourceMappingURL=usePipelineImageLoader.js.map

package/lib/commonjs/usePipelineImageLoader.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","_NitroImagePipeline","usePipelineImageLoader","url","options","blur","cache","cornerRadius","isUniformRadius","uniformRadius","hasCornerObject","undefined","topLeft","topRight","bottomLeft","bottomRight","resizeWidth","resize","width","resizeHeight","height","useMemo","cornerRadiusOption","stableOptions","loader","NitroImagePipeline","createImageLoader","Object","defineProperty","enumerable","configurable","value"],"sourceRoot":"../../src","sources":["usePipelineImageLoader.ts"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAGA,IAAAC,mBAAA,GAAAD,OAAA;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASE,sBAAsBA,CACpCC,GAAW,EACXC,OAAqB,EACR;EACb;EACA;EACA;EACA,MAAMC,IAAI,GAAGD,OAAO,EAAEC,IAAI;EAC1B,MAAMC,KAAK,GAAGF,OAAO,EAAEE,KAAK;EAC5B,MAAMC,YAAY,GAAGH,OAAO,EAAEG,YAAY;EAC1C,MAAMC,eAAe,GAAG,OAAOD,YAAY,KAAK,QAAQ;EACxD,MAAME,aAAa,GAAGD,eAAe,GAAGD,YAAY,GAAG,CAAC;EACxD,MAAMG,eAAe,GAAG,CAACF,eAAe,IAAID,YAAY,KAAKI,SAAS;EACtE,MAAM;IACJC,OAAO,GAAG,CAAC;IACXC,QAAQ,GAAG,CAAC;IACZC,UAAU,GAAG,CAAC;IACdC,WAAW,GAAG;EAChB,CAAC,GAAGP,eAAe,IAAID,YAAY,KAAKI,SAAS,GAAG,CAAC,CAAC,GAAGJ,YAAY;EACrE,MAAMS,WAAW,GAAGZ,OAAO,EAAEa,MAAM,EAAEC,KAAK;EAC1C,MAAMC,YAAY,GAAGf,OAAO,EAAEa,MAAM,EAAEG,MAAM;EAE5C,OAAO,IAAAC,cAAO,EAAC,MAAM;IACnB,MAAMC,kBAAoD,GAAGd,eAAe,GACxEC,aAAa,GACbC,eAAe,GACb;MAAEE,OAAO;MAAEC,QAAQ;MAAEC,UAAU;MAAEC;IAAY,CAAC,GAC9CJ,SAAS;IACf,MAAMY,aAA0B,GAAG;MACjClB,IAAI;MACJC,KAAK;MACLC,YAAY,EAAEe,kBAAkB;MAChCL,MAAM,EACJD,WAAW,KAAKL,SAAS,IAAIQ,YAAY,KAAKR,SAAS,GACnD;QAAEO,KAAK,EAAEF,WAAW;QAAEI,MAAM,EAAED;MAAa,CAAC,GAC5CR;IACR,CAAC;IACD,MAAMa,MAAM,GAAGC,sCAAkB,CAACC,iBAAiB,CAACvB,GAAG,EAAEoB,aAAa,CAAC;IACvE;IACA;IACA;IACAI,MAAM,CAACC,cAAc,CAACJ,MAAM,EAAE,UAAU,EAAE;MACxCK,UAAU,EAAE,IAAI;MAChBC,YAAY,EAAE,IAAI;MAClBC,KAAK,EAAE;QAAE5B,GAAG;QAAEC,OAAO,EAAEmB;MAAc;IACvC,CAAC,CAAC;IACF,OAAOC,MAAM;EACf,CAAC,EAAE,CACDrB,GAAG,EACHE,IAAI,EACJC,KAAK,EACLE,eAAe,EACfC,aAAa,EACbC,eAAe,EACfE,OAAO,EACPC,QAAQ,EACRC,UAAU,EACVC,WAAW,EACXC,WAAW,EACXG,YAAY,CACb,CAAC;AACJ","ignoreList":[]}