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

package/android/src/main/java/com/margelo/nitro/perpdepthbar/HybridPerpDepthBars.kt

@@ -3,6 +3,7 @@ package com.margelo.nitro.perpdepthbar
 import android.animation.ValueAnimator
 import android.graphics.Canvas
 import android.graphics.Paint
+import android.view.MotionEvent
 import android.view.View
 import android.view.animation.PathInterpolator
 import com.facebook.proguard.annotations.DoNotStrip
@@ -18,6 +19,8 @@ class HybridPerpDepthBars(val context: ThemedReactContext) : HybridPerpDepthBars
 
   private val density = context.resources.displayMetrics.density
   private val paint = Paint(Paint.ANTI_ALIAS_FLAG)
+  private val pricePaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { textAlign = Paint.Align.LEFT }
+  private val sizePaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { textAlign = Paint.Align.RIGHT }
 
   private var current = DoubleArray(0)
   private var start = DoubleArray(0)
@@ -31,9 +34,21 @@ class HybridPerpDepthBars(val context: ThemedReactContext) : HybridPerpDepthBars
   override val view: View = object : View(context) {
     override fun onDraw(canvas: Canvas) {
       drawBars(canvas)
+      drawTexts(canvas)
+    }
+
+    override fun onTouchEvent(event: MotionEvent): Boolean {
+      when (event.action) {
+        MotionEvent.ACTION_DOWN -> return true // claim the gesture
+        MotionEvent.ACTION_UP -> {
+          handleTap(event.y)
+          return true
+        }
+      }
+      return super.onTouchEvent(event)
     }
   }.apply {
-    isClickable = false
+    isClickable = true
     isFocusable = false
   }
 
@@ -75,6 +90,67 @@ class HybridPerpDepthBars(val context: ThemedReactContext) : HybridPerpDepthBars
       view.invalidate()
     }
 
+  // MARK: - Text props
+  override var prices: Array<String> = emptyArray()
+    get() = field
+    set(value) { if (!isDisposed) { field = value; view.invalidate() } }
+
+  override var sizes: Array<String> = emptyArray()
+    get() = field
+    set(value) { if (!isDisposed) { field = value; view.invalidate() } }
+
+  override var priceColor: String = ""
+    get() = field
+    set(value) {
+      if (isDisposed) return
+      field = value
+      pricePaint.color = PerpColorParser.parse(value)
+      view.invalidate()
+    }
+
+  override var sizeColor: String = ""
+    get() = field
+    set(value) {
+      if (isDisposed) return
+      field = value
+      sizePaint.color = PerpColorParser.parse(value)
+      view.invalidate()
+    }
+
+  override var priceFontSize: Double = 11.0
+    get() = field
+    set(value) {
+      if (isDisposed) return
+      field = value
+      pricePaint.textSize = (value * density).toFloat()
+      view.invalidate()
+    }
+
+  override var sizeFontSize: Double = 11.0
+    get() = field
+    set(value) {
+      if (isDisposed) return
+      field = value
+      sizePaint.textSize = (value * density).toFloat()
+      view.invalidate()
+    }
+
+  override var textInset: Double = 0.0
+    get() = field
+    set(value) { if (!isDisposed) { field = value; view.invalidate() } }
+
+  override var onRowPress: ((rowIndex: Double) -> Unit)? = null
+
+  private fun handleTap(y: Float) {
+    if (isDisposed) return
+    val step = ((rowHeight + rowMarginTop) * density).toFloat()
+    if (step <= 0f) return
+    val mt = (rowMarginTop * density).toFloat()
+    val i = ((y - mt) / step).toInt()
+    val count = maxOf(percents.size, maxOf(prices.size, sizes.size))
+    if (i in 0 until count) onRowPress?.invoke(i.toDouble())
+  }
+
   /**
    * Called by Nitro once after a prop-update transaction. Recompute targets and
    * (re)start the animation here so a multi-prop update animates once.
@@ -148,6 +224,29 @@ class HybridPerpDepthBars(val context: ThemedReactContext) : HybridPerpDepthBars
     }
   }
 
+  private fun drawTexts(canvas: Canvas) {
+    if (prices.isEmpty() && sizes.isEmpty()) return
+    val w = view.width.toFloat()
+    if (w <= 0f) return
+    val rh = (rowHeight * density).toFloat()
+    val mt = (rowMarginTop * density).toFloat()
+    val pad = (textInset * density).toFloat()
+    val rightX = w - pad
+    val rows = maxOf(prices.size, sizes.size)
+    for (i in 0 until rows) {
+      val rowTop = mt + i * (rh + mt)
+      // Vertically center single-line text within the row.
+      if (i < prices.size && prices[i].isNotEmpty()) {
+        val baseline = rowTop + rh / 2f - (pricePaint.descent() + pricePaint.ascent()) / 2f
+        canvas.drawText(prices[i], pad, baseline, pricePaint)
+      }
+      if (i < sizes.size && sizes[i].isNotEmpty()) {
+        val baseline = rowTop + rh / 2f - (sizePaint.descent() + sizePaint.ascent()) / 2f
+        canvas.drawText(sizes[i], rightX, baseline, sizePaint)
+      }
+    }
+  }
+
   private fun clampFrac(percent: Double): Double =
     (percent.coerceIn(0.0, 100.0)) / 100.0
 

package/ios/HybridPerpDepthBars.swift

@@ -12,6 +12,11 @@ final class HybridPerpDepthBars: HybridPerpDepthBarsSpec {
   // MARK: - Per-row fill layers
   private var barLayers: [CALayer] = []
 
+  // MARK: - Per-row text layers (price left, size right)
+  private var priceLayers: [CATextLayer] = []
+  private var sizeLayers: [CATextLayer] = []
+  private let textScale = UIScreen.main.scale
+
   // MARK: - State for animation decisions
   private var lastPercents: [Double] = []
   private var lastEpoch: Double = .nan
@@ -34,13 +39,49 @@ final class HybridPerpDepthBars: HybridPerpDepthBarsSpec {
   }
   private var cachedColor: CGColor = UIColor.clear.cgColor
 
+  // MARK: - Text props
+  var prices: [String] = [] { didSet { scheduleLayout() } }
+  var sizes: [String] = [] { didSet { scheduleLayout() } }
+  var priceFontSize: Double = 11 { didSet { scheduleLayout() } }
+  var sizeFontSize: Double = 11 { didSet { scheduleLayout() } }
+  var textInset: Double = 0 { didSet { scheduleLayout() } }
+
+  var priceColor: String = "" {
+    didSet {
+      cachedPriceColor = PerpColorParser.parse(priceColor).cgColor
+      scheduleLayout()
+    }
+  }
+  var sizeColor: String = "" {
+    didSet {
+      cachedSizeColor = PerpColorParser.parse(sizeColor).cgColor
+      scheduleLayout()
+    }
+  }
+  private var cachedPriceColor: CGColor = UIColor.black.cgColor
+  private var cachedSizeColor: CGColor = UIColor.gray.cgColor
+
+  // MARK: - Tap callback (native row hit-testing)
+  var onRowPress: ((Double) -> Void)?
+
   // MARK: - Init
   override init() {
     super.init()
-    view.isUserInteractionEnabled = false // taps handled by RN overlay
+    view.isUserInteractionEnabled = true // native row tap handling
     view.clipsToBounds = true
     if let layoutView = view as? PerpLayoutView {
       layoutView.onLayout = { [weak self] in self?.performLayout() }
+      layoutView.onTap = { [weak self] y in self?.handleTap(atY: y) }
+    }
+  }
+
+  private func handleTap(atY y: CGFloat) {
+    let step = CGFloat(rowHeight + rowMarginTop)
+    guard step > 0 else { return }
+    let i = Int((y - CGFloat(rowMarginTop)) / step)
+    let count = max(percents.count, max(prices.count, sizes.count))
+    if i >= 0 && i < count {
+      onRowPress?(Double(i))
     }
   }
 
@@ -55,6 +96,7 @@ final class HybridPerpDepthBars: HybridPerpDepthBarsSpec {
 
     let count = percents.count
     syncLayerCount(count)
+    syncTextLayerCount(count)
 
     // Decide whether this update should animate or snap.
     let epochChanged = epoch != lastEpoch
@@ -94,11 +136,65 @@ final class HybridPerpDepthBars: HybridPerpDepthBarsSpec {
 
     CATransaction.commit()
 
+    // Text never animates — snap frames/strings each layout pass.
+    CATransaction.begin()
+    CATransaction.setDisableActions(true)
+    let half = rowW / 2
+    let pad = CGFloat(textInset)
+    for i in 0..<count {
+      let rowTop = CGFloat(rowMarginTop) + CGFloat(i) * (h + CGFloat(rowMarginTop))
+      let priceLine = CGFloat(priceFontSize) * 1.16
+      let sizeLine = CGFloat(sizeFontSize) * 1.16
+      let priceLayer = priceLayers[i]
+      priceLayer.frame = CGRect(
+        x: pad, y: rowTop + (h - priceLine) / 2,
+        width: max(half - pad, 0), height: priceLine)
+      priceLayer.fontSize = CGFloat(priceFontSize)
+      priceLayer.foregroundColor = cachedPriceColor
+      priceLayer.string = i < prices.count ? prices[i] : ""
+
+      let sizeLayer = sizeLayers[i]
+      sizeLayer.frame = CGRect(
+        x: half, y: rowTop + (h - sizeLine) / 2,
+        width: max(half - pad, 0), height: sizeLine)
+      sizeLayer.fontSize = CGFloat(sizeFontSize)
+      sizeLayer.foregroundColor = cachedSizeColor
+      sizeLayer.string = i < sizes.count ? sizes[i] : ""
+    }
+    CATransaction.commit()
+
     lastPercents = percents
     lastEpoch = epoch
     hasLaidOut = true
   }
 
+  private func makeTextLayer(alignment: CATextLayerAlignmentMode) -> CATextLayer {
+    let l = CATextLayer()
+    l.contentsScale = textScale
+    l.alignmentMode = alignment
+    l.truncationMode = .none
+    l.isWrapped = false
+    return l
+  }
+
+  private func syncTextLayerCount(_ count: Int) {
+    if priceLayers.count < count {
+      for _ in priceLayers.count..<count {
+        let p = makeTextLayer(alignment: .left)
+        let s = makeTextLayer(alignment: .right)
+        view.layer.addSublayer(p)
+        view.layer.addSublayer(s)
+        priceLayers.append(p)
+        sizeLayers.append(s)
+      }
+    } else if priceLayers.count > count {
+      for l in priceLayers[count...] { l.removeFromSuperlayer() }
+      for l in sizeLayers[count...] { l.removeFromSuperlayer() }
+      priceLayers.removeLast(priceLayers.count - count)
+      sizeLayers.removeLast(sizeLayers.count - count)
+    }
+  }
+
   private func animateScaleX(layer: CALayer, to target: CGFloat) {
     // Continue from the on-screen (presentation) value to avoid snap-back when
     // a new animation starts every tick (~10Hz).

package/ios/PerpColorParser.swift

@@ -84,9 +84,17 @@ enum PerpTiming {
 /// HybridView can re-lay-out its CALayers when bounds change.
 final class PerpLayoutView: UIView {
   var onLayout: (() -> Void)?
+  /// Native tap handler — receives the tap's y in view coordinates (points).
+  var onTap: ((CGFloat) -> Void)?
 
   override func layoutSubviews() {
     super.layoutSubviews()
     onLayout?()
   }
+
+  override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {
+    super.touchesEnded(touches, with: event)
+    guard let onTap, let touch = touches.first else { return }
+    onTap(touch.location(in: self).y)
+  }
 }

package/lib/module/index.js

@@ -1,8 +1,31 @@
 "use strict";
 
-import { getHostComponent } from 'react-native-nitro-modules';
+import { useCallback, useRef } from 'react';
+import { callback, getHostComponent } from 'react-native-nitro-modules';
+import { jsx as _jsx } from "react/jsx-runtime";
 const PerpDepthBarsConfig = require('../nitrogen/generated/shared/json/PerpDepthBarsConfig.json');
 const PerpSideRatioConfig = require('../nitrogen/generated/shared/json/PerpSideRatioConfig.json');
-export const PerpDepthBarsView = getHostComponent('PerpDepthBars', () => PerpDepthBarsConfig);
+const PerpDepthBarsHost = getHostComponent('PerpDepthBars', () => PerpDepthBarsConfig);
+
+/**
+ * Thin wrapper so consumers pass a plain `onRowPress` function. Nitro view
+ * callbacks must be wrapped with `callback(...)` to cross the JSI boundary;
+ * we encapsulate that here (with a ref so the underlying callback stays
+ * stable across re-renders) instead of leaking it to every call site.
+ */
+export function PerpDepthBarsView({
+  onRowPress,
+  ...props
+}) {
+  const onRowPressRef = useRef(onRowPress);
+  onRowPressRef.current = onRowPress;
+  const stableOnRowPress = useCallback(rowIndex => {
+    onRowPressRef.current?.(rowIndex);
+  }, []);
+  return /*#__PURE__*/_jsx(PerpDepthBarsHost, {
+    ...props,
+    onRowPress: onRowPress ? callback(stableOnRowPress) : undefined
+  });
+}
 export const PerpSideRatioView = getHostComponent('PerpSideRatio', () => PerpSideRatioConfig);
 //# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["getHostComponent","PerpDepthBarsConfig","require","PerpSideRatioConfig","PerpDepthBarsView","PerpSideRatioView"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,gBAAgB,QAAQ,4BAA4B;AAW7D,MAAMC,mBAAmB,GAAGC,OAAO,CAAC,4DAA4D,CAAC;AACjG,MAAMC,mBAAmB,GAAGD,OAAO,CAAC,4DAA4D,CAAC;AASjG,OAAO,MAAME,iBAAiB,GAAGJ,gBAAgB,CAG/C,eAAe,EAAE,MAAMC,mBAAmB,CAAC;AAE7C,OAAO,MAAMI,iBAAiB,GAAGL,gBAAgB,CAG/C,eAAe,EAAE,MAAMG,mBAAmB,CAAC","ignoreList":[]}
+{"version":3,"names":["useCallback","useRef","callback","getHostComponent","jsx","_jsx","PerpDepthBarsConfig","require","PerpSideRatioConfig","PerpDepthBarsHost","PerpDepthBarsView","onRowPress","props","onRowPressRef","current","stableOnRowPress","rowIndex","undefined","PerpSideRatioView"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,WAAW,EAAEC,MAAM,QAAQ,OAAO;AAC3C,SAASC,QAAQ,EAAEC,gBAAgB,QAAQ,4BAA4B;AAAC,SAAAC,GAAA,IAAAC,IAAA;AAWxE,MAAMC,mBAAmB,GAAGC,OAAO,CAAC,4DAA4D,CAAC;AACjG,MAAMC,mBAAmB,GAAGD,OAAO,CAAC,4DAA4D,CAAC;AASjG,MAAME,iBAAiB,GAAGN,gBAAgB,CAGxC,eAAe,EAAE,MAAMG,mBAAmB,CAAC;;AAE7C;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASI,iBAAiBA,CAAC;EAChCC,UAAU;EACV,GAAGC;AACe,CAAC,EAAE;EACrB,MAAMC,aAAa,GAAGZ,MAAM,CAACU,UAAU,CAAC;EACxCE,aAAa,CAACC,OAAO,GAAGH,UAAU;EAElC,MAAMI,gBAAgB,GAAGf,WAAW,CAAEgB,QAAgB,IAAK;IACzDH,aAAa,CAACC,OAAO,GAAGE,QAAQ,CAAC;EACnC,CAAC,EAAE,EAAE,CAAC;EAEN,oBACEX,IAAA,CAACI,iBAAiB;IAAA,GACZG,KAAK;IACTD,UAAU,EAAEA,UAAU,GAAGT,QAAQ,CAACa,gBAAgB,CAAC,GAAGE;EAAU,CACjE,CAAC;AAEN;AAEA,OAAO,MAAMC,iBAAiB,GAAGf,gBAAgB,CAG/C,eAAe,EAAE,MAAMK,mBAAmB,CAAC","ignoreList":[]}

package/lib/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/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/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/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/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)
+  }
+}