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

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

@@ -36,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
@@ -44,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 {
@@ -103,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
@@ -151,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())
   }
 
@@ -170,6 +214,10 @@ class HybridPerpDepthBars(val context: ThemedReactContext) : HybridPerpDepthBars
   override fun afterUpdate() {
     super.afterUpdate()
     if (isDisposed) return
+    // 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)
   }
 
@@ -183,6 +231,7 @@ class HybridPerpDepthBars(val context: ThemedReactContext) : HybridPerpDepthBars
    */
   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()
@@ -190,6 +239,21 @@ class HybridPerpDepthBars(val context: ThemedReactContext) : HybridPerpDepthBars
     syncTargets(depths)
   }
 
+  /**
+   * 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
@@ -287,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
@@ -98,17 +103,23 @@ class HybridPerpSideRatio(val context: ThemedReactContext) : HybridPerpSideRatio
    */
   override fun setRatio(bidPercentage: Double, askPercentage: Double) {
     if (isDisposed) return
-    this.bidPercentage = bidPercentage
-    this.askPercentage = askPercentage
-    // Note: the prop path goes through the framework's beforeUpdate()/afterUpdate()
-    // pair; beforeUpdate() is an empty base-class hook, so calling afterUpdate()
-    // directly here is equivalent. If beforeUpdate() ever gains behavior, mirror it.
-    afterUpdate()
+    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
@@ -122,6 +129,16 @@ final class HybridPerpDepthBars: HybridPerpDepthBarsSpec {
     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 }
@@ -133,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
@@ -141,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)
 
@@ -169,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()
@@ -205,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(
@@ -213,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()
 
@@ -295,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

@@ -71,7 +71,13 @@ final class HybridPerpSideRatio: HybridPerpSideRatioSpec {
   }
 
   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

@@ -229,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);
@@ -252,5 +270,27 @@ namespace margelo::nitro::perpdepthbar {
     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++/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

@@ -133,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?
@@ -151,6 +163,10 @@ abstract class HybridPerpDepthBarsSpec: HybridView() {
   @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/ios/c++/HybridPerpDepthBarsSpecSwift.hpp

@@ -159,6 +159,19 @@ namespace margelo::nitro::perpdepthbar {
     inline void setTextInset(double textInset) noexcept override {
       _swiftPart.setTextInset(std::forward<decltype(textInset)>(textInset));
     }
+    inline std::string getPlaceholderText() noexcept override {
+      auto __result = _swiftPart.getPlaceholderText();
+      return __result;
+    }
+    inline void setPlaceholderText(const std::string& placeholderText) noexcept override {
+      _swiftPart.setPlaceholderText(placeholderText);
+    }
+    inline double getPlaceholderRows() noexcept override {
+      return _swiftPart.getPlaceholderRows();
+    }
+    inline void setPlaceholderRows(double placeholderRows) noexcept override {
+      _swiftPart.setPlaceholderRows(std::forward<decltype(placeholderRows)>(placeholderRows));
+    }
     inline std::optional<std::function<void(double /* rowIndex */)>> getOnRowPress() noexcept override {
       auto __result = _swiftPart.getOnRowPress();
       return __result;
@@ -175,6 +188,12 @@ namespace margelo::nitro::perpdepthbar {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void setText(const std::vector<std::string>& prices, const std::vector<std::string>& sizes) override {
+      auto __result = _swiftPart.setText(prices, sizes);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
 
   private:
     PerpDepthBar::HybridPerpDepthBarsSpec_cxx _swiftPart;

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

@@ -146,6 +146,16 @@ using namespace margelo::nitro::perpdepthbar::views;
     swiftPart.setTextInset(newViewProps.textInset.value);
     newViewProps.textInset.isDirty = false;
   }
+  // placeholderText: string
+  if (newViewProps.placeholderText.isDirty) {
+    swiftPart.setPlaceholderText(newViewProps.placeholderText.value);
+    newViewProps.placeholderText.isDirty = false;
+  }
+  // placeholderRows: number
+  if (newViewProps.placeholderRows.isDirty) {
+    swiftPart.setPlaceholderRows(newViewProps.placeholderRows.value);
+    newViewProps.placeholderRows.isDirty = false;
+  }
   // onRowPress: optional
   if (newViewProps.onRowPress.isDirty) {
     swiftPart.setOnRowPress(newViewProps.onRowPress.value);

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

@@ -26,10 +26,13 @@ public protocol HybridPerpDepthBarsSpec_protocol: HybridObject, HybridView {
   var priceFontSize: Double { get set }
   var sizeFontSize: Double { get set }
   var textInset: Double { get set }
+  var placeholderText: String { get set }
+  var placeholderRows: Double { get set }
   var onRowPress: ((_ rowIndex: Double) -> Void)? { get set }
 
   // Methods
   func setDepth(buffer: ArrayBuffer) throws -> Void
+  func setText(prices: [String], sizes: [String]) throws -> Void
 }
 
 public extension HybridPerpDepthBarsSpec_protocol {

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

@@ -297,6 +297,28 @@ open class HybridPerpDepthBarsSpec_cxx {
     }
   }
   
+  public final var placeholderText: std.string {
+    @inline(__always)
+    get {
+      return std.string(self.__implementation.placeholderText)
+    }
+    @inline(__always)
+    set {
+      self.__implementation.placeholderText = String(newValue)
+    }
+  }
+  
+  public final var placeholderRows: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.placeholderRows
+    }
+    @inline(__always)
+    set {
+      self.__implementation.placeholderRows = newValue
+    }
+  }
+  
   public final var onRowPress: bridge.std__optional_std__function_void_double____rowIndex______ {
     @inline(__always)
     get {
@@ -341,6 +363,17 @@ open class HybridPerpDepthBarsSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func setText(prices: bridge.std__vector_std__string_, sizes: bridge.std__vector_std__string_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setText(prices: prices.map({ __item in String(__item) }), sizes: sizes.map({ __item in String(__item) }))
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
   public final func getView() -> UnsafeMutableRawPointer {
     return Unmanaged.passRetained(__implementation.view).toOpaque()
   }

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

@@ -44,9 +44,14 @@ namespace margelo::nitro::perpdepthbar {
       prototype.registerHybridSetter("sizeFontSize", &HybridPerpDepthBarsSpec::setSizeFontSize);
       prototype.registerHybridGetter("textInset", &HybridPerpDepthBarsSpec::getTextInset);
       prototype.registerHybridSetter("textInset", &HybridPerpDepthBarsSpec::setTextInset);
+      prototype.registerHybridGetter("placeholderText", &HybridPerpDepthBarsSpec::getPlaceholderText);
+      prototype.registerHybridSetter("placeholderText", &HybridPerpDepthBarsSpec::setPlaceholderText);
+      prototype.registerHybridGetter("placeholderRows", &HybridPerpDepthBarsSpec::getPlaceholderRows);
+      prototype.registerHybridSetter("placeholderRows", &HybridPerpDepthBarsSpec::setPlaceholderRows);
       prototype.registerHybridGetter("onRowPress", &HybridPerpDepthBarsSpec::getOnRowPress);
       prototype.registerHybridSetter("onRowPress", &HybridPerpDepthBarsSpec::setOnRowPress);
       prototype.registerHybridMethod("setDepth", &HybridPerpDepthBarsSpec::setDepth);
+      prototype.registerHybridMethod("setText", &HybridPerpDepthBarsSpec::setText);
     });
   }
 

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

@@ -78,12 +78,17 @@ namespace margelo::nitro::perpdepthbar {
       virtual void setSizeFontSize(double sizeFontSize) = 0;
       virtual double getTextInset() = 0;
       virtual void setTextInset(double textInset) = 0;
+      virtual std::string getPlaceholderText() = 0;
+      virtual void setPlaceholderText(const std::string& placeholderText) = 0;
+      virtual double getPlaceholderRows() = 0;
+      virtual void setPlaceholderRows(double placeholderRows) = 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
       virtual void setDepth(const std::shared_ptr<ArrayBuffer>& buffer) = 0;
+      virtual void setText(const std::vector<std::string>& prices, const std::vector<std::string>& sizes) = 0;
 
     protected:
       // Hybrid Setup