cactus-react-native 1.0.2 → 1.2.0

package/nitrogen/generated/android/kotlin/com/margelo/nitro/cactus/HybridCactusImageSpec.kt

@@ -0,0 +1,62 @@
+///
+/// HybridCactusImageSpec.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.cactus
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.core.HybridObject
+
+/**
+ * A Kotlin class representing the CactusImage HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of CactusImage.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridCactusImageSpec: HybridObject() {
+  @DoNotStrip
+  private var mHybridData: HybridData = initHybrid()
+
+  init {
+    super.updateNative(mHybridData)
+  }
+
+  override fun updateNative(hybridData: HybridData) {
+    mHybridData = hybridData
+    super.updateNative(hybridData)
+  }
+
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject CactusImage]"
+  }
+
+  // Properties
+  
+
+  // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun base64(path: String): Promise<String>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun resize(path: String, height: Double, width: Double, quality: Double): Promise<String>
+
+  private external fun initHybrid(): HybridData
+
+  companion object {
+    protected const val TAG = "HybridCactusImageSpec"
+  }
+}

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

@@ -12,6 +12,7 @@
 #include "HybridCactusCryptoSpecSwift.hpp"
 #include "HybridCactusDeviceInfoSpecSwift.hpp"
 #include "HybridCactusFileSystemSpecSwift.hpp"
+#include "HybridCactusImageSpecSwift.hpp"
 
 namespace margelo::nitro::cactus::bridge::swift {
 
@@ -118,5 +119,21 @@ namespace margelo::nitro::cactus::bridge::swift {
     Cactus::HybridCactusFileSystemSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
     return swiftPart.toUnsafe();
   }
+  
+  // pragma MARK: std::shared_ptr<HybridCactusImageSpec>
+  std::shared_ptr<HybridCactusImageSpec> create_std__shared_ptr_HybridCactusImageSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    Cactus::HybridCactusImageSpec_cxx swiftPart = Cactus::HybridCactusImageSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::cactus::HybridCactusImageSpecSwift>(swiftPart);
+  }
+  void* NON_NULL get_std__shared_ptr_HybridCactusImageSpec_(std__shared_ptr_HybridCactusImageSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::cactus::HybridCactusImageSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::cactus::HybridCactusImageSpecSwift>(cppType);
+    #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridCactusImageSpec\" is not implemented in Swift!");
+    }
+    #endif
+    Cactus::HybridCactusImageSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
 
 } // namespace margelo::nitro::cactus::bridge::swift

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

@@ -16,6 +16,8 @@ namespace margelo::nitro::cactus { class HybridCactusCryptoSpec; }
 namespace margelo::nitro::cactus { class HybridCactusDeviceInfoSpec; }
 // Forward declaration of `HybridCactusFileSystemSpec` to properly resolve imports.
 namespace margelo::nitro::cactus { class HybridCactusFileSystemSpec; }
+// Forward declaration of `HybridCactusImageSpec` to properly resolve imports.
+namespace margelo::nitro::cactus { class HybridCactusImageSpec; }
 
 // Forward declarations of Swift defined types
 // Forward declaration of `HybridCactusCryptoSpec_cxx` to properly resolve imports.
@@ -24,12 +26,15 @@ namespace Cactus { class HybridCactusCryptoSpec_cxx; }
 namespace Cactus { class HybridCactusDeviceInfoSpec_cxx; }
 // Forward declaration of `HybridCactusFileSystemSpec_cxx` to properly resolve imports.
 namespace Cactus { class HybridCactusFileSystemSpec_cxx; }
+// Forward declaration of `HybridCactusImageSpec_cxx` to properly resolve imports.
+namespace Cactus { class HybridCactusImageSpec_cxx; }
 
 // Include C++ defined types
 #include "DeviceInfo.hpp"
 #include "HybridCactusCryptoSpec.hpp"
 #include "HybridCactusDeviceInfoSpec.hpp"
 #include "HybridCactusFileSystemSpec.hpp"
+#include "HybridCactusImageSpec.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
 #include <NitroModules/Result.hpp>
@@ -369,5 +374,17 @@ namespace margelo::nitro::cactus::bridge::swift {
   inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<Promise<void>>>::withError(error);
   }
+  
+  // pragma MARK: std::shared_ptr<HybridCactusImageSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridCactusImageSpec>`.
+   */
+  using std__shared_ptr_HybridCactusImageSpec_ = std::shared_ptr<HybridCactusImageSpec>;
+  std::shared_ptr<HybridCactusImageSpec> create_std__shared_ptr_HybridCactusImageSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridCactusImageSpec_(std__shared_ptr_HybridCactusImageSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridCactusImageSpec>
+  using std__weak_ptr_HybridCactusImageSpec_ = std::weak_ptr<HybridCactusImageSpec>;
+  inline std__weak_ptr_HybridCactusImageSpec_ weakify_std__shared_ptr_HybridCactusImageSpec_(const std::shared_ptr<HybridCactusImageSpec>& strong) noexcept { return strong; }
 
 } // namespace margelo::nitro::cactus::bridge::swift

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

@@ -16,12 +16,15 @@ namespace margelo::nitro::cactus { class HybridCactusCryptoSpec; }
 namespace margelo::nitro::cactus { class HybridCactusDeviceInfoSpec; }
 // Forward declaration of `HybridCactusFileSystemSpec` to properly resolve imports.
 namespace margelo::nitro::cactus { class HybridCactusFileSystemSpec; }
+// Forward declaration of `HybridCactusImageSpec` to properly resolve imports.
+namespace margelo::nitro::cactus { class HybridCactusImageSpec; }
 
 // Include C++ defined types
 #include "DeviceInfo.hpp"
 #include "HybridCactusCryptoSpec.hpp"
 #include "HybridCactusDeviceInfoSpec.hpp"
 #include "HybridCactusFileSystemSpec.hpp"
+#include "HybridCactusImageSpec.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/Result.hpp>
 #include <exception>
@@ -46,6 +49,8 @@ namespace Cactus { class HybridCactusCryptoSpec_cxx; }
 namespace Cactus { class HybridCactusDeviceInfoSpec_cxx; }
 // Forward declaration of `HybridCactusFileSystemSpec_cxx` to properly resolve imports.
 namespace Cactus { class HybridCactusFileSystemSpec_cxx; }
+// Forward declaration of `HybridCactusImageSpec_cxx` to properly resolve imports.
+namespace Cactus { class HybridCactusImageSpec_cxx; }
 
 // Include Swift defined types
 #if __has_include("Cactus-Swift.h")

package/nitrogen/generated/ios/CactusAutolinking.mm

@@ -15,6 +15,7 @@
 #include "HybridCactusFileSystemSpecSwift.hpp"
 #include "HybridCactusCryptoSpecSwift.hpp"
 #include "HybridCactusDeviceInfoSpecSwift.hpp"
+#include "HybridCactusImageSpecSwift.hpp"
 
 @interface CactusAutolinking : NSObject
 @end
@@ -64,6 +65,13 @@
       return hybridObject;
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "CactusImage",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridCactusImageSpec> hybridObject = Cactus::CactusAutolinking::createCactusImage();
+      return hybridObject;
+    }
+  );
 }
 
 @end

package/nitrogen/generated/ios/CactusAutolinking.swift

@@ -52,4 +52,19 @@ public final class CactusAutolinking {
       return __cxxWrapped.getCxxPart()
     }()
   }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridCactusImageSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridCactusImageSpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridCactusImage`).
+   */
+  public static func createCactusImage() -> bridge.std__shared_ptr_HybridCactusImageSpec_ {
+    let hybridObject = HybridCactusImage()
+    return { () -> bridge.std__shared_ptr_HybridCactusImageSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
 }

package/nitrogen/generated/ios/c++/HybridCactusImageSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridCactusImageSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridCactusImageSpecSwift.hpp"
+
+namespace margelo::nitro::cactus {
+} // namespace margelo::nitro::cactus

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

@@ -0,0 +1,85 @@
+///
+/// HybridCactusImageSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridCactusImageSpec.hpp"
+
+// Forward declaration of `HybridCactusImageSpec_cxx` to properly resolve imports.
+namespace Cactus { class HybridCactusImageSpec_cxx; }
+
+
+
+#include <string>
+#include <NitroModules/Promise.hpp>
+
+#include "Cactus-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::cactus {
+
+  /**
+   * The C++ part of HybridCactusImageSpec_cxx.swift.
+   *
+   * HybridCactusImageSpecSwift (C++) accesses HybridCactusImageSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridCactusImageSpec_cxx can directly inherit from the C++ class HybridCactusImageSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridCactusImageSpecSwift: public virtual HybridCactusImageSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridCactusImageSpecSwift(const Cactus::HybridCactusImageSpec_cxx& swiftPart):
+      HybridObject(HybridCactusImageSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline Cactus::HybridCactusImageSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline std::shared_ptr<Promise<std::string>> base64(const std::string& path) override {
+      auto __result = _swiftPart.base64(path);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::string>> resize(const std::string& path, double height, double width, double quality) override {
+      auto __result = _swiftPart.resize(path, std::forward<decltype(height)>(height), std::forward<decltype(width)>(width), std::forward<decltype(quality)>(quality));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    Cactus::HybridCactusImageSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::cactus

package/nitrogen/generated/ios/swift/HybridCactusImageSpec.swift

@@ -0,0 +1,58 @@
+///
+/// HybridCactusImageSpec.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+import NitroModules
+
+/// See ``HybridCactusImageSpec``
+public protocol HybridCactusImageSpec_protocol: HybridObject {
+  // Properties
+  
+
+  // Methods
+  func base64(path: String) throws -> Promise<String>
+  func resize(path: String, height: Double, width: Double, quality: Double) throws -> Promise<String>
+}
+
+public extension HybridCactusImageSpec_protocol {
+  /// Default implementation of ``HybridObject.toString``
+  func toString() -> String {
+    return "[HybridObject CactusImage]"
+  }
+}
+
+/// See ``HybridCactusImageSpec``
+open class HybridCactusImageSpec_base {
+  private weak var cxxWrapper: HybridCactusImageSpec_cxx? = nil
+  public init() { }
+  public func getCxxWrapper() -> HybridCactusImageSpec_cxx {
+  #if DEBUG
+    guard self is HybridCactusImageSpec else {
+      fatalError("`self` is not a `HybridCactusImageSpec`! Did you accidentally inherit from `HybridCactusImageSpec_base` instead of `HybridCactusImageSpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridCactusImageSpec_cxx(self as! HybridCactusImageSpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the CactusImage HybridObject.
+ * Implement this protocol to create Swift-based instances of CactusImage.
+ * ```swift
+ * class HybridCactusImage : HybridCactusImageSpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridCactusImageSpec = HybridCactusImageSpec_protocol & HybridCactusImageSpec_base

package/nitrogen/generated/ios/swift/HybridCactusImageSpec_cxx.swift

@@ -0,0 +1,158 @@
+///
+/// HybridCactusImageSpec_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+import NitroModules
+
+/**
+ * A class implementation that bridges HybridCactusImageSpec over to C++.
+ * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
+ *
+ * Also, some Swift types need to be bridged with special handling:
+ * - Enums need to be wrapped in Structs, otherwise they cannot be accessed bi-directionally (Swift bug: https://github.com/swiftlang/swift/issues/75330)
+ * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper
+ * - Throwing methods need to be wrapped with a Result<T, Error> type, as exceptions cannot be propagated to C++
+ */
+open class HybridCactusImageSpec_cxx {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::cactus::bridge::swift`)
+   * from `Cactus-Swift-Cxx-Bridge.hpp`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.cactus.bridge.swift
+
+  /**
+   * Holds an instance of the `HybridCactusImageSpec` Swift protocol.
+   */
+  private var __implementation: any HybridCactusImageSpec
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_HybridCactusImageSpec_
+
+  /**
+   * Create a new `HybridCactusImageSpec_cxx` that wraps the given `HybridCactusImageSpec`.
+   * All properties and methods bridge to C++ types.
+   */
+  public init(_ implementation: any HybridCactusImageSpec) {
+    self.__implementation = implementation
+    self.__cxxPart = .init()
+    /* no base class */
+  }
+
+  /**
+   * Get the actual `HybridCactusImageSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridCactusImageSpec() -> any HybridCactusImageSpec {
+    return __implementation
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `HybridCactusImageSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridCactusImageSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridCactusImageSpec_cxx {
+    return Unmanaged<HybridCactusImageSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * The C++ part is a `std::shared_ptr<HybridCactusImageSpec>`.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridCactusImageSpec_ {
+    let cachedCxxPart = self.__cxxPart.lock()
+    if Bool(fromCxx: cachedCxxPart) {
+      return cachedCxxPart
+    } else {
+      let newCxxPart = bridge.create_std__shared_ptr_HybridCactusImageSpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridCactusImageSpec_(newCxxPart)
+      return newCxxPart
+    }
+  }
+
+  
+
+  /**
+   * Get the memory size of the Swift class (plus size of any other allocations)
+   * so the JS VM can properly track it and garbage-collect the JS object if needed.
+   */
+  @inline(__always)
+  public var memorySize: Int {
+    return MemoryHelper.getSizeOf(self.__implementation) + self.__implementation.memorySize
+  }
+
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    self.__implementation.dispose()
+  }
+
+  /**
+   * Call toString() on the Swift class.
+   */
+  @inline(__always)
+  public func toString() -> String {
+    return self.__implementation.toString()
+  }
+
+  // Properties
+  
+
+  // Methods
+  @inline(__always)
+  public final func base64(path: std.string) -> bridge.Result_std__shared_ptr_Promise_std__string___ {
+    do {
+      let __result = try self.__implementation.base64(path: String(path))
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__string__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__string__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__string__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(std.string(__result)) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_std__string___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__string___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func resize(path: std.string, height: Double, width: Double, quality: Double) -> bridge.Result_std__shared_ptr_Promise_std__string___ {
+    do {
+      let __result = try self.__implementation.resize(path: String(path), height: height, width: width, quality: quality)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__string__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__string__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__string__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(std.string(__result)) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_std__string___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__string___(__exceptionPtr)
+    }
+  }
+}

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

@@ -0,0 +1,22 @@
+///
+/// HybridCactusImageSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridCactusImageSpec.hpp"
+
+namespace margelo::nitro::cactus {
+
+  void HybridCactusImageSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("base64", &HybridCactusImageSpec::base64);
+      prototype.registerHybridMethod("resize", &HybridCactusImageSpec::resize);
+    });
+  }
+
+} // namespace margelo::nitro::cactus

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

@@ -0,0 +1,64 @@
+///
+/// HybridCactusImageSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+#include <NitroModules/Promise.hpp>
+
+namespace margelo::nitro::cactus {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `CactusImage`
+   * Inherit this class to create instances of `HybridCactusImageSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCactusImage: public HybridCactusImageSpec {
+   * public:
+   *   HybridCactusImage(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCactusImageSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCactusImageSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCactusImageSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<std::string>> base64(const std::string& path) = 0;
+      virtual std::shared_ptr<Promise<std::string>> resize(const std::string& path, double height, double width, double quality) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "CactusImage";
+  };
+
+} // namespace margelo::nitro::cactus

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

@@ -16,7 +16,10 @@ namespace margelo::nitro::cactus {
     registerHybrids(this, [](Prototype& prototype) {
       prototype.registerHybridMethod("init", &HybridCactusSpec::init);
       prototype.registerHybridMethod("complete", &HybridCactusSpec::complete);
+      prototype.registerHybridMethod("transcribe", &HybridCactusSpec::transcribe);
       prototype.registerHybridMethod("embed", &HybridCactusSpec::embed);
+      prototype.registerHybridMethod("imageEmbed", &HybridCactusSpec::imageEmbed);
+      prototype.registerHybridMethod("audioEmbed", &HybridCactusSpec::audioEmbed);
       prototype.registerHybridMethod("reset", &HybridCactusSpec::reset);
       prototype.registerHybridMethod("stop", &HybridCactusSpec::stop);
       prototype.registerHybridMethod("destroy", &HybridCactusSpec::destroy);

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

@@ -54,7 +54,10 @@ namespace margelo::nitro::cactus {
       // Methods
       virtual std::shared_ptr<Promise<void>> init(const std::string& modelPath, double contextSize, const std::optional<std::string>& corpusDir) = 0;
       virtual std::shared_ptr<Promise<std::string>> complete(const std::string& messagesJson, double responseBufferSize, const std::optional<std::string>& optionsJson, const std::optional<std::string>& toolsJson, const std::optional<std::function<void(const std::string& /* token */, double /* tokenId */)>>& callback) = 0;
+      virtual std::shared_ptr<Promise<std::string>> transcribe(const std::string& audioFilePath, const std::string& prompt, double responseBufferSize, const std::optional<std::string>& optionsJson, const std::optional<std::function<void(const std::string& /* token */, double /* tokenId */)>>& callback) = 0;
       virtual std::shared_ptr<Promise<std::vector<double>>> embed(const std::string& text, double embeddingBufferSize) = 0;
+      virtual std::shared_ptr<Promise<std::vector<double>>> imageEmbed(const std::string& imagePath, double embeddingBufferSize) = 0;
+      virtual std::shared_ptr<Promise<std::vector<double>>> audioEmbed(const std::string& audioPath, double embeddingBufferSize) = 0;
       virtual std::shared_ptr<Promise<void>> reset() = 0;
       virtual std::shared_ptr<Promise<void>> stop() = 0;
       virtual std::shared_ptr<Promise<void>> destroy() = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cactus-react-native",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "description": "Run AI models locally on mobile devices",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/api/Database.ts

@@ -54,6 +54,33 @@ export class Database {
     return await CactusUtil.registerApp(await response.text());
   }
 
+  public static async getModel(slug: string): Promise<CactusModel> {
+    const response = await fetch(
+      `${this.url}/functions/v1/get-models?slug=${slug}&sdk_name=react&sdk_version=${packageVersion}`,
+      {
+        headers: { apikey: this.key, Authorization: `Bearer ${this.key}` },
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error('Getting model failed');
+    }
+
+    const model = (await response.json()) as CactusModelResponse;
+
+    return {
+      name: model.name,
+      slug: model.slug,
+      quantization: model.quantization,
+      sizeMb: model.size_mb,
+      downloadUrl: model.download_url,
+      supportsToolCalling: model.supports_tool_calling,
+      supportsVision: model.supports_vision,
+      createdAt: model.created_at,
+      isDownloaded: false,
+    };
+  }
+
   public static async getModels(): Promise<CactusModel[]> {
     const response = await fetch(
       `${this.url}/functions/v1/get-models?sdk_name=react&sdk_version=${packageVersion}`,