react-native-vroom-chart 0.13.1 → 0.15.0

package/cpp/VroomChartHostObject.cpp

@@ -42,7 +42,7 @@ ChartHostObject::~ChartHostObject() {
 std::vector<jsi::PropNameID> ChartHostObject::getPropertyNames(
     jsi::Runtime& rt) {
   std::vector<jsi::PropNameID> out;
-  out.reserve(39);
+  out.reserve(42);
   out.push_back(jsi::PropNameID::forAscii(rt, "setCandles"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setSize"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setColor"));
@@ -82,6 +82,9 @@ std::vector<jsi::PropNameID> ChartHostObject::getPropertyNames(
   out.push_back(jsi::PropNameID::forAscii(rt, "hitTestPriceLine"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setPriceLineHover"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setPriceLineDrag"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setFootprints"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "hitTestFootprint"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setFootprintHover"));
   out.push_back(jsi::PropNameID::forAscii(rt, "render"));
   return out;
 }
@@ -484,17 +487,25 @@ jsi::Value ChartHostObject::get(jsi::Runtime& rt,
   }
 
   if (name == "beginIntervalMorph") {
-    // beginIntervalMorph() — capture the visible candle geometry so the next
-    // setCandles can be animated as a reshape. Call before setCandles.
+    // beginIntervalMorph(mode?) — capture the visible candle geometry so the
+    // next setCandles can animate. Optional string `'fade'` or `'transform'`
+    // (default). Call before setCandles.
     return jsi::Function::createFromHostFunction(
         rt,
         jsi::PropNameID::forAscii(rt, "beginIntervalMorph"),
-        0,
-        [this](jsi::Runtime& /*rt2*/,
+        1,
+        [this](jsi::Runtime& rt2,
                const jsi::Value& /*thisVal*/,
-               const jsi::Value* /*args*/,
-               size_t /*count*/) -> jsi::Value {
-          vroom_chart_begin_interval_morph(chart_);
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          int32_t mode = 0;
+          if (count >= 1 && args[0].isString()) {
+            const auto s = args[0].asString(rt2).utf8(rt2);
+            mode = s == "fade" ? 1 : 0;
+          } else if (count >= 1 && args[0].isNumber()) {
+            mode = args[0].asNumber() != 0 ? 1 : 0;
+          }
+          vroom_chart_begin_interval_morph(chart_, mode);
           return jsi::Value::undefined();
         });
   }
@@ -1181,6 +1192,120 @@ jsi::Value ChartHostObject::get(jsi::Runtime& rt,
         });
   }
 
+  if (name == "setFootprints") {
+    // setFootprints({ prints: [{ timeMs, side }, ...], radiusPx, gapPx, marginPx,
+    // hoverBoost }) — replaces the full set of executed-trade badges. The core
+    // buckets them onto candles itself, so raw fill times are what to pass. No
+    // render; the next render() picks it up.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setFootprints"),
+        1,
+        [this](jsi::Runtime& rt2,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 1 || !args[0].isObject()) return jsi::Value::undefined();
+          auto cfg = args[0].asObject(rt2);
+          auto prints_val = cfg.getProperty(rt2, "prints");
+          if (!prints_val.isObject()) return jsi::Value::undefined();
+          auto prints_obj = prints_val.asObject(rt2);
+          if (!prints_obj.isArray(rt2)) return jsi::Value::undefined();
+          auto arr = prints_obj.asArray(rt2);
+          const size_t len = arr.size(rt2);
+          std::vector<VroomFootprint> prints(len);
+          for (size_t i = 0; i < len; ++i) {
+            auto f = arr.getValueAtIndex(rt2, i).asObject(rt2);
+            prints[i].time_ms =
+                static_cast<int64_t>(f.getProperty(rt2, "timeMs").asNumber());
+            prints[i].side =
+                static_cast<int32_t>(f.getProperty(rt2, "side").asNumber());
+          }
+          VroomFootprintStyle style{};
+          style.radius_px = static_cast<float>(
+              cfg.getProperty(rt2, "radiusPx").asNumber());
+          style.gap_px = static_cast<float>(
+              cfg.getProperty(rt2, "gapPx").asNumber());
+          style.margin_px = static_cast<float>(
+              cfg.getProperty(rt2, "marginPx").asNumber());
+          style.hover_boost = static_cast<float>(
+              cfg.getProperty(rt2, "hoverBoost").asNumber());
+          vroom_chart_set_footprints(chart_, prints.data(), prints.size(), &style);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "hitTestFootprint") {
+    // hitTestFootprint(x, y) -> { side, candleTimeMs, x, y, radius, pane,
+    // indices } | null. `indices` addresses the array last passed to
+    // setFootprints and covers *both* sides of that candle, so one call fills a
+    // tooltip; `pane` is the plot rect, for deciding which side of the badge that
+    // tooltip fits on. No rendering.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "hitTestFootprint"),
+        2,
+        [this](jsi::Runtime& rt2,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 2) return jsi::Value::null();
+          VroomFootprintHit hit{};
+          if (!vroom_chart_hit_test_footprint(
+                  chart_, static_cast<float>(args[0].asNumber()),
+                  static_cast<float>(args[1].asNumber()), &hit)) {
+            return jsi::Value::null();
+          }
+
+          const int32_t n =
+              vroom_chart_footprints_at(chart_, hit.candle_time_ms, nullptr, 0);
+          std::vector<int32_t> idx(static_cast<size_t>(n > 0 ? n : 0));
+          if (n > 0) {
+            vroom_chart_footprints_at(chart_, hit.candle_time_ms, idx.data(), n);
+          }
+          jsi::Array indices(rt2, idx.size());
+          for (size_t i = 0; i < idx.size(); ++i) {
+            indices.setValueAtIndex(rt2, i, jsi::Value(idx[i]));
+          }
+
+          jsi::Object pane(rt2);
+          pane.setProperty(rt2, "left", hit.pane_left);
+          pane.setProperty(rt2, "top", hit.pane_top);
+          pane.setProperty(rt2, "right", hit.pane_right);
+          pane.setProperty(rt2, "bottom", hit.pane_bottom);
+
+          jsi::Object obj(rt2);
+          obj.setProperty(rt2, "side", hit.side);
+          obj.setProperty(rt2, "candleTimeMs",
+                          static_cast<double>(hit.candle_time_ms));
+          obj.setProperty(rt2, "x", hit.center_x);
+          obj.setProperty(rt2, "y", hit.center_y);
+          obj.setProperty(rt2, "radius", hit.radius);
+          obj.setProperty(rt2, "pane", std::move(pane));
+          obj.setProperty(rt2, "indices", std::move(indices));
+          return obj;
+        });
+  }
+
+  if (name == "setFootprintHover") {
+    // setFootprintHover(candleTimeMs, side) — highlight one badge; side -1
+    // clears. Touch has no hover, so on RN this tracks the tapped badge.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setFootprintHover"),
+        2,
+        [this](jsi::Runtime& /*rt2*/,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 2) return jsi::Value::undefined();
+          vroom_chart_set_footprint_hover(
+              chart_, static_cast<int64_t>(args[0].asNumber()),
+              static_cast<int32_t>(args[1].asNumber()));
+          return jsi::Value::undefined();
+        });
+  }
+
   if (name == "render") {
     return jsi::Function::createFromHostFunction(
         rt,

package/cpp/_core_include/vroom/vroom_chart.h

@@ -257,6 +257,53 @@ typedef struct VroomPriceLineStyle {
     float    hover_boost;       // brightness multiplier for the hovered segment (1 = flat)
 } VroomPriceLineStyle;
 
+// ---- Footprints (executed-trade badges) -----------------------------------
+
+typedef enum {
+    VROOM_FOOTPRINT_BUY = 0,   // position entry — "+" badge in the bull color
+    VROOM_FOOTPRINT_SELL = 1,  // position exit  — "-" badge in the bear color
+} VroomFootprintSide;
+
+// A single executed trade, drawn as a circular badge above the candle it fell in.
+//
+// `time_ms` is the raw execution time, *not* a bar-open time: the core buckets
+// each footprint into whichever candle's window contains it, so one array renders
+// correctly at every interval and re-groups by itself when the candles change.
+// Order is irrelevant — the core sorts within each bucket.
+//
+// Only the fields the renderer needs live here; a host's per-trade payload (id,
+// price, size) stays on the host side and is rejoined via the indices reported by
+// vroom_chart_footprints_at.
+typedef struct VroomFootprint {
+    int64_t time_ms;
+    int32_t side;  // VroomFootprintSide
+} VroomFootprint;
+
+// Layout/style shared by every footprint badge.
+typedef struct VroomFootprintStyle {
+    float radius_px;   // badge radius; <= 0 falls back to 9
+    float gap_px;      // vertical gap between the two stacked badges; < 0 => 4
+    float margin_px;   // gap between the candle's high and the first badge; < 0 => 8
+    float hover_boost; // brightness multiplier for the hovered badge (1 = flat)
+} VroomFootprintStyle;
+
+// The badge under a pixel, as reported by vroom_chart_hit_test_footprint.
+typedef struct VroomFootprintHit {
+    int64_t candle_time_ms;  // bar-open time of the candle the badge sits on
+    int32_t side;            // VroomFootprintSide — which of the candle's two badges
+    float   center_x;        // badge center, in the same px space as the hit test
+    float   center_y;
+    float   radius;
+    // The plot rect the badge was clipped to — same px space, axis strips
+    // excluded. Reported because a host placing its own tooltip has no other way
+    // to know it: the surface it measures includes the price and time axes, so
+    // sizing against that overstates the room next to a badge near the edge.
+    float   pane_left;
+    float   pane_top;
+    float   pane_right;
+    float   pane_bottom;
+} VroomFootprintHit;
+
 // A continuous data coordinate at a pixel position (no candle snapping). Used to
 // translate a drawing-tool click into a data-space anchor.
 typedef struct VroomCoord {
@@ -420,14 +467,13 @@ void vroom_chart_preserve_price_envelope(VroomChart* chart,
                                          double prev_low, double prev_high);
 
 // Captures the currently visible candle geometry so the next data swap can be
-// animated as a reshape rather than a jump: each candle's wick and body slide
-// and stretch into the shape of its counterpart in the new data.
+// animated. `mode` 0 (transform) lerps each visible column into its counterpart,
+// paired by slot counting back from the right edge. `mode` 1 (fade) fades the
+// capture out then the new scene in on the same envelope the axes already use.
 //
-// Candles are paired by *slot* — position counting back from the right edge of
-// the visible window, which a timeframe switch preserves. Call before
-// set_candles, then drive vroom_chart_set_interval_morph from 0 to 1.
-// No-op when nothing is visible.
-void vroom_chart_begin_interval_morph(VroomChart* chart);
+// Call before set_candles, then drive vroom_chart_set_interval_morph from 0
+// to 1. No-op when nothing is visible.
+void vroom_chart_begin_interval_morph(VroomChart* chart, int32_t mode);
 
 // Advances the interval morph started by vroom_chart_begin_interval_morph. `t`
 // (clamped to 0..1) is the eased progress: 0 renders the captured geometry
@@ -690,6 +736,43 @@ void vroom_chart_set_price_line_hover(VroomChart* chart, int32_t index,
 void vroom_chart_set_price_line_drag(VroomChart* chart, int32_t index,
                                      double price);
 
+// Replaces the full set of footprints and their shared style. Pass count 0 to
+// clear; `style` may be null when count is 0.
+//
+// Footprints are grouped onto candles by timestamp, so at most two badges render
+// per candle: one for that bar's buys and one for its sells, however many trades
+// went into each. When a candle has both, they stack upward with `gap_px` between
+// them, the side whose latest trade came first sitting nearest the bar. Badges sit
+// above the candle's high, clipped to the price pane, and re-group on their own
+// whenever the candles change (a new interval, more history) — the host never
+// re-buckets anything.
+void vroom_chart_set_footprints(VroomChart* chart, const VroomFootprint* prints,
+                                size_t count,
+                                const VroomFootprintStyle* style);
+
+// Hit-tests pixel (x_px, y_px) against the footprint badges. On a hit fills *out
+// with the badge's candle, side and pixel geometry and returns true; returns false
+// on a miss (out untouched). `out` may be null to test without reading the hit.
+// When two badges overlap the nearest center wins.
+bool vroom_chart_hit_test_footprint(VroomChart* chart, float x_px, float y_px,
+                                    VroomFootprintHit* out);
+
+// Fills `out_indices` with the indices — into the array last passed to
+// vroom_chart_set_footprints — of every footprint bucketed into the candle opening
+// at `candle_time_ms`, *both* sides, ascending by time. Returns the total count,
+// which may exceed `max` (only the first `max` are written), or 0 when that candle
+// has no footprints. Pass a null `out_indices` with max 0 to size the buffer first.
+//
+// This is how a host rejoins a hit badge to its own trade objects: hit-test to get
+// the candle, then map these indices back through the array it supplied.
+int32_t vroom_chart_footprints_at(VroomChart* chart, int64_t candle_time_ms,
+                                  int32_t* out_indices, int32_t max);
+
+// Marks one footprint badge as hovered so it renders highlighted. `side` -1
+// clears the hover; `candle_time_ms` and `side` match vroom_chart_hit_test_footprint.
+void vroom_chart_set_footprint_hover(VroomChart* chart, int64_t candle_time_ms,
+                                     int32_t side);
+
 // Sets the transient in-progress "draft" the drawing tool shows while the user
 // places points. Node A is always shown; when `has_b`, node B is shown too.
 // `guide != 0` also draws the live preview (a guideline for a line, or a preview

package/cpp/_core_src/candles.h

@@ -28,11 +28,13 @@ namespace vroom::candles {
 // body/wick heights and width shrink to the line). `opacity` (0..1) fades the
 // whole candle layer out as the line fades in. Both default to a no-op.
 //
-// `from` / `from_n` is the outgoing geometry of an interval morph, indexed from
-// the right of the visible slice (slot 0 = newest), and `morph_t` (0..1) is the
-// eased progress toward `visible`. Each slot's wick and body interpolate between
-// the two; slots present on only one side fade in or out. `morph_t == 1` (the
-// default) draws `visible` alone.
+// `from` / `from_n` is the outgoing geometry of an interval *transform*, indexed
+// from the right of the visible slice (slot 0 = newest), and `morph_t` (0..1)
+// is the eased progress toward `visible`. Each slot's wick and body interpolate
+// between the two; slots present on only one side fade in or out. A host-chosen
+// fade (see interval_morph_fade) skips this lerp: the chart draws the capture
+// then the new scene via interval_phase instead. `morph_t == 1` (the default)
+// draws `visible` alone.
 void draw(SkCanvas* canvas,
           const ::VroomCandle* visible,
           std::size_t n,