@onekeyfe/react-native-perp-depth-bar 3.0.39 → 3.0.42

package/lib/nitrogen/generated/shared/json/PerpDepthBarsConfig.json

@@ -12,6 +12,14 @@
     "origin": true,
     "reducedMotion": true,
     "epoch": true,
+    "prices": true,
+    "sizes": true,
+    "priceColor": true,
+    "sizeColor": true,
+    "priceFontSize": true,
+    "sizeFontSize": true,
+    "textInset": true,
+    "onRowPress": true,
     "hybridRef": true
   }
 }

package/lib/nitrogen/nitrogen/generated/android/c++/JFunc_void_double.hpp

@@ -0,0 +1,75 @@
+///
+/// JFunc_void_double.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::perpdepthbar {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(rowIndex: Double) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_double: public jni::JavaClass<JFunc_void_double> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/perpdepthbar/Func_void_double;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_double` instance holds through JNI.
+     */
+    void invoke(double rowIndex) const {
+      static const auto method = javaClassStatic()->getMethod<void(double /* rowIndex */)>("invoke");
+      method(self(), rowIndex);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_double that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_double_cxx final: public jni::HybridClass<JFunc_void_double_cxx, JFunc_void_double> {
+  public:
+    static jni::local_ref<JFunc_void_double::javaobject> fromCpp(const std::function<void(double /* rowIndex */)>& func) {
+      return JFunc_void_double_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_double_cxx` instance holds.
+     */
+    void invoke_cxx(double rowIndex) {
+      _func(rowIndex);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(double /* rowIndex */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/perpdepthbar/Func_void_double_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_double_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_double_cxx(const std::function<void(double /* rowIndex */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(double /* rowIndex */)> _func;
+  };
+
+} // namespace margelo::nitro::perpdepthbar

package/lib/nitrogen/nitrogen/generated/android/c++/JHybridPerpDepthBarsSpec.cpp

@@ -11,6 +11,10 @@
 
 #include <vector>
 #include <string>
+#include <functional>
+#include <optional>
+#include "JFunc_void_double.hpp"
+#include <NitroModules/JNICallable.hpp>
 
 namespace margelo::nitro::perpdepthbar {
 
@@ -123,6 +127,122 @@ namespace margelo::nitro::perpdepthbar {
     static const auto method = javaClassStatic()->getMethod<void(double /* epoch */)>("setEpoch");
     method(_javaPart, epoch);
   }
+  std::vector<std::string> JHybridPerpDepthBarsSpec::getPrices() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<jni::JString>>()>("getPrices");
+    auto __result = method(_javaPart);
+    return [&]() {
+      size_t __size = __result->size();
+      std::vector<std::string> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __result->getElement(__i);
+        __vector.push_back(__element->toStdString());
+      }
+      return __vector;
+    }();
+  }
+  void JHybridPerpDepthBarsSpec::setPrices(const std::vector<std::string>& prices) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<jni::JString>> /* prices */)>("setPrices");
+    method(_javaPart, [&]() {
+      size_t __size = prices.size();
+      jni::local_ref<jni::JArrayClass<jni::JString>> __array = jni::JArrayClass<jni::JString>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = prices[__i];
+        auto __elementJni = jni::make_jstring(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }());
+  }
+  std::vector<std::string> JHybridPerpDepthBarsSpec::getSizes() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<jni::JString>>()>("getSizes");
+    auto __result = method(_javaPart);
+    return [&]() {
+      size_t __size = __result->size();
+      std::vector<std::string> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __result->getElement(__i);
+        __vector.push_back(__element->toStdString());
+      }
+      return __vector;
+    }();
+  }
+  void JHybridPerpDepthBarsSpec::setSizes(const std::vector<std::string>& sizes) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<jni::JString>> /* sizes */)>("setSizes");
+    method(_javaPart, [&]() {
+      size_t __size = sizes.size();
+      jni::local_ref<jni::JArrayClass<jni::JString>> __array = jni::JArrayClass<jni::JString>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = sizes[__i];
+        auto __elementJni = jni::make_jstring(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }());
+  }
+  std::string JHybridPerpDepthBarsSpec::getPriceColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getPriceColor");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridPerpDepthBarsSpec::setPriceColor(const std::string& priceColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* priceColor */)>("setPriceColor");
+    method(_javaPart, jni::make_jstring(priceColor));
+  }
+  std::string JHybridPerpDepthBarsSpec::getSizeColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getSizeColor");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridPerpDepthBarsSpec::setSizeColor(const std::string& sizeColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* sizeColor */)>("setSizeColor");
+    method(_javaPart, jni::make_jstring(sizeColor));
+  }
+  double JHybridPerpDepthBarsSpec::getPriceFontSize() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getPriceFontSize");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridPerpDepthBarsSpec::setPriceFontSize(double priceFontSize) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* priceFontSize */)>("setPriceFontSize");
+    method(_javaPart, priceFontSize);
+  }
+  double JHybridPerpDepthBarsSpec::getSizeFontSize() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getSizeFontSize");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridPerpDepthBarsSpec::setSizeFontSize(double sizeFontSize) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* sizeFontSize */)>("setSizeFontSize");
+    method(_javaPart, sizeFontSize);
+  }
+  double JHybridPerpDepthBarsSpec::getTextInset() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getTextInset");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridPerpDepthBarsSpec::setTextInset(double textInset) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* textInset */)>("setTextInset");
+    method(_javaPart, textInset);
+  }
+  std::optional<std::function<void(double /* rowIndex */)>> JHybridPerpDepthBarsSpec::getOnRowPress() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_double::javaobject>()>("getOnRowPress_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(double /* rowIndex */)> {
+      if (__result->isInstanceOf(JFunc_void_double_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_double_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_double, void(double)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridPerpDepthBarsSpec::setOnRowPress(const std::optional<std::function<void(double /* rowIndex */)>>& onRowPress) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_double::javaobject> /* onRowPress */)>("setOnRowPress_cxx");
+    method(_javaPart, onRowPress.has_value() ? JFunc_void_double_cxx::fromCpp(onRowPress.value()) : nullptr);
+  }
 
   // Methods
   

package/lib/nitrogen/nitrogen/generated/android/c++/JHybridPerpDepthBarsSpec.hpp

@@ -66,6 +66,22 @@ namespace margelo::nitro::perpdepthbar {
     void setReducedMotion(bool reducedMotion) override;
     double getEpoch() override;
     void setEpoch(double epoch) override;
+    std::vector<std::string> getPrices() override;
+    void setPrices(const std::vector<std::string>& prices) override;
+    std::vector<std::string> getSizes() override;
+    void setSizes(const std::vector<std::string>& sizes) override;
+    std::string getPriceColor() override;
+    void setPriceColor(const std::string& priceColor) override;
+    std::string getSizeColor() override;
+    void setSizeColor(const std::string& sizeColor) override;
+    double getPriceFontSize() override;
+    void setPriceFontSize(double priceFontSize) override;
+    double getSizeFontSize() override;
+    void setSizeFontSize(double sizeFontSize) override;
+    double getTextInset() override;
+    void setTextInset(double textInset) override;
+    std::optional<std::function<void(double /* rowIndex */)>> getOnRowPress() override;
+    void setOnRowPress(const std::optional<std::function<void(double /* rowIndex */)>>& onRowPress) override;
 
   public:
     // Methods

package/lib/nitrogen/nitrogen/generated/android/c++/views/JHybridPerpDepthBarsStateUpdater.cpp

@@ -68,6 +68,38 @@ void JHybridPerpDepthBarsStateUpdater::updateViewProps(jni::alias_ref<jni::JClas
     view->setEpoch(props.epoch.value);
     // TODO: Set isDirty = false
   }
+  if (props.prices.isDirty) {
+    view->setPrices(props.prices.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.sizes.isDirty) {
+    view->setSizes(props.sizes.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.priceColor.isDirty) {
+    view->setPriceColor(props.priceColor.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.sizeColor.isDirty) {
+    view->setSizeColor(props.sizeColor.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.priceFontSize.isDirty) {
+    view->setPriceFontSize(props.priceFontSize.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.sizeFontSize.isDirty) {
+    view->setSizeFontSize(props.sizeFontSize.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.textInset.isDirty) {
+    view->setTextInset(props.textInset.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.onRowPress.isDirty) {
+    view->setOnRowPress(props.onRowPress.value);
+    // TODO: Set isDirty = false
+  }
 
   // Update hybridRef if it changed
   if (props.hybridRef.isDirty) {

package/lib/nitrogen/nitrogen/generated/android/kotlin/com/margelo/nitro/perpdepthbar/Func_void_double.kt

@@ -0,0 +1,80 @@
+///
+/// Func_void_double.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.perpdepthbar
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `(rowIndex: 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) -> 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(rowIndex: Double): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(rowIndex: 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_cxx: Func_void_double {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(rowIndex: Double): Unit
+    = invoke_cxx(rowIndex)
+
+  @FastNative
+  private external fun invoke_cxx(rowIndex: Double): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(rowIndex: number) => void`.
+ * This is implemented in Java/Kotlin, via a `(Double) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_double_java(private val function: (Double) -> Unit): Func_void_double {
+  @DoNotStrip
+  @Keep
+  override fun invoke(rowIndex: Double): Unit {
+    return this.function(rowIndex)
+  }
+}

package/lib/nitrogen/nitrogen/generated/android/kotlin/com/margelo/nitro/perpdepthbar/HybridPerpDepthBarsSpec.kt

@@ -89,6 +89,62 @@ abstract class HybridPerpDepthBarsSpec: HybridView() {
   @set:DoNotStrip
   @set:Keep
   abstract var epoch: Double
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var prices: Array<String>
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var sizes: Array<String>
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var priceColor: String
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var sizeColor: String
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var priceFontSize: Double
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var sizeFontSize: Double
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var textInset: Double
+  
+  abstract var onRowPress: ((rowIndex: Double) -> Unit)?
+  
+  private var onRowPress_cxx: Func_void_double?
+    @Keep
+    @DoNotStrip
+    get() {
+      return onRowPress?.let { Func_void_double_java(it) }
+    }
+    @Keep
+    @DoNotStrip
+    set(value) {
+      onRowPress = value?.let { it }
+    }
 
   // Methods
   

package/lib/nitrogen/nitrogen/generated/android/perpdepthbarOnLoad.cpp

@@ -16,6 +16,7 @@
 #include <NitroModules/HybridObjectRegistry.hpp>
 
 #include "JHybridPerpDepthBarsSpec.hpp"
+#include "JFunc_void_double.hpp"
 #include "views/JHybridPerpDepthBarsStateUpdater.hpp"
 #include "JHybridPerpSideRatioSpec.hpp"
 #include "views/JHybridPerpSideRatioStateUpdater.hpp"
@@ -31,6 +32,7 @@ int initialize(JavaVM* vm) {
   return facebook::jni::initialize(vm, [] {
     // Register native JNI methods
     margelo::nitro::perpdepthbar::JHybridPerpDepthBarsSpec::registerNatives();
+    margelo::nitro::perpdepthbar::JFunc_void_double_cxx::registerNatives();
     margelo::nitro::perpdepthbar::views::JHybridPerpDepthBarsStateUpdater::registerNatives();
     margelo::nitro::perpdepthbar::JHybridPerpSideRatioSpec::registerNatives();
     margelo::nitro::perpdepthbar::views::JHybridPerpSideRatioStateUpdater::registerNatives();

package/lib/nitrogen/nitrogen/generated/ios/PerpDepthBar-Swift-Cxx-Bridge.cpp

@@ -15,6 +15,14 @@
 
 namespace margelo::nitro::perpdepthbar::bridge::swift {
 
+  // pragma MARK: std::function<void(double /* rowIndex */)>
+  Func_void_double create_Func_void_double(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = PerpDepthBar::Func_void_double::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](double rowIndex) mutable -> void {
+      swiftClosure.call(rowIndex);
+    };
+  }
+  
   // pragma MARK: std::shared_ptr<HybridPerpDepthBarsSpec>
   std::shared_ptr<HybridPerpDepthBarsSpec> create_std__shared_ptr_HybridPerpDepthBarsSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     PerpDepthBar::HybridPerpDepthBarsSpec_cxx swiftPart = PerpDepthBar::HybridPerpDepthBarsSpec_cxx::fromUnsafe(swiftUnsafePointer);

package/lib/nitrogen/nitrogen/generated/ios/PerpDepthBar-Swift-Cxx-Bridge.hpp

@@ -22,7 +22,10 @@ namespace PerpDepthBar { class HybridPerpSideRatioSpec_cxx; }
 // Include C++ defined types
 #include "HybridPerpDepthBarsSpec.hpp"
 #include "HybridPerpSideRatioSpec.hpp"
+#include <functional>
 #include <memory>
+#include <optional>
+#include <string>
 #include <vector>
 
 /**
@@ -42,6 +45,54 @@ namespace margelo::nitro::perpdepthbar::bridge::swift {
     return vector;
   }
   
+  // pragma MARK: std::vector<std::string>
+  /**
+   * Specialized version of `std::vector<std::string>`.
+   */
+  using std__vector_std__string_ = std::vector<std::string>;
+  inline std::vector<std::string> create_std__vector_std__string_(size_t size) noexcept {
+    std::vector<std::string> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::function<void(double /* rowIndex */)>
+  /**
+   * Specialized version of `std::function<void(double)>`.
+   */
+  using Func_void_double = std::function<void(double /* rowIndex */)>;
+  /**
+   * Wrapper class for a `std::function<void(double / * rowIndex * /)>`, this can be used from Swift.
+   */
+  class Func_void_double_Wrapper final {
+  public:
+    explicit Func_void_double_Wrapper(std::function<void(double /* rowIndex */)>&& func): _function(std::make_unique<std::function<void(double /* rowIndex */)>>(std::move(func))) {}
+    inline void call(double rowIndex) const noexcept {
+      _function->operator()(rowIndex);
+    }
+  private:
+    std::unique_ptr<std::function<void(double /* rowIndex */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_double create_Func_void_double(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_double_Wrapper wrap_Func_void_double(Func_void_double value) noexcept {
+    return Func_void_double_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void(double /* rowIndex */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(double / * rowIndex * /)>>`.
+   */
+  using std__optional_std__function_void_double____rowIndex______ = std::optional<std::function<void(double /* rowIndex */)>>;
+  inline std::optional<std::function<void(double /* rowIndex */)>> create_std__optional_std__function_void_double____rowIndex______(const std::function<void(double /* rowIndex */)>& value) noexcept {
+    return std::optional<std::function<void(double /* rowIndex */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_double____rowIndex______(const std::optional<std::function<void(double /* rowIndex */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(double /* rowIndex */)> get_std__optional_std__function_void_double____rowIndex______(const std::optional<std::function<void(double /* rowIndex */)>>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::shared_ptr<HybridPerpDepthBarsSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridPerpDepthBarsSpec>`.

package/lib/nitrogen/nitrogen/generated/ios/PerpDepthBar-Swift-Cxx-Umbrella.hpp

@@ -16,7 +16,9 @@ namespace margelo::nitro::perpdepthbar { class HybridPerpSideRatioSpec; }
 // Include C++ defined types
 #include "HybridPerpDepthBarsSpec.hpp"
 #include "HybridPerpSideRatioSpec.hpp"
+#include <functional>
 #include <memory>
+#include <optional>
 #include <string>
 #include <vector>
 

package/lib/nitrogen/nitrogen/generated/ios/c++/HybridPerpDepthBarsSpecSwift.hpp

@@ -16,6 +16,8 @@ namespace PerpDepthBar { class HybridPerpDepthBarsSpec_cxx; }
 
 #include <vector>
 #include <string>
+#include <functional>
+#include <optional>
 
 #include "PerpDepthBar-Swift-Cxx-Umbrella.hpp"
 
@@ -108,6 +110,59 @@ namespace margelo::nitro::perpdepthbar {
     inline void setEpoch(double epoch) noexcept override {
       _swiftPart.setEpoch(std::forward<decltype(epoch)>(epoch));
     }
+    inline std::vector<std::string> getPrices() noexcept override {
+      auto __result = _swiftPart.getPrices();
+      return __result;
+    }
+    inline void setPrices(const std::vector<std::string>& prices) noexcept override {
+      _swiftPart.setPrices(prices);
+    }
+    inline std::vector<std::string> getSizes() noexcept override {
+      auto __result = _swiftPart.getSizes();
+      return __result;
+    }
+    inline void setSizes(const std::vector<std::string>& sizes) noexcept override {
+      _swiftPart.setSizes(sizes);
+    }
+    inline std::string getPriceColor() noexcept override {
+      auto __result = _swiftPart.getPriceColor();
+      return __result;
+    }
+    inline void setPriceColor(const std::string& priceColor) noexcept override {
+      _swiftPart.setPriceColor(priceColor);
+    }
+    inline std::string getSizeColor() noexcept override {
+      auto __result = _swiftPart.getSizeColor();
+      return __result;
+    }
+    inline void setSizeColor(const std::string& sizeColor) noexcept override {
+      _swiftPart.setSizeColor(sizeColor);
+    }
+    inline double getPriceFontSize() noexcept override {
+      return _swiftPart.getPriceFontSize();
+    }
+    inline void setPriceFontSize(double priceFontSize) noexcept override {
+      _swiftPart.setPriceFontSize(std::forward<decltype(priceFontSize)>(priceFontSize));
+    }
+    inline double getSizeFontSize() noexcept override {
+      return _swiftPart.getSizeFontSize();
+    }
+    inline void setSizeFontSize(double sizeFontSize) noexcept override {
+      _swiftPart.setSizeFontSize(std::forward<decltype(sizeFontSize)>(sizeFontSize));
+    }
+    inline double getTextInset() noexcept override {
+      return _swiftPart.getTextInset();
+    }
+    inline void setTextInset(double textInset) noexcept override {
+      _swiftPart.setTextInset(std::forward<decltype(textInset)>(textInset));
+    }
+    inline std::optional<std::function<void(double /* rowIndex */)>> getOnRowPress() noexcept override {
+      auto __result = _swiftPart.getOnRowPress();
+      return __result;
+    }
+    inline void setOnRowPress(const std::optional<std::function<void(double /* rowIndex */)>>& onRowPress) noexcept override {
+      _swiftPart.setOnRowPress(onRowPress);
+    }
 
   public:
     // Methods

package/lib/nitrogen/nitrogen/generated/ios/c++/views/HybridPerpDepthBarsComponent.mm

@@ -111,6 +111,46 @@ using namespace margelo::nitro::perpdepthbar::views;
     swiftPart.setEpoch(newViewProps.epoch.value);
     newViewProps.epoch.isDirty = false;
   }
+  // prices: array
+  if (newViewProps.prices.isDirty) {
+    swiftPart.setPrices(newViewProps.prices.value);
+    newViewProps.prices.isDirty = false;
+  }
+  // sizes: array
+  if (newViewProps.sizes.isDirty) {
+    swiftPart.setSizes(newViewProps.sizes.value);
+    newViewProps.sizes.isDirty = false;
+  }
+  // priceColor: string
+  if (newViewProps.priceColor.isDirty) {
+    swiftPart.setPriceColor(newViewProps.priceColor.value);
+    newViewProps.priceColor.isDirty = false;
+  }
+  // sizeColor: string
+  if (newViewProps.sizeColor.isDirty) {
+    swiftPart.setSizeColor(newViewProps.sizeColor.value);
+    newViewProps.sizeColor.isDirty = false;
+  }
+  // priceFontSize: number
+  if (newViewProps.priceFontSize.isDirty) {
+    swiftPart.setPriceFontSize(newViewProps.priceFontSize.value);
+    newViewProps.priceFontSize.isDirty = false;
+  }
+  // sizeFontSize: number
+  if (newViewProps.sizeFontSize.isDirty) {
+    swiftPart.setSizeFontSize(newViewProps.sizeFontSize.value);
+    newViewProps.sizeFontSize.isDirty = false;
+  }
+  // textInset: number
+  if (newViewProps.textInset.isDirty) {
+    swiftPart.setTextInset(newViewProps.textInset.value);
+    newViewProps.textInset.isDirty = false;
+  }
+  // onRowPress: optional
+  if (newViewProps.onRowPress.isDirty) {
+    swiftPart.setOnRowPress(newViewProps.onRowPress.value);
+    newViewProps.onRowPress.isDirty = false;
+  }
 
   swiftPart.afterUpdate();