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

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

@@ -12,6 +12,8 @@
 namespace margelo::nitro::nitroimagepipeline { enum class CacheOption; }
 // Forward declaration of `CornerRadii` to properly resolve imports.
 namespace margelo::nitro::nitroimagepipeline { struct CornerRadii; }
+// Forward declaration of `HybridImageLoaderSpec` to properly resolve imports.
+namespace margelo::nitro::image { class HybridImageLoaderSpec; }
 // Forward declaration of `HybridImageSpec` to properly resolve imports.
 namespace margelo::nitro::image { class HybridImageSpec; }
 // Forward declaration of `HybridNitroImagePipelineSpec` to properly resolve imports.
@@ -20,8 +22,12 @@ namespace margelo::nitro::nitroimagepipeline { class HybridNitroImagePipelineSpe
 namespace margelo::nitro::nitroimagepipeline { struct Options; }
 // Forward declaration of `ResizeOptions` to properly resolve imports.
 namespace margelo::nitro::nitroimagepipeline { struct ResizeOptions; }
+// Forward declaration of `ViewOptions` to properly resolve imports.
+namespace margelo::nitro::nitroimagepipeline { struct ViewOptions; }
 
 // Forward declarations of Swift defined types
+// Forward declaration of `HybridImageLoaderSpec_cxx` to properly resolve imports.
+namespace NitroImage { class HybridImageLoaderSpec_cxx; }
 // Forward declaration of `HybridImageSpec_cxx` to properly resolve imports.
 namespace NitroImage { class HybridImageSpec_cxx; }
 // Forward declaration of `HybridNitroImagePipelineSpec_cxx` to properly resolve imports.
@@ -33,6 +39,8 @@ namespace NitroImagePipeline { class HybridNitroImagePipelineSpec_cxx; }
 #include "HybridNitroImagePipelineSpec.hpp"
 #include "Options.hpp"
 #include "ResizeOptions.hpp"
+#include "ViewOptions.hpp"
+#include <NitroImage/HybridImageLoaderSpec.hpp>
 #include <NitroImage/HybridImageSpec.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
@@ -223,6 +231,33 @@ namespace margelo::nitro::nitroimagepipeline::bridge::swift {
     return optional.value();
   }
   
+  // pragma MARK: std::shared_ptr<margelo::nitro::image::HybridImageLoaderSpec>
+  /**
+   * Specialized version of `std::shared_ptr<margelo::nitro::image::HybridImageLoaderSpec>`.
+   */
+  using std__shared_ptr_margelo__nitro__image__HybridImageLoaderSpec_ = std::shared_ptr<margelo::nitro::image::HybridImageLoaderSpec>;
+  std::shared_ptr<margelo::nitro::image::HybridImageLoaderSpec> create_std__shared_ptr_margelo__nitro__image__HybridImageLoaderSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__image__HybridImageLoaderSpec_(std__shared_ptr_margelo__nitro__image__HybridImageLoaderSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<margelo::nitro::image::HybridImageLoaderSpec>
+  using std__weak_ptr_margelo__nitro__image__HybridImageLoaderSpec_ = std::weak_ptr<margelo::nitro::image::HybridImageLoaderSpec>;
+  inline std__weak_ptr_margelo__nitro__image__HybridImageLoaderSpec_ weakify_std__shared_ptr_margelo__nitro__image__HybridImageLoaderSpec_(const std::shared_ptr<margelo::nitro::image::HybridImageLoaderSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: std::optional<ViewOptions>
+  /**
+   * Specialized version of `std::optional<ViewOptions>`.
+   */
+  using std__optional_ViewOptions_ = std::optional<ViewOptions>;
+  inline std::optional<ViewOptions> create_std__optional_ViewOptions_(const ViewOptions& value) noexcept {
+    return std::optional<ViewOptions>(value);
+  }
+  inline bool has_value_std__optional_ViewOptions_(const std::optional<ViewOptions>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline ViewOptions get_std__optional_ViewOptions_(const std::optional<ViewOptions>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::shared_ptr<Promise<void>>
   /**
    * Specialized version of `std::shared_ptr<Promise<void>>`.
@@ -289,6 +324,15 @@ namespace margelo::nitro::nitroimagepipeline::bridge::swift {
     return Result<std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::image::HybridImageSpec>>>>::withError(error);
   }
   
+  // pragma MARK: Result<std::shared_ptr<margelo::nitro::image::HybridImageLoaderSpec>>
+  using Result_std__shared_ptr_margelo__nitro__image__HybridImageLoaderSpec__ = Result<std::shared_ptr<margelo::nitro::image::HybridImageLoaderSpec>>;
+  inline Result_std__shared_ptr_margelo__nitro__image__HybridImageLoaderSpec__ create_Result_std__shared_ptr_margelo__nitro__image__HybridImageLoaderSpec__(const std::shared_ptr<margelo::nitro::image::HybridImageLoaderSpec>& value) noexcept {
+    return Result<std::shared_ptr<margelo::nitro::image::HybridImageLoaderSpec>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_margelo__nitro__image__HybridImageLoaderSpec__ create_Result_std__shared_ptr_margelo__nitro__image__HybridImageLoaderSpec__(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<margelo::nitro::image::HybridImageLoaderSpec>>::withError(error);
+  }
+  
   // pragma MARK: Result<std::shared_ptr<Promise<void>>>
   using Result_std__shared_ptr_Promise_void___ = Result<std::shared_ptr<Promise<void>>>;
   inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::shared_ptr<Promise<void>>& value) noexcept {
@@ -297,5 +341,14 @@ namespace margelo::nitro::nitroimagepipeline::bridge::swift {
   inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<Promise<void>>>::withError(error);
   }
+  
+  // pragma MARK: Result<void>
+  using Result_void_ = Result<void>;
+  inline Result_void_ create_Result_void_() noexcept {
+    return Result<void>::withValue();
+  }
+  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
+    return Result<void>::withError(error);
+  }
 
 } // namespace margelo::nitro::nitroimagepipeline::bridge::swift

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

@@ -12,6 +12,8 @@
 namespace margelo::nitro::nitroimagepipeline { enum class CacheOption; }
 // Forward declaration of `CornerRadii` to properly resolve imports.
 namespace margelo::nitro::nitroimagepipeline { struct CornerRadii; }
+// Forward declaration of `HybridImageLoaderSpec` to properly resolve imports.
+namespace margelo::nitro::image { class HybridImageLoaderSpec; }
 // Forward declaration of `HybridImageSpec` to properly resolve imports.
 namespace margelo::nitro::image { class HybridImageSpec; }
 // Forward declaration of `HybridNitroImagePipelineSpec` to properly resolve imports.
@@ -20,6 +22,8 @@ namespace margelo::nitro::nitroimagepipeline { class HybridNitroImagePipelineSpe
 namespace margelo::nitro::nitroimagepipeline { struct Options; }
 // Forward declaration of `ResizeOptions` to properly resolve imports.
 namespace margelo::nitro::nitroimagepipeline { struct ResizeOptions; }
+// Forward declaration of `ViewOptions` to properly resolve imports.
+namespace margelo::nitro::nitroimagepipeline { struct ViewOptions; }
 
 // Include C++ defined types
 #include "CacheOption.hpp"
@@ -27,6 +31,8 @@ namespace margelo::nitro::nitroimagepipeline { struct ResizeOptions; }
 #include "HybridNitroImagePipelineSpec.hpp"
 #include "Options.hpp"
 #include "ResizeOptions.hpp"
+#include "ViewOptions.hpp"
+#include <NitroImage/HybridImageLoaderSpec.hpp>
 #include <NitroImage/HybridImageSpec.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/Result.hpp>
@@ -47,6 +53,8 @@ namespace margelo::nitro::nitroimagepipeline { struct ResizeOptions; }
 #include <NitroModules/DateToChronoDate.hpp>
 
 // Forward declarations of Swift defined types
+// Forward declaration of `HybridImageLoaderSpec_cxx` to properly resolve imports.
+namespace NitroImage { class HybridImageLoaderSpec_cxx; }
 // Forward declaration of `HybridImageSpec_cxx` to properly resolve imports.
 namespace NitroImage { class HybridImageSpec_cxx; }
 // Forward declaration of `HybridNitroImagePipelineSpec_cxx` to properly resolve imports.

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

@@ -22,6 +22,10 @@ namespace margelo::nitro::nitroimagepipeline { enum class CacheOption; }
 namespace margelo::nitro::nitroimagepipeline { struct CornerRadii; }
 // Forward declaration of `ResizeOptions` to properly resolve imports.
 namespace margelo::nitro::nitroimagepipeline { struct ResizeOptions; }
+// Forward declaration of `HybridImageLoaderSpec` to properly resolve imports.
+namespace margelo::nitro::image { class HybridImageLoaderSpec; }
+// Forward declaration of `ViewOptions` to properly resolve imports.
+namespace margelo::nitro::nitroimagepipeline { struct ViewOptions; }
 
 #include <memory>
 #include <NitroImage/HybridImageSpec.hpp>
@@ -33,6 +37,8 @@ namespace margelo::nitro::nitroimagepipeline { struct ResizeOptions; }
 #include "CornerRadii.hpp"
 #include <variant>
 #include "ResizeOptions.hpp"
+#include <NitroImage/HybridImageLoaderSpec.hpp>
+#include "ViewOptions.hpp"
 #include <vector>
 
 #include "NitroImagePipeline-Swift-Cxx-Umbrella.hpp"
@@ -93,6 +99,14 @@ namespace margelo::nitro::nitroimagepipeline {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<margelo::nitro::image::HybridImageLoaderSpec> createImageLoader(const std::string& url, const std::optional<ViewOptions>& options) override {
+      auto __result = _swiftPart.createImageLoader(url, options);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline std::shared_ptr<Promise<void>> preLoadImage(const std::string& url) override {
       auto __result = _swiftPart.preLoadImage(url);
       if (__result.hasError()) [[unlikely]] {
@@ -117,6 +131,12 @@ namespace margelo::nitro::nitroimagepipeline {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline void setMemoryCacheLimit(double bytes) override {
+      auto __result = _swiftPart.setMemoryCacheLimit(std::forward<decltype(bytes)>(bytes));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline std::shared_ptr<Promise<void>> clearCache() override {
       auto __result = _swiftPart.clearCache();
       if (__result.hasError()) [[unlikely]] {

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

@@ -15,9 +15,11 @@ public protocol HybridNitroImagePipelineSpec_protocol: HybridObject {
 
   // Methods
   func loadImage(url: String, options: Options?) throws -> Promise<(any HybridImageSpec)>
+  func createImageLoader(url: String, options: ViewOptions?) throws -> (any HybridImageLoaderSpec)
   func preLoadImage(url: String) throws -> Promise<Void>
   func preLoadImages(urls: [String]) throws -> Promise<Void>
   func gaussianBlur(image: (any HybridImageSpec), radius: Double) throws -> Promise<(any HybridImageSpec)>
+  func setMemoryCacheLimit(bytes: Double) throws -> Void
   func clearCache() throws -> Promise<Void>
 }
 

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

@@ -147,6 +147,21 @@ open class HybridNitroImagePipelineSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func createImageLoader(url: std.string, options: bridge.std__optional_ViewOptions_) -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridImageLoaderSpec__ {
+    do {
+      let __result = try self.__implementation.createImageLoader(url: String(url), options: options.value)
+      let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageLoaderSpec_ in
+        let __cxxWrapped = __result.getCxxWrapper()
+        return __cxxWrapped.getCxxPart()
+      }()
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridImageLoaderSpec__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridImageLoaderSpec__(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func preLoadImage(url: std.string) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
@@ -211,6 +226,17 @@ open class HybridNitroImagePipelineSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func setMemoryCacheLimit(bytes: Double) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setMemoryCacheLimit(bytes: bytes)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func clearCache() -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {

package/nitrogen/generated/ios/swift/ViewOptions.swift

@@ -0,0 +1,101 @@
+///
+/// ViewOptions.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `ViewOptions`, backed by a C++ struct.
+ */
+public typealias ViewOptions = margelo.nitro.nitroimagepipeline.ViewOptions
+
+public extension ViewOptions {
+  private typealias bridge = margelo.nitro.nitroimagepipeline.bridge.swift
+
+  /**
+   * Create a new instance of `ViewOptions`.
+   */
+  init(blur: Double?, cache: CacheOption?, cornerRadius: Variant_Double_CornerRadii?, resize: ResizeOptions?) {
+    self.init({ () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = blur {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_CacheOption_ in
+      if let __unwrappedValue = cache {
+        return bridge.create_std__optional_CacheOption_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__variant_double__CornerRadii__ in
+      if let __unwrappedValue = cornerRadius {
+        return bridge.create_std__optional_std__variant_double__CornerRadii__({ () -> bridge.std__variant_double__CornerRadii_ in
+          switch __unwrappedValue {
+            case .first(let __value):
+              return bridge.create_std__variant_double__CornerRadii_(__value)
+            case .second(let __value):
+              return bridge.create_std__variant_double__CornerRadii_(__value)
+          }
+        }().variant)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_ResizeOptions_ in
+      if let __unwrappedValue = resize {
+        return bridge.create_std__optional_ResizeOptions_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  @inline(__always)
+  var blur: Double? {
+    return { () -> Double? in
+      if bridge.has_value_std__optional_double_(self.__blur) {
+        let __unwrapped = bridge.get_std__optional_double_(self.__blur)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var cache: CacheOption? {
+    return self.__cache.value
+  }
+  
+  @inline(__always)
+  var cornerRadius: Variant_Double_CornerRadii? {
+    return { () -> Variant_Double_CornerRadii? in
+      if bridge.has_value_std__optional_std__variant_double__CornerRadii__(self.__cornerRadius) {
+        let __unwrapped = bridge.get_std__optional_std__variant_double__CornerRadii__(self.__cornerRadius)
+        return { () -> Variant_Double_CornerRadii in
+          let __variant = bridge.std__variant_double__CornerRadii_(__unwrapped)
+          switch __variant.index() {
+            case 0:
+              let __actual = __variant.get_0()
+              return .first(__actual)
+            case 1:
+              let __actual = __variant.get_1()
+              return .second(__actual)
+            default:
+              fatalError("Variant can never have index \(__variant.index())!")
+          }
+        }()
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var resize: ResizeOptions? {
+    return self.__resize.value
+  }
+}

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

@@ -15,9 +15,11 @@ namespace margelo::nitro::nitroimagepipeline {
     // load custom methods/properties
     registerHybrids(this, [](Prototype& prototype) {
       prototype.registerHybridMethod("loadImage", &HybridNitroImagePipelineSpec::loadImage);
+      prototype.registerHybridMethod("createImageLoader", &HybridNitroImagePipelineSpec::createImageLoader);
       prototype.registerHybridMethod("preLoadImage", &HybridNitroImagePipelineSpec::preLoadImage);
       prototype.registerHybridMethod("preLoadImages", &HybridNitroImagePipelineSpec::preLoadImages);
       prototype.registerHybridMethod("gaussianBlur", &HybridNitroImagePipelineSpec::gaussianBlur);
+      prototype.registerHybridMethod("setMemoryCacheLimit", &HybridNitroImagePipelineSpec::setMemoryCacheLimit);
       prototype.registerHybridMethod("clearCache", &HybridNitroImagePipelineSpec::clearCache);
     });
   }

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

@@ -17,6 +17,10 @@
 namespace margelo::nitro::image { class HybridImageSpec; }
 // Forward declaration of `Options` to properly resolve imports.
 namespace margelo::nitro::nitroimagepipeline { struct Options; }
+// Forward declaration of `HybridImageLoaderSpec` to properly resolve imports.
+namespace margelo::nitro::image { class HybridImageLoaderSpec; }
+// Forward declaration of `ViewOptions` to properly resolve imports.
+namespace margelo::nitro::nitroimagepipeline { struct ViewOptions; }
 
 #include <memory>
 #include <NitroImage/HybridImageSpec.hpp>
@@ -24,6 +28,8 @@ namespace margelo::nitro::nitroimagepipeline { struct Options; }
 #include <string>
 #include "Options.hpp"
 #include <optional>
+#include <NitroImage/HybridImageLoaderSpec.hpp>
+#include "ViewOptions.hpp"
 #include <vector>
 
 namespace margelo::nitro::nitroimagepipeline {
@@ -58,9 +64,11 @@ namespace margelo::nitro::nitroimagepipeline {
     public:
       // Methods
       virtual std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::image::HybridImageSpec>>> loadImage(const std::string& url, const std::optional<Options>& options) = 0;
+      virtual std::shared_ptr<margelo::nitro::image::HybridImageLoaderSpec> createImageLoader(const std::string& url, const std::optional<ViewOptions>& options) = 0;
       virtual std::shared_ptr<Promise<void>> preLoadImage(const std::string& url) = 0;
       virtual std::shared_ptr<Promise<void>> preLoadImages(const std::vector<std::string>& urls) = 0;
       virtual std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::image::HybridImageSpec>>> gaussianBlur(const std::shared_ptr<margelo::nitro::image::HybridImageSpec>& image, double radius) = 0;
+      virtual void setMemoryCacheLimit(double bytes) = 0;
       virtual std::shared_ptr<Promise<void>> clearCache() = 0;
 
     protected:

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

@@ -0,0 +1,104 @@
+///
+/// ViewOptions.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `CacheOption` to properly resolve imports.
+namespace margelo::nitro::nitroimagepipeline { enum class CacheOption; }
+// Forward declaration of `CornerRadii` to properly resolve imports.
+namespace margelo::nitro::nitroimagepipeline { struct CornerRadii; }
+// Forward declaration of `ResizeOptions` to properly resolve imports.
+namespace margelo::nitro::nitroimagepipeline { struct ResizeOptions; }
+
+#include <optional>
+#include "CacheOption.hpp"
+#include "CornerRadii.hpp"
+#include <variant>
+#include "ResizeOptions.hpp"
+
+namespace margelo::nitro::nitroimagepipeline {
+
+  /**
+   * A struct which can be represented as a JavaScript object (ViewOptions).
+   */
+  struct ViewOptions final {
+  public:
+    std::optional<double> blur     SWIFT_PRIVATE;
+    std::optional<CacheOption> cache     SWIFT_PRIVATE;
+    std::optional<std::variant<double, CornerRadii>> cornerRadius     SWIFT_PRIVATE;
+    std::optional<ResizeOptions> resize     SWIFT_PRIVATE;
+
+  public:
+    ViewOptions() = default;
+    explicit ViewOptions(std::optional<double> blur, std::optional<CacheOption> cache, std::optional<std::variant<double, CornerRadii>> cornerRadius, std::optional<ResizeOptions> resize): blur(blur), cache(cache), cornerRadius(cornerRadius), resize(resize) {}
+
+  public:
+    friend bool operator==(const ViewOptions& lhs, const ViewOptions& rhs) = default;
+  };
+
+} // namespace margelo::nitro::nitroimagepipeline
+
+namespace margelo::nitro {
+
+  // C++ ViewOptions <> JS ViewOptions (object)
+  template <>
+  struct JSIConverter<margelo::nitro::nitroimagepipeline::ViewOptions> final {
+    static inline margelo::nitro::nitroimagepipeline::ViewOptions fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::nitroimagepipeline::ViewOptions(
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "blur"))),
+        JSIConverter<std::optional<margelo::nitro::nitroimagepipeline::CacheOption>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "cache"))),
+        JSIConverter<std::optional<std::variant<double, margelo::nitro::nitroimagepipeline::CornerRadii>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "cornerRadius"))),
+        JSIConverter<std::optional<margelo::nitro::nitroimagepipeline::ResizeOptions>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "resize")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitroimagepipeline::ViewOptions& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "blur"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.blur));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "cache"), JSIConverter<std::optional<margelo::nitro::nitroimagepipeline::CacheOption>>::toJSI(runtime, arg.cache));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "cornerRadius"), JSIConverter<std::optional<std::variant<double, margelo::nitro::nitroimagepipeline::CornerRadii>>>::toJSI(runtime, arg.cornerRadius));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "resize"), JSIConverter<std::optional<margelo::nitro::nitroimagepipeline::ResizeOptions>>::toJSI(runtime, arg.resize));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "blur")))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::nitroimagepipeline::CacheOption>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "cache")))) return false;
+      if (!JSIConverter<std::optional<std::variant<double, margelo::nitro::nitroimagepipeline::CornerRadii>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "cornerRadius")))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::nitroimagepipeline::ResizeOptions>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "resize")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-image-pipeline",
-  "version": "1.3.2",
+  "version": "1.5.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",
@@ -17,7 +17,8 @@
     "release": "semantic-release",
     "build": "bun run typecheck && bob build",
     "codegen": "nitrogen --logLevel=\"debug\" && bun run build",
-    "verify:blur": "swiftc -O -o \"${TMPDIR:-/tmp}/nitro-verify-blur\" scripts/verify-blur.swift ios/GaussianBlur.swift && \"${TMPDIR:-/tmp}/nitro-verify-blur\""
+    "fixtures": "bun scripts/fixture-server.ts",
+    "verify:blur": "sh scripts/verify-blur.sh"
   },
   "keywords": [
     "react-native",
@@ -83,7 +84,7 @@
     "react": "*",
     "react-native": "*",
     "react-native-nitro-modules": "*",
-    "react-native-nitro-image": "0.15.1"
+    "react-native-nitro-image": ">=0.15.1 <0.16.0"
   },
   "overrides": {
     "lodash-es": "4.17.21",

package/src/NativePipelineImage.tsx

@@ -0,0 +1,103 @@
+import { type ComponentRef, forwardRef } from 'react';
+import type { HostComponent } from 'react-native';
+import { NativeNitroImage } from 'react-native-nitro-image';
+
+import { cornerRadiusForStyle } from './resizeForStyle';
+import type {
+  CacheOption,
+  CornerRadii,
+  ResizeOptions,
+} from './specs/nitro-image-toolkit.nitro';
+import { usePipelineImageLoader } from './usePipelineImageLoader';
+
+type ReactProps<T> = T extends HostComponent<infer P> ? P : never;
+type NativeImageProps = ReactProps<typeof NativeNitroImage>;
+
+/**
+ * The instance `<NativePipelineImage>` exposes through its `ref` — the
+ * underlying `NativeNitroImage` host view, with the usual native-view
+ * methods (`measure`, …).
+ */
+export type NativePipelineImageRef = ComponentRef<typeof NativeNitroImage>;
+
+export interface NativePipelineImageProps extends Omit<
+  NativeImageProps,
+  'image'
+> {
+  /** URL of the image to load through the pipeline. */
+  url: string;
+  /**
+   * Gaussian blur sigma in **points** (density-independent), like
+   * `PipelineImage`. Applied natively with the screen scale.
+   * @default 0
+   */
+  blur?: number;
+  /**
+   * Corner radius in **points** — a single number or per-corner radii.
+   * When omitted, it's derived from `style`'s `borderRadius`-family
+   * properties instead — set this prop to override that.
+   * @default undefined (derived from `style`, or square corners if unset there)
+   */
+  cornerRadius?: number | CornerRadii;
+  cache?: CacheOption;
+  /**
+   * Target bitmap size in **pixels**, overriding the size the native side
+   * measures from the view. Rarely needed.
+   * @default undefined (measure the view natively)
+   */
+  resize?: ResizeOptions;
+}
+
+/**
+ * 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}
+ * />
+ * ```
+ */
+export const NativePipelineImage = forwardRef<
+  NativePipelineImageRef,
+  NativePipelineImageProps
+>(function NativePipelineImage(
+  { url, blur, cornerRadius, cache, resize, style, ...viewProps },
+  ref,
+) {
+  // Same precedence as PipelineImage: an explicit prop wins over style.
+  const effectiveCornerRadius = cornerRadius ?? cornerRadiusForStyle(style);
+  const loader = usePipelineImageLoader(url, {
+    blur,
+    cornerRadius: effectiveCornerRadius,
+    cache,
+    resize,
+  });
+
+  return (
+    <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';

package/src/index.ts

@@ -1,3 +1,8 @@
+export {
+  NativePipelineImage,
+  type NativePipelineImageProps,
+  type NativePipelineImageRef,
+} from './NativePipelineImage';
 export { NitroImagePipeline } from './NitroImagePipeline';
 export {
   PipelineImage,
@@ -14,5 +19,7 @@ export type {
   CornerRadii,
   Options,
   ResizeOptions,
+  ViewOptions,
 } from './specs/nitro-image-toolkit.nitro';
 export { useImage } from './useImage';
+export { usePipelineImageLoader } from './usePipelineImageLoader';