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

package/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/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/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/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/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/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

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

@@ -175,6 +175,26 @@ namespace margelo::nitro::perpdepthbar::views {
         throw std::runtime_error(std::string("PerpDepthBars.textInset: ") + exc.what());
       }
     }()),
+    placeholderText([&]() -> CachedProp<std::string> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("placeholderText", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.placeholderText;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.placeholderText);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PerpDepthBars.placeholderText: ") + exc.what());
+      }
+    }()),
+    placeholderRows([&]() -> CachedProp<double> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("placeholderRows", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.placeholderRows;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.placeholderRows);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PerpDepthBars.placeholderRows: ") + exc.what());
+      }
+    }()),
     onRowPress([&]() -> CachedProp<std::optional<std::function<void(double /* rowIndex */)>>> {
       try {
         const react::RawValue* rawValue = rawProps.at("onRowPress", nullptr, nullptr);
@@ -213,6 +233,8 @@ namespace margelo::nitro::perpdepthbar::views {
     priceFontSize(other.priceFontSize),
     sizeFontSize(other.sizeFontSize),
     textInset(other.textInset),
+    placeholderText(other.placeholderText),
+    placeholderRows(other.placeholderRows),
     onRowPress(other.onRowPress),
     hybridRef(other.hybridRef) { }
 
@@ -233,6 +255,8 @@ namespace margelo::nitro::perpdepthbar::views {
       case hashString("priceFontSize"): return true;
       case hashString("sizeFontSize"): return true;
       case hashString("textInset"): return true;
+      case hashString("placeholderText"): return true;
+      case hashString("placeholderRows"): return true;
       case hashString("onRowPress"): return true;
       case hashString("hybridRef"): return true;
       default: return false;

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

@@ -59,6 +59,8 @@ namespace margelo::nitro::perpdepthbar::views {
     CachedProp<double> priceFontSize;
     CachedProp<double> sizeFontSize;
     CachedProp<double> textInset;
+    CachedProp<std::string> placeholderText;
+    CachedProp<double> placeholderRows;
     CachedProp<std::optional<std::function<void(double /* rowIndex */)>>> onRowPress;
     CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridPerpDepthBarsSpec>& /* ref */)>>> hybridRef;
 

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

@@ -19,6 +19,8 @@
     "priceFontSize": true,
     "sizeFontSize": true,
     "textInset": true,
+    "placeholderText": true,
+    "placeholderRows": true,
     "onRowPress": true,
     "hybridRef": true
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-perp-depth-bar",
-  "version": "3.0.49",
+  "version": "3.0.52",
   "description": "react-native-perp-depth-bar",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/PerpDepthBars.nitro.ts

@@ -16,7 +16,17 @@ import type {
  * All values are in points (DIP); the native side quantizes to physical pixels.
  */
 export interface PerpDepthBarsProps extends HybridViewProps {
-  /** Depth percentage per row, 0..100. Length == number of rows on this side. */
+  /**
+   * Depth percentage per row, 0..100. Length == number of rows on this side.
+   *
+   * INITIAL VALUE ONLY when using the imperative path. The first
+   * `setDepth(buffer)` call switches the view into imperative mode; from then on
+   * this prop is IGNORED on every prop-update transaction (so unrelated
+   * high-frequency prop commits like `prices`/`sizes` can't wipe the bars —
+   * REACT-NATIVE-1JZ). For high-frequency depth updates ALWAYS call `setDepth`;
+   * do NOT keep writing this prop at tick rate. Callers that never call
+   * `setDepth` may drive the bars purely through this prop (each write retargets).
+   */
   percents: number[];
   /** Row height in points (matches the sibling RN text row height). */
   rowHeight: number;
@@ -36,14 +46,28 @@ export interface PerpDepthBarsProps extends HybridViewProps {
    */
   epoch: number;
 
-  // --- Per-row text (optional). When `prices`/`sizes` are empty the view
-  // renders bars only (backward compatible). When provided they are drawn
-  // natively per row — price left-aligned, size right-aligned, vertically
-  // centred — so the order-book ladder needs NO sibling RN <Text> rows.
-  // Each array is parallel to `percents` (same length / order).
-  /** Formatted price string per row (e.g. "1981.4"). */
+  /**
+   * Per-row price text, parallel to `percents` (same length / order). Drawn
+   * natively per row (price left-aligned), so the order-book ladder needs NO
+   * sibling RN <Text> rows. Empty => the view renders bars only.
+   *
+   * INITIAL VALUE ONLY for high-frequency callers: the first `setText` call
+   * switches the text layer into imperative mode and this prop is then IGNORED on
+   * every prop-update transaction. For high-frequency text updates ALWAYS call
+   * `setText`; do NOT keep writing this prop at tick rate (string-array prop
+   * commits are the heaviest part of the Fabric props + JSI path — exactly what
+   * REACT-NATIVE-1JZ avoids). Callers that update infrequently may drive it
+   * purely through this prop.
+   */
   prices: string[];
-  /** Formatted size string per row (e.g. "389.04"). */
+  /**
+   * Per-row size text, parallel to `percents`. Drawn natively per row (size
+   * right-aligned). Empty => bars only.
+   *
+   * INITIAL VALUE ONLY for high-frequency callers: update via `setText`; this
+   * prop is IGNORED once `setText` has been called (see `prices` —
+   * REACT-NATIVE-1JZ).
+   */
   sizes: string[];
   /** Price text color: hex or rgba()/rgb(). */
   priceColor: string;
@@ -56,6 +80,24 @@ export interface PerpDepthBarsProps extends HybridViewProps {
   /** Horizontal text inset in points (price padding-left, size padding-right). */
   textInset: number;
 
+  /**
+   * Per-row placeholder text drawn while the column has NO real data (no rows
+   * from `percents`/`setDepth` and no `prices`/`sizes`/`setText`), e.g. "--".
+   * Empty string disables the placeholder. This replaces any RN skeleton/overlay:
+   * the view draws the placeholder itself, then atomically swaps to real numbers
+   * the moment data lands — so there is never a blank frame between the two
+   * (the old overlay approach removed the JS skeleton a few frames before the
+   * native view had painted, flashing blank). Drawn in `priceColor` (left) and
+   * `sizeColor` (right); no bar fill.
+   */
+  placeholderText: string;
+  /**
+   * How many placeholder rows to draw when `placeholderText` is shown. Match the
+   * order book's rows-per-side so the column reserves a stable height before any
+   * data arrives. Ignored once real data is present.
+   */
+  placeholderRows: number;
+
   /**
    * Fired natively when a row is tapped. `rowIndex` is the 0-based row
    * (top→bottom, parallel to `percents`/`prices`/`sizes`). The view handles
@@ -82,6 +124,22 @@ export interface PerpDepthBarsMethods extends HybridViewMethods {
    * use either path.
    */
   setDepth(buffer: ArrayBuffer): void;
+
+  /**
+   * Imperatively update the per-row price/size text, bypassing the
+   * high-frequency `prices`/`sizes` prop write path (and its props/JSICache lock
+   * contention — REACT-NATIVE-1JZ). Companion to [setDepth] for the text layer.
+   *
+   * `prices[i]` / `sizes[i]` are the formatted strings for row `i`, parallel to
+   * the depth buffer pushed via `setDepth` (same length / order). Pass `[]` for a
+   * side that draws bars only. Call this in the SAME frame/effect as `setDepth`
+   * so the bar fill and its row text always come from one source frame (no
+   * fill-vs-text misalignment).
+   *
+   * The `prices`/`sizes` props are retained for backward compatibility; callers
+   * may use either path.
+   */
+  setText(prices: string[], sizes: string[]): void;
 }
 
 export type PerpDepthBars = HybridView<PerpDepthBarsProps, PerpDepthBarsMethods>;

package/src/PerpSideRatio.nitro.ts

@@ -11,9 +11,19 @@ import type {
  * alignment risk is low.
  */
 export interface PerpSideRatioProps extends HybridViewProps {
-  /** Bid (long) share, 0..100. */
+  /**
+   * Bid (long) share, 0..100. INITIAL VALUE ONLY for high-frequency callers:
+   * the first `setRatio` call switches the view into imperative mode and this
+   * prop is then ignored, so unrelated prop commits can't reset the split to the
+   * static initial value (REACT-NATIVE-1JZ). Update via `setRatio`. Callers that
+   * update infrequently may drive it purely through this prop.
+   */
   bidPercentage: number;
-  /** Ask (short) share, 0..100. */
+  /**
+   * Ask (short) share, 0..100. INITIAL VALUE ONLY for high-frequency callers:
+   * this prop is IGNORED once `setRatio` has been called; update via `setRatio`
+   * (see `bidPercentage` — REACT-NATIVE-1JZ).
+   */
   askPercentage: number;
   /** Resolved long (bid) color. */
   longColor: string;