react-native-nitro-image-pipeline 1.4.0 → 1.6.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)
     }()
 
@@ -121,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
@@ -181,53 +228,74 @@ 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, 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) {
+            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 {
+            guard let imageUrl = Self.url(from: 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 {
+            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(

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 = HybridNitroImagePipeline.url(from: 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 = HybridNitroImagePipeline.url(from: 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,72 @@
+"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 _resolveImageSource = require("./resolveImageSource");
+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: (0, _resolveImageSource.recyclingKeyFor)(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","_resolveImageSource","_usePipelineImageLoader","_jsxRuntime","NativePipelineImage","exports","forwardRef","url","blur","cornerRadius","cache","resize","style","viewProps","ref","effectiveCornerRadius","cornerRadiusForStyle","loader","usePipelineImageLoader","jsx","NativeNitroImage","recyclingKey","recyclingKeyFor","image","displayName"],"sourceRoot":"../../src","sources":["NativePipelineImage.tsx"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,sBAAA,GAAAD,OAAA;AAEA,IAAAE,eAAA,GAAAF,OAAA;AACA,IAAAG,mBAAA,GAAAH,OAAA;AAMA,IAAAI,uBAAA,GAAAJ,OAAA;AAAkE,IAAAK,WAAA,GAAAL,OAAA;AAKlE;AACA;AACA;AACA;AACA;;AAmCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMM,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,EAACpB,sBAAA,CAAAqB;EACC;EAAA;IACAC,YAAY,EAAE,IAAAC,mCAAe,EAACf,GAAG,CAAE;IAAA,GAC/BM,SAAS;IACbC,GAAG,EAAEA,GAAI;IACTF,KAAK,EAAEA,KAAM;IACbW,KAAK,EAAEN;EAAO,CACf,CAAC;AAEN,CAAC,CAAC;;AAEF;AACA;AACAb,mBAAmB,CAACoB,WAAW,GAAG,qBAAqB","ignoreList":[]}

package/lib/commonjs/PipelineImage.js.map

@@ -1 +1 @@
-{"version":3,"names":["_react","require","_reactNative","_reactNativeNitroImage","_resizeForStyle","_useImage","_jsxRuntime","sameSize","a","b","width","height","scaleRadius","cornerRadius","scale","topLeft","topRight","bottomLeft","bottomRight","PipelineImage","exports","forwardRef","url","blur","cache","onLoad","onError","style","onLayout","viewProps","ref","PixelRatio","get","styleSize","resizeForStyle","layoutSize","setLayoutSize","useState","undefined","resize","effectiveCornerRadius","cornerRadiusForStyle","image","error","useImage","enabled","onLoadRef","useRef","onErrorRef","useEffect","current","handleLayout","event","nativeEvent","layout","next","resizeForLayout","prev","jsx","NativeNitroImage","displayName"],"sourceRoot":"../../src","sources":["PipelineImage.tsx"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_react","require","_reactNative","_reactNativeNitroImage","_resizeForStyle","_useImage","_jsxRuntime","sameSize","a","b","width","height","scaleRadius","cornerRadius","scale","topLeft","topRight","bottomLeft","bottomRight","PipelineImage","exports","forwardRef","url","blur","cache","onLoad","onError","style","onLayout","viewProps","ref","PixelRatio","get","styleSize","resizeForStyle","layoutSize","setLayoutSize","useState","undefined","resize","effectiveCornerRadius","cornerRadiusForStyle","image","error","useImage","enabled","onLoadRef","useRef","onErrorRef","useEffect","current","handleLayout","event","nativeEvent","layout","next","resizeForLayout","prev","jsx","NativeNitroImage","displayName"],"sourceRoot":"../../src","sources":["PipelineImage.tsx"],"mappings":"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","ignoreList":[]}