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

package/lib/nitrogen/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 {
@@ -330,6 +352,28 @@ open class HybridPerpDepthBarsSpec_cxx {
   }
 
   // Methods
+  @inline(__always)
+  public final func setDepth(buffer: ArrayBuffer) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setDepth(buffer: buffer)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @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/nitrogen/generated/ios/swift/HybridPerpSideRatioSpec.swift

@@ -21,7 +21,7 @@ public protocol HybridPerpSideRatioSpec_protocol: HybridObject, HybridView {
   var reducedMotion: Bool { get set }
 
   // Methods
-  
+  func setRatio(bidPercentage: Double, askPercentage: Double) throws -> Void
 }
 
 public extension HybridPerpSideRatioSpec_protocol {

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

@@ -203,6 +203,17 @@ open class HybridPerpSideRatioSpec_cxx {
   }
 
   // Methods
+  @inline(__always)
+  public final func setRatio(bidPercentage: Double, askPercentage: Double) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setRatio(bidPercentage: bidPercentage, askPercentage: askPercentage)
+      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/nitrogen/generated/shared/c++/HybridPerpDepthBarsSpec.cpp

@@ -44,8 +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/nitrogen/generated/shared/c++/HybridPerpDepthBarsSpec.hpp

@@ -19,6 +19,7 @@
 #include <string>
 #include <functional>
 #include <optional>
+#include <NitroModules/ArrayBuffer.hpp>
 
 namespace margelo::nitro::perpdepthbar {
 
@@ -77,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/lib/nitrogen/nitrogen/generated/shared/c++/HybridPerpSideRatioSpec.cpp

@@ -30,6 +30,7 @@ namespace margelo::nitro::perpdepthbar {
       prototype.registerHybridSetter("gap", &HybridPerpSideRatioSpec::setGap);
       prototype.registerHybridGetter("reducedMotion", &HybridPerpSideRatioSpec::getReducedMotion);
       prototype.registerHybridSetter("reducedMotion", &HybridPerpSideRatioSpec::setReducedMotion);
+      prototype.registerHybridMethod("setRatio", &HybridPerpSideRatioSpec::setRatio);
     });
   }
 

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

@@ -63,7 +63,7 @@ namespace margelo::nitro::perpdepthbar {
 
     public:
       // Methods
-      
+      virtual void setRatio(double bidPercentage, double askPercentage) = 0;
 
     protected:
       // Hybrid Setup

package/lib/nitrogen/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/lib/nitrogen/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/lib/nitrogen/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/lib/typescript/src/PerpDepthBars.nitro.d.ts

@@ -11,7 +11,17 @@ import type { HybridView, HybridViewMethods, HybridViewProps } from 'react-nativ
  * 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;
@@ -30,9 +40,28 @@ export interface PerpDepthBarsProps extends HybridViewProps {
      * empty<->full so native snaps to the new values WITHOUT animating.
      */
     epoch: number;
-    /** 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;
@@ -44,6 +73,23 @@ export interface PerpDepthBarsProps extends HybridViewProps {
     sizeFontSize: number;
     /** 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
@@ -52,6 +98,38 @@ export interface PerpDepthBarsProps extends HybridViewProps {
     onRowPress?: (rowIndex: number) => void;
 }
 export interface PerpDepthBarsMethods extends HybridViewMethods {
+    /**
+     * Imperatively update the per-row depth percentages, bypassing the
+     * high-frequency `percents` prop write path (and its props/JSICache lock
+     * contention — REACT-NATIVE-1JZ).
+     *
+     * `buffer` is a packed `Float32Array` (little-endian): one float per row,
+     * each the row's depth percentage with the SAME semantics as the
+     * `percents: number[]` prop (0..100, clamped natively exactly like the prop
+     * setter). Row count == `buffer.byteLength / 4`. The native side rebuilds
+     * its animation targets from these values and reuses the identical
+     * clamp/target/frame-loop logic as the `percents` prop path — only the data
+     * source differs.
+     *
+     * The `percents` prop is retained for backward compatibility; callers may
+     * 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>;
 //# sourceMappingURL=PerpDepthBars.nitro.d.ts.map

package/lib/typescript/src/PerpDepthBars.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PerpDepthBars.nitro.d.ts","sourceRoot":"","sources":["../../../src/PerpDepthBars.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EACjB,eAAe,EAChB,MAAM,4BAA4B,CAAC;AAEpC;;;;;;;;;;GAUG;AACH,MAAM,WAAW,kBAAmB,SAAQ,eAAe;IACzD,+EAA+E;IAC/E,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,qEAAqE;IACrE,SAAS,EAAE,MAAM,CAAC;IAClB,kFAAkF;IAClF,YAAY,EAAE,MAAM,CAAC;IACrB,iFAAiF;IACjF,QAAQ,EAAE,MAAM,CAAC;IACjB,yEAAyE;IACzE,KAAK,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,MAAM,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,aAAa,EAAE,OAAO,CAAC;IACvB;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAOd,sDAAsD;IACtD,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,qDAAqD;IACrD,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,6CAA6C;IAC7C,UAAU,EAAE,MAAM,CAAC;IACnB,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAC;IAClB,sCAAsC;IACtC,aAAa,EAAE,MAAM,CAAC;IACtB,qCAAqC;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,gFAAgF;IAChF,SAAS,EAAE,MAAM,CAAC;IAElB;;;;OAIG;IACH,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC;AAED,MAAM,WAAW,oBAAqB,SAAQ,iBAAiB;CAAG;AAElE,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,kBAAkB,EAAE,oBAAoB,CAAC,CAAC"}
+{"version":3,"file":"PerpDepthBars.nitro.d.ts","sourceRoot":"","sources":["../../../src/PerpDepthBars.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EACjB,eAAe,EAChB,MAAM,4BAA4B,CAAC;AAEpC;;;;;;;;;;GAUG;AACH,MAAM,WAAW,kBAAmB,SAAQ,eAAe;IACzD;;;;;;;;;;OAUG;IACH,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,qEAAqE;IACrE,SAAS,EAAE,MAAM,CAAC;IAClB,kFAAkF;IAClF,YAAY,EAAE,MAAM,CAAC;IACrB,iFAAiF;IACjF,QAAQ,EAAE,MAAM,CAAC;IACjB,yEAAyE;IACzE,KAAK,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,MAAM,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,aAAa,EAAE,OAAO,CAAC;IACvB;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;;;;;;;;OAYG;IACH,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB;;;;;;;OAOG;IACH,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,6CAA6C;IAC7C,UAAU,EAAE,MAAM,CAAC;IACnB,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAC;IAClB,sCAAsC;IACtC,aAAa,EAAE,MAAM,CAAC;IACtB,qCAAqC;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,gFAAgF;IAChF,SAAS,EAAE,MAAM,CAAC;IAElB;;;;;;;;;OASG;IACH,eAAe,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,eAAe,EAAE,MAAM,CAAC;IAExB;;;;OAIG;IACH,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC;AAED,MAAM,WAAW,oBAAqB,SAAQ,iBAAiB;IAC7D;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;IAEpC;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;CAClD;AAED,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,kBAAkB,EAAE,oBAAoB,CAAC,CAAC"}

package/lib/typescript/src/PerpSideRatio.nitro.d.ts

@@ -6,9 +6,19 @@ import type { HybridView, HybridViewMethods, HybridViewProps } from 'react-nativ
  * 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;
@@ -24,6 +34,19 @@ export interface PerpSideRatioProps extends HybridViewProps {
     reducedMotion: boolean;
 }
 export interface PerpSideRatioMethods extends HybridViewMethods {
+    /**
+     * Imperatively update the bid/ask ratio, bypassing the high-frequency
+     * `bidPercentage`/`askPercentage` prop write path (and its props/JSICache
+     * lock contention — REACT-NATIVE-1JZ). Companion to `PerpDepthBars.setDepth`.
+     *
+     * `bidPercentage`/`askPercentage` carry the EXACT SAME semantics as the
+     * props of the same name (0..100 shares; the native side derives the split
+     * fraction identically). The native side routes these through the same
+     * clamp/target/animation path the prop setters use — only the data source
+     * differs. The `bidPercentage`/`askPercentage` props are retained for
+     * backward compatibility; callers may use either path.
+     */
+    setRatio(bidPercentage: number, askPercentage: number): void;
 }
 export type PerpSideRatio = HybridView<PerpSideRatioProps, PerpSideRatioMethods>;
 //# sourceMappingURL=PerpSideRatio.nitro.d.ts.map

package/lib/typescript/src/PerpSideRatio.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PerpSideRatio.nitro.d.ts","sourceRoot":"","sources":["../../../src/PerpSideRatio.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EACjB,eAAe,EAChB,MAAM,4BAA4B,CAAC;AAEpC;;;;;GAKG;AACH,MAAM,WAAW,kBAAmB,SAAQ,eAAe;IACzD,gCAAgC;IAChC,aAAa,EAAE,MAAM,CAAC;IACtB,iCAAiC;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,iCAAiC;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,kCAAkC;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,sCAAsC;IACtC,aAAa,EAAE,MAAM,CAAC;IACtB,qCAAqC;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,8CAA8C;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,gEAAgE;IAChE,aAAa,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,oBAAqB,SAAQ,iBAAiB;CAAG;AAElE,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,kBAAkB,EAAE,oBAAoB,CAAC,CAAC"}
+{"version":3,"file":"PerpSideRatio.nitro.d.ts","sourceRoot":"","sources":["../../../src/PerpSideRatio.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EACjB,eAAe,EAChB,MAAM,4BAA4B,CAAC;AAEpC;;;;;GAKG;AACH,MAAM,WAAW,kBAAmB,SAAQ,eAAe;IACzD;;;;;;OAMG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB,iCAAiC;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,kCAAkC;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,sCAAsC;IACtC,aAAa,EAAE,MAAM,CAAC;IACtB,qCAAqC;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,8CAA8C;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,gEAAgE;IAChE,aAAa,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,oBAAqB,SAAQ,iBAAiB;IAC7D;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9D;AAED,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,kBAAkB,EAAE,oBAAoB,CAAC,CAAC"}

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

package/nitrogen/generated/ios/c++/HybridPerpDepthBarsSpecSwift.hpp

@@ -12,12 +12,15 @@
 // Forward declaration of `HybridPerpDepthBarsSpec_cxx` to properly resolve imports.
 namespace PerpDepthBar { class HybridPerpDepthBarsSpec_cxx; }
 
-
+// Forward declaration of `ArrayBufferHolder` to properly resolve imports.
+namespace NitroModules { class ArrayBufferHolder; }
 
 #include <vector>
 #include <string>
 #include <functional>
 #include <optional>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/ArrayBufferHolder.hpp>
 
 #include "PerpDepthBar-Swift-Cxx-Umbrella.hpp"
 
@@ -156,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;
@@ -166,7 +182,18 @@ namespace margelo::nitro::perpdepthbar {
 
   public:
     // Methods
-    
+    inline void setDepth(const std::shared_ptr<ArrayBuffer>& buffer) override {
+      auto __result = _swiftPart.setDepth(ArrayBufferHolder(buffer));
+      if (__result.hasError()) [[unlikely]] {
+        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;