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

package/lib/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/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/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/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/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/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/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();
 

package/lib/nitrogen/generated/ios/swift/Func_void_double.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_double.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ rowIndex: 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 {
+  public typealias bridge = margelo.nitro.perpdepthbar.bridge.swift
+
+  private let closure: (_ rowIndex: Double) -> Void
+
+  public init(_ closure: @escaping (_ rowIndex: Double) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(rowIndex: Double) -> Void {
+    self.closure(rowIndex)
+  }
+
+  /**
+   * 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`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_double>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_double {
+    return Unmanaged<Func_void_double>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/lib/nitrogen/generated/ios/swift/HybridPerpDepthBarsSpec.swift

@@ -19,6 +19,14 @@ public protocol HybridPerpDepthBarsSpec_protocol: HybridObject, HybridView {
   var origin: String { get set }
   var reducedMotion: Bool { get set }
   var epoch: Double { get set }
+  var prices: [String] { get set }
+  var sizes: [String] { get set }
+  var priceColor: String { get set }
+  var sizeColor: String { get set }
+  var priceFontSize: Double { get set }
+  var sizeFontSize: Double { get set }
+  var textInset: Double { get set }
+  var onRowPress: ((_ rowIndex: Double) -> Void)? { get set }
 
   // Methods
   

package/lib/nitrogen/generated/ios/swift/HybridPerpDepthBarsSpec_cxx.swift

@@ -207,6 +207,127 @@ open class HybridPerpDepthBarsSpec_cxx {
       self.__implementation.epoch = newValue
     }
   }
+  
+  public final var prices: bridge.std__vector_std__string_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__vector_std__string_ in
+        var __vector = bridge.create_std__vector_std__string_(self.__implementation.prices.count)
+        for __item in self.__implementation.prices {
+          __vector.push_back(std.string(__item))
+        }
+        return __vector
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.prices = newValue.map({ __item in String(__item) })
+    }
+  }
+  
+  public final var sizes: bridge.std__vector_std__string_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__vector_std__string_ in
+        var __vector = bridge.create_std__vector_std__string_(self.__implementation.sizes.count)
+        for __item in self.__implementation.sizes {
+          __vector.push_back(std.string(__item))
+        }
+        return __vector
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.sizes = newValue.map({ __item in String(__item) })
+    }
+  }
+  
+  public final var priceColor: std.string {
+    @inline(__always)
+    get {
+      return std.string(self.__implementation.priceColor)
+    }
+    @inline(__always)
+    set {
+      self.__implementation.priceColor = String(newValue)
+    }
+  }
+  
+  public final var sizeColor: std.string {
+    @inline(__always)
+    get {
+      return std.string(self.__implementation.sizeColor)
+    }
+    @inline(__always)
+    set {
+      self.__implementation.sizeColor = String(newValue)
+    }
+  }
+  
+  public final var priceFontSize: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.priceFontSize
+    }
+    @inline(__always)
+    set {
+      self.__implementation.priceFontSize = newValue
+    }
+  }
+  
+  public final var sizeFontSize: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.sizeFontSize
+    }
+    @inline(__always)
+    set {
+      self.__implementation.sizeFontSize = newValue
+    }
+  }
+  
+  public final var textInset: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.textInset
+    }
+    @inline(__always)
+    set {
+      self.__implementation.textInset = newValue
+    }
+  }
+  
+  public final var onRowPress: bridge.std__optional_std__function_void_double____rowIndex______ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void_double____rowIndex______ in
+        if let __unwrappedValue = self.__implementation.onRowPress {
+          return bridge.create_std__optional_std__function_void_double____rowIndex______({ () -> bridge.Func_void_double in
+            let __closureWrapper = Func_void_double(__unwrappedValue)
+            return bridge.create_Func_void_double(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onRowPress = { () -> ((_ rowIndex: Double) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_double____rowIndex______(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_double____rowIndex______(newValue)
+          return { () -> (Double) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_double(__unwrapped)
+            return { (__rowIndex: Double) -> Void in
+              __wrappedFunction.call(__rowIndex)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
 
   // Methods
   public final func getView() -> UnsafeMutableRawPointer {

package/lib/nitrogen/generated/shared/c++/HybridPerpDepthBarsSpec.cpp

@@ -30,6 +30,22 @@ namespace margelo::nitro::perpdepthbar {
       prototype.registerHybridSetter("reducedMotion", &HybridPerpDepthBarsSpec::setReducedMotion);
       prototype.registerHybridGetter("epoch", &HybridPerpDepthBarsSpec::getEpoch);
       prototype.registerHybridSetter("epoch", &HybridPerpDepthBarsSpec::setEpoch);
+      prototype.registerHybridGetter("prices", &HybridPerpDepthBarsSpec::getPrices);
+      prototype.registerHybridSetter("prices", &HybridPerpDepthBarsSpec::setPrices);
+      prototype.registerHybridGetter("sizes", &HybridPerpDepthBarsSpec::getSizes);
+      prototype.registerHybridSetter("sizes", &HybridPerpDepthBarsSpec::setSizes);
+      prototype.registerHybridGetter("priceColor", &HybridPerpDepthBarsSpec::getPriceColor);
+      prototype.registerHybridSetter("priceColor", &HybridPerpDepthBarsSpec::setPriceColor);
+      prototype.registerHybridGetter("sizeColor", &HybridPerpDepthBarsSpec::getSizeColor);
+      prototype.registerHybridSetter("sizeColor", &HybridPerpDepthBarsSpec::setSizeColor);
+      prototype.registerHybridGetter("priceFontSize", &HybridPerpDepthBarsSpec::getPriceFontSize);
+      prototype.registerHybridSetter("priceFontSize", &HybridPerpDepthBarsSpec::setPriceFontSize);
+      prototype.registerHybridGetter("sizeFontSize", &HybridPerpDepthBarsSpec::getSizeFontSize);
+      prototype.registerHybridSetter("sizeFontSize", &HybridPerpDepthBarsSpec::setSizeFontSize);
+      prototype.registerHybridGetter("textInset", &HybridPerpDepthBarsSpec::getTextInset);
+      prototype.registerHybridSetter("textInset", &HybridPerpDepthBarsSpec::setTextInset);
+      prototype.registerHybridGetter("onRowPress", &HybridPerpDepthBarsSpec::getOnRowPress);
+      prototype.registerHybridSetter("onRowPress", &HybridPerpDepthBarsSpec::setOnRowPress);
     });
   }
 

package/lib/nitrogen/generated/shared/c++/HybridPerpDepthBarsSpec.hpp

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

package/lib/nitrogen/generated/shared/c++/views/HybridPerpDepthBarsComponent.cpp

@@ -105,6 +105,86 @@ namespace margelo::nitro::perpdepthbar::views {
         throw std::runtime_error(std::string("PerpDepthBars.epoch: ") + exc.what());
       }
     }()),
+    prices([&]() -> CachedProp<std::vector<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("prices", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.prices;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::vector<std::string>>::fromRawValue(*runtime, value, sourceProps.prices);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PerpDepthBars.prices: ") + exc.what());
+      }
+    }()),
+    sizes([&]() -> CachedProp<std::vector<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("sizes", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.sizes;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::vector<std::string>>::fromRawValue(*runtime, value, sourceProps.sizes);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PerpDepthBars.sizes: ") + exc.what());
+      }
+    }()),
+    priceColor([&]() -> CachedProp<std::string> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("priceColor", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.priceColor;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.priceColor);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PerpDepthBars.priceColor: ") + exc.what());
+      }
+    }()),
+    sizeColor([&]() -> CachedProp<std::string> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("sizeColor", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.sizeColor;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.sizeColor);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PerpDepthBars.sizeColor: ") + exc.what());
+      }
+    }()),
+    priceFontSize([&]() -> CachedProp<double> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("priceFontSize", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.priceFontSize;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.priceFontSize);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PerpDepthBars.priceFontSize: ") + exc.what());
+      }
+    }()),
+    sizeFontSize([&]() -> CachedProp<double> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("sizeFontSize", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.sizeFontSize;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.sizeFontSize);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PerpDepthBars.sizeFontSize: ") + exc.what());
+      }
+    }()),
+    textInset([&]() -> CachedProp<double> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("textInset", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.textInset;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.textInset);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PerpDepthBars.textInset: ") + exc.what());
+      }
+    }()),
+    onRowPress([&]() -> CachedProp<std::optional<std::function<void(double /* rowIndex */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onRowPress", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onRowPress;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(double /* rowIndex */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onRowPress);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PerpDepthBars.onRowPress: ") + exc.what());
+      }
+    }()),
     hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridPerpDepthBarsSpec>& /* ref */)>>> {
       try {
         const react::RawValue* rawValue = rawProps.at("hybridRef", nullptr, nullptr);
@@ -126,6 +206,14 @@ namespace margelo::nitro::perpdepthbar::views {
     origin(other.origin),
     reducedMotion(other.reducedMotion),
     epoch(other.epoch),
+    prices(other.prices),
+    sizes(other.sizes),
+    priceColor(other.priceColor),
+    sizeColor(other.sizeColor),
+    priceFontSize(other.priceFontSize),
+    sizeFontSize(other.sizeFontSize),
+    textInset(other.textInset),
+    onRowPress(other.onRowPress),
     hybridRef(other.hybridRef) { }
 
   bool HybridPerpDepthBarsProps::filterObjectKeys(const std::string& propName) {
@@ -138,6 +226,14 @@ namespace margelo::nitro::perpdepthbar::views {
       case hashString("origin"): return true;
       case hashString("reducedMotion"): return true;
       case hashString("epoch"): return true;
+      case hashString("prices"): return true;
+      case hashString("sizes"): return true;
+      case hashString("priceColor"): return true;
+      case hashString("sizeColor"): return true;
+      case hashString("priceFontSize"): return true;
+      case hashString("sizeFontSize"): return true;
+      case hashString("textInset"): return true;
+      case hashString("onRowPress"): return true;
       case hashString("hybridRef"): return true;
       default: return false;
     }

package/lib/nitrogen/generated/shared/c++/views/HybridPerpDepthBarsComponent.hpp

@@ -18,10 +18,10 @@
 
 #include <vector>
 #include <string>
-#include <memory>
-#include "HybridPerpDepthBarsSpec.hpp"
 #include <functional>
 #include <optional>
+#include <memory>
+#include "HybridPerpDepthBarsSpec.hpp"
 
 namespace margelo::nitro::perpdepthbar::views {
 
@@ -52,6 +52,14 @@ namespace margelo::nitro::perpdepthbar::views {
     CachedProp<std::string> origin;
     CachedProp<bool> reducedMotion;
     CachedProp<double> epoch;
+    CachedProp<std::vector<std::string>> prices;
+    CachedProp<std::vector<std::string>> sizes;
+    CachedProp<std::string> priceColor;
+    CachedProp<std::string> sizeColor;
+    CachedProp<double> priceFontSize;
+    CachedProp<double> sizeFontSize;
+    CachedProp<double> textInset;
+    CachedProp<std::optional<std::function<void(double /* rowIndex */)>>> onRowPress;
     CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridPerpDepthBarsSpec>& /* ref */)>>> hybridRef;
 
   private: