react-native-vroom-chart 0.1.0 → 0.1.2

package/cpp/_core_src/crosshair.h

@@ -8,6 +8,9 @@
 
 #pragma once
 
+#include <cstdint>
+
+#include "viewport.h"
 #include "vroom/vroom_chart.h"
 
 class SkCanvas;
@@ -22,11 +25,20 @@ namespace vroom::crosshair {
 // (the bottom of the indicator region, so it stays visible over any RSI/MACD
 // panes); pass `candle_area_h` for both when there are no panes. `snap_x` is the
 // candle-snapped x for the vertical line and ring.
+//
+// Two axis badges are drawn over the strips: a date/time badge (formatted from
+// `snap_time_ms`) centered on the vertical line in the x-axis strip, and a
+// price badge (the price at the crosshair y, via `lay`/`bounds`) centered in
+// the y-axis strip. Both render on top of the axis labels and the current-price
+// indicator since the crosshair is the last thing drawn.
 void draw(SkCanvas* canvas,
           const VroomChart& chart,
+          const vroom::Layout& lay,
+          const vroom::PriceBounds& bounds,
           float candle_right,
           float candle_area_h,
           float vline_bottom,
-          float snap_x);
+          float snap_x,
+          int64_t snap_time_ms);
 
 }  // namespace vroom::crosshair

package/cpp/_core_src/labels.cpp

@@ -171,17 +171,16 @@ void update_x_fades(VroomChart& chart, const Layout& lay) {
     if (candle_area_w <= 0.f) return;
 
     const int64_t window_ms = chart.visible_end_ms - chart.visible_start_ms;
-    const int64_t interval = vroom::pick_time_interval(window_ms, candle_area_w);
-    if (interval <= 0) return;
+    const vroom::TimeTick tick =
+        vroom::pick_time_tick(window_ms, candle_area_w);
 
     for (auto& f : chart.x_fades) f.target = 0.f;
 
-    int64_t t = (chart.visible_start_ms / interval) * interval;
-    if (t < chart.visible_start_ms) t += interval;
+    int64_t t = vroom::first_tick_at_or_after(chart.visible_start_ms, tick);
     constexpr int kMaxLabels = 64;
     int promoted = 0;
     for (; t <= chart.visible_end_ms && promoted < kMaxLabels;
-         t += interval, ++promoted) {
+         t = vroom::next_tick(t, tick), ++promoted) {
         bool found = false;
         for (auto& f : chart.x_fades) {
             if (f.time_ms == t) {
@@ -238,8 +237,9 @@ void draw_x_labels(SkCanvas* canvas,
     if (candle_area_w <= 0.f) return;
 
     const int64_t window_ms = chart.visible_end_ms - chart.visible_start_ms;
-    // Recompute interval here just to decide HH:MM vs MM/DD formatting.
-    const int64_t interval = vroom::pick_time_interval(window_ms, candle_area_w);
+    // Recompute the cadence here just to decide label formatting.
+    const vroom::TimeTick tick =
+        vroom::pick_time_tick(window_ms, candle_area_w);
 
     SkFont font(tf, chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX]);
     font.setSubpixel(true);
@@ -257,7 +257,9 @@ void draw_x_labels(SkCanvas* canvas,
 
     const float baseline_y =
         candle_area_h + (lay.x_axis_height_px + cap_h) * 0.5f;
-    const bool use_date = interval >= 24LL * 60 * 60 * 1000;
+    const bool use_date =
+        tick.unit == vroom::TimeUnit::Fixed &&
+        tick.step_ms >= 24LL * 60 * 60 * 1000;
     for (const auto& f : chart.x_fades) {
         if (f.opacity <= 1e-3f) continue;
         const float frac =
@@ -269,7 +271,16 @@ void draw_x_labels(SkCanvas* canvas,
         const time_t time_s = static_cast<time_t>(f.time_ms / 1000);
         struct tm tm_buf;
         localtime_r(&time_s, &tm_buf);
-        if (use_date) {
+        if (tick.unit == vroom::TimeUnit::Year) {
+            std::snprintf(buf, sizeof(buf), "%d", tm_buf.tm_year + 1900);
+        } else if (tick.unit == vroom::TimeUnit::Month) {
+            // Show the year at January so month ticks read across years.
+            if (tm_buf.tm_mon == 0) {
+                std::snprintf(buf, sizeof(buf), "%d", tm_buf.tm_year + 1900);
+            } else {
+                std::strftime(buf, sizeof(buf), "%b", &tm_buf);
+            }
+        } else if (use_date) {
             std::snprintf(buf, sizeof(buf), "%02d/%02d",
                           tm_buf.tm_mon + 1, tm_buf.tm_mday);
         } else {

package/cpp/_core_src/macd_pane.cpp

@@ -52,7 +52,10 @@ void draw(SkCanvas* canvas,
     if (band_h <= 0.f) return;
 
     const float mid = (pane_top + pane_bottom) * 0.5f;
-    const float half = band_h * 0.5f * kPadFrac;
+    // User y-zoom scales the amplitude about the zero line (mid). 1.0 = the
+    // default auto-fit; >1 zooms in, <1 zooms out.
+    const float half =
+        band_h * 0.5f * kPadFrac * static_cast<float>(chart.macd_y_scale);
 
     // Auto-scale symmetric about zero across all visible finite values.
     double scale = 0.0;
@@ -100,8 +103,8 @@ void draw(SkCanvas* canvas,
             vroom::candle_body_width(lay, window_ms, candle_duration_ms);
         const float half_body = body_w * 0.5f;
         const float zero_y = y_for(0.0);
-        const SkColor bull = chart.theme.colors[VROOM_COLOR_BULL];
-        const SkColor bear = chart.theme.colors[VROOM_COLOR_BEAR];
+        const SkColor bull = chart.theme.colors[VROOM_COLOR_ACCENT_BULL];
+        const SkColor bear = chart.theme.colors[VROOM_COLOR_ACCENT_BEAR];
         for (std::size_t i = 0; i < n; ++i) {
             const double h = hist_visible[i];
             if (!std::isfinite(h)) continue;

package/cpp/_core_src/price_indicator.cpp

@@ -43,7 +43,7 @@ void draw(SkCanvas* canvas,
     const ::VroomCandle& last = chart.candles.back();
     const bool bull = last.close >= last.open;
     const SkColor color =
-        chart.theme.colors[bull ? VROOM_COLOR_BULL : VROOM_COLOR_BEAR];
+        chart.theme.colors[bull ? VROOM_COLOR_ACCENT_BULL : VROOM_COLOR_ACCENT_BEAR];
 
     const float y = vroom::price_to_y(lay, bounds, last.close);
     if (y < 0.f || y > candle_area_h) return;  // price scrolled off-range

package/cpp/_core_src/rsi_pane.cpp

@@ -50,8 +50,13 @@ void draw(SkCanvas* canvas,
     const float band_h = pane_bottom - pane_top;
     if (band_h <= 0.f) return;
 
+    // Map 0..100 about the pane center so the user y-zoom scales symmetrically
+    // around 50. z == 1 reproduces the default fit (0 -> pane_bottom, 100 ->
+    // pane_top); z > 1 zooms in (taller), z < 1 zooms out (flatter).
+    const float center_y = (pane_top + pane_bottom) * 0.5f;
+    const float z = static_cast<float>(chart.rsi_y_scale);
     auto y_for = [&](double v) -> float {
-        return pane_bottom - static_cast<float>(v / 100.0) * band_h;
+        return center_y - static_cast<float>((v - 50.0) / 100.0) * band_h * z;
     };
 
     // Mask the band with the background so candles/volume that overflow below

package/cpp/_core_src/theme.cpp

@@ -16,6 +16,12 @@ constexpr uint32_t kDefaultColors[VROOM_COLOR_COUNT_] = {
     0xff161b22,  // TOOLTIP_BG
     0xffc9d1d9,  // TOOLTIP_TEXT
     0xff3e4855,  // CROSSHAIR_TARGET — CROSSHAIR lightened 30% (prior derived ring)
+    0x00000000,  // BORDER_BULL — transparent sentinel: inherit BULL fill
+    0x00000000,  // BORDER_BEAR — transparent sentinel: inherit BEAR fill
+    0x00000000,  // WICK_BULL   — transparent sentinel: inherit BULL fill
+    0x00000000,  // WICK_BEAR   — transparent sentinel: inherit BEAR fill
+    0xff26a69a,  // ACCENT_BULL — classic teal-green (price indicator, volume, MACD)
+    0xffef5350,  // ACCENT_BEAR — classic red
 };
 
 constexpr float kDefaultFloats[VROOM_FLOAT_COUNT_] = {

package/cpp/_core_src/ticks.cpp

@@ -2,10 +2,44 @@
 
 #include <algorithm>
 #include <cmath>
+#include <ctime>
 
 namespace vroom {
 
-int64_t pick_time_interval(int64_t window_ms, float candle_area_w) {
+namespace {
+
+// Approximate average lengths used only to choose a cadence (the actual ticks
+// land on exact calendar boundaries). 30.436875 d / 365.2425 d.
+constexpr int64_t kMonthMs = 2'629'746'000LL;
+constexpr int64_t kYearMs = 31'556'952'000LL;
+
+// Smallest 1/2/5 × 10ⁿ integer that is >= x (>= 1).
+int nice_ceil_int(double x) {
+    if (x <= 1.0) return 1;
+    const double mag = std::pow(10.0, std::floor(std::log10(x)));
+    for (double m : {1.0, 2.0, 5.0, 10.0}) {
+        const double cand = m * mag;
+        if (cand >= x) return static_cast<int>(cand);
+    }
+    return static_cast<int>(10.0 * mag);
+}
+
+// Local-time midnight of year/mon(0-11)/mday as epoch ms.
+int64_t ymd_to_ms(int year, int mon, int mday) {
+    std::tm t{};
+    t.tm_year = year - 1900;
+    t.tm_mon = mon;
+    t.tm_mday = mday;
+    t.tm_hour = 0;
+    t.tm_min = 0;
+    t.tm_sec = 0;
+    t.tm_isdst = -1;
+    return static_cast<int64_t>(std::mktime(&t)) * 1000;
+}
+
+}  // namespace
+
+TimeTick pick_time_tick(int64_t window_ms, float candle_area_w) {
     static constexpr int64_t kIntervals[] = {
         60'000LL,                // 1m
         5 * 60'000LL,            // 5m
@@ -20,15 +54,80 @@ int64_t pick_time_interval(int64_t window_ms, float candle_area_w) {
         2 * 24 * 60 * 60'000LL,  // 2d
         7 * 24 * 60 * 60'000LL,  // 1w
     };
-    if (window_ms <= 0 || candle_area_w <= 0.f) return kIntervals[0];
-    const double ms_per_px =
-        static_cast<double>(window_ms) / candle_area_w;
+    if (window_ms <= 0 || candle_area_w <= 0.f) {
+        return {TimeUnit::Fixed, kIntervals[0], 0};
+    }
+    const double ms_per_px = static_cast<double>(window_ms) / candle_area_w;
+
     for (int64_t i : kIntervals) {
         if (static_cast<double>(i) / ms_per_px >= kXLabelMinSpacing) {
-            return i;
+            return {TimeUnit::Fixed, i, 0};
         }
     }
-    return kIntervals[sizeof(kIntervals) / sizeof(kIntervals[0]) - 1];
+
+    static constexpr int kMonthSteps[] = {1, 3, 6};
+    for (int s : kMonthSteps) {
+        const double span = static_cast<double>(s) *
+                            static_cast<double>(kMonthMs);
+        if (span / ms_per_px >= kXLabelMinSpacing) {
+            return {TimeUnit::Month, 0, s};
+        }
+    }
+
+    // Years: smallest nice step whose spacing clears the minimum. Unbounded, so
+    // arbitrarily wide windows still get non-overlapping labels.
+    const double needed = (static_cast<double>(kXLabelMinSpacing) * ms_per_px) /
+                          static_cast<double>(kYearMs);
+    return {TimeUnit::Year, 0, nice_ceil_int(needed)};
+}
+
+int64_t first_tick_at_or_after(int64_t from_ms, const TimeTick& tick) {
+    if (tick.unit == TimeUnit::Fixed) {
+        const int64_t step = tick.step_ms;
+        if (step <= 0) return from_ms;
+        int64_t t = (from_ms / step) * step;
+        if (t < from_ms) t += step;
+        return t;
+    }
+
+    const time_t from_s = static_cast<time_t>(from_ms / 1000);
+    std::tm lt{};
+    localtime_r(&from_s, &lt);
+    const int step = tick.step > 0 ? tick.step : 1;
+
+    if (tick.unit == TimeUnit::Year) {
+        int year = ((lt.tm_year + 1900 + step - 1) / step) * step;
+        for (;;) {
+            const int64_t ms = ymd_to_ms(year, 0, 1);
+            if (ms >= from_ms) return ms;
+            year += step;
+        }
+    }
+
+    // Month: align the month index (year*12 + mon) up to a multiple of step.
+    int mi = (((lt.tm_year + 1900) * 12 + lt.tm_mon) + step - 1) / step * step;
+    for (;;) {
+        const int64_t ms = ymd_to_ms(mi / 12, mi % 12, 1);
+        if (ms >= from_ms) return ms;
+        mi += step;
+    }
+}
+
+int64_t next_tick(int64_t t, const TimeTick& tick) {
+    if (tick.unit == TimeUnit::Fixed) {
+        return t + (tick.step_ms > 0 ? tick.step_ms : 0);
+    }
+
+    const time_t s = static_cast<time_t>(t / 1000);
+    std::tm lt{};
+    localtime_r(&s, &lt);
+    const int step = tick.step > 0 ? tick.step : 1;
+
+    if (tick.unit == TimeUnit::Year) {
+        return ymd_to_ms(lt.tm_year + 1900 + step, 0, 1);
+    }
+    const int mi = (lt.tm_year + 1900) * 12 + lt.tm_mon + step;
+    return ymd_to_ms(mi / 12, mi % 12, 1);
 }
 
 double pick_price_interval(double range, float candle_area_h) {

package/cpp/_core_src/ticks.h

@@ -17,10 +17,33 @@ inline constexpr float kXLabelMinSpacing = 50.f;
 // Target spacing for y-axis labels — used to derive a target count.
 inline constexpr float kYLabelTargetSpacing = 55.f;
 
-// Selects the smallest time interval whose pixel-spacing meets the minimum.
-// Returns milliseconds. Hierarchy: 1m → 5m → 15m → 30m → 1h → 2h → 4h → 6h →
-// 12h → 1d → 2d → 1w.
-int64_t pick_time_interval(int64_t window_ms, float candle_area_w);
+// X-axis tick cadence. The hierarchy starts with fixed millisecond intervals
+// (1m … 1w) and, beyond a week, switches to calendar-aware month/year steps so
+// labels land on real month and year boundaries instead of drifting epoch
+// multiples.
+enum class TimeUnit { Fixed, Month, Year };
+
+// A chosen tick cadence. For Fixed, ticks land on epoch multiples of step_ms.
+// For Month/Year, ticks land on local-calendar boundaries `step` units apart
+// (e.g. {Month, step=3} → quarter starts; {Year, step=1} → Jan 1 each year).
+struct TimeTick {
+    TimeUnit unit;
+    int64_t  step_ms;  // valid iff unit == Fixed
+    int      step;     // valid iff unit == Month or Year
+};
+
+// Selects the coarsest-enough cadence whose on-screen spacing meets the minimum.
+// Hierarchy: 1m → 5m → 15m → 30m → 1h → 2h → 4h → 6h → 12h → 1d → 2d → 1w →
+// 1mo → 3mo → 6mo → 1y → 2y → 5y → … (the year step grows as 1/2/5 × 10ⁿ so
+// arbitrarily wide windows never overlap).
+TimeTick pick_time_tick(int64_t window_ms, float candle_area_w);
+
+// First tick at or after from_ms for the given cadence. Calendar units align to
+// local month/year boundaries.
+int64_t first_tick_at_or_after(int64_t from_ms, const TimeTick& tick);
+
+// The next tick strictly after t for the given cadence.
+int64_t next_tick(int64_t t, const TimeTick& tick);
 
 // "Nice number" tick selection for the y-axis: snaps to 1, 2, or 5 × 10ⁿ
 // based on the price range and target spacing. Returns the price interval

package/cpp/_core_src/viewport.cpp

@@ -1,6 +1,7 @@
 #include "viewport.h"
 
 #include <algorithm>
+#include <cmath>
 #include <limits>
 
 namespace vroom {
@@ -66,6 +67,62 @@ size_t snap_index_to_candle(const Layout& layout,
                                  : static_cast<size_t>(it - 1 - candles);
 }
 
+SnapResult snap_to_slot(const Layout& layout,
+                        const ::VroomCandle* candles,
+                        size_t count,
+                        int64_t candle_duration_ms,
+                        int64_t visible_start_ms,
+                        int64_t window_ms,
+                        float x_px) {
+    if (count == 0) return {visible_start_ms, false, 0};
+
+    const float usable =
+        layout.width_px - layout.y_axis_width_px - layout.right_padding_px;
+    if (usable <= 0.f || window_ms <= 0 || candle_duration_ms <= 0) {
+        return {candles[0].time_ms, true, 0};
+    }
+
+    // Clamp to the usable candle width so snapping never runs past the visible
+    // right edge into off-screen space.
+    const float clamped_x = std::clamp(x_px, 0.f, usable);
+
+    // Pixel x -> the period start time of the candle that would sit there.
+    const double target_center =
+        static_cast<double>(visible_start_ms) +
+        (static_cast<double>(clamped_x) / static_cast<double>(usable)) *
+            static_cast<double>(window_ms);
+    const int64_t key =
+        static_cast<int64_t>(target_center) - candle_duration_ms / 2;
+
+    const int64_t last_time = candles[count - 1].time_ms;
+    if (key > last_time) {
+        // Past the last candle: snap to the nearest candle-aligned grid slot.
+        // Within half a period of the last candle we still land on it (steps
+        // 0); beyond that we snap to an empty future slot with no candle data.
+        const double k = static_cast<double>(key - last_time) /
+                         static_cast<double>(candle_duration_ms);
+        const int64_t steps = std::llround(k);
+        if (steps <= 0) return {last_time, true, count - 1};
+        return {last_time + steps * candle_duration_ms, false, 0};
+    }
+
+    // Populated region: pick whichever of the lower_bound candle / its
+    // predecessor is closer in time.
+    auto* it = std::lower_bound(
+        candles, candles + count, key,
+        [](const ::VroomCandle& c, int64_t t) { return c.time_ms < t; });
+    if (it == candles) return {candles[0].time_ms, true, 0};
+    if (it == candles + count) {
+        return {candles[count - 1].time_ms, true, count - 1};
+    }
+    const int64_t hi = it->time_ms;
+    const int64_t lo = (it - 1)->time_ms;
+    const size_t idx = (hi - key < key - lo)
+                           ? static_cast<size_t>(it - candles)
+                           : static_cast<size_t>(it - 1 - candles);
+    return {candles[idx].time_ms, true, idx};
+}
+
 float snap_x_to_candle(const Layout& layout,
                        const ::VroomCandle* candles,
                        size_t count,
@@ -79,10 +136,10 @@ float snap_x_to_candle(const Layout& layout,
         layout.width_px - layout.y_axis_width_px - layout.right_padding_px;
     if (usable <= 0.f) return x_px;
 
-    const size_t idx = snap_index_to_candle(
+    const SnapResult snap = snap_to_slot(
         layout, candles, count, candle_duration_ms, visible_start_ms,
         window_ms, x_px);
-    return candle_center_x(layout, candles[idx].time_ms, candle_duration_ms,
+    return candle_center_x(layout, snap.time_ms, candle_duration_ms,
                            visible_start_ms, window_ms);
 }
 
@@ -138,4 +195,17 @@ float price_to_y(const Layout& layout,
     return bot - static_cast<float>(t) * draw_h;    // invert: high price → low y
 }
 
+double y_to_price(const Layout& layout,
+                  const PriceBounds& bounds,
+                  float y) {
+    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 (draw_h <= 0.f || range <= 0.0) return bounds.min;
+    const double t = (bot - y) / draw_h;  // 0 at min (bottom), 1 at top
+    return bounds.min + t * range;
+}
+
 }  // namespace vroom

package/cpp/_core_src/viewport.h

@@ -79,10 +79,32 @@ size_t snap_index_to_candle(const Layout& layout,
                             int64_t window_ms,
                             float x_px);
 
-// On-screen x of the candle whose center is nearest pixel x_px, searching
-// [candles, candles+count). Clamps to the first/last candle. Returns x_px
-// unchanged when there are no candles or the window is degenerate. Used to snap
-// the crosshair to candles.
+// Result of snapping a pixel x to the candle grid. The grid extends past the
+// last candle into the empty "future" space: slots there sit at
+// last_candle.time_ms + k × candle_duration_ms and carry no candle data.
+struct SnapResult {
+    int64_t time_ms;     // period-start time of the snapped slot (real or future)
+    bool has_candle;     // true when a real candle sits at this slot
+    size_t index;        // index into [candles, candles+count); valid iff has_candle
+};
+
+// Snaps pixel x_px to the nearest candle-grid slot. Over the populated region
+// this returns the nearest real candle (has_candle = true). To the right of the
+// last candle it snaps to future grid slots (has_candle = false). x_px is
+// clamped to the usable candle width so snapping never runs past the visible
+// right edge. Precondition: count > 0 and window_ms > 0 (callers guard).
+SnapResult snap_to_slot(const Layout& layout,
+                        const ::VroomCandle* candles,
+                        size_t count,
+                        int64_t candle_duration_ms,
+                        int64_t visible_start_ms,
+                        int64_t window_ms,
+                        float x_px);
+
+// On-screen x of the slot whose center is nearest pixel x_px, searching
+// [candles, candles+count) and the future grid past the last candle. Returns
+// x_px unchanged when there are no candles or the window is degenerate. Used to
+// snap the crosshair to candles (and to future candle-aligned slots).
 float snap_x_to_candle(const Layout& layout,
                        const ::VroomCandle* candles,
                        size_t count,
@@ -97,4 +119,8 @@ PriceBounds price_bounds(const ::VroomCandle* candles, size_t count);
 // 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);
 
+// 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);
+
 }  // namespace vroom

package/cpp/_core_src/volume.cpp

@@ -43,12 +43,12 @@ void draw(SkCanvas* canvas,
     const float opacity = theme.floats[VROOM_FLOAT_VOLUME_OPACITY];
     SkPaint bull_paint;
     bull_paint.setAntiAlias(true);
-    bull_paint.setColor(theme.colors[VROOM_COLOR_BULL]);
+    bull_paint.setColor(theme.colors[VROOM_COLOR_ACCENT_BULL]);
     bull_paint.setAlphaf(opacity);
 
     SkPaint bear_paint;
     bear_paint.setAntiAlias(true);
-    bear_paint.setColor(theme.colors[VROOM_COLOR_BEAR]);
+    bear_paint.setColor(theme.colors[VROOM_COLOR_ACCENT_BEAR]);
     bear_paint.setAlphaf(opacity);
 
     for (std::size_t i = 0; i < n; ++i) {

package/lib/index.d.mts

@@ -20,8 +20,18 @@ type Candle = {
 type CrosshairEvent = {
     /** True while the crosshair is showing; false when it's dismissed. */
     active: boolean;
-    /** OHLCV of the candle under the crosshair, or null when inactive. */
+    /**
+     * OHLCV of the candle under the crosshair, or null when inactive. Also null
+     * when the crosshair is parked on a *future* candle-aligned slot in the empty
+     * space ahead of the most recent candle (no candle exists there yet) — use
+     * `timeMs` to read the slot's time in that case.
+     */
     candle: Candle | null;
+    /**
+     * Bar-open time (Unix epoch ms) of the slot the crosshair snaps to, including
+     * future candle-aligned slots past the last candle. Null when inactive.
+     */
+    timeMs: number | null;
     /**
      * Why this event fired — lets the host react differently (e.g. haptics):
      *   'show' — long-press activated the crosshair
@@ -42,10 +52,22 @@ type VroomColor = string | number;
 type VroomTheme = {
     /** Chart + axis-strip background. */
     background?: VroomColor;
-    /** Up candles (also bull wicks, bull volume bars, rising price indicator). */
+    /** Up candle body fill. Wick and border default to this unless overridden. */
     bull?: VroomColor;
-    /** Down candles (also bear wicks, bear volume bars, falling price indicator). */
+    /** Down candle body fill. Wick and border default to this unless overridden. */
     bear?: VroomColor;
+    /** Generic up color for the price indicator, volume bars, and MACD histogram. Defaults to teal-green; independent of `bull`. */
+    accentBull?: VroomColor;
+    /** Generic down color for the price indicator, volume bars, and MACD histogram. Defaults to red; independent of `bear`. */
+    accentBear?: VroomColor;
+    /** Up candle body 1px border. Defaults to the bull fill color. */
+    borderBull?: VroomColor;
+    /** Down candle body 1px border. Defaults to the bear fill color. */
+    borderBear?: VroomColor;
+    /** Up candle wick color. Defaults to the bull fill color. */
+    wickBull?: VroomColor;
+    /** Down candle wick color. Defaults to the bear fill color. */
+    wickBear?: VroomColor;
     /** Gridlines. */
     grid?: VroomColor;
     /** Axis label text (price + time). */

package/lib/index.d.ts

@@ -20,8 +20,18 @@ type Candle = {
 type CrosshairEvent = {
     /** True while the crosshair is showing; false when it's dismissed. */
     active: boolean;
-    /** OHLCV of the candle under the crosshair, or null when inactive. */
+    /**
+     * OHLCV of the candle under the crosshair, or null when inactive. Also null
+     * when the crosshair is parked on a *future* candle-aligned slot in the empty
+     * space ahead of the most recent candle (no candle exists there yet) — use
+     * `timeMs` to read the slot's time in that case.
+     */
     candle: Candle | null;
+    /**
+     * Bar-open time (Unix epoch ms) of the slot the crosshair snaps to, including
+     * future candle-aligned slots past the last candle. Null when inactive.
+     */
+    timeMs: number | null;
     /**
      * Why this event fired — lets the host react differently (e.g. haptics):
      *   'show' — long-press activated the crosshair
@@ -42,10 +52,22 @@ type VroomColor = string | number;
 type VroomTheme = {
     /** Chart + axis-strip background. */
     background?: VroomColor;
-    /** Up candles (also bull wicks, bull volume bars, rising price indicator). */
+    /** Up candle body fill. Wick and border default to this unless overridden. */
     bull?: VroomColor;
-    /** Down candles (also bear wicks, bear volume bars, falling price indicator). */
+    /** Down candle body fill. Wick and border default to this unless overridden. */
     bear?: VroomColor;
+    /** Generic up color for the price indicator, volume bars, and MACD histogram. Defaults to teal-green; independent of `bull`. */
+    accentBull?: VroomColor;
+    /** Generic down color for the price indicator, volume bars, and MACD histogram. Defaults to red; independent of `bear`. */
+    accentBear?: VroomColor;
+    /** Up candle body 1px border. Defaults to the bull fill color. */
+    borderBull?: VroomColor;
+    /** Down candle body 1px border. Defaults to the bear fill color. */
+    borderBear?: VroomColor;
+    /** Up candle wick color. Defaults to the bull fill color. */
+    wickBull?: VroomColor;
+    /** Down candle wick color. Defaults to the bear fill color. */
+    wickBear?: VroomColor;
     /** Gridlines. */
     grid?: VroomColor;
     /** Axis label text (price + time). */

package/lib/index.js

@@ -80,8 +80,20 @@ var COLOR_KEYS = {
   // VROOM_COLOR_AXIS_TEXT
   crosshair: 6,
   // VROOM_COLOR_CROSSHAIR
-  crosshairTarget: 9
+  crosshairTarget: 9,
   // VROOM_COLOR_CROSSHAIR_TARGET
+  borderBull: 10,
+  // VROOM_COLOR_BORDER_BULL
+  borderBear: 11,
+  // VROOM_COLOR_BORDER_BEAR
+  wickBull: 12,
+  // VROOM_COLOR_WICK_BULL
+  wickBear: 13,
+  // VROOM_COLOR_WICK_BEAR
+  accentBull: 14,
+  // VROOM_COLOR_ACCENT_BULL
+  accentBear: 15
+  // VROOM_COLOR_ACCENT_BEAR
 };
 function parseColor(value) {
   if (typeof value === "number") {
@@ -297,11 +309,11 @@ function VroomChart(props) {
     } else if (crosshairActive.current) {
       const ch = handle.setCrosshair(e.x, e.y - crosshairOffset);
       if (ch) pictureSV.value = ch;
-      const c = handle.getCrosshairCandle();
-      const t = c?.timeMs ?? null;
+      const info = handle.getCrosshairInfo();
+      const t = info?.timeMs ?? null;
       if (t !== lastCrosshairTime.current) {
         lastCrosshairTime.current = t;
-        onCrosshair?.({ active: true, candle: c, reason: "move" });
+        onCrosshair?.({ active: true, candle: info?.candle ?? null, timeMs: t, reason: "move" });
       }
       return;
     } else {
@@ -391,9 +403,14 @@ function VroomChart(props) {
     crosshairActive.current = true;
     const ch = handle.setCrosshair(e.x, e.y - crosshairOffset);
     if (ch) pictureSV.value = ch;
-    const c = handle.getCrosshairCandle();
-    lastCrosshairTime.current = c?.timeMs ?? null;
-    onCrosshair?.({ active: true, candle: c, reason: "show" });
+    const info = handle.getCrosshairInfo();
+    lastCrosshairTime.current = info?.timeMs ?? null;
+    onCrosshair?.({
+      active: true,
+      candle: info?.candle ?? null,
+      timeMs: info?.timeMs ?? null,
+      reason: "show"
+    });
   });
   const tap = import_react_native_gesture_handler.Gesture.Tap().runOnJS(true).onStart((e) => {
     if (!handle || !crosshairActive.current) return;
@@ -402,7 +419,7 @@ function VroomChart(props) {
     const ch = handle.clearCrosshair();
     if (ch) pictureSV.value = ch;
     lastCrosshairTime.current = null;
-    onCrosshair?.({ active: false, candle: null, reason: "hide" });
+    onCrosshair?.({ active: false, candle: null, timeMs: null, reason: "hide" });
   });
   const gesture = import_react_native_gesture_handler.Gesture.Simultaneous(pan, pinch, longPress, tap);
   return /* @__PURE__ */ import_react2.default.createElement(