react-native-vroom-chart 0.4.0 → 0.5.0

package/cpp/VroomChartHostObject.cpp

@@ -51,6 +51,7 @@ std::vector<jsi::PropNameID> ChartHostObject::getPropertyNames(
   out.push_back(jsi::PropNameID::forAscii(rt, "setMACD"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setOverlays"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setVWAP"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setBollinger"));
   out.push_back(jsi::PropNameID::forAscii(rt, "render"));
   return out;
 }
@@ -551,6 +552,52 @@ jsi::Value ChartHostObject::get(jsi::Runtime& rt,
         });
   }
 
+  if (name == "setBollinger") {
+    // setBollinger({enabled, period, mult, source, basisKind, upperColor,
+    // upperWidth, middleColor, middleWidth, lowerColor, lowerWidth,
+    // fillEnabled, fillOpacity}) — Bollinger Bands overlay. No render; the
+    // next render() picks it up.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setBollinger"),
+        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 s = args[0].asObject(rt2);
+          VroomBollinger cfg{};
+          cfg.enabled = s.getProperty(rt2, "enabled").asBool() ? 1 : 0;
+          cfg.period = static_cast<int32_t>(
+              s.getProperty(rt2, "period").asNumber());
+          cfg.mult = static_cast<float>(
+              s.getProperty(rt2, "mult").asNumber());
+          cfg.source = static_cast<int32_t>(
+              s.getProperty(rt2, "source").asNumber());
+          cfg.basis_kind = static_cast<int32_t>(
+              s.getProperty(rt2, "basisKind").asNumber());
+          cfg.upper_color = static_cast<uint32_t>(
+              s.getProperty(rt2, "upperColor").asNumber());
+          cfg.upper_width = static_cast<float>(
+              s.getProperty(rt2, "upperWidth").asNumber());
+          cfg.middle_color = static_cast<uint32_t>(
+              s.getProperty(rt2, "middleColor").asNumber());
+          cfg.middle_width = static_cast<float>(
+              s.getProperty(rt2, "middleWidth").asNumber());
+          cfg.lower_color = static_cast<uint32_t>(
+              s.getProperty(rt2, "lowerColor").asNumber());
+          cfg.lower_width = static_cast<float>(
+              s.getProperty(rt2, "lowerWidth").asNumber());
+          cfg.fill_enabled =
+              s.getProperty(rt2, "fillEnabled").asBool() ? 1 : 0;
+          cfg.fill_opacity = static_cast<float>(
+              s.getProperty(rt2, "fillOpacity").asNumber());
+          vroom_chart_set_bollinger(chart_, &cfg);
+          return jsi::Value::undefined();
+        });
+  }
+
   if (name == "render") {
     return jsi::Function::createFromHostFunction(
         rt,

package/cpp/_core_include/vroom/vroom_chart.h

@@ -49,6 +49,26 @@ typedef struct VroomOverlay {
     float    width;   // stroke width in px
 } VroomOverlay;
 
+// Bollinger Bands overlay drawn on the price pane: a basis MA of `source` over
+// `period`, banded at ± `mult` × population standard deviation of the same
+// window. Per TradingView semantics the stdev always uses the window's
+// arithmetic mean, even when `basis_kind` selects an EMA basis line.
+typedef struct VroomBollinger {
+    int32_t  enabled;       // 0/1
+    int32_t  period;        // lookback in candles (clamped >= 1; default 20)
+    float    mult;          // stdev multiplier (clamped >= 0; default 2)
+    int32_t  source;        // 0=close,1=open,2=high,3=low,4=hl2,5=hlc3,6=ohlc4
+    int32_t  basis_kind;    // 0 = SMA, 1 = EMA
+    uint32_t upper_color;   // 0xAARRGGBB
+    float    upper_width;   // stroke px
+    uint32_t middle_color;
+    float    middle_width;
+    uint32_t lower_color;
+    float    lower_width;
+    int32_t  fill_enabled;  // 0/1: translucent fill between upper and lower
+    float    fill_opacity;  // 0..1, multiplied into upper_color's alpha
+} VroomBollinger;
+
 // A drawing anchor in data space (so a drawing tracks the candles on pan/zoom).
 typedef struct VroomDrawPoint {
     int64_t time_ms;  // epoch milliseconds (not snapped to a candle slot)
@@ -321,6 +341,11 @@ void vroom_chart_set_overlays(VroomChart* chart, const VroomOverlay* overlays,
 void vroom_chart_set_vwap(VroomChart* chart, bool enabled, int reset_offset_min,
                           uint32_t color, float width);
 
+// Configures the Bollinger Bands overlay (three price-pane lines + an optional
+// translucent fill between the bands; no pane is reserved). Color/width/fill
+// changes only re-render; enabled/period/mult/source/basis changes recompute.
+void vroom_chart_set_bollinger(VroomChart* chart, const VroomBollinger* cfg);
+
 // ---- Drawings (line annotations) ------------------------------------------
 
 // Replaces the full set of committed line drawings (data-anchored, so they track

package/cpp/_core_src/bollinger.cpp

@@ -0,0 +1,43 @@
+#include "bollinger.h"
+
+#include <cmath>  // std::nan, std::sqrt
+
+#include "ma.h"
+
+namespace vroom::bollinger {
+
+void compute(const ::VroomCandle* candles, std::size_t n, int period,
+             double mult, int source, int basis_kind,
+             std::vector<double>& middle, std::vector<double>& upper,
+             std::vector<double>& lower) {
+    vroom::ma::compute(candles, n, basis_kind, period, source, middle);
+    upper.assign(n, std::nan(""));
+    lower.assign(n, std::nan(""));
+    if (!candles || period < 1) return;
+    const std::size_t P = static_cast<std::size_t>(period);
+    if (n < P) return;
+
+    std::vector<double> src(n);
+    for (std::size_t i = 0; i < n; ++i) src[i] = vroom::ma::source_value(candles[i], source);
+
+    // Two-pass stdev around the true window mean per bar. O(n·period), but
+    // numerically stable — the rolling Σx²−n·mean² form cancels catastrophically
+    // on large prices with small deviations (e.g. BTC-scale values).
+    for (std::size_t i = P - 1; i < n; ++i) {
+        const std::size_t s = i + 1 - P;
+        double mean = 0.0;
+        for (std::size_t j = s; j <= i; ++j) mean += src[j];
+        mean /= static_cast<double>(P);
+        double var = 0.0;
+        for (std::size_t j = s; j <= i; ++j) {
+            const double d = src[j] - mean;
+            var += d * d;
+        }
+        var /= static_cast<double>(P);
+        const double band = mult * std::sqrt(var);
+        upper[i] = middle[i] + band;
+        lower[i] = middle[i] - band;
+    }
+}
+
+}  // namespace vroom::bollinger

package/cpp/_core_src/bollinger.h

@@ -0,0 +1,31 @@
+// Bollinger Bands over a candle source series — pure, no Skia, so it builds
+// into the unit-test target. Drawn as price-pane overlay lines + a band fill.
+
+#pragma once
+
+#include <cstddef>
+#include <vector>
+
+#include "vroom/vroom_chart.h"  // ::VroomCandle
+
+namespace vroom::bollinger {
+
+// Computes the three band series over [candles, candles+n). `period` is clamped
+// to >= 1; `mult` is the standard-deviation multiplier. `source` is a
+// vroom::ma::Source index and `basis_kind` a vroom::ma::Kind (SMA/EMA).
+//
+//   middle = ma::compute(basis_kind, period, source)
+//   upper/lower = middle ± mult * population stdev of source over the trailing
+//                 period window
+//
+// The stdev always uses the window's arithmetic mean, even when basis_kind
+// selects an EMA basis line (TradingView semantics).
+//
+// Each output is resized to n; values are NaN for i < period-1 and when
+// n < period.
+void compute(const ::VroomCandle* candles, std::size_t n, int period,
+             double mult, int source, int basis_kind,
+             std::vector<double>& middle, std::vector<double>& upper,
+             std::vector<double>& lower);
+
+}  // namespace vroom::bollinger

package/cpp/_core_src/chart.cpp

@@ -18,6 +18,7 @@
 #include "include/core/SkRect.h"
 #pragma clang diagnostic pop
 
+#include "bollinger.h"
 #include "candles.h"
 #include "chart_internal.h"
 #include "crosshair.h"
@@ -100,6 +101,15 @@ void VroomChart::ensure_vwap() {
     vwap_dirty = false;
 }
 
+void VroomChart::ensure_bollinger() {
+    if (!bollinger.enabled || !bollinger_dirty) return;
+    vroom::bollinger::compute(candles.data(), candles.size(), bollinger.period,
+                              bollinger.mult, bollinger.source,
+                              bollinger.basis_kind, bb_middle_cache,
+                              bb_upper_cache, bb_lower_cache);
+    bollinger_dirty = false;
+}
+
 void VroomChart::draw_chart(SkCanvas* canvas) {
     const auto lay = layout();
 
@@ -149,6 +159,23 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     vroom::liquidity::draw(canvas, *this, lay, bounds, candle_right,
                            candle_area_h);
 
+    // 4.7. Bollinger Band fill — the translucent region between the upper and
+    //      lower bands, behind the candles so their bull/bear colors stay
+    //      untinted. The band lines themselves draw above the candles (5.65).
+    if (bollinger.enabled) {
+        ensure_bollinger();
+        if (bollinger.fill_enabled &&
+            bb_upper_cache.size() == candles.size() &&
+            bb_lower_cache.size() == candles.size()) {
+            vroom::ma_overlay::fill_between(
+                canvas, lay, bounds, visible, n,
+                bb_upper_cache.data() + range.start,
+                bb_lower_cache.data() + range.start, window_ms,
+                visible_start_ms, candle_duration_ms, candle_right,
+                candle_area_h, bollinger.upper_color, bollinger.fill_opacity);
+        }
+    }
+
     // 5. Price series — candles, a close-price line, or a blend of the two during
     //    the candle↔line morph. `morph_fade` crossfades candles→line and
     //    `morph_collapse` folds each candle toward its close (the line vertex).
@@ -202,6 +229,28 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
         }
     }
 
+    // 5.65. Bollinger Band lines — upper, lower, then the basis last so it
+    //       reads on top where the bands pinch. Same price scale as the
+    //       candles; the fill went down in 4.7.
+    if (bollinger.enabled) {
+        ensure_bollinger();
+        const std::size_t sz = candles.size();
+        if (bb_upper_cache.size() == sz && bb_lower_cache.size() == sz &&
+            bb_middle_cache.size() == sz) {
+            const auto stroke = [&](const std::vector<double>& cache,
+                                    uint32_t color, float width) {
+                vroom::ma_overlay::draw(canvas, lay, bounds, visible, n,
+                                        cache.data() + range.start, window_ms,
+                                        visible_start_ms, candle_duration_ms,
+                                        candle_right, candle_area_h, color,
+                                        width);
+            };
+            stroke(bb_upper_cache, bollinger.upper_color, bollinger.upper_width);
+            stroke(bb_lower_cache, bollinger.lower_color, bollinger.lower_width);
+            stroke(bb_middle_cache, bollinger.middle_color, bollinger.middle_width);
+        }
+    }
+
     // 5.7. Drawing annotations (committed line tools + the in-progress draft).
     //      On the price pane above the candles/overlays, below the axis labels.
     vroom::drawings::draw(canvas, *this, lay, bounds, candle_right,

package/cpp/_core_src/chart.h

@@ -135,6 +135,20 @@ struct VroomChart {
     std::vector<unsigned char> vwap_breaks;
     bool vwap_dirty = true;
 
+    // Bollinger Bands overlay (price pane; no pane reserved). Caches aligned to
+    // `candles` (NaN warmup), recomputed lazily by ensure_bollinger() when
+    // bollinger_dirty. Defaults: 20-period SMA of close, ±2σ, blue bands /
+    // orange basis, 10% fill.
+    VroomBollinger bollinger{0, 20, 2.f, 0, 0,
+                             0xff2962ff, 1.f,   // upper: blue
+                             0xffff6d00, 1.f,   // middle: orange
+                             0xff2962ff, 1.f,   // lower: blue
+                             1, 0.1f};
+    std::vector<double> bb_middle_cache;
+    std::vector<double> bb_upper_cache;
+    std::vector<double> bb_lower_cache;
+    bool bollinger_dirty = true;
+
     // --- drawings (annotations) --------------------------------------------
     // Committed drawings, anchored in data space so they track the candles on
     // pan/zoom. Drawn on the price pane above candles/overlays.
@@ -222,6 +236,10 @@ struct VroomChart {
     // Recomputes the VWAP cache when vwap_dirty and VWAP is enabled.
     void ensure_vwap();
 
+    // Recomputes the Bollinger Band caches when bollinger_dirty and the
+    // indicator is enabled.
+    void ensure_bollinger();
+
     // The main drawing pass. Calls into the labels and candles modules.
     void draw_chart(SkCanvas* canvas);
 

package/cpp/_core_src/chart_facade.cpp

@@ -131,6 +131,7 @@ extern "C" void vroom_chart_set_candles(VroomChart* chart, const VroomCandle* da
     chart->macd_dirty = true;
     chart->overlays_dirty = true;
     chart->vwap_dirty = true;
+    chart->bollinger_dirty = true;
 
     // Infer the candle period from the first interval. Robust enough for
     // uniform-duration series (the only kind we model today).
@@ -158,6 +159,7 @@ extern "C" void vroom_chart_append_candle(VroomChart* chart, const VroomCandle*
     chart->macd_dirty = true;
     chart->overlays_dirty = true;
     chart->vwap_dirty = true;
+    chart->bollinger_dirty = true;
     chart->mark_dirty();
 }
 
@@ -168,6 +170,7 @@ extern "C" void vroom_chart_update_last(VroomChart* chart, const VroomCandle* c)
     chart->macd_dirty = true;
     chart->overlays_dirty = true;
     chart->vwap_dirty = true;
+    chart->bollinger_dirty = true;
     chart->mark_dirty();
 }
 
@@ -1049,6 +1052,29 @@ extern "C" void vroom_chart_set_vwap(VroomChart* chart, bool enabled,
     chart->mark_dirty();
 }
 
+extern "C" void vroom_chart_set_bollinger(VroomChart* chart,
+                                          const VroomBollinger* cfg) {
+    if (!chart || !cfg) return;
+    VroomBollinger next = *cfg;
+    next.enabled = next.enabled ? 1 : 0;
+    next.fill_enabled = next.fill_enabled ? 1 : 0;
+    if (next.period < 1) next.period = 1;
+    if (!(next.mult >= 0.f)) next.mult = 0.f;
+    next.fill_opacity = std::clamp(next.fill_opacity, 0.f, 1.f);
+
+    // Only the series-affecting fields force a recompute; style and fill
+    // changes are render-only.
+    const VroomBollinger& cur = chart->bollinger;
+    const bool recompute = cur.enabled != next.enabled ||
+                           cur.period != next.period ||
+                           cur.mult != next.mult ||
+                           cur.source != next.source ||
+                           cur.basis_kind != next.basis_kind;
+    chart->bollinger = next;
+    if (recompute) chart->bollinger_dirty = true;
+    chart->mark_dirty();
+}
+
 // ---- Direct draw (used by hosts that don't need the SkPicture cache) ------
 
 extern "C" void vroom_chart_draw(VroomChart* chart, SkCanvas* canvas) {

package/cpp/_core_src/ma_overlay.cpp

@@ -78,4 +78,71 @@ void draw(SkCanvas* canvas,
     canvas->restore();
 }
 
+void fill_between(SkCanvas* canvas,
+                  const Layout& lay,
+                  const PriceBounds& bounds,
+                  const ::VroomCandle* visible,
+                  std::size_t n,
+                  const double* upper_visible,
+                  const double* lower_visible,
+                  int64_t window_ms,
+                  int64_t visible_start_ms,
+                  int64_t candle_duration_ms,
+                  float candle_right,
+                  float candle_area_h,
+                  uint32_t color,
+                  float opacity) {
+    if (!canvas || !upper_visible || !lower_visible || n == 0 ||
+        candle_right <= 0.f || candle_area_h <= 0.f) {
+        return;
+    }
+    opacity = std::clamp(opacity, 0.f, 1.f);
+    if (opacity <= 0.f) return;
+
+    // One closed contour per maximal run where both series are finite; a
+    // single-point run has no area. Multiple runs (e.g. around a data gap)
+    // become multiple contours in one path.
+    SkPathBuilder path;
+    std::size_t i = 0;
+    while (i < n) {
+        if (!std::isfinite(upper_visible[i]) ||
+            !std::isfinite(lower_visible[i])) {
+            ++i;
+            continue;
+        }
+        std::size_t e = i;
+        while (e + 1 < n && std::isfinite(upper_visible[e + 1]) &&
+               std::isfinite(lower_visible[e + 1])) {
+            ++e;
+        }
+        if (e > i) {
+            const auto x_at = [&](std::size_t k) {
+                return vroom::candle_center_x(lay, visible[k].time_ms,
+                                              candle_duration_ms,
+                                              visible_start_ms, window_ms);
+            };
+            path.moveTo(x_at(i), vroom::price_to_y(lay, bounds, upper_visible[i]));
+            for (std::size_t k = i + 1; k <= e; ++k) {
+                path.lineTo(x_at(k), vroom::price_to_y(lay, bounds, upper_visible[k]));
+            }
+            for (std::size_t k = e + 1; k-- > i;) {
+                path.lineTo(x_at(k), vroom::price_to_y(lay, bounds, lower_visible[k]));
+            }
+            path.close();
+        }
+        i = e + 1;
+    }
+
+    SkPaint fill;
+    fill.setAntiAlias(true);
+    fill.setColor(static_cast<SkColor>(color));
+    fill.setAlphaf(fill.getAlphaf() * opacity);
+    fill.setStyle(SkPaint::kFill_Style);
+
+    canvas->save();
+    canvas->clipRect(SkRect::MakeLTRB(0.f, 0.f, candle_right, candle_area_h));
+    canvas->drawPath(path.detach(), fill);
+    canvas->restore();
+}
+
 }  // namespace vroom::ma_overlay

package/cpp/_core_src/ma_overlay.h

@@ -40,4 +40,25 @@ void draw(SkCanvas* canvas,
           const unsigned char* break_before = nullptr,
           float opacity = 1.f);
 
+// Fills the closed region between two aligned series (NaN where undefined)
+// with `color` at its alpha × `opacity` — used for the Bollinger Band fill.
+// Runs where either series is NaN are skipped, so the fill never bridges the
+// warmup gap. Plain-alpha SkPaint fill, no gradient shader (the Skia gradient
+// APIs diverge across our pinned versions; see liquidity.cpp). Clipped to the
+// candle area like draw().
+void fill_between(SkCanvas* canvas,
+                  const Layout& lay,
+                  const PriceBounds& bounds,
+                  const ::VroomCandle* visible,
+                  std::size_t n,
+                  const double* upper_visible,
+                  const double* lower_visible,
+                  int64_t window_ms,
+                  int64_t visible_start_ms,
+                  int64_t candle_duration_ms,
+                  float candle_right,
+                  float candle_area_h,
+                  uint32_t color,
+                  float opacity);
+
 }  // namespace vroom::ma_overlay

package/lib/index.d.mts

@@ -201,6 +201,31 @@ type DrawingStore = {
      */
     save: (marketId: string, data: string) => void | Promise<void>;
 };
+/**
+ * Whether undo/redo are currently available for the chart's drawings — the
+ * payload of `onHistoryChange`, for binding toolbar button enabled-states.
+ */
+type UndoRedoState = {
+    canUndo: boolean;
+    canRedo: boolean;
+};
+/**
+ * Programmatic undo/redo controls, published through the `historyRef` prop in
+ * managed mode — for toolbar buttons and other UI outside the chart. The
+ * keyboard shortcuts (⌘Z / ⇧⌘Z / Ctrl+Y) work without this.
+ */
+type UndoRedoControls = {
+    /** Roll back the most recent committed drawing action. No-op when empty. */
+    undo: () => void;
+    /** Re-apply the most recently undone action. No-op when empty. */
+    redo: () => void;
+    /**
+     * Drop the undo/redo stacks without touching the drawings. Rarely needed —
+     * users find a cleared history surprising — but useful when reusing a mounted
+     * chart for what the user perceives as a brand-new context.
+     */
+    clearHistory: () => void;
+};
 /** RSI indicator config. Rendered in a pane below the candles when enabled. */
 type RSIConfig = {
     enabled?: boolean;
@@ -246,6 +271,42 @@ type VWAPConfig = {
     /** Stroke width in px. Default 1.5. */
     width?: number;
 };
+/**
+ * Bollinger Bands overlay config. A basis moving average of `source` over
+ * `period`, banded at ± `stdDev` × population standard deviation of the same
+ * window, drawn as three lines on the price pane with an optional translucent
+ * fill between the bands. No pane is reserved.
+ */
+type BollingerBandsConfig = {
+    enabled?: boolean;
+    /** Lookback in candles. Default 20, clamped to >= 1. */
+    period?: number;
+    /** Standard-deviation multiplier. Default 2. */
+    stdDev?: number;
+    /** Price source. Default 'close'. */
+    source?: MASource;
+    /**
+     * Basis (middle) line type. Default 'sma'. The stdev always uses the
+     * window's arithmetic mean, even with an EMA basis (TradingView semantics).
+     */
+    basis?: 'sma' | 'ema';
+    /** Upper band color (hex string or packed ARGB number). Default blue. */
+    upperColor?: string | number;
+    /** Upper band stroke width in px. Default 1. */
+    upperWidth?: number;
+    /** Basis (middle) line color. Default orange. */
+    middleColor?: string | number;
+    /** Basis line stroke width in px. Default 1. */
+    middleWidth?: number;
+    /** Lower band color. Default blue. */
+    lowerColor?: string | number;
+    /** Lower band stroke width in px. Default 1. */
+    lowerWidth?: number;
+    /** Translucent fill between the bands. Default true. */
+    fill?: boolean;
+    /** Fill opacity 0..1, applied to the upper band color. Default 0.1. */
+    fillOpacity?: number;
+};
 /**
  * A single resting-liquidity band: a price interval carrying a total order size
  * on one side of the book. Consolidate raw L2 levels into these buckets before
@@ -355,6 +416,8 @@ type VroomChartCoreProps = {
     movingAverages?: MovingAverageOverlay[];
     /** VWAP overlay (session anchor, configurable reset). */
     vwap?: VWAPConfig;
+    /** Bollinger Bands overlay (three lines + fill on the price pane). */
+    bollingerBands?: BollingerBandsConfig;
     /** Resting-order / order-book liquidity bands drawn behind the candles. */
     liquidity?: LiquidityConfig;
     /**
@@ -417,6 +480,40 @@ type VroomChartCoreProps = {
      * host should apply the requested mode.
      */
     onModeChange?: (mode: ChartMode) => void;
+    /**
+     * Max drawing undo depth in managed mode (one step = one committed drawing
+     * action). Oldest steps are evicted beyond this. Default 100. History is
+     * in-memory and per-`seriesKey`: it resets on market switch and is never
+     * persisted — only the drawings themselves are saved. Web only.
+     */
+    historyLimit?: number;
+    /**
+     * Fired when drawing undo/redo availability changes in managed mode — bind
+     * toolbar undo/redo buttons' enabled-state to it. (In controlled mode you own
+     * the history, so track availability yourself.) Web only.
+     */
+    onHistoryChange?: (state: UndoRedoState) => void;
+    /**
+     * Receives programmatic `undo`/`redo`/`clearHistory` controls in managed mode
+     * (e.g. `useRef<UndoRedoControls | null>(null)` passed here, then
+     * `historyRef.current?.undo()` from a toolbar button). Set to `null` while
+     * unmounted or when no `drawingStore` is present. Web only.
+     */
+    historyRef?: {
+        current: UndoRedoControls | null;
+    };
+    /**
+     * Fired when the user presses the undo shortcut (⌘Z / Ctrl+Z) in controlled
+     * mode — apply the undo to your own drawings state. Ignored when
+     * `drawingStore` is set (managed mode undoes internally). Web only.
+     */
+    onUndo?: () => void;
+    /**
+     * Fired when the user presses the redo shortcut (⇧⌘Z / Ctrl+Shift+Z /
+     * Ctrl+Y) in controlled mode — apply the redo to your own drawings state.
+     * Ignored when `drawingStore` is set. Web only.
+     */
+    onRedo?: () => void;
     onCrosshair?: (e: CrosshairEvent) => void;
     onViewportChange?: (startMs: number, endMs: number) => void;
 };
@@ -450,4 +547,4 @@ declare global {
  */
 declare function VroomChart(props: VroomChartProps): React.JSX.Element;
 
-export { type Candle, type ChartType, type CrosshairEvent, type MACDConfig, type MASource, type MovingAverageOverlay, type RSIConfig, type VWAPConfig, type VisibleRange, VroomChart, type VroomChartProps, type VroomColor, type VroomTheme };
+export { type BollingerBandsConfig, type Candle, type ChartType, type CrosshairEvent, type MACDConfig, type MASource, type MovingAverageOverlay, type RSIConfig, type VWAPConfig, type VisibleRange, VroomChart, type VroomChartProps, type VroomColor, type VroomTheme };