@wick-charts/vue 0.6.1 → 0.6.3

package/dist/core/dist/series/scale-stack.js

@@ -0,0 +1,25 @@
+class r {
+  #i;
+  /** Drawn top edge so far — starts at the plot floor when 0 has no place on the axis. */
+  #s;
+  /** Data value the stack so far stands for; trails `#edge` while a floor stand-in fades out. */
+  #t = 0;
+  constructor(s) {
+    this.#i = s, this.#s = s.baselineValue();
+  }
+  get edge() {
+    return this.#s;
+  }
+  /** Stacks `weight` of `value` (weight in `[0, 1]`) and returns the new top edge. */
+  push(s, i) {
+    if (s === 0) return this.#s;
+    const t = this.#t + s;
+    if (i === 1)
+      return this.#s = t, this.#t = t, t;
+    const h = this.#i.lerpValue(this.#s, t, i);
+    return this.#t = h - (this.#s - this.#t) * (1 - i), this.#s = h, h;
+  }
+}
+export {
+  r as ScaleStack
+};

package/dist/core/dist/tooltip-position.js

@@ -1,10 +1,10 @@
-function s(m) {
-  const { x: t, y: o, chartWidth: n, chartHeight: f, tooltipWidth: a, tooltipHeight: h, offsetX: i = 16, offsetY: e = 16 } = m, p = t + i + a > n ? t - i - a : t + i, x = o + e + h > f ? o - e - h : o + e, c = Math.max(0, n - a), r = Math.max(0, f - h);
+function c(f) {
+  const { y: t, chartLeft: m = 0, chartWidth: n, chartHeight: p, tooltipWidth: o, tooltipHeight: a, offsetX: h = 16, offsetY: i = 16 } = f, e = f.x - m, r = e + h + o > n ? e - h - o : e + h, x = t + i + a > p ? t - i - a : t + i, M = Math.max(0, n - o), s = Math.max(0, p - a);
   return {
-    left: Math.max(0, Math.min(c, p)),
-    top: Math.max(0, Math.min(r, x))
+    left: m + Math.max(0, Math.min(M, r)),
+    top: Math.max(0, Math.min(s, x))
   };
 }
 export {
-  s as computeTooltipPosition
+  c as computeTooltipPosition
 };

package/dist/core/dist/utils/pixel-grid.js

@@ -0,0 +1,10 @@
+function r(n) {
+  return Math.max(1, Math.round(n));
+}
+function t(n) {
+  return r(n) % 2 === 1 ? 0.5 : 0;
+}
+export {
+  t as crispCenterOffset,
+  r as crispLineWidth
+};

package/dist/index.d.ts

@@ -268,7 +268,7 @@ declare type __VLS_Props_3 = {
      * change, use `viewport.initialRange` instead.
      */
     visibleRange?: VisibleRangeSpec;
-    /** Show the chart background gradient. Live. Defaults to true. */
+    /** Show the chart background gradient. Live. Defaults to false. */
     gradient?: boolean;
     /**
      * Enable zoom, pan, and crosshair interactions. Defaults to true.
@@ -285,16 +285,20 @@ declare type __VLS_Props_3 = {
      * Soft fade-out at the top of the plot area, so series content dissolves
      * under a floating `<Title>` / `<InfoBar>` instead of colliding with it.
      * The mask erases canvas alpha rather than painting a cover color, so it
-     * stays correct over the default background gradient. Live.
+     * stays correct over a background gradient. Live.
      *
      * Two directions, independently controlled:
      *
      * **X (under the axis)** — panning content slides under the Y-axis
      * column and dissolves instead of hard-clipping at the pane edge. **On
      * by default** as a 60px ramp that finishes just inside the axis
-     * column, before the label glyphs; `{ right }` overrides the total
-     * ramp width in CSS px (`0` disables). `{ left }` adds the mirror zone
-     * at the left pane edge (default off).
+     * column, before the label glyphs — on whichever side
+     * `axis.y.position` puts it (a left-axis ramp ends at the pane edge
+     * instead). The axis side's key (`{ right }` by default, `{ left }` for
+     * a left axis) overrides the total ramp width in CSS px (`0` disables);
+     * the other key adds a plain zone at the opposite pane edge (default
+     * off). A chart with only pie / heatmap series has no axis column, so
+     * both keys add plain zones there.
      *
      * **Top (under the header)** — opt-in. `true` enables the auto zone
      * (measured header + 24px run-out, half the header fold-in released so
@@ -760,6 +764,15 @@ export declare interface AnimationsConfig {
          * @default {@link DEFAULT_TICKS_MS}
          */
         ticks?: AnimationTime;
+        /**
+         * Gridline layer opacity: the opening reveal on first paint and the
+         * fade out when `grid.visible` flips off. Independent of
+         * {@link ticks}, which owns the per-tick cross-fade on relabel.
+         * `false` makes the grid appear and disappear instantly.
+         *
+         * @default {@link DEFAULT_GRID_MS}
+         */
+        grid?: AnimationTime;
     };
     /**
      * Series-visibility toggle duration. Drives BOTH the renderer's alpha
@@ -1071,8 +1084,9 @@ export declare interface BarIntroDirectives {
         fromX?: number;
         toX?: number;
     };
-    /** Per-value transform applied before geometry and stacking. Scaling the
-     *  value grows the bar from the baseline on every render path. */
+    /** Per-value transform applied before geometry. Moving the value from
+     *  `frame.baseline` grows the bar on every render path. A stack applies it
+     *  to each segment before stacking, or to each drawn edge on a non-linear axis. */
     value?: (args: BarIntroValueArgs) => number;
     /** Per-bar transform applied after the geometry is resolved. */
     element?: (el: BarIntroElement) => BarElementTransform;
@@ -1100,6 +1114,14 @@ export declare type BarIntroFn = (frame: BarIntroFrame) => BarIntroDirectives;
 export declare interface BarIntroFrame extends WaveIntroFrame {
     /** Time → bitmap X through the live time scale. */
     timeToX(time: number): number;
+    /** The value bars grow from: `0`, or the plot floor's value on a scale with no place for 0 (log). */
+    baseline: number;
+    /**
+     * The value `t` of the way from `from` to `to` on the Y axis — a plain lerp
+     * on a linear axis, a geometric one on log. Grow bars through this: a bare
+     * `value * t` stays below a log axis's floor for most of the intro.
+     */
+    lerpValue(from: number, to: number, t: number): number;
 }
 
 /** Arguments handed to {@link BarIntroDirectives.value} for every rendered value. */
@@ -1864,7 +1886,20 @@ export declare class ChartInstance extends EventEmitter<ChartEvents> implements
     readonly timeScale: XScale;
     /** Maps price/value to vertical pixel coordinates. */
     readonly yScale: YScale;
+    /** CSS px of the Y-axis column. The default collapses to `0` on a spatial-only chart. */
     get yAxisWidth(): number;
+    /** Side of the plot area the Y-axis column sits on. */
+    get yAxisPosition(): YAxisPosition;
+    /**
+     * Left edge of the plot area in container CSS px — the Y-axis width when
+     * the axis sits on the left, `0` otherwise. Scales map into the plot area,
+     * so add this to `timeScale.timeToX()` to get a container coordinate.
+     */
+    get plotLeft(): number;
+    /** CSS px height of the floating Title / InfoBar header, `0` without one. A left
+     *  axis shares its column with it, so tick labels fade out underneath. */
+    get headerHeight(): number;
+    /** CSS px of the time-axis row. The default collapses to `0` on a spatial-only chart. */
     get xAxisHeight(): number;
     constructor(container: HTMLElement, options?: ChartOptions);
     /**
@@ -2284,6 +2319,9 @@ export declare class ChartInstance extends EventEmitter<ChartEvents> implements
      * the next render frame.
      */
     setFade(fade: ChartOptions['fade']): void;
+    /** Report the floating header's height (see {@link headerHeight}). The
+     *  framework wrappers keep it in sync with the measured Title / InfoBar. */
+    setHeaderHeight(height: number): void;
     /**
      * Set the visual state for one side of the chart. Typically called in
      * response to the `onEdgeReached` callback:
@@ -2359,8 +2397,10 @@ export declare class ChartInstance extends EventEmitter<ChartEvents> implements
 
 /** Layout metrics describing the chart area, Y axis, and time axis sizes. */
 export declare interface ChartLayout {
+    /** Plot area in container CSS px — `x` is the Y-axis width when the axis sits on the left. */
     chartArea: Rect;
     yAxisWidth: number;
+    yAxisPosition: YAxisPosition;
     xAxisHeight: number;
 }
 
@@ -2428,11 +2468,11 @@ export declare interface ChartOptions {
      * Soft alpha fade applied at the edges of the plot area. Anything the main
      * layer draws inside a zone (series, grid, time-region bands) dissolves to
      * transparent as it approaches the edge: horizontally sliding under the
-     * Y-axis labels on the right (`right`, **on by default**), toward a
-     * floating Title / InfoBar at the top (`top`), or out the left edge
-     * (`left`). The mask *erases* pixels rather than painting a cover color,
+     * Y-axis labels (the axis side, **on by default**), toward a floating
+     * Title / InfoBar at the top (`top`), or out the edge opposite the axis.
+     * The mask *erases* pixels rather than painting a cover color,
      * so it stays correct over any container background — including the
-     * default CSS gradient. Live — `chart.setFade()` updates it after
+     * optional CSS gradient. Live — `chart.setFade()` updates it after
      * construction.
      */
     fade?: FadeConfig;
@@ -2809,18 +2849,30 @@ declare interface FadeConfig {
      *  area. `0` / omitted disables the mask. */
     top?: number;
     /**
-     * Total width in CSS pixels of the horizontal dissolve at the right edge.
-     * The ramp finishes just inside the Y-axis column — 12px past the pane
-     * edge, before the right-anchored label glyphs start — so content melts
-     * on approach (pan / tail-scroll exit) and is fully gone before it can
-     * cross any axis text; the rest of the width runs backward into the pane
-     * as a soft lead-in. **Defaults to a 60px ramp** — on out of the box;
+     * Width in CSS pixels of the horizontal dissolve at the right edge.
+     *
+     * On the Y-axis side (the default `axis.y.position`) this is the total
+     * width of a ramp that finishes just inside the axis column — 12px past
+     * the pane edge, before the label glyphs start — so content melts on
+     * approach (pan / tail-scroll exit) and is fully gone before it can cross
+     * any axis text; the rest of the width runs backward into the pane as a
+     * soft lead-in. **Defaults to a 60px ramp** there — on out of the box;
      * `0` disables. A no-op while the Y axis is hidden.
+     *
+     * On the side opposite the axis it's a plain zone at the pane edge —
+     * content leaving the plot dissolves instead of hard-clipping at the
+     * canvas boundary. Off by default.
+     *
+     * A chart whose series are all spatial (pie, heatmap) has no axis column,
+     * so both sides take the plain zone, off by default.
      */
     right?: number;
-    /** Fade-zone width in CSS pixels at the left pane edge — content panning
-     *  out to the left dissolves instead of hard-clipping at the canvas
-     *  boundary. `0` / omitted disables. */
+    /**
+     * Width in CSS pixels of the horizontal dissolve at the left edge. Same
+     * rules as {@link right}, except that with `axis.y.position: 'left'` the
+     * ramp (60px by default) finishes at the pane edge rather than under the
+     * column: data scrolls out through the left edge and isn't drawn past it.
+     */
     left?: number;
 }
 
@@ -3137,11 +3189,20 @@ export declare interface LineIntroFrame {
     xToTime(x: number): number;
     /** Value → bitmap Y through the live Y scale. */
     valueToY(value: number): number;
+    /**
+     * The value `t` of the way from `from` to `to` on the Y axis — a plain lerp
+     * on a linear axis, a geometric one on log. Move values through this, or a
+     * log axis bunches the motion at one end and overshoots past 0.
+     */
+    lerpValue(from: number, to: number, t: number): number;
     /** Number of layers in the series. */
     layerCount: number;
     /** Visible data of one layer (memoized per frame). */
     layerData(layerIndex: number): readonly TimePoint[];
-    /** Mean of the layer's visible finite values, or `null` for an empty/poisoned layer (memoized per frame). */
+    /**
+     * Mean of the layer's visible plottable values, taken on the Y axis (the
+     * geometric mean on log), or `null` for an empty/poisoned layer (memoized per frame).
+     */
     layerMean(layerIndex: number): number | null;
     /**
      * Bitmap-space polyline of the first visible layer (finite values only,
@@ -3478,6 +3539,24 @@ export declare interface LoadingIndicatorArgs {
 /** Pure function contract for a pluggable loading indicator. */
 export declare type LoadingIndicatorFn = (args: LoadingIndicatorArgs) => void;
 
+/**
+ * Logarithmic Y scale for `axis.y.scale`: each power of the base gets the same
+ * height. Ticks sit on powers of the base, thinned when they crowd and — for
+ * base 10 — with 2× / 5× steps when a decade has room; a range too narrow to
+ * catch a power falls back to linear ticks. Values ≤ 0 have no position.
+ *
+ * Tree-shakeable: charts that never call it don't ship the log code.
+ */
+export declare function logScale(options?: LogScaleOptions): YScaleTransform;
+
+export declare interface LogScaleOptions {
+    /**
+     * Base whose powers carry the ticks. The mapping itself is the same for
+     * every base — only tick placement changes. Default: 10.
+     */
+    base?: number;
+}
+
 export declare const Marker: DefineComponent<__VLS_Props_10, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_10> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
 
 /**
@@ -3612,8 +3691,9 @@ export declare interface NavigatorCandlePoint {
  * left handle, right handle. The overlay is purely visual; pointer input is
  * captured on the canvas and hit-tested against the current window geometry.
  *
- * Both layers reserve `chart.yAxisWidth` on the right so the navigator's
- * active zone aligns with the main chart's plot area (matches the TimeAxis).
+ * Both layers reserve `chart.yAxisWidth` on the Y-axis side so the
+ * navigator's active zone aligns with the main chart's plot area (matches
+ * the TimeAxis).
  *
  * Event topology — navigator is a pure listener on the chart side, never emits:
  *   chart.viewportChange → reposition window DOM on next frame (canvas untouched)
@@ -3770,6 +3850,12 @@ declare interface PanZoomTarget {
      * chart keeps working. Targets that omit the hook are always pan/zoomable.
      */
     canPanZoom?(): boolean;
+    /**
+     * Left edge of the plot area in canvas CSS px — nonzero when the Y axis
+     * sits on the left. Pointer offsets subtract it before mapping through the
+     * time scale. Omitted means `0`.
+     */
+    readonly plotLeft?: number;
 }
 
 /**
@@ -4346,6 +4432,24 @@ export declare function sampleRamp(stops: readonly string[], t: number): string;
 
 export declare const sandDune: ThemePreset;
 
+/** What a {@link YScaleTransform.ticks} generator is asked to fill. */
+export declare interface ScaleTickArgs {
+    /** Visible value range. Both bounds are plottable on the scale. */
+    min: number;
+    max: number;
+    /** Plot height in CSS pixels. */
+    height: number;
+    /** Minimum pixel gap between adjacent labels. */
+    minSpacing: number;
+    /** Desired label count from `<YAxis labelCount>`, or `null`. */
+    labelCount: number | null;
+    /**
+     * Linear {1,2,5}×10^k ticks already spaced for this mapping (with the axis's
+     * anti-flicker hold). Return this array itself to keep them.
+     */
+    linear: readonly number[];
+}
+
 /** Environment the chart hands a {@link SeriesDefinition} when constructing its renderer. */
 export declare interface SeriesCreateEnv {
     /** Active chart theme — definitions read their default colours from it. */
@@ -4729,11 +4833,18 @@ export declare interface TimeSeriesRenderer extends BaseSeriesRenderer {
     sampleTimes(maxCount: number): number[];
     /** Visible points in `[from, to]` (layer 0 for multi-layer). */
     getVisibleDataPoints(from: number, to: number): readonly (OHLCData | TimePoint)[];
-    /** Effective min/max for auto-range (stacked totals for multi-layer; raw min/max otherwise). */
-    getValueRange(from: number, to: number): {
+    /**
+     * Effective min/max for auto-range (stacked totals for multi-layer; raw
+     * min/max otherwise). With `opts.plottable` (a non-linear Y scale) values
+     * it rejects are left out, so the range covers only what the scale can
+     * place; `null` when nothing plottable is in view.
+     */
+    getValueRange(from: number, to: number, opts?: ValueRangeOptions): {
         min: number;
         max: number;
     } | null;
+    /** Stacking mode of a multi-layer series — the chart rejects `'percent'` on a Y scale with no 0. */
+    readonly stacking?: StackingMode;
 }
 
 /** Custom tick-value generator — replaces the built-in `niceTimeIntervals` tier resolution entirely when installed. */
@@ -4772,10 +4883,16 @@ export declare interface TooltipPosition {
  * time-series, full media size for pie).
  */
 export declare interface TooltipPositionArgs {
-    /** Cursor or anchor x in CSS pixels, relative to the chart area origin. */
+    /** Cursor or anchor x in CSS pixels, relative to the overlay container. */
     x: number;
     /** Cursor or anchor y in CSS pixels, relative to the chart area origin. */
     y: number;
+    /**
+     * Left edge of the plot area in the same space as `x` — `chart.plotLeft`
+     * for a time-series tooltip, so it stays clear of a left-side Y axis.
+     * The result is in that space too. Default `0`.
+     */
+    chartLeft?: number;
     /** Plot-area width in CSS pixels. */
     chartWidth: number;
     /** Plot-area height in CSS pixels. */
@@ -4937,6 +5054,12 @@ declare type ValueColor = string | ((value: number) => string);
 /** Signature for a value-to-string formatter (YAxis, YLabel, Pie, Sparkline, NumberFlow). */
 export declare type ValueFormatter = (value: number) => string;
 
+/** Options for {@link TimeSeriesRenderer.getValueRange}. */
+declare interface ValueRangeOptions {
+    /** Whether a value has a position on the Y scale (e.g. `v > 0` on log); others are left out. */
+    plottable?: (value: number) => boolean;
+}
+
 /** Custom tick-value generator — replaces the built-in {1,2,5}×10^k resolution entirely when installed. */
 export declare type ValueTickGenerator = (range: YRange) => number[];
 
@@ -5027,7 +5150,7 @@ export declare function wipeIntro(): WaveIntroFn;
 
 /** Configuration for the X (time) axis. */
 export declare interface XAxisConfig {
-    /** Height in CSS pixels. Default: 30. */
+    /** Height in CSS pixels. Default: 30, or 0 when every series is spatial (pie, heatmap). */
     height?: number;
     /** Whether the axis is visible. Default: true. When false, height is treated as 0. */
     visible?: boolean;
@@ -5099,7 +5222,17 @@ export declare class XScale {
     formatX(timestamp: number, interval: number): string;
     private resetHysteresis;
     timeToX(time: number): number;
+    /** X in physical (bitmap) pixels, snapped to the pixel grid — for
+     *  axis-aligned edges that have to stay crisp. */
     timeToBitmapX(time: number): number;
+    /** Same in physical pixels, off the grid — see {@link YScale.valueToBitmapYExact}. */
+    timeToBitmapXExact(time: number): number;
+    /**
+     * X position in CSS pixels of the *stroke center* the canvas grid draws for
+     * `time`. DOM axis labels position off this instead of raw {@link timeToX}
+     * so text and gridline share one pixel grid.
+     */
+    timeToSnappedX(time: number): number;
     xToTime(x: number): number;
     pixelDeltaToTimeDelta(pixelDelta: number): number;
     barWidthMedia(dataInterval: number): number;
@@ -5130,8 +5263,26 @@ containerRef: HTMLDivElement;
 
 /** Configuration for the Y axis. */
 export declare interface YAxisConfig {
-    /** Width in CSS pixels. Default: 55. */
+    /**
+     * Side the axis column sits on — the plot area shifts right by the axis
+     * width when it's `'left'`. The default edge fade follows the axis to
+     * whichever side it's on. Default: 'right'.
+     */
+    position?: YAxisPosition;
+    /** Width in CSS pixels. Default: 55, or 0 when every series is spatial (pie, heatmap). */
     width?: number;
+    /**
+     * Value mapping. Omitted: linear. `logScale()` gives each power of ten equal
+     * height — for series spanning orders of magnitude; `logScale({ base: 2 })`
+     * puts the ticks on powers of two. Any {@link YScaleTransform} works.
+     *
+     * Autoscale and Y animations run in the scale's space. Values the scale
+     * can't place (≤ 0 on log) are skipped — a gap in a line, no bar or candle —
+     * a fixed `min` / `max` it can't place falls back to `'auto'`, and area
+     * fills close to the plot floor. Percent stacking is rejected when the
+     * scale has no position for 0. Live — a different scale refits the Y range.
+     */
+    scale?: YScaleTransform;
     /** Minimum bound. Default: 'auto'. */
     min?: AxisBound;
     /** Maximum bound. Default: 'auto'. */
@@ -5140,6 +5291,9 @@ export declare interface YAxisConfig {
     visible?: boolean;
 }
 
+/** Side of the plot area the Y axis column sits on. */
+export declare type YAxisPosition = 'left' | 'right';
+
 export declare const YLabel: __VLS_WithTemplateSlots_8<typeof __VLS_component_8, __VLS_TemplateResult_8["slots"]>;
 
 /**
@@ -5178,8 +5332,13 @@ export declare interface YRange {
 export declare class YScale {
     /** Shared fade state for Y ticks; see {@link TimeScale.tickTracker}. */
     readonly tickTracker: AxisTickTracker;
+    /** Non-linear value mapping (`axis.y.scale`); `null` is linear. */
+    private transform;
     private min;
     private max;
+    /** Domain bounds in scale space — `transform.forward` of `min` / `max`. */
+    private lo;
+    private hi;
     private height;
     private pixelRatio;
     private labelCountHintValue;
@@ -5196,6 +5355,8 @@ export declare class YScale {
      * the boundary doesn't instantly flip back.
      */
     private lastRawInterval;
+    /** The transform's own ticks (e.g. powers of ten); `null` while linear ticks are in use. */
+    private ownTicks;
     /** Custom formatter (driven by `<YAxis format=…>`). */
     private customFormat;
     /** Custom tick generator — bypasses {1,2,5}×10^k resolution in `niceTickValues` when set. */
@@ -5204,11 +5365,23 @@ export declare class YScale {
     private get minLabelSpacing();
     /** Recalculate the scale with a new Y range, chart height, and device pixel ratio. */
     update(range: YRange, mediaHeight: number, pixelRatio: number): void;
+    /** Install a non-linear value mapping, or `null` for linear. The range is kept as-is — the chart refits it. */
+    setTransform(transform: YScaleTransform | null): void;
+    getTransform(): YScaleTransform | null;
+    /**
+     * Whether `value` has a position on this scale: finite, and inside the
+     * transform's domain (positive on log). Renderers skip values that fail —
+     * {@link valueToY} still maps them (to the plot floor) so nothing
+     * downstream sees NaN.
+     */
+    isPlottable(value: number): boolean;
     /** Desired label count. Invalid values (NaN, <2, Infinity) clear the hint. */
     setLabelCount(n: number | null | undefined): void;
     /** Minimum pixel gap between adjacent labels. */
     setMinSpacing(px: number | null | undefined): void;
     private resetHysteresis;
+    /** A transformed domain needs both bounds plottable; anything else collapses to a flat one. */
+    private updateDomain;
     /** Install (or clear) a custom formatter. */
     setFormat(fn: ValueFormatter | null): void;
     /** Read back the currently installed formatter — null when the built-in is active. */
@@ -5219,17 +5392,43 @@ export declare class YScale {
      * with the current range.
      */
     setTickGenerator(fn: ValueTickGenerator | null): void;
-    /** Convert a value to a Y position in CSS (media) pixels. */
+    /**
+     * Convert a value to a Y position in CSS (media) pixels. A value the
+     * transform can't place (≤ 0 on log) lands on the plot floor.
+     */
     valueToY(value: number): number;
-    /** Convert a value to a Y position in physical (bitmap) pixels. */
+    /** Convert a value to a Y position in physical (bitmap) pixels, snapped to
+     *  the pixel grid — for axis-aligned edges that have to stay crisp. */
     valueToBitmapY(value: number): number;
-    /** Convert a Y position in CSS pixels back to a value. */
+    /**
+     * Same in physical pixels, off the grid. Anti-aliased geometry reads this
+     * one: snapping buys a diagonal stroke no sharpness, and during a slow
+     * animation it quantises the motion into whole-pixel jumps.
+     */
+    valueToBitmapYExact(value: number): number;
+    /**
+     * Y position in CSS pixels of the *stroke center* the canvas grid draws for
+     * `value`. DOM axis labels position off this instead of raw {@link valueToY}
+     * so text and gridline share one pixel grid.
+     */
+    valueToSnappedY(value: number): number;
+    /** Convert a Y position in CSS pixels back to a value — the exact inverse of {@link valueToY}. */
     yToValue(y: number): number;
+    /** The value bars and stacks grow from: `0`, or the plot floor's value on a scale with no place for 0 (log). */
+    baselineValue(): number;
+    /**
+     * The value `t` of the way from `from` to `to` in pixels — a plain lerp on a
+     * linear axis, a geometric one on log. `t` past `[0, 1]` overshoots along the
+     * axis. An endpoint the transform can't place returns `to`, so a gap stays a gap.
+     */
+    lerpValue(from: number, to: number, t: number): number;
     /**
      * Generate evenly spaced "nice" tick values for the current range and
      * chart height. Pure read — resolution happens in `update()`.
      */
     niceTickValues(): number[];
+    /** {1,2,5}×10^k ticks at the resolved interval, limited to what the transform can place. */
+    private linearTickValues;
     getRange(): YRange;
     getMediaHeight(): number;
     /**
@@ -5240,9 +5439,18 @@ export declare class YScale {
      * range happens to be < 1000.
      */
     formatY(value: number): string;
+    private resolveTicks;
+    /**
+     * Smallest linear interval whose ticks stay `minLabelSpacing` apart on the
+     * transformed axis. A monotonic mapping squeezes its gaps hardest at one
+     * end — the top for log (concave), the bottom for a convex one — so
+     * checking both ends covers it.
+     */
+    private transformedGapFloor;
     /**
      * Resolve the interval to a {1,2,5}×10^k tick size that satisfies the pixel
-     * floor and (optionally) targets `labelCountHint` labels.
+     * floor and (optionally) targets `labelCountHint` labels. `gapFloorValue` is
+     * the smallest interval that clears `minLabelSpacing` anywhere on the axis.
      *
      * Hysteresis: the band [0.8×, 1.25×] is anchored to **rawInterval at last
      * snap**, not to `lastInterval`. After an escalation (e.g. 100 → 200),
@@ -5255,4 +5463,43 @@ export declare class YScale {
     private countTicks;
 }
 
+/**
+ * A non-linear value mapping for the Y axis — pass one as `axis.y.scale`.
+ * `logScale()` is the built-in one; any monotonic mapping works, e.g. a
+ * square-root axis:
+ *
+ * ```ts
+ * const sqrtScale: YScaleTransform = {
+ *   forward: Math.sqrt,
+ *   inverse: (s) => s * s,
+ *   isPlottable: (v) => v >= 0,
+ * };
+ * ```
+ *
+ * Everything vertical runs in the transformed space: pixel positions,
+ * autoscale padding and the Y animations. Keep the object stable — define it
+ * outside a component, since a new object means a new scale and resets the
+ * Y range.
+ */
+export declare interface YScaleTransform {
+    /** Value → scale space. Must be strictly increasing over the plottable values. */
+    forward(value: number): number;
+    /** Scale space → value; the exact inverse of {@link forward}. */
+    inverse(scaled: number): number;
+    /**
+     * Whether a finite value has a position on this scale — one contiguous
+     * interval, e.g. `v > 0` for log. Values that fail are skipped: a gap in a
+     * line, no bar or candle, left out of autoscale. Default: every finite value.
+     */
+    isPlottable?(value: number): boolean;
+    /**
+     * The scale's own tick values (e.g. powers of ten), or `args.linear` to keep
+     * the linear ticks — say, on a range too narrow for its own. Omitted: linear
+     * ticks, spaced so the tightest gap on this mapping clears `minSpacing`.
+     */
+    ticks?(args: ScaleTickArgs): readonly number[];
+    /** Label format while the scale's own ticks are in use. Default: the linear formatter. */
+    format?(value: number): string;
+}
+
 export { }