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

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

@@ -23,7 +23,13 @@ data class ResizeOptions(
   val width: Double,
   @DoNotStrip
   @Keep
-  val height: Double
+  val height: Double,
+  @DoNotStrip
+  @Keep
+  val fit: ResizeFit?,
+  @DoNotStrip
+  @Keep
+  val allowUpscale: Boolean?
 ) {
   /* primary constructor */
 
@@ -32,12 +38,16 @@ data class ResizeOptions(
     if (other !is ResizeOptions) return false
     return Objects.deepEquals(this.width, other.width)
       && Objects.deepEquals(this.height, other.height)
+      && Objects.deepEquals(this.fit, other.fit)
+      && Objects.deepEquals(this.allowUpscale, other.allowUpscale)
   }
 
   override fun hashCode(): Int {
     return arrayOf<Any?>(
       width,
-      height
+      height,
+      fit,
+      allowUpscale
     ).contentDeepHashCode()
   }
 
@@ -49,8 +59,8 @@ data class ResizeOptions(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(width: Double, height: Double): ResizeOptions {
-      return ResizeOptions(width, height)
+    private fun fromCpp(width: Double, height: Double, fit: ResizeFit?, allowUpscale: Boolean?): ResizeOptions {
+      return ResizeOptions(width, height, fit, allowUpscale)
     }
   }
 }

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

@@ -29,9 +29,25 @@ data class ViewOptions(
   val cornerRadius: Variant_Double_CornerRadii?,
   @DoNotStrip
   @Keep
-  val resize: ResizeOptions?
+  val resize: ResizeOptions?,
+  @DoNotStrip
+  @Keep
+  val fit: ResizeFit?,
+  @DoNotStrip
+  @Keep
+  val allowUpscale: Boolean?,
+  @DoNotStrip
+  @Keep
+  val onLoad: Func_void_double_double?,
+  @DoNotStrip
+  @Keep
+  val onError: Func_void_std__string?
 ) {
-  /* primary constructor */
+  /**
+   * Create a new instance of ViewOptions from Kotlin
+   */
+  constructor(blur: Double?, cache: CacheOption?, cornerRadius: Variant_Double_CornerRadii?, resize: ResizeOptions?, fit: ResizeFit?, allowUpscale: Boolean?, onLoad: ((width: Double, height: Double) -> Unit)?, onError: ((message: String) -> Unit)?):
+         this(blur, cache, cornerRadius, resize, fit, allowUpscale, onLoad?.let { Func_void_double_double_java(it) }, onError?.let { Func_void_std__string_java(it) })
 
   override fun equals(other: Any?): Boolean {
     if (this === other) return true
@@ -40,6 +56,10 @@ data class ViewOptions(
       && Objects.deepEquals(this.cache, other.cache)
       && Objects.deepEquals(this.cornerRadius, other.cornerRadius)
       && Objects.deepEquals(this.resize, other.resize)
+      && Objects.deepEquals(this.fit, other.fit)
+      && Objects.deepEquals(this.allowUpscale, other.allowUpscale)
+      && Objects.deepEquals(this.onLoad, other.onLoad)
+      && Objects.deepEquals(this.onError, other.onError)
   }
 
   override fun hashCode(): Int {
@@ -47,7 +67,11 @@ data class ViewOptions(
       blur,
       cache,
       cornerRadius,
-      resize
+      resize,
+      fit,
+      allowUpscale,
+      onLoad,
+      onError
     ).contentDeepHashCode()
   }
 
@@ -59,8 +83,8 @@ data class ViewOptions(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(blur: Double?, cache: CacheOption?, cornerRadius: Variant_Double_CornerRadii?, resize: ResizeOptions?): ViewOptions {
-      return ViewOptions(blur, cache, cornerRadius, resize)
+    private fun fromCpp(blur: Double?, cache: CacheOption?, cornerRadius: Variant_Double_CornerRadii?, resize: ResizeOptions?, fit: ResizeFit?, allowUpscale: Boolean?, onLoad: Func_void_double_double?, onError: Func_void_std__string?): ViewOptions {
+      return ViewOptions(blur, cache, cornerRadius, resize, fit, allowUpscale, onLoad, onError)
     }
   }
 }

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

@@ -51,6 +51,22 @@ namespace margelo::nitro::nitroimagepipeline::bridge::swift {
     return margelo::nitro::image::bridge::swift::get_std__shared_ptr_HybridImageLoaderSpec_(cppType);
   }
   
+  // pragma MARK: std::function<void(double /* width */, double /* height */)>
+  Func_void_double_double create_Func_void_double_double(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = NitroImagePipeline::Func_void_double_double::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](double width, double height) mutable -> void {
+      swiftClosure.call(width, height);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const std::string& /* message */)>
+  Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = NitroImagePipeline::Func_void_std__string::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::string& message) mutable -> void {
+      swiftClosure.call(message);
+    };
+  }
+  
   // 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

@@ -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
+      }
+    }()
+  }
 }