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

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

@@ -105,6 +105,86 @@ namespace margelo::nitro::perpdepthbar::views {
         throw std::runtime_error(std::string("PerpDepthBars.epoch: ") + exc.what());
       }
     }()),
+    prices([&]() -> CachedProp<std::vector<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("prices", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.prices;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::vector<std::string>>::fromRawValue(*runtime, value, sourceProps.prices);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PerpDepthBars.prices: ") + exc.what());
+      }
+    }()),
+    sizes([&]() -> CachedProp<std::vector<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("sizes", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.sizes;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::vector<std::string>>::fromRawValue(*runtime, value, sourceProps.sizes);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PerpDepthBars.sizes: ") + exc.what());
+      }
+    }()),
+    priceColor([&]() -> CachedProp<std::string> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("priceColor", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.priceColor;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.priceColor);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PerpDepthBars.priceColor: ") + exc.what());
+      }
+    }()),
+    sizeColor([&]() -> CachedProp<std::string> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("sizeColor", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.sizeColor;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.sizeColor);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PerpDepthBars.sizeColor: ") + exc.what());
+      }
+    }()),
+    priceFontSize([&]() -> CachedProp<double> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("priceFontSize", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.priceFontSize;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.priceFontSize);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PerpDepthBars.priceFontSize: ") + exc.what());
+      }
+    }()),
+    sizeFontSize([&]() -> CachedProp<double> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("sizeFontSize", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.sizeFontSize;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.sizeFontSize);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PerpDepthBars.sizeFontSize: ") + exc.what());
+      }
+    }()),
+    textInset([&]() -> CachedProp<double> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("textInset", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.textInset;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.textInset);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PerpDepthBars.textInset: ") + exc.what());
+      }
+    }()),
+    onRowPress([&]() -> CachedProp<std::optional<std::function<void(double /* rowIndex */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onRowPress", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onRowPress;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(double /* rowIndex */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onRowPress);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PerpDepthBars.onRowPress: ") + exc.what());
+      }
+    }()),
     hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridPerpDepthBarsSpec>& /* ref */)>>> {
       try {
         const react::RawValue* rawValue = rawProps.at("hybridRef", nullptr, nullptr);
@@ -126,6 +206,14 @@ namespace margelo::nitro::perpdepthbar::views {
     origin(other.origin),
     reducedMotion(other.reducedMotion),
     epoch(other.epoch),
+    prices(other.prices),
+    sizes(other.sizes),
+    priceColor(other.priceColor),
+    sizeColor(other.sizeColor),
+    priceFontSize(other.priceFontSize),
+    sizeFontSize(other.sizeFontSize),
+    textInset(other.textInset),
+    onRowPress(other.onRowPress),
     hybridRef(other.hybridRef) { }
 
   bool HybridPerpDepthBarsProps::filterObjectKeys(const std::string& propName) {
@@ -138,6 +226,14 @@ namespace margelo::nitro::perpdepthbar::views {
       case hashString("origin"): return true;
       case hashString("reducedMotion"): return true;
       case hashString("epoch"): return true;
+      case hashString("prices"): return true;
+      case hashString("sizes"): return true;
+      case hashString("priceColor"): return true;
+      case hashString("sizeColor"): return true;
+      case hashString("priceFontSize"): return true;
+      case hashString("sizeFontSize"): return true;
+      case hashString("textInset"): return true;
+      case hashString("onRowPress"): return true;
       case hashString("hybridRef"): return true;
       default: return false;
     }

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

@@ -18,10 +18,10 @@
 
 #include <vector>
 #include <string>
-#include <memory>
-#include "HybridPerpDepthBarsSpec.hpp"
 #include <functional>
 #include <optional>
+#include <memory>
+#include "HybridPerpDepthBarsSpec.hpp"
 
 namespace margelo::nitro::perpdepthbar::views {
 
@@ -52,6 +52,14 @@ namespace margelo::nitro::perpdepthbar::views {
     CachedProp<std::string> origin;
     CachedProp<bool> reducedMotion;
     CachedProp<double> epoch;
+    CachedProp<std::vector<std::string>> prices;
+    CachedProp<std::vector<std::string>> sizes;
+    CachedProp<std::string> priceColor;
+    CachedProp<std::string> sizeColor;
+    CachedProp<double> priceFontSize;
+    CachedProp<double> sizeFontSize;
+    CachedProp<double> textInset;
+    CachedProp<std::optional<std::function<void(double /* rowIndex */)>>> onRowPress;
     CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridPerpDepthBarsSpec>& /* ref */)>>> hybridRef;
 
   private:

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

@@ -12,6 +12,14 @@
     "origin": true,
     "reducedMotion": true,
     "epoch": true,
+    "prices": true,
+    "sizes": true,
+    "priceColor": true,
+    "sizeColor": true,
+    "priceFontSize": true,
+    "sizeFontSize": true,
+    "textInset": true,
+    "onRowPress": true,
     "hybridRef": true
   }
 }

package/package.json

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

package/src/PerpDepthBars.nitro.ts

@@ -35,6 +35,33 @@ export interface PerpDepthBarsProps extends HybridViewProps {
    * empty<->full so native snaps to the new values WITHOUT animating.
    */
   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"). */
+  prices: string[];
+  /** Formatted size string per row (e.g. "389.04"). */
+  sizes: string[];
+  /** Price text color: hex or rgba()/rgb(). */
+  priceColor: string;
+  /** Size text color: hex or rgba()/rgb(). */
+  sizeColor: string;
+  /** Price text font size in points. */
+  priceFontSize: number;
+  /** Size text font size in points. */
+  sizeFontSize: number;
+  /** Horizontal text inset in points (price padding-left, size padding-right). */
+  textInset: number;
+
+  /**
+   * Fired natively when a row is tapped. `rowIndex` is the 0-based row
+   * (top→bottom, parallel to `percents`/`prices`/`sizes`). The view handles
+   * the touch itself — no RN overlay / JS hit-testing needed.
+   */
+  onRowPress?: (rowIndex: number) => void;
 }
 
 export interface PerpDepthBarsMethods extends HybridViewMethods {}

package/src/index.tsx

@@ -1,4 +1,5 @@
-import { getHostComponent } from 'react-native-nitro-modules';
+import { useCallback, useRef } from 'react';
+import { callback, getHostComponent } from 'react-native-nitro-modules';
 
 import type {
   PerpDepthBarsMethods,
@@ -19,11 +20,36 @@ export type {
   PerpSideRatioProps,
 };
 
-export const PerpDepthBarsView = getHostComponent<
+const PerpDepthBarsHost = getHostComponent<
   PerpDepthBarsProps,
   PerpDepthBarsMethods
 >('PerpDepthBars', () => PerpDepthBarsConfig);
 
+/**
+ * Thin wrapper so consumers pass a plain `onRowPress` function. Nitro view
+ * callbacks must be wrapped with `callback(...)` to cross the JSI boundary;
+ * we encapsulate that here (with a ref so the underlying callback stays
+ * stable across re-renders) instead of leaking it to every call site.
+ */
+export function PerpDepthBarsView({
+  onRowPress,
+  ...props
+}: PerpDepthBarsProps) {
+  const onRowPressRef = useRef(onRowPress);
+  onRowPressRef.current = onRowPress;
+
+  const stableOnRowPress = useCallback((rowIndex: number) => {
+    onRowPressRef.current?.(rowIndex);
+  }, []);
+
+  return (
+    <PerpDepthBarsHost
+      {...props}
+      onRowPress={onRowPress ? callback(stableOnRowPress) : undefined}
+    />
+  );
+}
+
 export const PerpSideRatioView = getHostComponent<
   PerpSideRatioProps,
   PerpSideRatioMethods