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

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

@@ -20,6 +20,8 @@ namespace margelo::nitro::image { class HybridImageSpec; }
 namespace margelo::nitro::nitroimagepipeline { class HybridNitroImagePipelineSpec; }
 // Forward declaration of `Options` to properly resolve imports.
 namespace margelo::nitro::nitroimagepipeline { struct Options; }
+// Forward declaration of `ResizeFit` to properly resolve imports.
+namespace margelo::nitro::nitroimagepipeline { enum class ResizeFit; }
 // Forward declaration of `ResizeOptions` to properly resolve imports.
 namespace margelo::nitro::nitroimagepipeline { struct ResizeOptions; }
 // Forward declaration of `ViewOptions` to properly resolve imports.
@@ -38,6 +40,7 @@ namespace NitroImagePipeline { class HybridNitroImagePipelineSpec_cxx; }
 #include "CornerRadii.hpp"
 #include "HybridNitroImagePipelineSpec.hpp"
 #include "Options.hpp"
+#include "ResizeFit.hpp"
 #include "ResizeOptions.hpp"
 #include "ViewOptions.hpp"
 #include <NitroImage/HybridImageLoaderSpec.hpp>
@@ -201,6 +204,36 @@ namespace margelo::nitro::nitroimagepipeline::bridge::swift {
     return optional.value();
   }
   
+  // pragma MARK: std::optional<ResizeFit>
+  /**
+   * Specialized version of `std::optional<ResizeFit>`.
+   */
+  using std__optional_ResizeFit_ = std::optional<ResizeFit>;
+  inline std::optional<ResizeFit> create_std__optional_ResizeFit_(const ResizeFit& value) noexcept {
+    return std::optional<ResizeFit>(value);
+  }
+  inline bool has_value_std__optional_ResizeFit_(const std::optional<ResizeFit>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline ResizeFit get_std__optional_ResizeFit_(const std::optional<ResizeFit>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<bool>
+  /**
+   * Specialized version of `std::optional<bool>`.
+   */
+  using std__optional_bool_ = std::optional<bool>;
+  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
+    return std::optional<bool>(value);
+  }
+  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::optional<ResizeOptions>
   /**
    * Specialized version of `std::optional<ResizeOptions>`.
@@ -243,6 +276,80 @@ namespace margelo::nitro::nitroimagepipeline::bridge::swift {
   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::function<void(double /* width */, double /* height */)>
+  /**
+   * Specialized version of `std::function<void(double, double)>`.
+   */
+  using Func_void_double_double = std::function<void(double /* width */, double /* height */)>;
+  /**
+   * Wrapper class for a `std::function<void(double / * width * /, double / * height * /)>`, this can be used from Swift.
+   */
+  class Func_void_double_double_Wrapper final {
+  public:
+    explicit Func_void_double_double_Wrapper(std::function<void(double /* width */, double /* height */)>&& func): _function(std::make_unique<std::function<void(double /* width */, double /* height */)>>(std::move(func))) {}
+    inline void call(double width, double height) const noexcept {
+      _function->operator()(width, height);
+    }
+  private:
+    std::unique_ptr<std::function<void(double /* width */, double /* height */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_double_double create_Func_void_double_double(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_double_double_Wrapper wrap_Func_void_double_double(Func_void_double_double value) noexcept {
+    return Func_void_double_double_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void(double /* width */, double /* height */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(double / * width * /, double / * height * /)>>`.
+   */
+  using std__optional_std__function_void_double____width_____double____height______ = std::optional<std::function<void(double /* width */, double /* height */)>>;
+  inline std::optional<std::function<void(double /* width */, double /* height */)>> create_std__optional_std__function_void_double____width_____double____height______(const std::function<void(double /* width */, double /* height */)>& value) noexcept {
+    return std::optional<std::function<void(double /* width */, double /* height */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_double____width_____double____height______(const std::optional<std::function<void(double /* width */, double /* height */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(double /* width */, double /* height */)> get_std__optional_std__function_void_double____width_____double____height______(const std::optional<std::function<void(double /* width */, double /* height */)>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::function<void(const std::string& /* message */)>
+  /**
+   * Specialized version of `std::function<void(const std::string&)>`.
+   */
+  using Func_void_std__string = std::function<void(const std::string& /* message */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::string& / * message * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__string_Wrapper final {
+  public:
+    explicit Func_void_std__string_Wrapper(std::function<void(const std::string& /* message */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* message */)>>(std::move(func))) {}
+    inline void call(std::string message) const noexcept {
+      _function->operator()(message);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::string& /* message */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__string_Wrapper wrap_Func_void_std__string(Func_void_std__string value) noexcept {
+    return Func_void_std__string_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void(const std::string& /* message */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(const std::string& / * message * /)>>`.
+   */
+  using std__optional_std__function_void_const_std__string_____message______ = std::optional<std::function<void(const std::string& /* message */)>>;
+  inline std::optional<std::function<void(const std::string& /* message */)>> create_std__optional_std__function_void_const_std__string_____message______(const std::function<void(const std::string& /* message */)>& value) noexcept {
+    return std::optional<std::function<void(const std::string& /* message */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_const_std__string_____message______(const std::optional<std::function<void(const std::string& /* message */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const std::string& /* message */)> get_std__optional_std__function_void_const_std__string_____message______(const std::optional<std::function<void(const std::string& /* message */)>>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::optional<ViewOptions>
   /**
    * Specialized version of `std::optional<ViewOptions>`.

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

@@ -20,6 +20,8 @@ namespace margelo::nitro::image { class HybridImageSpec; }
 namespace margelo::nitro::nitroimagepipeline { class HybridNitroImagePipelineSpec; }
 // Forward declaration of `Options` to properly resolve imports.
 namespace margelo::nitro::nitroimagepipeline { struct Options; }
+// Forward declaration of `ResizeFit` to properly resolve imports.
+namespace margelo::nitro::nitroimagepipeline { enum class ResizeFit; }
 // Forward declaration of `ResizeOptions` to properly resolve imports.
 namespace margelo::nitro::nitroimagepipeline { struct ResizeOptions; }
 // Forward declaration of `ViewOptions` to properly resolve imports.
@@ -30,6 +32,7 @@ namespace margelo::nitro::nitroimagepipeline { struct ViewOptions; }
 #include "CornerRadii.hpp"
 #include "HybridNitroImagePipelineSpec.hpp"
 #include "Options.hpp"
+#include "ResizeFit.hpp"
 #include "ResizeOptions.hpp"
 #include "ViewOptions.hpp"
 #include <NitroImage/HybridImageLoaderSpec.hpp>
@@ -37,6 +40,7 @@ namespace margelo::nitro::nitroimagepipeline { struct ViewOptions; }
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/Result.hpp>
 #include <exception>
+#include <functional>
 #include <memory>
 #include <optional>
 #include <string>

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

@@ -22,6 +22,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 `HybridImageLoaderSpec` to properly resolve imports.
 namespace margelo::nitro::image { class HybridImageLoaderSpec; }
 // Forward declaration of `ViewOptions` to properly resolve imports.
@@ -37,8 +39,10 @@ namespace margelo::nitro::nitroimagepipeline { struct ViewOptions; }
 #include "CornerRadii.hpp"
 #include <variant>
 #include "ResizeOptions.hpp"
+#include "ResizeFit.hpp"
 #include <NitroImage/HybridImageLoaderSpec.hpp>
 #include "ViewOptions.hpp"
+#include <functional>
 #include <vector>
 
 #include "NitroImagePipeline-Swift-Cxx-Umbrella.hpp"

package/nitrogen/generated/ios/swift/Func_void_double_double.swift

@@ -0,0 +1,46 @@
+///
+/// Func_void_double_double.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ width: Double, _ height: Double) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_double_double {
+  public typealias bridge = margelo.nitro.nitroimagepipeline.bridge.swift
+
+  private let closure: (_ width: Double, _ height: Double) -> Void
+
+  public init(_ closure: @escaping (_ width: Double, _ height: Double) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(width: Double, height: Double) -> Void {
+    self.closure(width, height)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_double_double`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_double_double>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_double_double {
+    return Unmanaged<Func_void_double_double>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_std__string.swift

@@ -0,0 +1,46 @@
+///
+/// Func_void_std__string.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ message: String) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_std__string {
+  public typealias bridge = margelo.nitro.nitroimagepipeline.bridge.swift
+
+  private let closure: (_ message: String) -> Void
+
+  public init(_ closure: @escaping (_ message: String) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(message: std.string) -> Void {
+    self.closure(String(message))
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_std__string`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__string>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__string {
+    return Unmanaged<Func_void_std__string>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/ResizeFit.swift

@@ -0,0 +1,48 @@
+///
+/// ResizeFit.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `ResizeFit`, backed by a C++ enum.
+ */
+public typealias ResizeFit = margelo.nitro.nitroimagepipeline.ResizeFit
+
+public extension ResizeFit {
+  /**
+   * Get a ResizeFit for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "cover":
+        self = .cover
+      case "contain":
+        self = .contain
+      case "stretch":
+        self = .stretch
+      case "center":
+        self = .center
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this ResizeFit represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .cover:
+        return "cover"
+      case .contain:
+        return "contain"
+      case .stretch:
+        return "stretch"
+      case .center:
+        return "center"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/ResizeOptions.swift

@@ -18,8 +18,20 @@ public extension ResizeOptions {
   /**
    * Create a new instance of `ResizeOptions`.
    */
-  init(width: Double, height: Double) {
-    self.init(width, height)
+  init(width: Double, height: Double, fit: ResizeFit?, allowUpscale: Bool?) {
+    self.init(width, height, { () -> bridge.std__optional_ResizeFit_ in
+      if let __unwrappedValue = fit {
+        return bridge.create_std__optional_ResizeFit_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = allowUpscale {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }())
   }
 
   @inline(__always)
@@ -31,4 +43,21 @@ public extension ResizeOptions {
   var height: Double {
     return self.__height
   }
+  
+  @inline(__always)
+  var fit: ResizeFit? {
+    return self.__fit.value
+  }
+  
+  @inline(__always)
+  var allowUpscale: Bool? {
+    return { () -> Bool? in
+      if bridge.has_value_std__optional_bool_(self.__allowUpscale) {
+        let __unwrapped = bridge.get_std__optional_bool_(self.__allowUpscale)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
 }

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

@@ -18,7 +18,7 @@ public extension ViewOptions {
   /**
    * Create a new instance of `ViewOptions`.
    */
-  init(blur: Double?, cache: CacheOption?, cornerRadius: Variant_Double_CornerRadii?, resize: ResizeOptions?) {
+  init(blur: Double?, cache: CacheOption?, cornerRadius: Variant_Double_CornerRadii?, resize: ResizeOptions?, fit: ResizeFit?, allowUpscale: Bool?, onLoad: ((_ width: Double, _ height: Double) -> Void)?, onError: ((_ message: String) -> Void)?) {
     self.init({ () -> bridge.std__optional_double_ in
       if let __unwrappedValue = blur {
         return bridge.create_std__optional_double_(__unwrappedValue)
@@ -50,6 +50,36 @@ public extension ViewOptions {
       } else {
         return .init()
       }
+    }(), { () -> bridge.std__optional_ResizeFit_ in
+      if let __unwrappedValue = fit {
+        return bridge.create_std__optional_ResizeFit_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = allowUpscale {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__function_void_double____width_____double____height______ in
+      if let __unwrappedValue = onLoad {
+        return bridge.create_std__optional_std__function_void_double____width_____double____height______({ () -> bridge.Func_void_double_double in
+          let __closureWrapper = Func_void_double_double(__unwrappedValue)
+          return bridge.create_Func_void_double_double(__closureWrapper.toUnsafe())
+        }())
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__function_void_const_std__string_____message______ in
+      if let __unwrappedValue = onError {
+        return bridge.create_std__optional_std__function_void_const_std__string_____message______({ () -> bridge.Func_void_std__string in
+          let __closureWrapper = Func_void_std__string(__unwrappedValue)
+          return bridge.create_Func_void_std__string(__closureWrapper.toUnsafe())
+        }())
+      } else {
+        return .init()
+      }
     }())
   }
 
@@ -98,4 +128,55 @@ public extension ViewOptions {
   var resize: ResizeOptions? {
     return self.__resize.value
   }
+  
+  @inline(__always)
+  var fit: ResizeFit? {
+    return self.__fit.value
+  }
+  
+  @inline(__always)
+  var allowUpscale: Bool? {
+    return { () -> Bool? in
+      if bridge.has_value_std__optional_bool_(self.__allowUpscale) {
+        let __unwrapped = bridge.get_std__optional_bool_(self.__allowUpscale)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var onLoad: ((_ width: Double, _ height: Double) -> Void)? {
+    return { () -> ((_ width: Double, _ height: Double) -> Void)? in
+      if bridge.has_value_std__optional_std__function_void_double____width_____double____height______(self.__onLoad) {
+        let __unwrapped = bridge.get_std__optional_std__function_void_double____width_____double____height______(self.__onLoad)
+        return { () -> (Double, Double) -> Void in
+          let __wrappedFunction = bridge.wrap_Func_void_double_double(__unwrapped)
+          return { (__width: Double, __height: Double) -> Void in
+            __wrappedFunction.call(__width, __height)
+          }
+        }()
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var onError: ((_ message: String) -> Void)? {
+    return { () -> ((_ message: String) -> Void)? in
+      if bridge.has_value_std__optional_std__function_void_const_std__string_____message______(self.__onError) {
+        let __unwrapped = bridge.get_std__optional_std__function_void_const_std__string_____message______(self.__onError)
+        return { () -> (String) -> Void in
+          let __wrappedFunction = bridge.wrap_Func_void_std__string(__unwrapped)
+          return { (__message: String) -> Void in
+            __wrappedFunction.call(std.string(__message))
+          }
+        }()
+      } else {
+        return nil
+      }
+    }()
+  }
 }

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

@@ -0,0 +1,84 @@
+///
+/// ResizeFit.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/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#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
+
+namespace margelo::nitro::nitroimagepipeline {
+
+  /**
+   * An enum which can be represented as a JavaScript union (ResizeFit).
+   */
+  enum class ResizeFit {
+    COVER      SWIFT_NAME(cover) = 0,
+    CONTAIN      SWIFT_NAME(contain) = 1,
+    STRETCH      SWIFT_NAME(stretch) = 2,
+    CENTER      SWIFT_NAME(center) = 3,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::nitroimagepipeline
+
+namespace margelo::nitro {
+
+  // C++ ResizeFit <> JS ResizeFit (union)
+  template <>
+  struct JSIConverter<margelo::nitro::nitroimagepipeline::ResizeFit> final {
+    static inline margelo::nitro::nitroimagepipeline::ResizeFit fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("cover"): return margelo::nitro::nitroimagepipeline::ResizeFit::COVER;
+        case hashString("contain"): return margelo::nitro::nitroimagepipeline::ResizeFit::CONTAIN;
+        case hashString("stretch"): return margelo::nitro::nitroimagepipeline::ResizeFit::STRETCH;
+        case hashString("center"): return margelo::nitro::nitroimagepipeline::ResizeFit::CENTER;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum ResizeFit - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::nitroimagepipeline::ResizeFit arg) {
+      switch (arg) {
+        case margelo::nitro::nitroimagepipeline::ResizeFit::COVER: return JSIConverter<std::string>::toJSI(runtime, "cover");
+        case margelo::nitro::nitroimagepipeline::ResizeFit::CONTAIN: return JSIConverter<std::string>::toJSI(runtime, "contain");
+        case margelo::nitro::nitroimagepipeline::ResizeFit::STRETCH: return JSIConverter<std::string>::toJSI(runtime, "stretch");
+        case margelo::nitro::nitroimagepipeline::ResizeFit::CENTER: return JSIConverter<std::string>::toJSI(runtime, "center");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert ResizeFit to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("cover"):
+        case hashString("contain"):
+        case hashString("stretch"):
+        case hashString("center"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -28,9 +28,11 @@
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
 
+// Forward declaration of `ResizeFit` to properly resolve imports.
+namespace margelo::nitro::nitroimagepipeline { enum class ResizeFit; }
 
-
-
+#include "ResizeFit.hpp"
+#include <optional>
 
 namespace margelo::nitro::nitroimagepipeline {
 
@@ -41,10 +43,12 @@ namespace margelo::nitro::nitroimagepipeline {
   public:
     double width     SWIFT_PRIVATE;
     double height     SWIFT_PRIVATE;
+    std::optional<ResizeFit> fit     SWIFT_PRIVATE;
+    std::optional<bool> allowUpscale     SWIFT_PRIVATE;
 
   public:
     ResizeOptions() = default;
-    explicit ResizeOptions(double width, double height): width(width), height(height) {}
+    explicit ResizeOptions(double width, double height, std::optional<ResizeFit> fit, std::optional<bool> allowUpscale): width(width), height(height), fit(fit), allowUpscale(allowUpscale) {}
 
   public:
     friend bool operator==(const ResizeOptions& lhs, const ResizeOptions& rhs) = default;
@@ -61,13 +65,17 @@ namespace margelo::nitro {
       jsi::Object obj = arg.asObject(runtime);
       return margelo::nitro::nitroimagepipeline::ResizeOptions(
         JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "width"))),
-        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "height")))
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "height"))),
+        JSIConverter<std::optional<margelo::nitro::nitroimagepipeline::ResizeFit>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "fit"))),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "allowUpscale")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitroimagepipeline::ResizeOptions& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "width"), JSIConverter<double>::toJSI(runtime, arg.width));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "height"), JSIConverter<double>::toJSI(runtime, arg.height));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "fit"), JSIConverter<std::optional<margelo::nitro::nitroimagepipeline::ResizeFit>>::toJSI(runtime, arg.fit));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "allowUpscale"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.allowUpscale));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -80,6 +88,8 @@ namespace margelo::nitro {
       }
       if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "width")))) return false;
       if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "height")))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::nitroimagepipeline::ResizeFit>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "fit")))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "allowUpscale")))) return false;
       return true;
     }
   };