react-native-vroom-chart 0.5.0 → 0.7.0

package/cpp/_core_src/series_ma.cpp

@@ -0,0 +1,64 @@
+#include "series_ma.h"
+
+#include <cmath>  // std::nan, std::isfinite
+#include <cstddef>
+
+#include "ma.h"
+
+namespace vroom::series_ma {
+
+void ema_seeded(const std::vector<double>& src, int period,
+                std::vector<double>& out) {
+    const std::size_t n = src.size();
+    out.assign(n, std::nan(""));
+    if (period < 1) return;
+    const std::size_t P = static_cast<std::size_t>(period);
+
+    std::size_t f = 0;
+    while (f < n && !std::isfinite(src[f])) ++f;
+    if (f >= n || f + P > n) return;  // not enough finite values to seed
+
+    const std::size_t seed = f + P - 1;
+    double sum = 0.0;
+    for (std::size_t k = f; k <= seed; ++k) sum += src[k];
+    double prev = sum / static_cast<double>(P);
+    out[seed] = prev;
+
+    const double alpha = 2.0 / (static_cast<double>(P) + 1.0);
+    for (std::size_t i = seed + 1; i < n; ++i) {
+        if (!std::isfinite(src[i])) break;  // series are contiguous after f
+        prev = alpha * src[i] + (1.0 - alpha) * prev;
+        out[i] = prev;
+    }
+}
+
+void sma_seeded(const std::vector<double>& src, int period,
+                std::vector<double>& out) {
+    const std::size_t n = src.size();
+    out.assign(n, std::nan(""));
+    if (period < 1) return;
+    const std::size_t P = static_cast<std::size_t>(period);
+
+    std::size_t f = 0;
+    while (f < n && !std::isfinite(src[f])) ++f;
+    if (f >= n || f + P > n) return;
+
+    double sum = 0.0;
+    for (std::size_t i = f; i < n; ++i) {
+        if (!std::isfinite(src[i])) break;  // series are contiguous after f
+        sum += src[i];
+        if (i >= f + P) sum -= src[i - P];
+        if (i >= f + P - 1) out[i] = sum / static_cast<double>(P);
+    }
+}
+
+void smooth(const std::vector<double>& src, int kind, int period,
+            std::vector<double>& out) {
+    if (kind == vroom::ma::KIND_SMA) {
+        sma_seeded(src, period, out);
+    } else {
+        ema_seeded(src, period, out);
+    }
+}
+
+}  // namespace vroom::series_ma

package/cpp/_core_src/series_ma.h

@@ -0,0 +1,30 @@
+// Moving averages over an already-computed series — pure computation, no Skia.
+//
+// Distinct from ma.h, which averages a *price* source off the candles. These
+// smooth a derived series that may open with a run of NaN warmup (the MACD
+// difference, an RSI line), so they skip that run and start counting from the
+// first finite value. Both smoothers therefore produce their first value at the
+// same index, which is what lets the MA kind be a config toggle.
+
+#pragma once
+
+#include <vector>
+
+namespace vroom::series_ma {
+
+// SMA-seeded EMA over `src`. Fills `out` (resized to src.size()): NaN until the
+// seed index, the seed = SMA of the first `period` finite values, then
+// ema = alpha*src + (1-alpha)*prev.
+void ema_seeded(const std::vector<double>& src, int period,
+                std::vector<double>& out);
+
+// Rolling SMA over `src`, skipping the same leading NaN run as ema_seeded.
+void sma_seeded(const std::vector<double>& src, int period,
+                std::vector<double>& out);
+
+// Dispatches on a vroom::ma KIND_* value: KIND_SMA picks sma_seeded, anything
+// else ema_seeded.
+void smooth(const std::vector<double>& src, int kind, int period,
+            std::vector<double>& out);
+
+}  // namespace vroom::series_ma

package/cpp/_core_src/style_inherit.h

@@ -0,0 +1,35 @@
+// Resolution of the indicator style "inherit sentinels".
+//
+// Every indicator style field is optional at the public API, so the marshalled
+// struct needs a value that means "the host didn't set this". A fully
+// transparent color and a non-positive width are those sentinels: they can't
+// name anything drawable, so they're free to carry the meaning. The renderer
+// swaps them for the theme value or the built-in default at draw time, which
+// keeps the fallback in one place instead of freezing it into every bridge.
+
+#pragma once
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#include "include/core/SkColor.h"
+#pragma clang diagnostic pop
+
+namespace vroom::style {
+
+inline SkColor color_or(uint32_t configured, SkColor fallback) {
+    return SkColorGetA(configured) == 0 ? fallback : configured;
+}
+
+// For an element whose default is another element's color dimmed — the easing
+// MACD histogram bars, say.
+inline SkColor faded_or(uint32_t configured, SkColor base, float alpha_frac) {
+    if (SkColorGetA(configured) != 0) return configured;
+    return SkColorSetA(base,
+                       static_cast<U8CPU>(SkColorGetA(base) * alpha_frac));
+}
+
+inline float width_or(float configured, float fallback) {
+    return configured > 0.f ? configured : fallback;
+}
+
+}  // namespace vroom::style

package/cpp/_core_src/theme.cpp

@@ -22,7 +22,7 @@ constexpr uint32_t kDefaultColors[VROOM_COLOR_COUNT_] = {
     0x00000000,  // WICK_BEAR   — transparent sentinel: inherit BEAR fill
     0xff26a69a,  // ACCENT_BULL — classic teal-green (price indicator, volume, MACD)
     0xffef5350,  // ACCENT_BEAR — classic red
-    0xffc9d1d9,  // LINE — line-chart close polyline; neutral foreground (AXIS_TEXT tone)
+    0xff8957e5,  // LINE — line-chart close polyline; violet, matching the RSI line
 };
 
 constexpr float kDefaultFloats[VROOM_FLOAT_COUNT_] = {
@@ -38,6 +38,7 @@ constexpr float kDefaultFloats[VROOM_FLOAT_COUNT_] = {
     0.f,    // WICK_ROUND_CAP — butt caps by default
     0.f,    // VOLUME_RADIUS_PX — square by default
     1.5f,   // LINE_WIDTH_PX — line-chart polyline stroke width
+    0.28f,  // LINE_GRADIENT_OPACITY — fill under the line, ramped to 0 at the pane bottom
 };
 
 }  // namespace

package/cpp/_core_src/viewport.cpp

@@ -10,8 +10,7 @@ float candle_body_width(const Layout& layout,
                         int64_t window_ms,
                         int64_t candle_duration_ms) {
     if (window_ms <= 0 || candle_duration_ms <= 0) return 0.f;
-    const float usable =
-        layout.width_px - layout.y_axis_width_px - layout.right_padding_px;
+    const float usable = candle_area_width(layout);
     const double slot = static_cast<double>(usable) *
         (static_cast<double>(candle_duration_ms) /
          static_cast<double>(window_ms));
@@ -24,8 +23,7 @@ float candle_center_x(const Layout& layout,
                       int64_t visible_start_ms,
                       int64_t window_ms) {
     if (window_ms <= 0) return 0.f;
-    const float usable =
-        layout.width_px - layout.y_axis_width_px - layout.right_padding_px;
+    const float usable = candle_area_width(layout);
     const double center_time =
         static_cast<double>(time_ms) +
         static_cast<double>(candle_duration_ms) * 0.5;
@@ -213,19 +211,45 @@ PriceBounds auto_price_bounds(const ::VroomCandle* candles, size_t count) {
     return {mid - half, mid + half};
 }
 
-float price_to_y(const Layout& layout,
-                 const PriceBounds& bounds,
-                 double price) {
+PriceBounds preserve_envelope_bounds(const PriceBounds& old_axis,
+                                     const PriceBounds& old_env,
+                                     const PriceBounds& new_env) {
+    const double axis_range = old_axis.max - old_axis.min;
+    const double old_span = old_env.max - old_env.min;
+    const double new_span = new_env.max - new_env.min;
+    if (axis_range <= 0.0 || old_span <= 0.0 || new_span <= 0.0) return old_axis;
+
+    // Same span/range ratio => same pixel height for the envelope.
+    const double new_range = axis_range * (new_span / old_span);
+    // Fraction of the axis (from the bottom) where the old envelope's midpoint
+    // sat; putting the new midpoint at the same fraction pins the envelope box.
+    const double t =
+        ((old_env.min + old_env.max) * 0.5 - old_axis.min) / axis_range;
+    const double new_mid = (new_env.min + new_env.max) * 0.5;
+    return {new_mid - t * new_range, new_mid + (1.0 - t) * new_range};
+}
+
+double price_fraction(const PriceBounds& bounds, double price) {
+    const double range = bounds.max - bounds.min;
+    // Degenerate range: everything sits at the band midpoint, which keeps
+    // price_to_y's flat-series fallback intact.
+    if (range <= 0.0) return 0.5;
+    return (price - bounds.min) / range;  // 0 at min, 1 at max
+}
+
+float y_at_fraction(const Layout& layout, double frac) {
     // The candle drawing area is the full height minus the x-axis strip and
     // any below-chart indicator pane.
     const float candle_area_h = price_pane_bottom(layout);
     const float top = candle_area_h * layout.top_padding_frac;
     const float bot = candle_area_h * (1.f - layout.bottom_padding_frac);
-    const float draw_h = bot - top;
-    const double range = bounds.max - bounds.min;
-    if (range <= 0.0) return (top + bot) * 0.5f;
-    const double t = (price - bounds.min) / range;  // 0..1, 0 at min
-    return bot - static_cast<float>(t) * draw_h;    // invert: high price → low y
+    return bot - static_cast<float>(frac) * (bot - top);  // invert: high → low y
+}
+
+float price_to_y(const Layout& layout,
+                 const PriceBounds& bounds,
+                 double price) {
+    return y_at_fraction(layout, price_fraction(bounds, price));
 }
 
 double y_to_price(const Layout& layout,

package/cpp/_core_src/viewport.h

@@ -34,6 +34,12 @@ inline float x_axis_top(const Layout& l) {
     return l.height_px - l.x_axis_height_px;
 }
 
+// Width available to candles: the full width minus the y-axis strip and the
+// right-hand gutter.
+inline float candle_area_width(const Layout& l) {
+    return l.width_px - l.y_axis_width_px - l.right_padding_px;
+}
+
 struct PriceBounds {
     double min;
     double max;
@@ -45,6 +51,27 @@ struct IndexRange {
     size_t end;
 };
 
+// One candle's geometry captured in normalized form for the interval morph:
+// x as a fraction of the candle-area width, prices as fractions of the price
+// band. Resolution-independent, so a resize mid-morph stays correct — and
+// independent of the price bounds, so the captured geometry keeps its pixel
+// position after a timeframe switch re-scales the y-axis.
+struct CandleSnapshot {
+    float x;
+    float open, high, low, close;
+    bool  bull;  // close >= open; selects the fill / wick / border color
+};
+
+// How many captured slots still contribute to a frame — 0 once the morph is
+// done, which releases the capture. Drawing routines take max(n, this) as their
+// slot count, pairing the new candle at slot k (visible[n - 1 - k]) with the
+// captured one (from[k]), both counting back from the right edge.
+inline std::size_t morph_from_count(const CandleSnapshot* from,
+                                    std::size_t from_n,
+                                    float morph_t) {
+    return (from && morph_t < 1.f) ? from_n : 0;
+}
+
 // Returns the indices of candles whose time_ms falls in [start_ms, end_ms].
 // When both are 0, returns the full range (Phase 1 default-everything behavior).
 // Candles must be sorted ascending by time_ms (invariant of the public API).
@@ -140,9 +167,32 @@ constexpr double kAutoYZoom = 1.5;
 // {0, 1} sentinel when count == 0 (callers keep their previous bounds).
 PriceBounds auto_price_bounds(const ::VroomCandle* candles, size_t count);
 
+// Rescales an axis range so a data envelope keeps the pixel height *and* the
+// pixel position it had before a data swap — the "scale lock" applied on a
+// timeframe switch, where the same price action re-buckets into a smaller or
+// larger high-low span.
+//
+// `old_axis` is the axis range that was in effect; `old_env` / `new_env` are the
+// visible high-low envelopes (as returned by price_bounds) before and after the
+// swap. Resolution-independent: both envelopes share the same draw band, so the
+// band height cancels out. Returns `old_axis` unchanged when any span is
+// degenerate.
+PriceBounds preserve_envelope_bounds(const PriceBounds& old_axis,
+                                     const PriceBounds& old_env,
+                                     const PriceBounds& new_env);
+
 // Map a price to y in pixels. y=0 is top of the chart.
 float price_to_y(const Layout& layout, const PriceBounds& bounds, double price);
 
+// Fraction of the price band a price sits at: 0 = bounds.min, 1 = bounds.max.
+// Returns 0.5 for a degenerate range, matching price_to_y's midpoint fallback.
+double price_fraction(const PriceBounds& bounds, double price);
+
+// The y of a band fraction. Splits price_to_y in two so geometry can be stored
+// independently of the price bounds (see CandleSnapshot):
+//   price_to_y(l, b, p) == y_at_fraction(l, price_fraction(b, p))
+float y_at_fraction(const Layout& layout, double frac);
+
 // Inverse of price_to_y: map a pixel y in the price pane back to a price.
 // Returns bounds.min for a degenerate range or draw band.
 double y_to_price(const Layout& layout, const PriceBounds& bounds, float y);

package/cpp/_core_src/volume.cpp

@@ -12,11 +12,13 @@
 
 #include "theme.h"
 #include "viewport.h"
+#include "volume_anim.h"
 
 namespace vroom::volume {
 
 namespace {
-constexpr float kVolumeFrac = 0.20f;  // tallest bar = this fraction of the area
+// Ceiling for the tallest bar when the config inherits it.
+constexpr float kDefaultHeightFrac = 0.20f;
 }  // namespace
 
 void draw(SkCanvas* canvas,
@@ -24,6 +26,9 @@ void draw(SkCanvas* canvas,
           std::size_t n,
           const Layout& lay,
           const Theme& theme,
+          const ::VroomVolume& cfg,
+          float collapse_t,
+          int32_t collapse_easing,
           int64_t window_ms,
           int64_t visible_start_ms,
           int64_t candle_duration_ms) {
@@ -34,23 +39,38 @@ void draw(SkCanvas* canvas,
     for (std::size_t i = 0; i < n; ++i) max_vol = std::max(max_vol, visible[i].volume);
     if (max_vol <= 0.0) return;
 
+    // Resolve every inherit sentinel up front so the loop reads plain values.
+    const float height_frac =
+        cfg.height_frac >= 0.f ? cfg.height_frac : kDefaultHeightFrac;
+    const float opacity = cfg.opacity >= 0.f
+        ? cfg.opacity
+        : theme.floats[VROOM_FLOAT_VOLUME_OPACITY];
+    const float vol_r = cfg.radius_px >= 0.f
+        ? cfg.radius_px
+        : theme.floats[VROOM_FLOAT_VOLUME_RADIUS_PX];
+    const SkColor up_color = cfg.up_color != 0
+        ? static_cast<SkColor>(cfg.up_color)
+        : theme.colors[VROOM_COLOR_ACCENT_BULL];
+    const SkColor down_color = cfg.down_color != 0
+        ? static_cast<SkColor>(cfg.down_color)
+        : theme.colors[VROOM_COLOR_ACCENT_BEAR];
+
     const float candle_area_h = vroom::price_pane_bottom(lay);
-    const float region_h = candle_area_h * kVolumeFrac;
+    const float region_h = candle_area_h * height_frac;
+    if (region_h <= 0.f) return;
 
     const float body_w = vroom::candle_body_width(
         lay, window_ms, candle_duration_ms);
     const float half_body = body_w * 0.5f;
 
-    const float opacity = theme.floats[VROOM_FLOAT_VOLUME_OPACITY];
-    const float vol_r = theme.floats[VROOM_FLOAT_VOLUME_RADIUS_PX];
     SkPaint bull_paint;
     bull_paint.setAntiAlias(true);
-    bull_paint.setColor(theme.colors[VROOM_COLOR_ACCENT_BULL]);
+    bull_paint.setColor(up_color);
     bull_paint.setAlphaf(opacity);
 
     SkPaint bear_paint;
     bear_paint.setAntiAlias(true);
-    bear_paint.setColor(theme.colors[VROOM_COLOR_ACCENT_BEAR]);
+    bear_paint.setColor(down_color);
     bear_paint.setAlphaf(opacity);
 
     for (std::size_t i = 0; i < n; ++i) {
@@ -61,8 +81,13 @@ void draw(SkCanvas* canvas,
         const float cx = vroom::candle_center_x(
             lay, c.time_ms, candle_duration_ms,
             visible_start_ms, window_ms);
-        const float h = std::max(
-            1.f, static_cast<float>(c.volume / max_vol) * region_h);
+        // The 1px floor applies to the settled height, not the animated one, so
+        // a collapsing bar can still reach zero.
+        const float frac = static_cast<float>(c.volume / max_vol);
+        const float full_h = std::max(1.f, frac * region_h);
+        const float h = full_h * (1.f - vroom::volume_anim::bar_collapse(
+                                            frac, collapse_t, collapse_easing));
+        if (h < 0.5f) continue;  // collapsed past the point of drawing anything
         const SkRect rect =
             SkRect::MakeXYWH(cx - half_body, candle_area_h - h, body_w, h);
         const SkPaint& paint = bull ? bull_paint : bear_paint;

package/cpp/_core_src/volume.h

@@ -21,12 +21,23 @@ namespace vroom::volume {
 
 // Draws a volume bar for each candle in [visible, visible + n). Bars share the
 // candles' x/width (via candle_center_x / candle_body_width) so they scroll and
-// resize with the candles. Heights auto-fit to the max volume in the slice.
+// resize with the candles. Heights auto-fit to the max volume in the slice, so
+// the loudest bar lands on cfg.height_frac of the pane.
+//
+// `cfg` supplies height/opacity/radius/colors; each of its style fields falls
+// back to `theme` when left on its inherit sentinel.
+//
+// `collapse_t` (0 = full height, 1 = flat) staggers the bars down out of view,
+// tallest first, all landing together — see volume_anim.h. It's also the
+// visibility gate: callers skip this entirely at 1, since nothing would draw.
 void draw(SkCanvas* canvas,
           const ::VroomCandle* visible,
           std::size_t n,
           const Layout& lay,
           const Theme& theme,
+          const ::VroomVolume& cfg,
+          float collapse_t,
+          int32_t collapse_easing,
           int64_t window_ms,
           int64_t visible_start_ms,
           int64_t candle_duration_ms);

package/cpp/_core_src/volume_anim.cpp

@@ -0,0 +1,32 @@
+#include "volume_anim.h"
+
+#include <algorithm>
+
+#include "vroom/vroom_chart.h"
+
+namespace vroom::volume_anim {
+
+float ease(int32_t kind, float p) {
+    const float t = std::clamp(p, 0.f, 1.f);
+    switch (kind) {
+        case VROOM_EASING_LINEAR:
+            return t;
+        case VROOM_EASING_IN:
+            return t * t;
+        case VROOM_EASING_OUT:
+            return t * (2.f - t);
+        default:
+            return t * t * (3.f - 2.f * t);  // smoothstep
+    }
+}
+
+float bar_collapse(float frac, float t, int32_t easing) {
+    const float progress = std::clamp(t, 0.f, 1.f);
+    const float window = std::clamp(frac, kMinWindow, 1.f);
+    // The window occupies the tail of the timeline, so a taller bar (bigger
+    // window) opens earlier. Every window ends at 1.
+    const float start = 1.f - window;
+    return ease(easing, (progress - start) / window);
+}
+
+}  // namespace vroom::volume_anim

package/cpp/_core_src/volume_anim.h

@@ -0,0 +1,41 @@
+// Volume-bar collapse timing — pure functions, no Skia, no state.
+//
+// Split out from volume.cpp so the stagger arithmetic unit-tests without a Skia
+// checkout, and so the one piece of easing the core owns lives somewhere
+// obvious.
+//
+// Unlike the candle↔line and interval morphs, the host can't pre-ease this
+// animation: every bar runs on its own window, so easing has to be applied per
+// bar, after the window split. Feed bar_collapse the raw linear progress.
+
+#pragma once
+
+#include <cstdint>
+
+namespace vroom::volume_anim {
+
+// Shortest window any bar gets, as a fraction of the timeline. Without a floor a
+// near-zero bar would collapse inside a single frame and read as a pop rather
+// than a fall. Clamping only moves a start earlier, so every bar still lands
+// together.
+constexpr float kMinWindow = 0.2f;
+
+// Linear progress (0..1) mapped through a VroomEasing curve. Mirrors ease() in
+// packages/react/src/easing.ts; unknown kinds fall back to smoothstep, matching
+// it. Progress outside 0..1 is clamped.
+float ease(int32_t kind, float p);
+
+// How far a single bar has collapsed at global linear progress `t`, from 0
+// (untouched, full height) to 1 (flat).
+//
+// `frac` is the bar's height as a fraction of the tallest bar in view, and
+// doubles as the length of its window: a bar falls over the last `frac` of the
+// timeline. So the tallest bar starts immediately and takes the whole
+// transition, shorter bars start progressively later, and everything reaches
+// zero at t = 1 — the "tallest first, all land together" cascade.
+//
+// Symmetric in `t`, so driving it backwards (1 -> 0) plays the reveal: the
+// shortest bar rises first and the tallest arrives last.
+float bar_collapse(float frac, float t, int32_t easing);
+
+}  // namespace vroom::volume_anim