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

package/lib/typescript/src/specs/nitro-image-toolkit.nitro.d.ts

@@ -1,4 +1,4 @@
-import type { Image } from 'react-native-nitro-image';
+import type { Image, ImageLoader } from 'react-native-nitro-image';
 import type { HybridObject } from 'react-native-nitro-modules';
 export type CacheOption = 'memory' | 'disk' | 'none';
 /**
@@ -60,11 +60,54 @@ export type Options = {
      */
     resize?: ResizeOptions;
 };
+/**
+ * Options for {@linkcode NitroImagePipeline.createImageLoader}. Unlike
+ * {@linkcode Options} (used by `loadImage`, where values are bitmap pixels),
+ * `blur` and `cornerRadius` here are in **points** (density-independent):
+ * the loader runs inside a view and converts to pixels natively with the
+ * screen scale. The one exception is {@linkcode resize}, which stays an
+ * explicit **pixel** size like everywhere else in the library.
+ */
+export type ViewOptions = {
+    /**
+     * Gaussian blur sigma in **points**. Multiplied by the screen scale
+     * natively, so the same value looks the same on every device.
+     * @default 0 (no blur)
+     */
+    blur?: number;
+    cache?: CacheOption;
+    /**
+     * Corner radius in **points**, uniform or per-corner. Converted to pixels
+     * with the screen scale and baked into the bitmap at the display size.
+     * @default 0 (square corners)
+     */
+    cornerRadius?: number | CornerRadii;
+    /**
+     * Target bitmap size in **pixels**, overriding the size measured from the
+     * view. Rarely needed — without it the loader resizes to the view's
+     * laid-out size × screen scale, which is what you want in a UI.
+     * @default undefined (measure the view)
+     */
+    resize?: ResizeOptions;
+};
 export interface NitroImagePipeline extends HybridObject<{
     ios: 'swift';
     android: 'kotlin';
 }> {
     loadImage(url: string, options?: Options): Promise<Image>;
+    /**
+     * Creates an {@linkcode ImageLoader} for `url` that a `<NativeNitroImage>`
+     * view drives entirely natively: the request starts when the view attaches
+     * to the window — at the view's own laid-out size, with no JS round trips —
+     * and is cancelled (and the bitmap released) when it detaches, so
+     * off-screen list cells stop costing memory. Loads go through the same
+     * pipeline and caches as {@linkcode loadImage}/{@linkcode preLoadImage}.
+     *
+     * `options` are in **points** (see {@linkcode ViewOptions}); the loader
+     * applies the screen scale natively. If the view has no size yet when it
+     * attaches, the load waits for its first layout.
+     */
+    createImageLoader(url: string, options?: ViewOptions): ImageLoader;
     preLoadImage(url: string): Promise<void>;
     preLoadImages(urls: string[]): Promise<void>;
     /**

package/lib/typescript/src/specs/nitro-image-toolkit.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nitro-image-toolkit.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/nitro-image-toolkit.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC;AAErD;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,OAAO,GAAG;IACpB;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB;;;;;;;;;;;;;OAaG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC;IACpC;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB,CAAC;AAEF,MAAM,WAAW,kBAAmB,SAAQ,YAAY,CAAC;IACvD,GAAG,EAAE,OAAO,CAAC;IACb,OAAO,EAAE,QAAQ,CAAC;CACnB,CAAC;IACA,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAC1D,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C;;;;OAIG;IACH,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAG3D;;;;;;;;OAQG;IACH,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAEzC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7B"}
+{"version":3,"file":"nitro-image-toolkit.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/nitro-image-toolkit.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC;AAErD;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,OAAO,GAAG;IACpB;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB;;;;;;;;;;;;;OAaG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC;IACpC;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC;IACpC;;;;;OAKG;IACH,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB,CAAC;AAEF,MAAM,WAAW,kBAAmB,SAAQ,YAAY,CAAC;IACvD,GAAG,EAAE,OAAO,CAAC;IACb,OAAO,EAAE,QAAQ,CAAC;CACnB,CAAC;IACA,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAC1D;;;;;;;;;;;OAWG;IACH,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,WAAW,CAAC;IACnE,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C;;;;OAIG;IACH,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAG3D;;;;;;;;OAQG;IACH,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAEzC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7B"}

package/lib/typescript/src/usePipelineImageLoader.d.ts

@@ -0,0 +1,15 @@
+import type { ImageLoader } from 'react-native-nitro-image';
+import type { ViewOptions } from './specs/nitro-image-toolkit.nitro';
+/**
+ * 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.
+ */
+export declare function usePipelineImageLoader(url: string, options?: ViewOptions): ImageLoader;
+//# sourceMappingURL=usePipelineImageLoader.d.ts.map

package/lib/typescript/src/usePipelineImageLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePipelineImageLoader.d.ts","sourceRoot":"","sources":["../../../src/usePipelineImageLoader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAG5D,OAAO,KAAK,EAEV,WAAW,EACZ,MAAM,mCAAmC,CAAC;AAE3C;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,WAAW,GACpB,WAAW,CA0Db"}

package/nitrogen/generated/android/c++/JHybridNitroImagePipelineSpec.cpp

@@ -9,6 +9,8 @@
 
 // Forward declaration of `HybridImageSpec` to properly resolve imports.
 namespace margelo::nitro::image { class HybridImageSpec; }
+// Forward declaration of `HybridImageLoaderSpec` to properly resolve imports.
+namespace margelo::nitro::image { class HybridImageLoaderSpec; }
 // Forward declaration of `Options` to properly resolve imports.
 namespace margelo::nitro::nitroimagepipeline { struct Options; }
 // Forward declaration of `CacheOption` to properly resolve imports.
@@ -17,12 +19,16 @@ 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 `ViewOptions` to properly resolve imports.
+namespace margelo::nitro::nitroimagepipeline { struct ViewOptions; }
 
 #include <memory>
 #include <NitroImage/HybridImageSpec.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/JPromise.hpp>
 #include <NitroImage/JHybridImageSpec.hpp>
+#include <NitroImage/HybridImageLoaderSpec.hpp>
+#include <NitroImage/JHybridImageLoaderSpec.hpp>
 #include <NitroModules/JUnit.hpp>
 #include <string>
 #include "Options.hpp"
@@ -36,6 +42,8 @@ namespace margelo::nitro::nitroimagepipeline { struct ResizeOptions; }
 #include "JCornerRadii.hpp"
 #include "ResizeOptions.hpp"
 #include "JResizeOptions.hpp"
+#include "ViewOptions.hpp"
+#include "JViewOptions.hpp"
 #include <vector>
 
 namespace margelo::nitro::nitroimagepipeline {
@@ -87,6 +95,11 @@ namespace margelo::nitro::nitroimagepipeline {
       return __promise;
     }();
   }
+  std::shared_ptr<margelo::nitro::image::HybridImageLoaderSpec> JHybridNitroImagePipelineSpec::createImageLoader(const std::string& url, const std::optional<ViewOptions>& options) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<margelo::nitro::image::JHybridImageLoaderSpec::JavaPart>(jni::alias_ref<jni::JString> /* url */, jni::alias_ref<JViewOptions> /* options */)>("createImageLoader");
+    auto __result = method(_javaPart, jni::make_jstring(url), options.has_value() ? JViewOptions::fromCpp(options.value()) : nullptr);
+    return __result->getJHybridImageLoaderSpec();
+  }
   std::shared_ptr<Promise<void>> JHybridNitroImagePipelineSpec::preLoadImage(const std::string& url) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* url */)>("preLoadImage");
     auto __result = method(_javaPart, jni::make_jstring(url));

package/nitrogen/generated/android/c++/JHybridNitroImagePipelineSpec.hpp

@@ -55,6 +55,7 @@ namespace margelo::nitro::nitroimagepipeline {
   public:
     // Methods
     std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::image::HybridImageSpec>>> loadImage(const std::string& url, const std::optional<Options>& options) override;
+    std::shared_ptr<margelo::nitro::image::HybridImageLoaderSpec> createImageLoader(const std::string& url, const std::optional<ViewOptions>& options) override;
     std::shared_ptr<Promise<void>> preLoadImage(const std::string& url) override;
     std::shared_ptr<Promise<void>> preLoadImages(const std::vector<std::string>& urls) override;
     std::shared_ptr<Promise<std::shared_ptr<margelo::nitro::image::HybridImageSpec>>> gaussianBlur(const std::shared_ptr<margelo::nitro::image::HybridImageSpec>& image, double radius) override;

package/nitrogen/generated/android/c++/JViewOptions.hpp

@@ -0,0 +1,77 @@
+///
+/// JViewOptions.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "ViewOptions.hpp"
+
+#include "CacheOption.hpp"
+#include "CornerRadii.hpp"
+#include "JCacheOption.hpp"
+#include "JCornerRadii.hpp"
+#include "JResizeOptions.hpp"
+#include "JVariant_Double_CornerRadii.hpp"
+#include "ResizeOptions.hpp"
+#include <optional>
+#include <variant>
+
+namespace margelo::nitro::nitroimagepipeline {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ViewOptions" and the Kotlin data class "ViewOptions".
+   */
+  struct JViewOptions final: public jni::JavaClass<JViewOptions> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroimagepipeline/ViewOptions;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ViewOptions by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ViewOptions toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldBlur = clazz->getField<jni::JDouble>("blur");
+      jni::local_ref<jni::JDouble> blur = this->getFieldValue(fieldBlur);
+      static const auto fieldCache = clazz->getField<JCacheOption>("cache");
+      jni::local_ref<JCacheOption> cache = this->getFieldValue(fieldCache);
+      static const auto fieldCornerRadius = clazz->getField<JVariant_Double_CornerRadii>("cornerRadius");
+      jni::local_ref<JVariant_Double_CornerRadii> cornerRadius = this->getFieldValue(fieldCornerRadius);
+      static const auto fieldResize = clazz->getField<JResizeOptions>("resize");
+      jni::local_ref<JResizeOptions> resize = this->getFieldValue(fieldResize);
+      return ViewOptions(
+        blur != nullptr ? std::make_optional(blur->value()) : std::nullopt,
+        cache != nullptr ? std::make_optional(cache->toCpp()) : std::nullopt,
+        cornerRadius != nullptr ? std::make_optional(cornerRadius->toCpp()) : std::nullopt,
+        resize != nullptr ? std::make_optional(resize->toCpp()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JViewOptions::javaobject> fromCpp(const ViewOptions& value) {
+      using JSignature = JViewOptions(jni::alias_ref<jni::JDouble>, jni::alias_ref<JCacheOption>, jni::alias_ref<JVariant_Double_CornerRadii>, jni::alias_ref<JResizeOptions>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.blur.has_value() ? jni::JDouble::valueOf(value.blur.value()) : nullptr,
+        value.cache.has_value() ? JCacheOption::fromCpp(value.cache.value()) : nullptr,
+        value.cornerRadius.has_value() ? JVariant_Double_CornerRadii::fromCpp(value.cornerRadius.value()) : nullptr,
+        value.resize.has_value() ? JResizeOptions::fromCpp(value.resize.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitroimagepipeline

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroimagepipeline/HybridNitroImagePipelineSpec.kt

@@ -13,6 +13,7 @@ import com.facebook.proguard.annotations.DoNotStrip
 import dalvik.annotation.optimization.FastNative
 import com.margelo.nitro.image.HybridImageSpec
 import com.margelo.nitro.core.Promise
+import com.margelo.nitro.image.HybridImageLoaderSpec
 import com.margelo.nitro.core.HybridObject
 
 /**
@@ -35,6 +36,10 @@ abstract class HybridNitroImagePipelineSpec: HybridObject() {
   @Keep
   abstract fun loadImage(url: String, options: Options?): Promise<com.margelo.nitro.image.HybridImageSpec>
   
+  @DoNotStrip
+  @Keep
+  abstract fun createImageLoader(url: String, options: ViewOptions?): com.margelo.nitro.image.HybridImageLoaderSpec
+  
   @DoNotStrip
   @Keep
   abstract fun preLoadImage(url: String): Promise<Unit>

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroimagepipeline/ViewOptions.kt

@@ -0,0 +1,66 @@
+///
+/// ViewOptions.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nitroimagepipeline
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
+
+
+/**
+ * Represents the JavaScript object/struct "ViewOptions".
+ */
+@DoNotStrip
+@Keep
+data class ViewOptions(
+  @DoNotStrip
+  @Keep
+  val blur: Double?,
+  @DoNotStrip
+  @Keep
+  val cache: CacheOption?,
+  @DoNotStrip
+  @Keep
+  val cornerRadius: Variant_Double_CornerRadii?,
+  @DoNotStrip
+  @Keep
+  val resize: ResizeOptions?
+) {
+  /* primary constructor */
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is ViewOptions) return false
+    return Objects.deepEquals(this.blur, other.blur)
+      && Objects.deepEquals(this.cache, other.cache)
+      && Objects.deepEquals(this.cornerRadius, other.cornerRadius)
+      && Objects.deepEquals(this.resize, other.resize)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf<Any?>(
+      blur,
+      cache,
+      cornerRadius,
+      resize
+    ).contentDeepHashCode()
+  }
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(blur: Double?, cache: CacheOption?, cornerRadius: Variant_Double_CornerRadii?, resize: ResizeOptions?): ViewOptions {
+      return ViewOptions(blur, cache, cornerRadius, resize)
+    }
+  }
+}

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

@@ -41,6 +41,16 @@ namespace margelo::nitro::nitroimagepipeline::bridge::swift {
     };
   }
   
+  // pragma MARK: 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 {
+    // Implemented in NitroImage
+    return margelo::nitro::image::bridge::swift::create_std__shared_ptr_HybridImageLoaderSpec_(swiftUnsafePointer);
+  }
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__image__HybridImageLoaderSpec_(std__shared_ptr_margelo__nitro__image__HybridImageLoaderSpec_ cppType) {
+    // Implemented in NitroImage
+    return margelo::nitro::image::bridge::swift::get_std__shared_ptr_HybridImageLoaderSpec_(cppType);
+  }
+  
   // pragma MARK: std::function<void()>
   Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = NitroImagePipeline::Func_void::fromUnsafe(swiftClosureWrapper);

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 {

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]] {

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

@@ -15,6 +15,7 @@ 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)>

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 {

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,6 +15,7 @@ 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);

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,6 +64,7 @@ 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;