react-native-vroom-chart 0.9.0 → 0.9.1

package/cpp/_core_include/vroom/vroom_chart.h

@@ -345,7 +345,8 @@ void vroom_chart_set_visible_range(VroomChart* chart, int64_t start_ms, int64_t
 // Target candle *body* width in px for the default/reset framing. Larger = more
 // zoomed in (fewer candles), smaller = more zoomed out. 0 restores the legacy
 // "most recent ~80 candles" default. Affects initial framing only; an explicit
-// set_visible_range still overrides it.
+// set_visible_range still overrides it. A series shorter than the implied window
+// is left-padded with empty slots so bars stay this wide instead of stretching.
 void vroom_chart_set_default_candle_width(VroomChart* chart, float px);
 
 // Chart render mode: 0 = candlesticks (default), 1 = line chart (a polyline

package/cpp/_core_src/chart_facade.cpp

@@ -50,6 +50,21 @@ int64_t max_future_gap(int64_t window_ms, int64_t cur_future) {
     return std::max<int64_t>((window_ms * 3) / 4, cur_future);
 }
 
+// Pan/translate future allowance. A window longer than the data has nowhere
+// useful to scroll, so don't grow the future gap — growing it used to combine
+// with a first-candle start pin and latch the view. Dense series keep the
+// usual 3/4-window rubber-band.
+int64_t pan_max_future(int64_t window_ms, int64_t cur_future,
+                       int64_t first_time, int64_t last_time,
+                       int64_t candle_duration_ms) {
+    const int64_t dur = candle_duration_ms > 0 ? candle_duration_ms : 0;
+    const int64_t data_extent = last_time + dur - first_time;
+    if (data_extent >= 0 && window_ms > data_extent) {
+        return std::max<int64_t>(0, cur_future);
+    }
+    return max_future_gap(window_ms, cur_future);
+}
+
 // Rubber-band a forward (into-future) pan delta: once the current future gap is
 // past the soft cap (window/2), damp the delta quadratically toward zero as it
 // nears the hard cap (3*window/4). Backward (into-past) deltas are unaffected.
@@ -109,13 +124,20 @@ void apply_default_framing(VroomChart* chart) {
         const double body = std::clamp(static_cast<double>(chart->default_candle_px),
                                        kMinCandleBodyPx, kMaxCandleBodyPx);
         if (usable > 0.0 && ratio > 0.0 && dur > 0.0 && body > 0.0) {
-            int64_t window_ms = static_cast<int64_t>((usable * dur * ratio) / body);
-            const int64_t span =
-                chart->candles.back().time_ms - chart->candles.front().time_ms;
-            window_ms = std::clamp<int64_t>(window_ms, chart->candle_duration_ms,
-                                            span > 0 ? span : window_ms);
-            frame(window_ms);
-            return;
+            int64_t window_ms = vroom::window_for_body_width(
+                lay, chart->candle_duration_ms, body);
+            // Floor at one slot so the window is valid. Do NOT clamp to the
+            // data span: a short series would then stretch each bar to fill
+            // the plot, the opposite of a target body width. Empty space on
+            // the left is intentional — same rule as timeframeWindow (width
+            // wins).
+            if (window_ms > 0) {
+                if (window_ms < chart->candle_duration_ms) {
+                    window_ms = chart->candle_duration_ms;
+                }
+                frame(window_ms);
+                return;
+            }
         }
     }
 
@@ -404,30 +426,23 @@ extern "C" void vroom_chart_pan(VroomChart* chart, float dx_px, float /*dy_px*/)
         (-dx_px / usable_px) * static_cast<float>(window_ms));
     if (delta_ms == 0) return;
 
-    // The right edge can overshoot the last candle into empty "future" space.
-    // Free scrolling up to half a window (candles fill >= 50%); from there to
-    // 3/4 of a window (candles fill >= 25%) panning forward is rubber-banded so
-    // it slows and hard-stops at the cap. The x-axis drag zoom can leave a gap
-    // larger than the cap (it zooms in until ~one candle remains), so the cap
-    // never forces it back — it just shrinks naturally as the user scrolls.
-    // Left edge still hard-clamps at the first candle.
+    // Forward pans rubber-band between half and 3/4 of a window of empty
+    // future (see damp_future_delta / max_future_gap). Past clamping lives in
+    // clamp_shifted_time_window: dense series pin start at the first candle;
+    // a window longer than the data keeps empty past instead of latching.
     const int64_t first_time = chart->candles.front().time_ms;
     const int64_t last_time = chart->candles.back().time_ms;
     const int64_t cur_future = chart->visible_end_ms - last_time;
     const int64_t eff_delta = damp_future_delta(delta_ms, cur_future, window_ms);
 
-    int64_t new_start = chart->visible_start_ms + eff_delta;
-    int64_t new_end = chart->visible_end_ms + eff_delta;
-
-    const int64_t max_future = max_future_gap(window_ms, cur_future);
-    if (new_end > last_time + max_future) {
-        new_end = last_time + max_future;
-        new_start = new_end - window_ms;
-    }
-    if (new_start < first_time) {
-        new_start = first_time;
-        new_end = new_start + window_ms;
-    }
+    const auto clamped = vroom::clamp_shifted_time_window(
+        chart->visible_start_ms + eff_delta,
+        chart->visible_end_ms + eff_delta,
+        first_time, last_time, chart->candle_duration_ms,
+        pan_max_future(window_ms, cur_future, first_time, last_time,
+                       chart->candle_duration_ms));
+    const int64_t new_start = clamped.start_ms;
+    const int64_t new_end = clamped.end_ms;
 
     if (new_start == chart->visible_start_ms &&
         new_end == chart->visible_end_ms) {
@@ -467,22 +482,16 @@ extern "C" void vroom_chart_translate(VroomChart* chart, float dx_px, float dy_p
                 const int64_t cur_future = chart->visible_end_ms - last_time;
                 const int64_t eff_delta =
                     damp_future_delta(delta_ms, cur_future, window_ms);
-                int64_t new_start = chart->visible_start_ms + eff_delta;
-                int64_t new_end = chart->visible_end_ms + eff_delta;
-                const int64_t max_future =
-                    max_future_gap(window_ms, cur_future);
-                if (new_end > last_time + max_future) {
-                    new_end = last_time + max_future;
-                    new_start = new_end - window_ms;
-                }
-                if (new_start < first_time) {
-                    new_start = first_time;
-                    new_end = new_start + window_ms;
-                }
-                if (new_start != chart->visible_start_ms ||
-                    new_end != chart->visible_end_ms) {
-                    chart->visible_start_ms = new_start;
-                    chart->visible_end_ms = new_end;
+                const auto clamped = vroom::clamp_shifted_time_window(
+                    chart->visible_start_ms + eff_delta,
+                    chart->visible_end_ms + eff_delta,
+                    first_time, last_time, chart->candle_duration_ms,
+                    pan_max_future(window_ms, cur_future, first_time, last_time,
+                                   chart->candle_duration_ms));
+                if (clamped.start_ms != chart->visible_start_ms ||
+                    clamped.end_ms != chart->visible_end_ms) {
+                    chart->visible_start_ms = clamped.start_ms;
+                    chart->visible_end_ms = clamped.end_ms;
                     changed = true;
                 }
             }
@@ -597,9 +606,9 @@ extern "C" void vroom_chart_scale_time_axis(VroomChart* chart, float dx_px) {
     if (new_window_ms > max_window) new_window_ms = max_window;
 
     // Pivot around the right edge — most-recent visible candle stays put.
+    // A window longer than the data may start before the first candle; that
+    // empty past is how defaultCandleWidth wins, so don't pin start to first.
     int64_t new_start = chart->visible_end_ms - new_window_ms;
-    const int64_t first_time = chart->candles.front().time_ms;
-    if (new_start < first_time) new_start = first_time;
 
     if (new_start == chart->visible_start_ms) return;
     chart->visible_start_ms = new_start;
@@ -779,17 +788,14 @@ extern "C" void vroom_chart_zoom(VroomChart* chart, float scale_x, float scale_y
                 const int64_t last_time = chart->candles.back().time_ms;
                 // Cap the future gap at 3/4 of the (new) window so >= 25% of the
                 // chart still shows candles, without snapping back an existing
-                // larger gap (e.g. from the x-axis drag zoom).
-                const int64_t max_future = max_future_gap(
-                    new_window, chart->visible_end_ms - last_time);
-                if (new_end > last_time + max_future) {
-                    new_end = last_time + max_future;
-                    new_start = new_end - new_window;
-                }
-                if (new_start < first_time) {
-                    new_start = first_time;
-                    new_end = new_start + new_window;
-                }
+                // larger gap (e.g. from the x-axis drag zoom). Past clamping
+                // matches pan: a window longer than the data keeps empty left.
+                const auto clamped = vroom::clamp_shifted_time_window(
+                    new_start, new_end, first_time, last_time,
+                    chart->candle_duration_ms,
+                    max_future_gap(new_window, chart->visible_end_ms - last_time));
+                new_start = clamped.start_ms;
+                new_end = clamped.end_ms;
                 if (new_start != chart->visible_start_ms ||
                     new_end != chart->visible_end_ms) {
                     chart->visible_start_ms = new_start;

package/cpp/_core_src/crosshair.cpp

@@ -21,6 +21,7 @@
 #include "chart.h"
 #include "fonts.h"
 #include "theme.h"
+#include "ticks.h"
 
 namespace vroom::crosshair {
 
@@ -146,7 +147,10 @@ void draw(SkCanvas* canvas,
     if (lay.y_axis_width_px > 0.f) {
         const double price = vroom::y_to_price(lay, bounds, cy);
         char buf[32];
-        std::snprintf(buf, sizeof(buf), "%.2f", price);
+        const int decimals = vroom::price_decimals(
+            vroom::pick_price_interval(bounds.max - bounds.min,
+                                       vroom::price_pane_bottom(lay)));
+        vroom::format_price(buf, sizeof(buf), price, decimals);
         const float axis_center_x = lay.width_px - lay.y_axis_width_px * 0.5f;
         draw_badge(canvas, font, buf, axis_center_x, cy, badge_fill,
                    SK_ColorWHITE);

package/cpp/_core_src/labels.cpp

@@ -153,13 +153,15 @@ void draw_y_labels(SkCanvas* canvas,
     // Horizontal center of the y-axis container ([width - y_axis_width, width]).
     // Labels (and the price box) center on this so their text shares a column.
     const float axis_center_x = lay.width_px - lay.y_axis_width_px * 0.5f;
+    const int decimals = vroom::price_decimals(
+        vroom::pick_price_interval(bounds.max - bounds.min, candle_area_h));
 
     for (const auto& f : chart.y_fades) {
         if (f.opacity <= 1e-3f) continue;
         const float y = vroom::price_to_y(lay, bounds, f.price);
 
         char buf[32];
-        std::snprintf(buf, sizeof(buf), "%.2f", f.price);
+        vroom::format_price(buf, sizeof(buf), f.price, decimals);
         const size_t len = std::strlen(buf);
         const float text_w = font.measureText(
             buf, len, SkTextEncoding::kUTF8);
@@ -367,9 +369,12 @@ void recompute_axis_width(VroomChart& chart) {
     }
 
     SkFont font(tf, chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX]);
+    const auto lay = chart.layout();
+    const int decimals = vroom::price_decimals(
+        vroom::pick_price_interval(hi - lo, vroom::price_pane_bottom(lay)));
     char buf_hi[32], buf_lo[32];
-    std::snprintf(buf_hi, sizeof(buf_hi), "%.2f", hi);
-    std::snprintf(buf_lo, sizeof(buf_lo), "%.2f", lo);
+    vroom::format_price(buf_hi, sizeof(buf_hi), hi, decimals);
+    vroom::format_price(buf_lo, sizeof(buf_lo), lo, decimals);
     const float w_hi = font.measureText(
         buf_hi, std::strlen(buf_hi), SkTextEncoding::kUTF8);
     const float w_lo = font.measureText(

package/cpp/_core_src/price_indicator.cpp

@@ -19,6 +19,7 @@
 #include "chart.h"
 #include "fonts.h"
 #include "theme.h"
+#include "ticks.h"
 #include "viewport.h"
 
 namespace vroom::price_indicator {
@@ -66,7 +67,9 @@ void draw(SkCanvas* canvas,
     font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
 
     char buf[32];
-    std::snprintf(buf, sizeof(buf), "%.2f", last.close);
+    const int decimals = vroom::price_decimals(
+        vroom::pick_price_interval(bounds.max - bounds.min, candle_area_h));
+    vroom::format_price(buf, sizeof(buf), last.close, decimals);
     const size_t len = std::strlen(buf);
 
     // Measure the tight glyph bounds (origin at the baseline) so we can center

package/cpp/_core_src/price_lines.cpp

@@ -23,6 +23,7 @@
 #include "fonts.h"
 #include "price_line_layout.h"
 #include "theme.h"
+#include "ticks.h"
 #include "viewport.h"
 
 namespace vroom::price_lines {
@@ -212,11 +213,12 @@ void draw_axis_badge(SkCanvas* canvas,
                      const Layout& lay,
                      double price,
                      float y,
-                     SkColor fill) {
+                     SkColor fill,
+                     int decimals) {
     if (lay.y_axis_width_px <= 0.f) return;
 
     char buf[32];
-    std::snprintf(buf, sizeof(buf), "%.2f", price);
+    vroom::format_price(buf, sizeof(buf), price, decimals);
     const size_t len = std::strlen(buf);
 
     SkRect tb;
@@ -253,6 +255,8 @@ void draw(SkCanvas* canvas,
     const VroomPriceLineStyle& style = chart.price_line_style;
     SkFont font;
     const bool has_font = label_font(chart, &font);
+    const int decimals = vroom::price_decimals(
+        vroom::pick_price_interval(bounds.max - bounds.min, candle_area_h));
 
     for (size_t i = 0; i < chart.price_lines.size(); ++i) {
         const VroomChart::StoredPriceLine& pl = chart.price_lines[i];
@@ -351,7 +355,7 @@ void draw(SkCanvas* canvas,
 
         if (has_font && (pl.flags & VROOM_PRICE_LINE_AXIS_LABEL) != 0) {
             draw_axis_badge(canvas, font, lay, render_price(chart, i), y,
-                            line_color);
+                            line_color, decimals);
         }
     }
 }

package/cpp/_core_src/ticks.cpp

@@ -2,6 +2,7 @@
 
 #include <algorithm>
 #include <cmath>
+#include <cstdio>
 #include <ctime>
 
 namespace vroom {
@@ -145,4 +146,17 @@ double pick_price_interval(double range, float candle_area_h) {
     return nice * magnitude;
 }
 
+int price_decimals(double interval) {
+    if (!(interval > 0.0) || !std::isfinite(interval)) return 2;
+    const double d = std::ceil(-std::log10(interval) - 1e-12);
+    if (d < 0.0) return 0;
+    if (d > 12.0) return 12;
+    return static_cast<int>(d);
+}
+
+void format_price(char* buf, size_t buf_size, double price, int decimals) {
+    if (!buf || buf_size == 0) return;
+    std::snprintf(buf, buf_size, "%.*f", decimals, price);
+}
+
 }  // namespace vroom

package/cpp/_core_src/ticks.h

@@ -6,6 +6,7 @@
 
 #pragma once
 
+#include <cstddef>
 #include <cstdint>
 
 namespace vroom {
@@ -50,4 +51,11 @@ int64_t next_tick(int64_t t, const TimeTick& tick);
 // in the same units as the data (e.g. dollars).
 double pick_price_interval(double range, float candle_area_h);
 
+// Decimal places needed so adjacent ticks `interval` apart don't collapse to
+// the same string. 0.01 → 2, 0.005 → 3, 1e-8 → 8. Clamped to [0, 12].
+int price_decimals(double interval);
+
+// Writes `price` into `buf` using `decimals` (from price_decimals).
+void format_price(char* buf, size_t buf_size, double price, int decimals);
+
 }  // namespace vroom

package/cpp/_core_src/viewport.cpp

@@ -17,6 +17,16 @@ float candle_body_width(const Layout& layout,
     return static_cast<float>(slot * layout.candle_width_ratio);
 }
 
+int64_t window_for_body_width(const Layout& layout,
+                              int64_t candle_duration_ms,
+                              double body_px) {
+    const double usable = candle_area_width(layout);
+    const double ratio = static_cast<double>(layout.candle_width_ratio);
+    const double dur = static_cast<double>(candle_duration_ms);
+    if (usable <= 0.0 || ratio <= 0.0 || dur <= 0.0 || body_px <= 0.0) return 0;
+    return static_cast<int64_t>((usable * dur * ratio) / body_px);
+}
+
 float candle_center_x(const Layout& layout,
                       int64_t time_ms,
                       int64_t candle_duration_ms,
@@ -265,4 +275,39 @@ double y_to_price(const Layout& layout,
     return bounds.min + t * range;
 }
 
+TimeWindow clamp_shifted_time_window(int64_t start_ms, int64_t end_ms,
+                                     int64_t first_time, int64_t last_time,
+                                     int64_t candle_duration_ms,
+                                     int64_t max_future) {
+    const int64_t window = end_ms - start_ms;
+    if (window <= 0) return {start_ms, end_ms};
+
+    const int64_t dur = candle_duration_ms > 0 ? candle_duration_ms : 0;
+    const int64_t last_slot_end = last_time + dur;
+    const int64_t data_extent = last_slot_end - first_time;
+
+    if (max_future >= 0 && end_ms > last_time + max_future) {
+        end_ms = last_time + max_future;
+        start_ms = end_ms - window;
+    }
+
+    // Window longer than the series: empty past is how width wins. Floor the
+    // right edge at last_time so a pan into the past is a no-op when the
+    // candles are already right-aligned. Do not pin start to first_time — that
+    // throws the extra length into the future and the two caps latch.
+    if (data_extent >= 0 && window > data_extent) {
+        if (end_ms < last_time) {
+            end_ms = last_time;
+            start_ms = end_ms - window;
+        }
+        return {start_ms, end_ms};
+    }
+
+    if (start_ms < first_time) {
+        start_ms = first_time;
+        end_ms = start_ms + window;
+    }
+    return {start_ms, end_ms};
+}
+
 }  // namespace vroom

package/cpp/_core_src/viewport.h

@@ -86,6 +86,36 @@ float candle_body_width(const Layout& layout,
                         int64_t window_ms,
                         int64_t candle_duration_ms);
 
+// Inverse of candle_body_width: the time window that makes each candle body
+// `body_px` wide. Returns 0 if any input is degenerate. Does not consult the
+// data span — a short series leaves empty space on the left (width wins).
+int64_t window_for_body_width(const Layout& layout,
+                              int64_t candle_duration_ms,
+                              double body_px);
+
+// A [start, end] time window of fixed length, used by pan/zoom clamping.
+struct TimeWindow {
+    int64_t start_ms;
+    int64_t end_ms;
+};
+
+// Clamp a same-length time window after a pan or pinch-zoom shift.
+//
+// The future cap (`max_future`, typically 3/4 of the window) is unchanged: the
+// right edge cannot run past last_time + max_future.
+//
+// The past cap depends on whether the window fits in the data:
+// - Window ≤ data extent: start cannot precede first_time (no empty past).
+// - Window > data extent: empty past is intentional (width wins). start MAY
+//   precede first_time. Instead, the last candle cannot leave the right edge
+//   (end >= last_time). Pinning start to first_time in this case would shove
+//   the extra length into the future and latch, because the future cap then
+//   fights the past cap on every subsequent pan.
+TimeWindow clamp_shifted_time_window(int64_t start_ms, int64_t end_ms,
+                                     int64_t first_time, int64_t last_time,
+                                     int64_t candle_duration_ms,
+                                     int64_t max_future);
+
 // Center-x of a candle whose period starts at time_ms and lasts
 // candle_duration_ms, given the current visible time window.
 float candle_center_x(const Layout& layout,

package/lib/index.d.mts

@@ -627,7 +627,8 @@ type VroomChartCoreProps = {
      * more zoomed in (fewer candles); smaller → more zoomed out. Only affects
      * first load / reset; an explicit `visibleRange` takes precedence. Omit for
      * the default (~80 candles). Useful to keep candles a consistent size across
-     * devices of different widths.
+     * devices of different widths. A series shorter than the window is left-padded
+     * with empty slots — bars stay this wide rather than stretching to fill.
      */
     defaultCandleWidth?: number;
     /**

package/lib/index.d.ts

@@ -627,7 +627,8 @@ type VroomChartCoreProps = {
      * more zoomed in (fewer candles); smaller → more zoomed out. Only affects
      * first load / reset; an explicit `visibleRange` takes precedence. Omit for
      * the default (~80 candles). Useful to keep candles a consistent size across
-     * devices of different widths.
+     * devices of different widths. A series shorter than the window is left-padded
+     * with empty slots — bars stay this wide rather than stretching to fill.
      */
     defaultCandleWidth?: number;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-vroom-chart",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Mobile-first Skia candlestick chart for React Native",
   "license": "MIT",
   "author": "Darion Welch",