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

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

@@ -1,4 +1,5 @@
 import type { Image } from 'react-native-nitro-image';
+import { type ImageSource } from './resolveImageSource';
 import type { CacheOption, CornerRadii, ResizeOptions } from './specs/nitro-image-toolkit.nitro';
 type Result = {
     image: undefined;
@@ -11,15 +12,20 @@ type Result = {
     error: Error;
 };
 /**
- * A hook to asynchronously load an image from the
- * given {@linkcode AsyncImageSource} into memory.
+ * A hook to asynchronously load an image from `url` through the pipeline
+ * into memory.
  * @example
  * ```ts
- * const { image, error } = useImage({ filePath: '/tmp/image.jpg' })
+ * const { image, error } = useImage({ url: 'https://example.com/photo.jpg' });
+ * const { image: logo } = useImage({ url: require('./logo.png') });
  * ```
  */
 export declare function useImage({ url, blur, cornerRadius, resize, cache, enabled, }: {
-    url: string;
+    /**
+     * The image to load: a URL string (`https://`, `file://`, an absolute path)
+     * or a `require()`d asset — see {@linkcode ImageSource}.
+     */
+    url: ImageSource;
     /**
      * Gaussian blur strength, as the standard deviation (sigma) of the blur in
      * source-image pixels (of the resized bitmap when `resize` is set). Matches
@@ -34,8 +40,9 @@ export declare function useImage({ url, blur, cornerRadius, resize, cache, enabl
      */
     cornerRadius?: number | CornerRadii;
     /**
-     * Resize the bitmap to exactly this size in pixels (aspect-fill,
-     * center-crop) before blur/rounding. Typically your display size in points
+     * Resize the bitmap into this box in pixels before blur/rounding —
+     * aspect-fill + center-crop by default, or another `fit` (see
+     * {@linkcode ResizeOptions}). Typically your display size in points
      * multiplied by `PixelRatio.get()`. Inline object literals are fine.
      */
     resize?: ResizeOptions;

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

@@ -1 +1 @@
-{"version":3,"file":"useImage.d.ts","sourceRoot":"","sources":["../../../src/useImage.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAGtD,OAAO,KAAK,EACV,WAAW,EACX,WAAW,EACX,aAAa,EACd,MAAM,mCAAmC,CAAC;AAE3C,KAAK,MAAM,GAEP;IACE,KAAK,EAAE,SAAS,CAAC;IACjB,KAAK,EAAE,SAAS,CAAC;CAClB,GAED;IACE,KAAK,EAAE,KAAK,CAAC;IACb,KAAK,EAAE,SAAS,CAAC;CAClB,GAED;IACE,KAAK,EAAE,SAAS,CAAC;IACjB,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEN;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,EACvB,GAAG,EACH,IAAQ,EACR,YAAgB,EAChB,MAAM,EACN,KAAK,EACL,OAAc,GACf,EAAE;IACD,GAAG,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC;IACpC;;;;OAIG;IACH,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GAAG,MAAM,CA4ET"}
+{"version":3,"file":"useImage.d.ts","sourceRoot":"","sources":["../../../src/useImage.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAGtD,OAAO,EAAE,KAAK,WAAW,EAAmB,MAAM,sBAAsB,CAAC;AACzE,OAAO,KAAK,EACV,WAAW,EACX,WAAW,EACX,aAAa,EACd,MAAM,mCAAmC,CAAC;AAE3C,KAAK,MAAM,GAEP;IACE,KAAK,EAAE,SAAS,CAAC;IACjB,KAAK,EAAE,SAAS,CAAC;CAClB,GAED;IACE,KAAK,EAAE,KAAK,CAAC;IACb,KAAK,EAAE,SAAS,CAAC;CAClB,GAED;IACE,KAAK,EAAE,SAAS,CAAC;IACjB,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEN;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,EACvB,GAAG,EACH,IAAQ,EACR,YAAgB,EAChB,MAAM,EACN,KAAK,EACL,OAAc,GACf,EAAE;IACD;;;OAGG;IACH,GAAG,EAAE,WAAW,CAAC;IACjB;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC;IACpC;;;;;OAKG;IACH,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GAAG,MAAM,CA0FT"}

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

@@ -1,7 +1,9 @@
 import type { ImageLoader } from 'react-native-nitro-image';
+import { type ImageSource } from './resolveImageSource';
 import type { ViewOptions } from './specs/nitro-image-toolkit.nitro';
 /**
- * Creates (and memoizes) an {@linkcode ImageLoader} for `url` to pass to
+ * Creates (and memoizes) an {@linkcode ImageLoader} for `source` — a URL
+ * string or a `require()`d asset, see {@linkcode ImageSource} — 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
@@ -9,7 +11,9 @@ import type { ViewOptions } from './specs/nitro-image-toolkit.nitro';
  *
  * `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.
+ * literals are fine — options are compared by value, not identity, and the
+ * `onLoad`/`onError` callbacks are read through a ref, so inline arrows don't
+ * recreate the loader either.
  */
-export declare function usePipelineImageLoader(url: string, options?: ViewOptions): ImageLoader;
+export declare function usePipelineImageLoader(source: ImageSource, options?: ViewOptions): ImageLoader;
 //# sourceMappingURL=usePipelineImageLoader.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"usePipelineImageLoader.d.ts","sourceRoot":"","sources":["../../../src/usePipelineImageLoader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAG5D,OAAO,EACL,KAAK,WAAW,EAEjB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAEV,WAAW,EACZ,MAAM,mCAAmC,CAAC;AAkC3C;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,WAAW,EACnB,OAAO,CAAC,EAAE,WAAW,GACpB,WAAW,CAsIb"}

package/nitrogen/generated/android/NitroImagePipelineOnLoad.cpp

@@ -16,6 +16,8 @@
 #include <NitroModules/HybridObjectRegistry.hpp>
 
 #include "JHybridNitroImagePipelineSpec.hpp"
+#include "JFunc_void_double_double.hpp"
+#include "JFunc_void_std__string.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 
 namespace margelo::nitro::nitroimagepipeline {
@@ -41,6 +43,8 @@ void registerAllNatives() {
 
   // Register native JNI methods
   margelo::nitro::nitroimagepipeline::JHybridNitroImagePipelineSpec::CxxPart::registerNatives();
+  margelo::nitro::nitroimagepipeline::JFunc_void_double_double_cxx::registerNatives();
+  margelo::nitro::nitroimagepipeline::JFunc_void_std__string_cxx::registerNatives();
 
   // Register Nitro Hybrid Objects
   HybridObjectRegistry::registerHybridObjectConstructor(

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

@@ -0,0 +1,75 @@
+///
+/// JFunc_void_double_double.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 <functional>
+
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::nitroimagepipeline {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(width: Double, height: Double) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_double_double: public jni::JavaClass<JFunc_void_double_double> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroimagepipeline/Func_void_double_double;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_double_double` instance holds through JNI.
+     */
+    void invoke(double width, double height) const {
+      static const auto method = javaClassStatic()->getMethod<void(double /* width */, double /* height */)>("invoke");
+      method(self(), width, height);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_double_double that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_double_double_cxx final: public jni::HybridClass<JFunc_void_double_double_cxx, JFunc_void_double_double> {
+  public:
+    static jni::local_ref<JFunc_void_double_double::javaobject> fromCpp(const std::function<void(double /* width */, double /* height */)>& func) {
+      return JFunc_void_double_double_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_double_double_cxx` instance holds.
+     */
+    void invoke_cxx(double width, double height) {
+      _func(width, height);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(double /* width */, double /* height */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroimagepipeline/Func_void_double_double_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_double_double_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_double_double_cxx(const std::function<void(double /* width */, double /* height */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(double /* width */, double /* height */)> _func;
+  };
+
+} // namespace margelo::nitro::nitroimagepipeline

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

@@ -0,0 +1,76 @@
+///
+/// JFunc_void_std__string.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 <functional>
+
+#include <string>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::nitroimagepipeline {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(message: String) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__string: public jni::JavaClass<JFunc_void_std__string> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroimagepipeline/Func_void_std__string;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__string` instance holds through JNI.
+     */
+    void invoke(const std::string& message) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* message */)>("invoke");
+      method(self(), jni::make_jstring(message));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__string that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__string_cxx final: public jni::HybridClass<JFunc_void_std__string_cxx, JFunc_void_std__string> {
+  public:
+    static jni::local_ref<JFunc_void_std__string::javaobject> fromCpp(const std::function<void(const std::string& /* message */)>& func) {
+      return JFunc_void_std__string_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__string_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JString> message) {
+      _func(message->toStdString());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::string& /* message */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroimagepipeline/Func_void_std__string_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__string_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__string_cxx(const std::function<void(const std::string& /* message */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::string& /* message */)> _func;
+  };
+
+} // namespace margelo::nitro::nitroimagepipeline

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

@@ -19,6 +19,8 @@ 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 `ResizeFit` to properly resolve imports.
+namespace margelo::nitro::nitroimagepipeline { enum class ResizeFit; }
 // Forward declaration of `ViewOptions` to properly resolve imports.
 namespace margelo::nitro::nitroimagepipeline { struct ViewOptions; }
 
@@ -42,8 +44,14 @@ namespace margelo::nitro::nitroimagepipeline { struct ViewOptions; }
 #include "JCornerRadii.hpp"
 #include "ResizeOptions.hpp"
 #include "JResizeOptions.hpp"
+#include "ResizeFit.hpp"
+#include "JResizeFit.hpp"
 #include "ViewOptions.hpp"
 #include "JViewOptions.hpp"
+#include <functional>
+#include "JFunc_void_double_double.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JFunc_void_std__string.hpp"
 #include <vector>
 
 namespace margelo::nitro::nitroimagepipeline {

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

@@ -14,8 +14,10 @@
 #include "CornerRadii.hpp"
 #include "JCacheOption.hpp"
 #include "JCornerRadii.hpp"
+#include "JResizeFit.hpp"
 #include "JResizeOptions.hpp"
 #include "JVariant_Double_CornerRadii.hpp"
+#include "ResizeFit.hpp"
 #include "ResizeOptions.hpp"
 #include <optional>
 #include <variant>

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

@@ -0,0 +1,64 @@
+///
+/// JResizeFit.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 "ResizeFit.hpp"
+
+namespace margelo::nitro::nitroimagepipeline {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "ResizeFit" and the Kotlin enum "ResizeFit".
+   */
+  struct JResizeFit final: public jni::JavaClass<JResizeFit> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroimagepipeline/ResizeFit;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum ResizeFit.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ResizeFit toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<ResizeFit>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JResizeFit> fromCpp(ResizeFit value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case ResizeFit::COVER:
+          static const auto fieldCOVER = clazz->getStaticField<JResizeFit>("COVER");
+          return clazz->getStaticFieldValue(fieldCOVER);
+        case ResizeFit::CONTAIN:
+          static const auto fieldCONTAIN = clazz->getStaticField<JResizeFit>("CONTAIN");
+          return clazz->getStaticFieldValue(fieldCONTAIN);
+        case ResizeFit::STRETCH:
+          static const auto fieldSTRETCH = clazz->getStaticField<JResizeFit>("STRETCH");
+          return clazz->getStaticFieldValue(fieldSTRETCH);
+        case ResizeFit::CENTER:
+          static const auto fieldCENTER = clazz->getStaticField<JResizeFit>("CENTER");
+          return clazz->getStaticFieldValue(fieldCENTER);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nitroimagepipeline

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

@@ -10,7 +10,9 @@
 #include <fbjni/fbjni.h>
 #include "ResizeOptions.hpp"
 
-
+#include "JResizeFit.hpp"
+#include "ResizeFit.hpp"
+#include <optional>
 
 namespace margelo::nitro::nitroimagepipeline {
 
@@ -35,9 +37,15 @@ namespace margelo::nitro::nitroimagepipeline {
       double width = this->getFieldValue(fieldWidth);
       static const auto fieldHeight = clazz->getField<double>("height");
       double height = this->getFieldValue(fieldHeight);
+      static const auto fieldFit = clazz->getField<JResizeFit>("fit");
+      jni::local_ref<JResizeFit> fit = this->getFieldValue(fieldFit);
+      static const auto fieldAllowUpscale = clazz->getField<jni::JBoolean>("allowUpscale");
+      jni::local_ref<jni::JBoolean> allowUpscale = this->getFieldValue(fieldAllowUpscale);
       return ResizeOptions(
         width,
-        height
+        height,
+        fit != nullptr ? std::make_optional(fit->toCpp()) : std::nullopt,
+        allowUpscale != nullptr ? std::make_optional(static_cast<bool>(allowUpscale->value())) : std::nullopt
       );
     }
 
@@ -47,13 +55,15 @@ namespace margelo::nitro::nitroimagepipeline {
      */
     [[maybe_unused]]
     static jni::local_ref<JResizeOptions::javaobject> fromCpp(const ResizeOptions& value) {
-      using JSignature = JResizeOptions(double, double);
+      using JSignature = JResizeOptions(double, double, jni::alias_ref<JResizeFit>, jni::alias_ref<jni::JBoolean>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
         clazz,
         value.width,
-        value.height
+        value.height,
+        value.fit.has_value() ? JResizeFit::fromCpp(value.fit.value()) : nullptr,
+        value.allowUpscale.has_value() ? jni::JBoolean::valueOf(value.allowUpscale.value()) : nullptr
       );
     }
   };

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

@@ -14,10 +14,17 @@
 #include "CornerRadii.hpp"
 #include "JCacheOption.hpp"
 #include "JCornerRadii.hpp"
+#include "JFunc_void_double_double.hpp"
+#include "JFunc_void_std__string.hpp"
+#include "JResizeFit.hpp"
 #include "JResizeOptions.hpp"
 #include "JVariant_Double_CornerRadii.hpp"
+#include "ResizeFit.hpp"
 #include "ResizeOptions.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include <functional>
 #include <optional>
+#include <string>
 #include <variant>
 
 namespace margelo::nitro::nitroimagepipeline {
@@ -47,11 +54,39 @@ namespace margelo::nitro::nitroimagepipeline {
       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);
+      static const auto fieldFit = clazz->getField<JResizeFit>("fit");
+      jni::local_ref<JResizeFit> fit = this->getFieldValue(fieldFit);
+      static const auto fieldAllowUpscale = clazz->getField<jni::JBoolean>("allowUpscale");
+      jni::local_ref<jni::JBoolean> allowUpscale = this->getFieldValue(fieldAllowUpscale);
+      static const auto fieldOnLoad = clazz->getField<JFunc_void_double_double::javaobject>("onLoad");
+      jni::local_ref<JFunc_void_double_double::javaobject> onLoad = this->getFieldValue(fieldOnLoad);
+      static const auto fieldOnError = clazz->getField<JFunc_void_std__string::javaobject>("onError");
+      jni::local_ref<JFunc_void_std__string::javaobject> onError = this->getFieldValue(fieldOnError);
       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
+        resize != nullptr ? std::make_optional(resize->toCpp()) : std::nullopt,
+        fit != nullptr ? std::make_optional(fit->toCpp()) : std::nullopt,
+        allowUpscale != nullptr ? std::make_optional(static_cast<bool>(allowUpscale->value())) : std::nullopt,
+        onLoad != nullptr ? std::make_optional([&]() -> std::function<void(double /* width */, double /* height */)> {
+          if (onLoad->isInstanceOf(JFunc_void_double_double_cxx::javaClassStatic())) [[likely]] {
+            auto downcast = jni::static_ref_cast<JFunc_void_double_double_cxx::javaobject>(onLoad);
+            return downcast->cthis()->getFunction();
+          } else {
+            auto onLoadRef = jni::make_global(onLoad);
+            return JNICallable<JFunc_void_double_double, void(double, double)>(std::move(onLoadRef));
+          }
+        }()) : std::nullopt,
+        onError != nullptr ? std::make_optional([&]() -> std::function<void(const std::string& /* message */)> {
+          if (onError->isInstanceOf(JFunc_void_std__string_cxx::javaClassStatic())) [[likely]] {
+            auto downcast = jni::static_ref_cast<JFunc_void_std__string_cxx::javaobject>(onError);
+            return downcast->cthis()->getFunction();
+          } else {
+            auto onErrorRef = jni::make_global(onError);
+            return JNICallable<JFunc_void_std__string, void(std::string)>(std::move(onErrorRef));
+          }
+        }()) : std::nullopt
       );
     }
 
@@ -61,7 +96,7 @@ namespace margelo::nitro::nitroimagepipeline {
      */
     [[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>);
+      using JSignature = JViewOptions(jni::alias_ref<jni::JDouble>, jni::alias_ref<JCacheOption>, jni::alias_ref<JVariant_Double_CornerRadii>, jni::alias_ref<JResizeOptions>, jni::alias_ref<JResizeFit>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<JFunc_void_double_double::javaobject>, jni::alias_ref<JFunc_void_std__string::javaobject>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
@@ -69,7 +104,11 @@ namespace margelo::nitro::nitroimagepipeline {
         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
+        value.resize.has_value() ? JResizeOptions::fromCpp(value.resize.value()) : nullptr,
+        value.fit.has_value() ? JResizeFit::fromCpp(value.fit.value()) : nullptr,
+        value.allowUpscale.has_value() ? jni::JBoolean::valueOf(value.allowUpscale.value()) : nullptr,
+        value.onLoad.has_value() ? JFunc_void_double_double_cxx::fromCpp(value.onLoad.value()) : nullptr,
+        value.onError.has_value() ? JFunc_void_std__string_cxx::fromCpp(value.onError.value()) : nullptr
       );
     }
   };

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

@@ -0,0 +1,78 @@
+///
+/// Func_void_double_double.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.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript callback `(width: number, height: number) => void`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_void_double_double: (Double, Double) -> Unit {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(width: Double, height: Double): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(width: number, height: number) => void`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_void_double_double_cxx: Func_void_double_double {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(width: Double, height: Double): Unit
+    = invoke_cxx(width,height)
+
+  private external fun invoke_cxx(width: Double, height: Double): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(width: number, height: number) => void`.
+ * This is implemented in Java/Kotlin, via a `(Double, Double) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_double_double_java(private val function: (Double, Double) -> Unit): Func_void_double_double {
+  @DoNotStrip
+  @Keep
+  override fun invoke(width: Double, height: Double): Unit {
+    return this.function(width, height)
+  }
+}

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

@@ -0,0 +1,78 @@
+///
+/// Func_void_std__string.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.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript callback `(message: string) => void`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_void_std__string: (String) -> Unit {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(message: String): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(message: string) => void`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_void_std__string_cxx: Func_void_std__string {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(message: String): Unit
+    = invoke_cxx(message)
+
+  private external fun invoke_cxx(message: String): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(message: string) => void`.
+ * This is implemented in Java/Kotlin, via a `(String) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_std__string_java(private val function: (String) -> Unit): Func_void_std__string {
+  @DoNotStrip
+  @Keep
+  override fun invoke(message: String): Unit {
+    return this.function(message)
+  }
+}

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

@@ -0,0 +1,25 @@
+///
+/// ResizeFit.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
+
+/**
+ * Represents the JavaScript enum/union "ResizeFit".
+ */
+@DoNotStrip
+@Keep
+enum class ResizeFit(@DoNotStrip @Keep val value: Int) {
+  COVER(0),
+  CONTAIN(1),
+  STRETCH(2),
+  CENTER(3);
+
+  companion object
+}