@onekeyfe/react-native-perp-depth-bar 3.0.48 → 3.0.52

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

@@ -7,6 +7,8 @@ import android.view.MotionEvent
 import android.view.View
 import com.facebook.proguard.annotations.DoNotStrip
 import com.facebook.react.uimanager.ThemedReactContext
+import com.margelo.nitro.core.ArrayBuffer
+import java.nio.ByteOrder
 import kotlin.math.abs
 import kotlin.math.exp
 
@@ -34,6 +36,12 @@ class HybridPerpDepthBars(val context: ThemedReactContext) : HybridPerpDepthBars
   private var lastEpoch = Double.NaN
   private var hasDrawn = false
   private var isDisposed = false
+  // Set once the caller drives depth through the imperative `setDepth` path. In
+  // that mode the `percents` prop is intentionally left empty, so `afterUpdate`
+  // must NOT re-sync targets from it — doing so would wipe `current` to an empty
+  // array on every unrelated prop commit (e.g. high-frequency prices/sizes text
+  // updates), blanking the bars between `setDepth` calls (REACT-NATIVE-1JZ).
+  private var imperativeDepth = false
 
   private val choreographer = Choreographer.getInstance()
   private var frameScheduled = false
@@ -42,8 +50,12 @@ class HybridPerpDepthBars(val context: ThemedReactContext) : HybridPerpDepthBars
 
   override val view: View = object : View(context) {
     override fun onDraw(canvas: Canvas) {
-      drawBars(canvas)
-      drawTexts(canvas)
+      if (hasRealData()) {
+        drawBars(canvas)
+        drawTexts(canvas)
+      } else {
+        drawPlaceholder(canvas)
+      }
     }
 
     override fun onTouchEvent(event: MotionEvent): Boolean {
@@ -101,13 +113,32 @@ class HybridPerpDepthBars(val context: ThemedReactContext) : HybridPerpDepthBars
     }
 
   // MARK: - Text props
+  // The strings actually drawn each frame. Decoupled from the `prices`/`sizes`
+  // props so the imperative `setText` path can drive them without the prop
+  // setters clobbering the values on unrelated prop commits (REACT-NATIVE-1JZ).
+  private var displayPrices: Array<String> = emptyArray()
+  private var displaySizes: Array<String> = emptyArray()
+  // Set once the caller drives text through `setText`; the `prices`/`sizes` props
+  // are then ignored (they are left empty in that mode).
+  private var imperativeText = false
+
   override var prices: Array<String> = emptyArray()
     get() = field
-    set(value) { if (!isDisposed) { field = value; view.invalidate() } }
+    set(value) {
+      if (isDisposed || imperativeText) return
+      field = value
+      displayPrices = value
+      view.invalidate()
+    }
 
   override var sizes: Array<String> = emptyArray()
     get() = field
-    set(value) { if (!isDisposed) { field = value; view.invalidate() } }
+    set(value) {
+      if (isDisposed || imperativeText) return
+      field = value
+      displaySizes = value
+      view.invalidate()
+    }
 
   override var priceColor: String = ""
     get() = field
@@ -149,15 +180,30 @@ class HybridPerpDepthBars(val context: ThemedReactContext) : HybridPerpDepthBars
     get() = field
     set(value) { if (!isDisposed) { field = value; view.invalidate() } }
 
+  // Per-row placeholder drawn natively while there is no real data (see
+  // PerpDepthBars.nitro.ts). Replaces the RN skeleton overlay so there is no
+  // blank handoff frame between placeholder and real numbers.
+  override var placeholderText: String = ""
+    get() = field
+    set(value) { if (!isDisposed) { field = value; view.invalidate() } }
+
+  override var placeholderRows: Double = 0.0
+    get() = field
+    set(value) { if (!isDisposed) { field = value; view.invalidate() } }
+
   override var onRowPress: ((rowIndex: Double) -> Unit)? = null
 
+  /** True once any real per-row data (bars or text) has been provided. */
+  private fun hasRealData(): Boolean =
+    current.isNotEmpty() || displayPrices.isNotEmpty() || displaySizes.isNotEmpty()
+
   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))
+    val count = maxOf(percents.size, maxOf(displayPrices.size, displaySizes.size))
     if (i in 0 until count) onRowPress?.invoke(i.toDouble())
   }
 
@@ -168,14 +214,51 @@ class HybridPerpDepthBars(val context: ThemedReactContext) : HybridPerpDepthBars
   override fun afterUpdate() {
     super.afterUpdate()
     if (isDisposed) return
-    syncTargets()
+    // In imperative mode the depth comes from `setDepth`; the `percents` prop is
+    // empty and must be ignored here, otherwise every prop commit would wipe the
+    // bars. Prop-path callers (never call `setDepth`) keep the original behaviour.
+    if (imperativeDepth) return
+    syncTargets(percents)
+  }
+
+  /**
+   * Imperative depth update — bypasses the high-frequency `percents` prop write
+   * path (props/JSICache lock contention, REACT-NATIVE-1JZ). `buffer` is a
+   * packed little-endian `Float32Array`: one float per row, each the row's depth
+   * percentage with the SAME 0..100 semantics as the `percents` prop. The parsed
+   * values flow through the identical [syncTargets] clamp/target/frame-loop logic
+   * the prop path uses — only the data source differs.
+   */
+  override fun setDepth(buffer: ArrayBuffer) {
+    if (isDisposed) return
+    imperativeDepth = true
+    val byteBuffer = buffer.getBuffer(false)
+    val count = buffer.size / 4
+    val floats = byteBuffer.order(ByteOrder.LITTLE_ENDIAN).asFloatBuffer()
+    val depths = DoubleArray(count) { floats.get(it).toDouble() }
+    syncTargets(depths)
   }
 
-  private fun syncTargets() {
-    val count = percents.size
+  /**
+   * Imperative per-row text update — companion to [setDepth] for the price/size
+   * layer. Bypasses the high-frequency `prices`/`sizes` prop write path (and the
+   * `afterUpdate`/prop-commit machinery) and just retargets the drawn strings in
+   * one call. Call in the SAME frame as [setDepth] so bar fill and row text come
+   * from the same source frame (REACT-NATIVE-1JZ).
+   */
+  override fun setText(prices: Array<String>, sizes: Array<String>) {
+    if (isDisposed) return
+    imperativeText = true
+    displayPrices = prices
+    displaySizes = sizes
+    view.invalidate()
+  }
+
+  private fun syncTargets(depths: DoubleArray) {
+    val count = depths.size
     val epochChanged = epoch != lastEpoch
     val snap = !hasDrawn || reducedMotion || epochChanged
-    val newTarget = DoubleArray(count) { clampFrac(percents[it]) }
+    val newTarget = DoubleArray(count) { clampFrac(depths[it]) }
 
     if (snap) {
       cancelFrameLoop()
@@ -268,28 +351,51 @@ class HybridPerpDepthBars(val context: ThemedReactContext) : HybridPerpDepthBars
   }
 
   private fun drawTexts(canvas: Canvas) {
-    if (prices.isEmpty() && sizes.isEmpty()) return
+    if (displayPrices.isEmpty() && displaySizes.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)
+    val rows = maxOf(displayPrices.size, displaySizes.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()) {
+      if (i < displayPrices.size && displayPrices[i].isNotEmpty()) {
         val baseline = rowTop + rh / 2f - (pricePaint.descent() + pricePaint.ascent()) / 2f
-        canvas.drawText(prices[i], pad, baseline, pricePaint)
+        canvas.drawText(displayPrices[i], pad, baseline, pricePaint)
       }
-      if (i < sizes.size && sizes[i].isNotEmpty()) {
+      if (i < displaySizes.size && displaySizes[i].isNotEmpty()) {
         val baseline = rowTop + rh / 2f - (sizePaint.descent() + sizePaint.ascent()) / 2f
-        canvas.drawText(sizes[i], rightX, baseline, sizePaint)
+        canvas.drawText(displaySizes[i], rightX, baseline, sizePaint)
       }
     }
   }
 
+  /**
+   * Draws `placeholderRows` rows of `placeholderText` (price left / size right,
+   * no bar) while there is no real data. Mirrors `drawTexts` geometry so the
+   * swap to real numbers is seamless.
+   */
+  private fun drawPlaceholder(canvas: Canvas) {
+    val rows = placeholderRows.toInt()
+    if (placeholderText.isEmpty() || rows <= 0) 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
+    for (i in 0 until rows) {
+      val rowTop = mt + i * (rh + mt)
+      val priceBaseline = rowTop + rh / 2f - (pricePaint.descent() + pricePaint.ascent()) / 2f
+      canvas.drawText(placeholderText, pad, priceBaseline, pricePaint)
+      val sizeBaseline = rowTop + rh / 2f - (sizePaint.descent() + sizePaint.ascent()) / 2f
+      canvas.drawText(placeholderText, rightX, sizeBaseline, sizePaint)
+    }
+  }
+
   private fun clampFrac(percent: Double): Double =
     (percent.coerceIn(0.0, 100.0)) / 100.0
 

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

@@ -29,6 +29,11 @@ class HybridPerpSideRatio(val context: ThemedReactContext) : HybridPerpSideRatio
   private var targetSplit = 0.5
   private var hasDrawn = false
   private var isDisposed = false
+  // Set once the caller drives the ratio through `setRatio`. The
+  // `bidPercentage`/`askPercentage` props are then ignored in `afterUpdate`,
+  // otherwise every prop commit would reset the split back to the (static)
+  // initial prop values (REACT-NATIVE-1JZ).
+  private var imperativeRatio = false
 
   private val choreographer = Choreographer.getInstance()
   private var frameScheduled = false
@@ -87,9 +92,34 @@ class HybridPerpSideRatio(val context: ThemedReactContext) : HybridPerpSideRatio
       view.invalidate()
     }
 
+  /**
+   * Imperative ratio update — bypasses the high-frequency
+   * `bidPercentage`/`askPercentage` prop write path (props/JSICache lock
+   * contention, REACT-NATIVE-1JZ). Companion to [HybridPerpDepthBars.setDepth].
+   * The two args carry the SAME 0..100 semantics as the props of the same name;
+   * we store them exactly like the prop setters and then route through the
+   * identical [afterUpdate] clamp/split/frame-loop logic the prop path uses —
+   * only the data source differs.
+   */
+  override fun setRatio(bidPercentage: Double, askPercentage: Double) {
+    if (isDisposed) return
+    imperativeRatio = true
+    // Apply the args directly — do NOT route through the `bidPercentage`/
+    // `askPercentage` prop fields, which a later prop commit could overwrite with
+    // the static initial values.
+    applyRatio(bidPercentage, askPercentage)
+  }
+
   override fun afterUpdate() {
     super.afterUpdate()
     if (isDisposed) return
+    // In imperative mode the ratio comes from `setRatio`; ignore the (static)
+    // props so a prop commit can't reset the bar to the initial values.
+    if (imperativeRatio) return
+    applyRatio(bidPercentage, askPercentage)
+  }
+
+  private fun applyRatio(bidPercentage: Double, askPercentage: Double) {
     val bid = maxOf(bidPercentage, 1.0)
     val ask = maxOf(askPercentage, 1.0)
     val split = bid / (bid + ask)

package/ios/HybridPerpDepthBars.swift

@@ -1,4 +1,5 @@
 import Foundation
+import NitroModules
 import UIKit
 
 /// Renders an entire column of order-book depth bars for one side (asks/bids).
@@ -61,6 +62,12 @@ final class HybridPerpDepthBars: HybridPerpDepthBarsSpec {
   var sizeFontSize: Double = 11 { didSet { scheduleLayout() } }
   var textInset: Double = 0 { didSet { scheduleLayout() } }
 
+  // Per-row placeholder drawn natively while there is no real data (see
+  // PerpDepthBars.nitro.ts). Replaces the RN skeleton overlay so there is no
+  // blank handoff frame between placeholder and real numbers.
+  var placeholderText: String = "" { didSet { scheduleLayout() } }
+  var placeholderRows: Double = 0 { didSet { scheduleLayout() } }
+
   var priceColor: String = "" {
     didSet {
       cachedPriceColor = PerpColorParser.parse(priceColor).cgColor
@@ -94,6 +101,44 @@ final class HybridPerpDepthBars: HybridPerpDepthBarsSpec {
     stopDisplayLink()
   }
 
+  // MARK: - Imperative depth update
+  /// Imperatively update the per-row depth percentages, bypassing the
+  /// high-frequency `percents` prop write path (props/JSICache lock contention,
+  /// REACT-NATIVE-1JZ). `buffer` is a packed little-endian `Float32Array`: one
+  /// float per row, each the row's depth percentage with the SAME 0..100
+  /// semantics as the `percents` prop. The parsed values are routed through the
+  /// exact same `performLayout` clamp (`clampScale`) / target / display-link
+  /// path the prop uses — only the data source differs.
+  func setDepth(buffer: ArrayBuffer) throws {
+    let count = buffer.size / 4
+    guard count > 0 else {
+      percents = []
+      return
+    }
+    // `buffer.data` is a `UInt8` pointer; reinterpret it as little-endian
+    // Float32. iOS (arm/x86) is little-endian and JS `Float32Array` is too, so
+    // an unaligned little-endian load matches the prop semantics exactly.
+    var depths = [Double](repeating: 0, count: count)
+    let raw = UnsafeRawPointer(buffer.data)
+    for i in 0..<count {
+      let bits = raw.loadUnaligned(fromByteOffset: i * 4, as: UInt32.self)
+      depths[i] = Double(Float(bitPattern: UInt32(littleEndian: bits)))
+    }
+    // Feed through the single source of truth so the clamp/target/easing logic
+    // is byte-for-byte identical to the `percents` prop path.
+    percents = depths
+  }
+
+  /// Imperatively update the per-row price/size text — companion to `setDepth`
+  /// for the text layer. Bypasses the high-frequency `prices`/`sizes` prop write
+  /// path; assigning them feeds through the identical `didSet` → `scheduleLayout`
+  /// → `performLayout` path the prop setters use (REACT-NATIVE-1JZ). Call in the
+  /// SAME frame as `setDepth` so bar fill and row text share one source frame.
+  func setText(prices: [String], sizes: [String]) throws {
+    self.prices = prices
+    self.sizes = sizes
+  }
+
   private func handleTap(atY y: CGFloat) {
     let step = CGFloat(rowHeight + rowMarginTop)
     guard step > 0 else { return }
@@ -105,7 +150,13 @@ final class HybridPerpDepthBars: HybridPerpDepthBarsSpec {
   }
 
   private func scheduleLayout() {
-    view.setNeedsLayout()
+    // Imperative setDepth/setText run on the JS thread (off-main); `setNeedsLayout`
+    // must be issued on the main thread.
+    if Thread.isMainThread {
+      view.setNeedsLayout()
+    } else {
+      DispatchQueue.main.async { [weak self] in self?.view.setNeedsLayout() }
+    }
   }
 
   // MARK: - Layout + retarget
@@ -113,7 +164,13 @@ final class HybridPerpDepthBars: HybridPerpDepthBarsSpec {
     let bounds = view.bounds
     guard bounds.width > 0 else { return }
 
-    let count = percents.count
+    // When there is no real data, draw `placeholderRows` rows of placeholder
+    // text (no bar fill) instead of nothing — the native view owns the empty
+    // state, so there is no RN overlay to remove and no blank handoff frame.
+    let dataCount = percents.count
+    let placeholderMode =
+      dataCount == 0 && !placeholderText.isEmpty && Int(placeholderRows) > 0
+    let count = placeholderMode ? Int(placeholderRows) : dataCount
     syncLayerCount(count)
     syncTextLayerCount(count)
 
@@ -141,8 +198,11 @@ final class HybridPerpDepthBars: HybridPerpDepthBarsSpec {
     }
     CATransaction.commit()
 
+    // Placeholder rows have no bar fill (all-zero targets); real rows use data.
     var newTargets = [CGFloat](repeating: 0, count: count)
-    for i in 0..<count { newTargets[i] = clampScale(percents[i]) }
+    if !placeholderMode {
+      for i in 0..<count { newTargets[i] = clampScale(percents[i]) }
+    }
 
     if snap {
       stopDisplayLink()
@@ -177,7 +237,8 @@ final class HybridPerpDepthBars: HybridPerpDepthBarsSpec {
         width: max(half - pad, 0), height: priceLine)
       priceLayer.fontSize = CGFloat(priceFontSize)
       priceLayer.foregroundColor = cachedPriceColor
-      priceLayer.string = i < prices.count ? prices[i] : ""
+      priceLayer.string =
+        placeholderMode ? placeholderText : (i < prices.count ? prices[i] : "")
 
       let sizeLayer = sizeLayers[i]
       sizeLayer.frame = CGRect(
@@ -185,7 +246,8 @@ final class HybridPerpDepthBars: HybridPerpDepthBarsSpec {
         width: max(half - pad, 0), height: sizeLine)
       sizeLayer.fontSize = CGFloat(sizeFontSize)
       sizeLayer.foregroundColor = cachedSizeColor
-      sizeLayer.string = i < sizes.count ? sizes[i] : ""
+      sizeLayer.string =
+        placeholderMode ? placeholderText : (i < sizes.count ? sizes[i] : "")
     }
     CATransaction.commit()
 
@@ -267,6 +329,23 @@ final class HybridPerpDepthBars: HybridPerpDepthBarsSpec {
     l.alignmentMode = alignment
     l.truncationMode = .none
     l.isWrapped = false
+    // Disable ALL implicit Core Animation actions on this text layer. CATextLayer
+    // crossfades its `contents` whenever `string`/`foregroundColor` changes; even
+    // inside `CATransaction.setDisableActions(true)` the fade can leak through, so
+    // pin the relevant keys to NSNull() to guarantee instant per-row text switches
+    // (PM: no fade/gradient when the order-book text updates). The bar fill keeps
+    // its own explicit display-link easing — only text is made instant here.
+    let noAction = NSNull()
+    l.actions = [
+      "contents": noAction,
+      "string": noAction,
+      "foregroundColor": noAction,
+      "fontSize": noAction,
+      "bounds": noAction,
+      "position": noAction,
+      "hidden": noAction,
+      "opacity": noAction,
+    ]
     return l
   }
 

package/ios/HybridPerpSideRatio.swift

@@ -58,8 +58,26 @@ final class HybridPerpSideRatio: HybridPerpSideRatioSpec {
     stopDisplayLink()
   }
 
+  /// Imperative ratio update — bypasses the high-frequency
+  /// `bidPercentage`/`askPercentage` prop write path (props/JSICache lock
+  /// contention, REACT-NATIVE-1JZ). Companion to `HybridPerpDepthBars.setDepth`.
+  /// The two args carry the SAME 0..100 semantics as the props of the same
+  /// name; assigning them feeds through the identical `didSet` →
+  /// `scheduleLayout` → `performLayout` clamp/split/display-link path the prop
+  /// setters use — only the data source differs.
+  func setRatio(bidPercentage: Double, askPercentage: Double) throws {
+    self.bidPercentage = bidPercentage
+    self.askPercentage = askPercentage
+  }
+
   private func scheduleLayout() {
-    view.setNeedsLayout()
+    // Imperative setRatio runs on the JS thread (off-main); `setNeedsLayout` must
+    // be issued on the main thread.
+    if Thread.isMainThread {
+      view.setNeedsLayout()
+    } else {
+      DispatchQueue.main.async { [weak self] in self?.view.setNeedsLayout() }
+    }
   }
 
   private func performLayout() {

package/ios/PerpColorParser.swift

@@ -100,7 +100,16 @@ final class PerpLayoutView: UIView {
 
   override func layoutSubviews() {
     super.layoutSubviews()
-    onLayout?()
+    guard let onLayout else { return }
+    // Fabric (New Architecture) can drive layout off the main thread. The
+    // `onLayout` callback mutates CALayer/CATextLayer state, which UIKit requires
+    // on the main thread — doing it off-main asserts ("Unsupported layout off the
+    // main thread") and can leave the view blank. Hop to main when needed.
+    if Thread.isMainThread {
+      onLayout()
+    } else {
+      DispatchQueue.main.async { onLayout() }
+    }
   }
 
   override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {

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

@@ -15,6 +15,9 @@
 #include <optional>
 #include "JFunc_void_double.hpp"
 #include <NitroModules/JNICallable.hpp>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+#include <NitroModules/JUnit.hpp>
 
 namespace margelo::nitro::perpdepthbar {
 
@@ -226,6 +229,24 @@ namespace margelo::nitro::perpdepthbar {
     static const auto method = javaClassStatic()->getMethod<void(double /* textInset */)>("setTextInset");
     method(_javaPart, textInset);
   }
+  std::string JHybridPerpDepthBarsSpec::getPlaceholderText() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getPlaceholderText");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridPerpDepthBarsSpec::setPlaceholderText(const std::string& placeholderText) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* placeholderText */)>("setPlaceholderText");
+    method(_javaPart, jni::make_jstring(placeholderText));
+  }
+  double JHybridPerpDepthBarsSpec::getPlaceholderRows() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getPlaceholderRows");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridPerpDepthBarsSpec::setPlaceholderRows(double placeholderRows) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* placeholderRows */)>("setPlaceholderRows");
+    method(_javaPart, placeholderRows);
+  }
   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);
@@ -245,6 +266,31 @@ namespace margelo::nitro::perpdepthbar {
   }
 
   // Methods
-  
+  void JHybridPerpDepthBarsSpec::setDepth(const std::shared_ptr<ArrayBuffer>& buffer) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JArrayBuffer::javaobject> /* buffer */)>("setDepth");
+    method(_javaPart, JArrayBuffer::wrap(buffer));
+  }
+  void JHybridPerpDepthBarsSpec::setText(const std::vector<std::string>& prices, const std::vector<std::string>& sizes) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<jni::JString>> /* prices */, jni::alias_ref<jni::JArrayClass<jni::JString>> /* sizes */)>("setText");
+    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;
+    }(), [&]() {
+      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;
+    }());
+  }
 
 } // namespace margelo::nitro::perpdepthbar

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

@@ -80,12 +80,17 @@ namespace margelo::nitro::perpdepthbar {
     void setSizeFontSize(double sizeFontSize) override;
     double getTextInset() override;
     void setTextInset(double textInset) override;
+    std::string getPlaceholderText() override;
+    void setPlaceholderText(const std::string& placeholderText) override;
+    double getPlaceholderRows() override;
+    void setPlaceholderRows(double placeholderRows) override;
     std::optional<std::function<void(double /* rowIndex */)>> getOnRowPress() override;
     void setOnRowPress(const std::optional<std::function<void(double /* rowIndex */)>>& onRowPress) override;
 
   public:
     // Methods
-    
+    void setDepth(const std::shared_ptr<ArrayBuffer>& buffer) override;
+    void setText(const std::vector<std::string>& prices, const std::vector<std::string>& sizes) override;
 
   private:
     friend HybridBase;

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

@@ -114,6 +114,9 @@ namespace margelo::nitro::perpdepthbar {
   }
 
   // Methods
-  
+  void JHybridPerpSideRatioSpec::setRatio(double bidPercentage, double askPercentage) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* bidPercentage */, double /* askPercentage */)>("setRatio");
+    method(_javaPart, bidPercentage, askPercentage);
+  }
 
 } // namespace margelo::nitro::perpdepthbar

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

@@ -69,7 +69,7 @@ namespace margelo::nitro::perpdepthbar {
 
   public:
     // Methods
-    
+    void setRatio(double bidPercentage, double askPercentage) override;
 
   private:
     friend HybridBase;

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

@@ -96,6 +96,14 @@ void JHybridPerpDepthBarsStateUpdater::updateViewProps(jni::alias_ref<jni::JClas
     view->setTextInset(props.textInset.value);
     // TODO: Set isDirty = false
   }
+  if (props.placeholderText.isDirty) {
+    view->setPlaceholderText(props.placeholderText.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.placeholderRows.isDirty) {
+    view->setPlaceholderRows(props.placeholderRows.value);
+    // TODO: Set isDirty = false
+  }
   if (props.onRowPress.isDirty) {
     view->setOnRowPress(props.onRowPress.value);
     // TODO: Set isDirty = false

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

@@ -10,6 +10,7 @@ package com.margelo.nitro.perpdepthbar
 import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.ArrayBuffer
 import com.margelo.nitro.views.HybridView
 
 /**
@@ -132,6 +133,18 @@ abstract class HybridPerpDepthBarsSpec: HybridView() {
   @set:Keep
   abstract var textInset: Double
   
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var placeholderText: String
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var placeholderRows: Double
+  
   abstract var onRowPress: ((rowIndex: Double) -> Unit)?
   
   private var onRowPress_cxx: Func_void_double?
@@ -147,7 +160,13 @@ abstract class HybridPerpDepthBarsSpec: HybridView() {
     }
 
   // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun setDepth(buffer: ArrayBuffer): Unit
   
+  @DoNotStrip
+  @Keep
+  abstract fun setText(prices: Array<String>, sizes: Array<String>): Unit
 
   private external fun initHybrid(): HybridData
 

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

@@ -91,7 +91,9 @@ abstract class HybridPerpSideRatioSpec: HybridView() {
   abstract var reducedMotion: Boolean
 
   // Methods
-  
+  @DoNotStrip
+  @Keep
+  abstract fun setRatio(bidPercentage: Double, askPercentage: Double): Unit
 
   private external fun initHybrid(): HybridData
 

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

@@ -22,6 +22,8 @@ namespace PerpDepthBar { class HybridPerpSideRatioSpec_cxx; }
 // Include C++ defined types
 #include "HybridPerpDepthBarsSpec.hpp"
 #include "HybridPerpSideRatioSpec.hpp"
+#include <NitroModules/Result.hpp>
+#include <exception>
 #include <functional>
 #include <memory>
 #include <optional>
@@ -105,6 +107,15 @@ namespace margelo::nitro::perpdepthbar::bridge::swift {
   using std__weak_ptr_HybridPerpDepthBarsSpec_ = std::weak_ptr<HybridPerpDepthBarsSpec>;
   inline std__weak_ptr_HybridPerpDepthBarsSpec_ weakify_std__shared_ptr_HybridPerpDepthBarsSpec_(const std::shared_ptr<HybridPerpDepthBarsSpec>& strong) noexcept { return strong; }
   
+  // pragma MARK: Result<void>
+  using Result_void_ = Result<void>;
+  inline Result_void_ create_Result_void_() noexcept {
+    return Result<void>::withValue();
+  }
+  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
+    return Result<void>::withError(error);
+  }
+  
   // pragma MARK: std::shared_ptr<HybridPerpSideRatioSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridPerpSideRatioSpec>`.

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

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