react-native-vroom-chart 0.11.1 → 0.13.0

package/cpp/VroomChartHostObject.cpp

@@ -63,6 +63,7 @@ std::vector<jsi::PropNameID> ChartHostObject::getPropertyNames(
   out.push_back(jsi::PropNameID::forAscii(rt, "setBollinger"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setVolume"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setVolumeCollapse"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setAxisCollapse"));
   out.push_back(jsi::PropNameID::forAscii(rt, "coordAt"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setPriceLines"));
   out.push_back(jsi::PropNameID::forAscii(rt, "hitTestPriceLine"));
@@ -919,6 +920,27 @@ jsi::Value ChartHostObject::get(jsi::Runtime& rt,
         });
   }
 
+  if (name == "setAxisCollapse") {
+    // setAxisCollapse(yT, xT) — hides the price / time axis strips. Both take
+    // EASED progress (0 shown, 1 hidden); there is no per-element stagger for
+    // the core to distribute, so the host owns the curve.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setAxisCollapse"),
+        2,
+        [this](jsi::Runtime& /*rt2*/,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 2) return jsi::Value::undefined();
+          vroom_chart_set_axis_collapse(
+              chart_,
+              static_cast<float>(args[0].asNumber()),
+              static_cast<float>(args[1].asNumber()));
+          return jsi::Value::undefined();
+        });
+  }
+
   if (name == "coordAt") {
     // coordAt(x, y) -> { timeMs, price } | null. The continuous data coordinate
     // at a pixel — not snapped to a candle slot. Null when there are no candles

package/cpp/_core_include/vroom/vroom_chart.h

@@ -282,8 +282,12 @@ typedef enum {
     VROOM_COLOR_GRID,
     VROOM_COLOR_AXIS_TEXT,
     VROOM_COLOR_CROSSHAIR,
-    VROOM_COLOR_TOOLTIP_BG,
-    VROOM_COLOR_TOOLTIP_TEXT,
+    // Retired (was VROOM_COLOR_TOOLTIP_BG, never rendered). Held open because
+    // the TypeScript theme maps hardcode the indices below it.
+    VROOM_COLOR_RESERVED_7_,
+    // Text drawn on a filled badge: the current-price indicator, the crosshair's
+    // axis badges, and price-line pills. Defaults to white.
+    VROOM_COLOR_BADGE_TEXT,
     VROOM_COLOR_CROSSHAIR_TARGET,  // the hollow ring/dot at the intersection
     VROOM_COLOR_BORDER_BULL,       // bull body 1px outline; 0 alpha => inherit BULL fill
     VROOM_COLOR_BORDER_BEAR,       // bear body 1px outline; 0 alpha => inherit BEAR fill
@@ -564,6 +568,19 @@ void vroom_chart_set_volume(VroomChart* chart, const VroomVolume* cfg);
 // `enabled`, so the host only needs it while animating.
 void vroom_chart_set_volume_collapse(VroomChart* chart, float t, int32_t easing);
 
+// Collapses the axis strips: 0 leaves a strip at full size, 1 hides it. Driven
+// per-frame by the host animation loop, which owns the eased clock — unlike the
+// volume collapse there is no per-element stagger, so these take *eased*
+// progress directly.
+//
+// Hiding is a collapse rather than a zeroed dimension because the y-axis width
+// is measured from the widest price label and recomputed on most data changes,
+// which would overwrite a zero. The price pane grows into whatever the strips
+// give up, and each strip's contents (labels, price badge, crosshair and
+// price-line badges) fade out over the first half of the collapse so text is
+// never squeezed into a strip too narrow to hold it.
+void vroom_chart_set_axis_collapse(VroomChart* chart, float y_t, float x_t);
+
 // ---- Drawings (line annotations) ------------------------------------------
 
 // Replaces the full set of committed line drawings (data-anchored, so they track

package/cpp/_core_src/chart.cpp

@@ -64,13 +64,16 @@ vroom::Layout VroomChart::layout() const {
     return vroom::Layout{
         width_px,
         height_px,
-        axis_w,
-        theme.floats[VROOM_FLOAT_X_AXIS_HEIGHT_PX],
+        vroom::axis_extent(axis_w, y_axis_collapse_t),
+        vroom::axis_extent(theme.floats[VROOM_FLOAT_X_AXIS_HEIGHT_PX],
+                           x_axis_collapse_t),
         theme.floats[VROOM_FLOAT_RIGHT_PADDING_PX],
         theme.floats[VROOM_FLOAT_CANDLE_WIDTH_RATIO],
         0.05f,
         0.05f,
         indicator_h,
+        vroom::axis_opacity(y_axis_collapse_t),
+        vroom::axis_opacity(x_axis_collapse_t),
     };
 }
 

package/cpp/_core_src/chart.h

@@ -191,6 +191,13 @@ struct VroomChart {
     float volume_collapse_t = 0.f;
     int32_t volume_collapse_easing = VROOM_EASING_IN_OUT;
 
+    // Collapse of the axis strips, driven per-frame by the host animation loop:
+    // 0 = full strip, 1 = hidden. Unlike the volume collapse these change the
+    // layout, so the price pane grows into whatever the strips give up. The host
+    // pre-eases them (there is no per-element stagger to distribute here).
+    float y_axis_collapse_t = 0.f;
+    float x_axis_collapse_t = 0.f;
+
     // --- drawings (annotations) --------------------------------------------
     // Committed drawings, anchored in data space so they track the candles on
     // pan/zoom. Drawn on the price pane above candles/overlays.

package/cpp/_core_src/chart_facade.cpp

@@ -1401,6 +1401,15 @@ extern "C" void vroom_chart_set_volume_collapse(VroomChart* chart, float t,
     chart->mark_dirty();
 }
 
+extern "C" void vroom_chart_set_axis_collapse(VroomChart* chart, float y_t,
+                                              float x_t) {
+    if (!chart) return;
+    chart->y_axis_collapse_t = std::clamp(y_t, 0.f, 1.f);
+    chart->x_axis_collapse_t = std::clamp(x_t, 0.f, 1.f);
+    // Changes the layout, so every cached pane geometry has to be re-derived.
+    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/crosshair.cpp

@@ -42,7 +42,9 @@ void draw_badge(SkCanvas* canvas,
                 float cx,
                 float cy,
                 SkColor fill,
-                SkColor text_color) {
+                SkColor text_color,
+                float opacity) {
+    if (opacity <= 0.f) return;
     const size_t len = std::strlen(text);
     SkRect tb;
     const float text_w = font.measureText(text, len, SkTextEncoding::kUTF8, &tb);
@@ -54,11 +56,13 @@ void draw_badge(SkCanvas* canvas,
     SkPaint box;
     box.setAntiAlias(true);
     box.setColor(fill);
+    box.setAlphaf(box.getAlphaf() * opacity);
     canvas->drawRRect(SkRRect::MakeRectXY(rect, kCorner, kCorner), box);
 
     SkPaint text_paint;
     text_paint.setAntiAlias(true);
     text_paint.setColor(text_color);
+    text_paint.setAlphaf(text_paint.getAlphaf() * opacity);
     canvas->drawString(text, cx - text_w * 0.5f,
                        cy - (tb.fTop + tb.fBottom) * 0.5f, font, text_paint);
 }
@@ -108,8 +112,8 @@ void draw(SkCanvas* canvas,
     ring.setStrokeWidth(2.f);  // thicker border so the dot reads clearly
     canvas->drawCircle(cx, cy, kRingRadius, ring);
 
-    // Axis badges (neutral grey, white text) sit on top of the axis labels and
-    // the current-price indicator since the crosshair is the last draw step.
+    // Axis badges sit on top of the axis labels and the current-price indicator
+    // since the crosshair is the last draw step.
     // They need the axis typeface; if it isn't loaded the lines alone suffice.
     auto tf = vroom::axis_typeface();
     if (!tf) return;
@@ -119,6 +123,7 @@ void draw(SkCanvas* canvas,
     font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
 
     const SkColor badge_fill = chart.theme.colors[VROOM_COLOR_CROSSHAIR_TARGET];
+    const SkColor badge_text = chart.theme.colors[VROOM_COLOR_BADGE_TEXT];
 
     // Date/time badge over the x-axis strip, centered on the vertical line and
     // vertically aligned with the time labels (centered in the strip).
@@ -140,7 +145,7 @@ void draw(SkCanvas* canvas,
         const float badge_cx =
             std::clamp(cx, half_w, std::max(half_w, candle_right - half_w));
         draw_badge(canvas, font, buf, badge_cx, strip_center_y, badge_fill,
-                   SK_ColorWHITE);
+                   badge_text, lay.x_axis_opacity);
     }
 
     // Price badge over the y-axis strip, centered on the horizontal line and
@@ -155,7 +160,7 @@ void draw(SkCanvas* canvas,
         vroom::format_price(buf, sizeof(buf), price, fmt);
         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);
+                   badge_text, lay.y_axis_opacity);
     }
 }
 

package/cpp/_core_src/labels.cpp

@@ -147,6 +147,9 @@ void draw_y_labels(SkCanvas* canvas,
                    const PriceBounds& bounds) {
     auto tf = vroom::axis_typeface();
     if (!tf) return;
+    // The fade state still advances in update_y_fades, so a hidden axis picks up
+    // wherever the ticks moved to once it is revealed again.
+    if (lay.y_axis_opacity <= 0.f) return;
 
     const float candle_area_h = vroom::price_pane_bottom(lay);
 
@@ -186,7 +189,7 @@ void draw_y_labels(SkCanvas* canvas,
         if (baseline_y - cap_h < 0.f) continue;
         if (baseline_y > candle_area_h) continue;
 
-        text_paint.setAlphaf(f.opacity);
+        text_paint.setAlphaf(f.opacity * lay.y_axis_opacity);
         canvas->drawString(buf, text_x, baseline_y, font, text_paint);
     }
 }
@@ -279,6 +282,8 @@ void draw_x_labels(SkCanvas* canvas,
     auto tf = vroom::axis_typeface();
     if (!tf || chart.candles.empty()) return;
     if (end_ms <= start_ms) return;
+    // See draw_y_labels: update_x_fades keeps running while the strip is hidden.
+    if (lay.x_axis_opacity <= 0.f) return;
 
     // X-axis labels live in the bottom strip, which stays anchored regardless
     // of any indicator pane above it.
@@ -345,7 +350,7 @@ void draw_x_labels(SkCanvas* canvas,
         if (text_x < 0.f) continue;
         if (text_x + text_w > candle_area_w) continue;
 
-        text_paint.setAlphaf(f.opacity);
+        text_paint.setAlphaf(f.opacity * lay.x_axis_opacity);
         canvas->drawString(buf, text_x, baseline_y, font, text_paint);
     }
 }

package/cpp/_core_src/macd_pane.cpp

@@ -211,14 +211,15 @@ void draw(SkCanvas* canvas,
     }
     canvas->restore();
 
-    // "0" label in the y-axis strip at the zero line.
-    if (tf) {
+    // "0" label in the y-axis strip at the zero line — hidden with that strip.
+    if (tf && lay.y_axis_opacity > 0.f) {
         SkFont font(tf, chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX]);
         font.setSubpixel(true);
         font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
         SkPaint text_paint;
         text_paint.setAntiAlias(true);
         text_paint.setColor(chart.theme.colors[VROOM_COLOR_AXIS_TEXT]);
+        text_paint.setAlphaf(text_paint.getAlphaf() * lay.y_axis_opacity);
         SkRect tb;
         const float tw =
             font.measureText("0", 1, SkTextEncoding::kUTF8, &tb);

package/cpp/_core_src/price_format.cpp

@@ -2,6 +2,7 @@
 
 #include <algorithm>
 #include <cmath>
+#include <cstddef>
 #include <cstdio>
 
 namespace vroom {
@@ -15,6 +16,38 @@ constexpr size_t kPlainCap = 340;
 constexpr char kGroupSeparator = ',';
 constexpr int kGroupSize = 3;
 
+constexpr double kMillion = 1e6;
+constexpr double kBillion = 1e9;
+constexpr double kTrillion = 1e12;
+
+double compact_divisor(CompactScale scale) {
+    switch (scale) {
+        case CompactScale::Million:  return kMillion;
+        case CompactScale::Billion:  return kBillion;
+        case CompactScale::Trillion: return kTrillion;
+        case CompactScale::None:     return 1.0;
+    }
+    return 1.0;
+}
+
+char compact_suffix(CompactScale scale) {
+    switch (scale) {
+        case CompactScale::Million:  return 'M';
+        case CompactScale::Billion:  return 'B';
+        case CompactScale::Trillion: return 'T';
+        case CompactScale::None:     return '\0';
+    }
+    return '\0';
+}
+
+CompactScale compact_scale_for(double reference) {
+    const double r = std::fabs(reference);
+    if (!std::isfinite(r) || r < kMillion) return CompactScale::None;
+    if (r >= kTrillion) return CompactScale::Trillion;
+    if (r >= kBillion) return CompactScale::Billion;
+    return CompactScale::Million;
+}
+
 }  // namespace
 
 int significant_decimals(double reference) {
@@ -28,7 +61,8 @@ int significant_decimals(double reference) {
 }
 
 PriceFormat price_format_for(double reference) {
-    return PriceFormat{significant_decimals(reference), true};
+    return PriceFormat{significant_decimals(reference), true,
+                       compact_scale_for(reference)};
 }
 
 int price_decimals(double interval) {
@@ -40,8 +74,13 @@ int price_decimals(double interval) {
 }
 
 PriceFormat with_tick_guard(const PriceFormat& fmt, double interval) {
-    return PriceFormat{std::max(fmt.decimals, price_decimals(interval)),
-                       fmt.group};
+    const double divisor = compact_divisor(fmt.compact);
+    const double display_interval =
+        (divisor != 1.0 && interval > 0.0 && std::isfinite(interval))
+            ? interval / divisor
+            : interval;
+    return PriceFormat{std::max(fmt.decimals, price_decimals(display_interval)),
+                       fmt.group, fmt.compact};
 }
 
 void format_price(char* buf, size_t buf_size, double price,
@@ -49,11 +88,23 @@ void format_price(char* buf, size_t buf_size, double price,
     if (!buf || buf_size == 0) return;
     const int decimals = std::clamp(fmt.decimals, 0, kPriceMaxDecimals);
 
+    const double divisor = compact_divisor(fmt.compact);
+    const double display = (divisor != 1.0) ? price / divisor : price;
+
     char plain[kPlainCap];
-    if (std::snprintf(plain, sizeof(plain), "%.*f", decimals, price) < 0) {
+    if (std::snprintf(plain, sizeof(plain), "%.*f", decimals, display) < 0) {
         buf[0] = '\0';
         return;
     }
+
+    const char suffix = compact_suffix(fmt.compact);
+    if (suffix != '\0') {
+        // Compact form is already short; grouping would only fire if a tick
+        // wandered across a suffix boundary (1000.00M). Skip it.
+        std::snprintf(buf, buf_size, "%s%c", plain, suffix);
+        return;
+    }
+
     if (!fmt.group) {
         std::snprintf(buf, buf_size, "%s", plain);
         return;

package/cpp/_core_src/price_format.h

@@ -13,6 +13,16 @@
 //   0.023397  -> 6 decimals   0.023397
 //   80285.20  -> 2 decimals   80,285.20   (floor)
 //   2513.92   -> 2 decimals   2,513.92    (floor)
+//   1.59e6    -> compact      1.59M
+//   3.219e7   -> compact      32.19M
+//   3.454e10  -> compact      34.54B
+//   1.2e12    -> compact      1.20T
+//
+// Past a million the integer digits eat the axis, so the format switches to a
+// suffix (M / B / T) with two decimal places. The suffix is keyed off the
+// asset's own price, not each tick, so every label on a market-cap chart
+// shares a column and a zoomed-in 32.1M–32.2M range does not mix "32.15M"
+// with "32,150,000.00".
 //
 // The reference is the asset's own price, not the visible range, so the
 // precision holds steady while the user pans and zooms. A range-derived count
@@ -32,18 +42,31 @@ namespace vroom {
 inline constexpr int kPriceSigDigits = 5;
 
 // Prices at or above ~1 unit read as currency, where fewer than two decimals
-// looks broken (a "$84,000" axis next to a "$80,285.20" last price).
+// looks broken (a "$84,000" axis next to a "$80,285.20" last price). Compact
+// suffixes use the same floor: "32.19M", not "32.2M".
 inline constexpr int kPriceMinDecimals = 2;
 
 // Past this the digits are noise, and %.*f starts printing the binary
 // representation's tail rather than anything the feed meant.
 inline constexpr int kPriceMaxDecimals = 12;
 
+// Compact suffix for assets priced in the millions and up. Keyed off the
+// reference, then applied to every label so the column stays uniform. Nothing
+// below a million is abbreviated — no K.
+enum class CompactScale {
+    None,
+    Million,    // |ref| >= 1e6
+    Billion,    // |ref| >= 1e9
+    Trillion,   // |ref| >= 1e12
+};
+
 // How to render a price. `group` inserts thousands separators, which only ever
-// affects the integer part.
+// affects the integer part of a non-compact format. `compact` scales the value
+// and appends M / B / T; grouping is skipped in that path.
 struct PriceFormat {
-    int  decimals = kPriceMinDecimals;
-    bool group = true;
+    int          decimals = kPriceMinDecimals;
+    bool         group = true;
+    CompactScale compact = CompactScale::None;
 };
 
 // Decimals giving kPriceSigDigits significant digits for an asset priced around
@@ -51,7 +74,8 @@ struct PriceFormat {
 // non-finite reference falls back to the floor.
 int significant_decimals(double reference);
 
-// The format for an asset priced around `reference`.
+// The format for an asset priced around `reference`, including the compact
+// suffix when |reference| is at least a million.
 PriceFormat price_format_for(double reference);
 
 // Decimal places needed so adjacent ticks `interval` apart don't collapse to
@@ -60,6 +84,9 @@ int price_decimals(double interval);
 
 // `fmt` raised, if need be, so ticks `interval` apart stay distinct. The asset's
 // precision is the floor; only a zoom deeper than that precision adds to it.
+// `interval` is in the data's units; when `fmt` is compact the guard converts
+// it into display units (interval / 1e6 for millions, etc.) so a 1,000-wide
+// step on a 32M chart still gets enough decimals to print as 32.192M vs 32.193M.
 PriceFormat with_tick_guard(const PriceFormat& fmt, double interval);
 
 // Writes `price` into `buf` per `fmt`, truncating rather than overrunning.

package/cpp/_core_src/price_indicator.cpp

@@ -59,9 +59,11 @@ void draw(SkCanvas* canvas,
     canvas->drawLine(0.f, y, candle_right, y, line);
 
     // Price box in the y-axis strip. Needs the axis typeface; if it isn't
-    // loaded yet, the line alone still conveys the level.
+    // loaded yet, the line alone still conveys the level. Same when the y-axis
+    // is hidden — the level stays readable, it just loses its badge.
     auto tf = vroom::axis_typeface();
     if (!tf) return;
+    if (lay.y_axis_opacity <= 0.f) return;
 
     SkFont font(tf, chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX]);
     font.setSubpixel(true);
@@ -95,14 +97,16 @@ void draw(SkCanvas* canvas,
     SkPaint box;
     box.setAntiAlias(true);
     box.setColor(color);
+    box.setAlphaf(box.getAlphaf() * lay.y_axis_opacity);
     canvas->drawRRect(SkRRect::MakeRectXY(rect, kCorner, kCorner), box);
 
-    // White price text, horizontally centered on the same axis center, and
-    // vertically centered: shift the baseline so the glyph bounds' midpoint
-    // lands on `y` (= the box center and the dotted line).
+    // Price text horizontally centered on the same axis center, and vertically
+    // centered: shift the baseline so the glyph bounds' midpoint lands on `y`
+    // (= the box center and the dotted line).
     SkPaint text_paint;
     text_paint.setAntiAlias(true);
-    text_paint.setColor(SK_ColorWHITE);
+    text_paint.setColor(chart.theme.colors[VROOM_COLOR_BADGE_TEXT]);
+    text_paint.setAlphaf(text_paint.getAlphaf() * lay.y_axis_opacity);
     const float text_x = axis_center_x - text_w * 0.5f;
     const float baseline_y = y - (tb.fTop + tb.fBottom) * 0.5f;
     canvas->drawString(buf, text_x, baseline_y, font, text_paint);

package/cpp/_core_src/price_lines.cpp

@@ -215,8 +215,10 @@ void draw_axis_badge(SkCanvas* canvas,
                      double price,
                      float y,
                      SkColor fill,
+                     SkColor text_color,
                      const PriceFormat& fmt) {
     if (lay.y_axis_width_px <= 0.f) return;
+    if (lay.y_axis_opacity <= 0.f) return;
 
     char buf[48];
     vroom::format_price(buf, sizeof(buf), price, fmt);
@@ -233,11 +235,13 @@ void draw_axis_badge(SkCanvas* canvas,
     SkPaint box;
     box.setAntiAlias(true);
     box.setColor(fill);
+    box.setAlphaf(box.getAlphaf() * lay.y_axis_opacity);
     canvas->drawRRect(SkRRect::MakeRectXY(rect, kCorner, kCorner), box);
 
     SkPaint text;
     text.setAntiAlias(true);
-    text.setColor(SK_ColorWHITE);
+    text.setColor(text_color);
+    text.setAlphaf(text.getAlphaf() * lay.y_axis_opacity);
     canvas->drawString(buf, cx - text_w * 0.5f,
                        y - (tb.fTop + tb.fBottom) * 0.5f, font, text);
 }
@@ -254,6 +258,7 @@ void draw(SkCanvas* canvas,
     if (chart.price_lines.empty()) return;
 
     const VroomPriceLineStyle& style = chart.price_line_style;
+    const SkColor badge_text = chart.theme.colors[VROOM_COLOR_BADGE_TEXT];
     SkFont font;
     const bool has_font = label_font(chart, &font);
     const vroom::PriceFormat fmt = vroom::with_tick_guard(
@@ -336,12 +341,12 @@ void draw(SkCanvas* canvas,
                                    line_color);
             }
             if (!group.quantity.empty()) {
-                // Solid fill + white text, so size reads at a glance against the
+                // Solid fill + badge text, so size reads at a glance against the
                 // translucent body.
                 draw_pill(canvas, group.quantity, first == &group.quantity,
                           last == &group.quantity, line_color, SK_ColorTRANSPARENT);
                 draw_centered_text(canvas, font, pl.quantity, group.quantity, y,
-                                   SK_ColorWHITE);
+                                   badge_text);
             }
             if (!group.close.empty()) {
                 const SkColor close_color =
@@ -357,7 +362,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, fmt);
+                            line_color, badge_text, fmt);
         }
     }
 }

package/cpp/_core_src/rsi_pane.cpp

@@ -158,13 +158,15 @@ void draw(SkCanvas* canvas,
     // 70 / 30 labels in the y-axis strip (drawn after the clip; the strip's
     // background was already masked by draw_chart before this call). They label
     // the band rules, so they go with them.
-    if (tf && cfg.bands_visible) {
+    // The band labels live in the y-axis strip, so they go with it when it hides.
+    if (tf && cfg.bands_visible && lay.y_axis_opacity > 0.f) {
         SkFont font(tf, chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX]);
         font.setSubpixel(true);
         font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
         SkPaint text_paint;
         text_paint.setAntiAlias(true);
         text_paint.setColor(chart.theme.colors[VROOM_COLOR_AXIS_TEXT]);
+        text_paint.setAlphaf(text_paint.getAlphaf() * lay.y_axis_opacity);
 
         const float axis_center_x = lay.width_px - lay.y_axis_width_px * 0.5f;
         auto label = [&](const char* s, float y) {

package/cpp/_core_src/theme.cpp

@@ -13,8 +13,8 @@ constexpr uint32_t kDefaultColors[VROOM_COLOR_COUNT_] = {
     0xff1a1e24,  // GRID — ~20% darker than the crosshair so it recedes
     0xffc9d1d9,  // AXIS_TEXT
     0xff303741,  // CROSSHAIR — grid tone lightened ~44%; reads above GRID
-    0xff161b22,  // TOOLTIP_BG
-    0xffc9d1d9,  // TOOLTIP_TEXT
+    0x00000000,  // RESERVED_7_ — retired slot, never read
+    0xffffffff,  // BADGE_TEXT — text on filled badges/pills
     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

package/cpp/_core_src/viewport.h

@@ -20,8 +20,40 @@ struct Layout {
     float top_padding_frac;     // fraction of candle area; keeps prices off edges
     float bottom_padding_frac;
     float indicator_area_h;     // height reserved for below-chart indicator panes
+    // Opacity of everything drawn *inside* an axis strip, 1 = shown, 0 = hidden.
+    // Separate from the strip's extent because the two ramp at different rates
+    // while an axis is being hidden or revealed (see axis_opacity).
+    float y_axis_opacity;
+    float x_axis_opacity;
 };
 
+// --- Axis show/hide ---------------------------------------------------------
+// An axis is hidden by collapsing its strip to nothing rather than by zeroing
+// the underlying dimension: the y-axis width is *measured* from the widest price
+// label (labels::recompute_axis_width) and gets recomputed constantly, so a zero
+// written there would not survive. `t` is the collapse progress the host eases,
+// 0 = fully shown, 1 = fully hidden.
+
+inline float clamp_collapse(float t) {
+    return t < 0.f ? 0.f : (t > 1.f ? 1.f : t);
+}
+
+// The strip's on-screen extent. Everything downstream (candle_area_width,
+// price_pane_bottom) is derived from this, so the plot reclaims the space as
+// the strip shrinks.
+inline float axis_extent(float base, float t) {
+    return base * (1.f - clamp_collapse(t));
+}
+
+// Opacity of the strip's contents. Deliberately front-loaded: the labels are
+// fully gone by the time the strip is halfway collapsed, so text never sits in
+// a strip too narrow to hold it.
+inline float axis_opacity(float t) {
+    constexpr float kFadeBy = 0.5f;  // fraction of the collapse spent fading
+    const float p = clamp_collapse(t) / kFadeBy;
+    return p >= 1.f ? 0.f : 1.f - p;
+}
+
 // Bottom of the price (candle) pane = top of the indicator band. Shrinks when
 // an indicator pane is present so candles, volume, and price labels reflow.
 inline float price_pane_bottom(const Layout& l) {

package/lib/index.d.mts

@@ -93,6 +93,13 @@ type VroomTheme = {
     grid?: VroomColor;
     /** Axis label text (price + time). */
     axisText?: VroomColor;
+    /**
+     * Text drawn on a filled badge — the current-price indicator, the crosshair's
+     * price and time badges, and price-line pills. Defaults to white, which reads
+     * against the saturated fills those badges use on a dark theme; light themes
+     * generally want a dark value here.
+     */
+    badgeText?: VroomColor;
     /** Crosshair dashed lines. */
     crosshair?: VroomColor;
     /** Crosshair target — the hollow ring/dot at the intersection. */
@@ -134,6 +141,26 @@ type VroomTheme = {
      * continuously — leave it off for charts that should be able to go idle.
      */
     lineTipPulse?: boolean;
+    /**
+     * Show the price (y) axis strip down the right edge. Defaults to `true`.
+     *
+     * Hiding it collapses the strip and hands the reclaimed width to the plot, so
+     * the candles widen to fill it. Its contents — price labels, the current-price
+     * badge, the crosshair price badge, price-line axis badges — fade out ahead of
+     * the collapse; gridlines and the price indicator's dotted line stay. Animated
+     * over `transitionMs` unless the OS asks for reduced motion.
+     *
+     * The axis drag-to-scale region goes with the strip, so a hidden axis can't be
+     * scaled by dragging it.
+     */
+    showYAxis?: boolean;
+    /**
+     * Show the time (x) axis strip along the bottom. Defaults to `true`.
+     *
+     * Behaves like {@link VroomTheme.showYAxis}: the strip collapses, the plot
+     * grows into it, and the time labels and crosshair time badge fade first.
+     */
+    showXAxis?: boolean;
 };
 /** A time window over the candle data, as Unix epoch milliseconds. */
 type VisibleRange = {

package/lib/index.d.ts

@@ -93,6 +93,13 @@ type VroomTheme = {
     grid?: VroomColor;
     /** Axis label text (price + time). */
     axisText?: VroomColor;
+    /**
+     * Text drawn on a filled badge — the current-price indicator, the crosshair's
+     * price and time badges, and price-line pills. Defaults to white, which reads
+     * against the saturated fills those badges use on a dark theme; light themes
+     * generally want a dark value here.
+     */
+    badgeText?: VroomColor;
     /** Crosshair dashed lines. */
     crosshair?: VroomColor;
     /** Crosshair target — the hollow ring/dot at the intersection. */
@@ -134,6 +141,26 @@ type VroomTheme = {
      * continuously — leave it off for charts that should be able to go idle.
      */
     lineTipPulse?: boolean;
+    /**
+     * Show the price (y) axis strip down the right edge. Defaults to `true`.
+     *
+     * Hiding it collapses the strip and hands the reclaimed width to the plot, so
+     * the candles widen to fill it. Its contents — price labels, the current-price
+     * badge, the crosshair price badge, price-line axis badges — fade out ahead of
+     * the collapse; gridlines and the price indicator's dotted line stay. Animated
+     * over `transitionMs` unless the OS asks for reduced motion.
+     *
+     * The axis drag-to-scale region goes with the strip, so a hidden axis can't be
+     * scaled by dragging it.
+     */
+    showYAxis?: boolean;
+    /**
+     * Show the time (x) axis strip along the bottom. Defaults to `true`.
+     *
+     * Behaves like {@link VroomTheme.showYAxis}: the strip collapses, the plot
+     * grows into it, and the time labels and crosshair time badge fade first.
+     */
+    showXAxis?: boolean;
 };
 /** A time window over the candle data, as Unix epoch milliseconds. */
 type VisibleRange = {