@wick-charts/vue 0.6.4 → 0.8.0

package/dist/composables.js

@@ -1,57 +1,67 @@
-import { ref as u, onMounted as a, onUnmounted as l } from "vue";
-function x(e) {
-  const o = u(e.getVisibleRange()), n = () => {
-    o.value = e.getVisibleRange();
+import { ref as l, onMounted as u, onUnmounted as a } from "vue";
+function A(e) {
+  const n = l(e.getVisibleRange()), i = () => {
+    n.value = e.getVisibleRange();
   };
-  return a(() => e.on("viewportChange", n)), l(() => e.off("viewportChange", n)), o;
+  return u(() => e.on("viewportChange", i)), a(() => e.off("viewportChange", i)), n;
 }
 function d(e) {
-  const o = u(e.getYRange()), n = () => {
-    o.value = e.getYRange();
+  const n = l(e.getYRange()), i = () => {
+    n.value = e.getYRange();
   };
-  return a(() => e.on("viewportChange", n)), l(() => e.off("viewportChange", n)), o;
+  return u(() => e.on("viewportChange", i)), a(() => e.off("viewportChange", i)), n;
 }
 function r(e) {
-  return { yAxisPosition: e.yAxisPosition, yAxisWidth: e.yAxisWidth, xAxisHeight: e.xAxisHeight };
+  return {
+    yAxisPosition: e.yAxisPosition,
+    yAxisWidth: e.yAxisWidth,
+    xAxisHeight: e.xAxisHeight,
+    leftAxisWidth: e.getAxisColumnWidth("left"),
+    rightAxisWidth: e.getAxisColumnWidth("right"),
+    leftAxisScale: e.getAxisColumnScale("left"),
+    rightAxisScale: e.getAxisColumnScale("right")
+  };
 }
-function p(e) {
-  const o = u(r(e)), n = () => {
-    const i = r(e), s = o.value;
-    s.yAxisPosition === i.yAxisPosition && s.yAxisWidth === i.yAxisWidth && s.xAxisHeight === i.xAxisHeight || (o.value = i);
+function h(e) {
+  const n = l(r(e)), i = () => {
+    const t = r(e), o = n.value;
+    o.yAxisPosition === t.yAxisPosition && o.yAxisWidth === t.yAxisWidth && o.xAxisHeight === t.xAxisHeight && o.leftAxisWidth === t.leftAxisWidth && o.rightAxisWidth === t.rightAxisWidth && o.leftAxisScale === t.leftAxisScale && o.rightAxisScale === t.rightAxisScale || (n.value = t);
   };
-  return a(() => {
-    n(), e.on("viewportChange", n);
-  }), l(() => e.off("viewportChange", n)), o;
+  return u(() => {
+    i(), e.on("viewportChange", i);
+  }), a(() => e.off("viewportChange", i)), n;
 }
-function A(e, o) {
-  let n = e.getLastValue(o), i = n ? e.yScale.valueToY(n.value) : null;
-  const s = u(n), g = () => {
-    const t = e.getLastValue(o), v = t ? e.yScale.valueToY(t.value) : null;
-    n?.value === t?.value && n?.isLive === t?.isLive && i === v || (n = t, i = v, s.value = t);
+function p(e, n) {
+  let i = e.getLastValue(n);
+  const t = () => e.getYScale(e.getSeriesScale(n));
+  let o = i ? t().valueToY(i.value) : null;
+  const x = l(i), g = () => {
+    const s = e.getLastValue(n), f = s ? t().valueToY(s.value) : null;
+    i?.value === s?.value && i?.isLive === s?.isLive && o === f || (i = s, o = f, x.value = s);
   };
-  return a(() => {
+  return u(() => {
     e.on("dataUpdate", g), e.on("viewportChange", g);
-  }), l(() => {
+  }), a(() => {
     e.off("dataUpdate", g), e.off("viewportChange", g);
-  }), s;
+  }), x;
 }
-function C(e, o) {
-  const n = u(e.getPreviousClose(o)), i = () => {
-    n.value = e.getPreviousClose(o);
+function C(e, n) {
+  const i = l(e.getPreviousClose(n)), t = () => {
+    i.value = e.getPreviousClose(n);
   };
-  return a(() => e.on("dataUpdate", i)), l(() => e.off("dataUpdate", i)), n;
+  return u(() => e.on("dataUpdate", t)), a(() => e.off("dataUpdate", t)), i;
 }
-function y(e) {
-  const o = u(e.getCrosshairPosition()), n = () => {
-    o.value = e.getCrosshairPosition();
+function c(e) {
+  const n = l(e.getCrosshairPosition()), i = () => {
+    n.value = e.getCrosshairPosition();
   };
-  return a(() => e.on("crosshairMove", n)), l(() => e.off("crosshairMove", n)), o;
+  return u(() => e.on("crosshairMove", i)), a(() => e.off("crosshairMove", i)), n;
 }
 export {
-  p as useAxisLayout,
-  y as useCrosshairPosition,
-  A as useLastYValue,
+  h as useAxisLayout,
+  c as useCrosshairPosition,
+  p as useLastYValue,
   C as usePreviousClose,
-  x as useVisibleRange,
+  A as useVisibleRange,
   d as useYRange
 };

package/dist/core/dist/animation/viewport-engine.js

@@ -1,31 +1,63 @@
-class g {
-  #t;
+class c {
   #i;
-  #r;
-  #e;
-  #g;
+  /** Y slots of the named scales, keyed by scale id. */
+  #s = /* @__PURE__ */ new Map();
+  #u;
+  #t;
+  #a;
+  #h;
+  #m;
   /** Per-frame `animating` snapshot — updated by `tick` so `get animating()`
    *  is O(1). Spans both axes; lives at the engine root rather than in
    *  XState/YState because it's a cross-axis flag. */
-  #s = !1;
+  #n = !1;
   constructor(t) {
-    this.#t = {
-      transition: t.y.curve({ initial: t.initial.yRange }),
-      settleMs: t.y.settleMs,
-      stickyMs: t.y.stickyMs,
-      stickyFloorMs: t.y.stickyFloorMs,
-      gestureMs: t.y.gestureMs,
-      toggleMs: t.y.toggleMs,
-      toggleUntil: 0
-    }, this.#i = {
+    this.#u = t.y, this.#i = this.#f({ initial: t.initial.yRange, primed: !0 }), this.#t = {
       transition: t.x.curve({ initial: t.initial.xRange }),
       settleMs: t.x.settleMs,
       gestureMs: t.x.gestureMs,
       lastTarget: null,
       gestureUntil: 0
-    }, this.#r = t.computeXTarget, this.#e = t.computeYTarget, this.#g = t.onWake;
+    }, this.#a = t.computeXTarget, this.#h = t.computeYTarget, this.#m = t.onWake;
   }
   // --- Helpers -------------------------------------------------------------
+  #f(t) {
+    const s = this.#u;
+    return {
+      transition: s.curve({ initial: t.initial }),
+      settleMs: s.settleMs,
+      stickyMs: s.stickyMs,
+      stickyFloorMs: s.stickyFloorMs,
+      gestureMs: s.gestureMs,
+      toggleMs: s.toggleMs,
+      toggleUntil: 0,
+      primed: t.primed
+    };
+  }
+  /** Every Y slot with the target the chart computes for it against `xTarget`. */
+  #r(t) {
+    const s = [{ y: this.#i, target: this.#h({ xTarget: t }) }];
+    for (const [i, e] of this.#s)
+      s.push({ y: e, target: this.#h({ xTarget: t, scale: i }) });
+    return s;
+  }
+  /** Ease a Y slot to `target` — or snap, when it's the slot's first target. */
+  #g(t, s, i) {
+    if (!t.primed) {
+      this.#o(t, s, i.now);
+      return;
+    }
+    t.transition.retarget(s, i);
+  }
+  #o(t, s, i) {
+    t.transition.snap(s, { now: i }), t.primed = !0;
+  }
+  #M() {
+    if (this.#i.transition.animating) return !0;
+    for (const t of this.#s.values())
+      if (t.transition.animating) return !0;
+    return !1;
+  }
   /**
    * Retarget X and record `#x.lastTarget` — autoscroll consults that field for
    * the logical destination, not the in-flight visual.
@@ -34,15 +66,15 @@ class g {
    * (fast — responsive feel) while stream ticks pass `#x.settleMs` (the
    * cadence-tuned baseline).
    */
-  #a(t, s, i) {
-    this.#i.transition.retarget(t, { now: s, expandMs: i }), this.#i.lastTarget = { from: t.from, to: t.to };
+  #l(t, s, i) {
+    this.#t.transition.retarget(t, { now: s, expandMs: i }), this.#t.lastTarget = { from: t.from, to: t.to };
   }
-  #o(t, s) {
-    this.#i.transition.snap({ from: t.from, to: t.to }, { now: s }), this.#i.lastTarget = { from: t.from, to: t.to };
+  #c(t, s) {
+    this.#t.transition.snap({ from: t.from, to: t.to }, { now: s }), this.#t.lastTarget = { from: t.from, to: t.to };
   }
   /** Fire `onWake` once when an idle engine receives a new retarget. */
-  #n(t) {
-    t && this.#g?.();
+  #e(t) {
+    t && this.#m?.();
   }
   /**
    * Magnitude-scaled inward (sticky) settle time. The configured `stickyMs`
@@ -60,115 +92,142 @@ class g {
    * contracts. `stickyFloorMs === stickyMs` collapses this back to a fixed
    * duration.
    */
-  #h(t, s) {
-    const i = this.#t.stickyMs;
-    if (i <= 0) return i;
-    const n = Math.max(t.max - t.min, Number.EPSILON), e = Math.max(0, s.min - t.min), r = Math.max(0, t.max - s.max), a = Math.min(1, Math.max(e, r) / n), h = Math.min(this.#t.stickyFloorMs, i);
-    return Math.max(h, i * a);
+  #p(t, s) {
+    const i = t.transition.current, e = t.stickyMs;
+    if (e <= 0) return e;
+    const n = Math.max(i.max - i.min, Number.EPSILON), r = Math.max(0, s.min - i.min), o = Math.max(0, i.max - s.max), a = Math.min(1, Math.max(r, o) / n), h = Math.min(t.stickyFloorMs, e);
+    return Math.max(h, e * a);
   }
   // --- Inputs --------------------------------------------------------------
   onPointAppended(t) {
     const s = t ?? performance.now();
-    if (s < this.#i.gestureUntil) return;
-    const i = this.#r(), n = i ?? this.#i.transition.target, e = this.#e({ xTarget: n });
-    if (i === null && e === null) return;
-    const r = !this.#s, a = s < this.#t.toggleUntil;
-    i !== null && this.#a(i, s, this.#i.settleMs), e !== null && !a && this.#t.transition.retarget(e, {
-      now: s,
-      expandMs: this.#t.settleMs,
-      contractMs: this.#h(this.#t.transition.current, e)
-    }), this.#n(r);
+    if (s < this.#t.gestureUntil) return;
+    const i = this.#a(), e = i ?? this.#t.transition.target, n = this.#r(e), r = n.some((a) => a.target !== null);
+    if (i === null && !r) return;
+    const o = !this.#n;
+    i !== null && this.#l(i, s, this.#t.settleMs);
+    for (const { y: a, target: h } of n) {
+      const l = s < a.toggleUntil;
+      h === null || l || this.#g(a, h, {
+        now: s,
+        expandMs: a.settleMs,
+        contractMs: this.#p(a, h)
+      });
+    }
+    this.#e(o);
   }
   onSeriesVisibilityChanged(t) {
-    const s = this.#e({ xTarget: this.#i.transition.target });
-    if (s === null) return;
-    const i = t ?? performance.now(), n = !this.#s;
-    this.#t.toggleMs > 0 ? (this.#t.transition.snap(this.#t.transition.current, { now: i }), this.#t.transition.retarget(s, {
-      now: i,
-      expandMs: this.#t.toggleMs,
-      contractMs: this.#t.toggleMs
-    }), this.#t.toggleUntil = i + this.#t.toggleMs) : (this.#t.transition.snap(s, { now: i }), this.#t.toggleUntil = 0), this.#n(n);
+    const s = this.#r(this.#t.transition.target);
+    if (s.every((n) => n.target === null)) return;
+    const i = t ?? performance.now(), e = !this.#n;
+    for (const { y: n, target: r } of s)
+      r !== null && (n.toggleMs > 0 && n.primed ? (n.transition.snap(n.transition.current, { now: i }), n.transition.retarget(r, {
+        now: i,
+        expandMs: n.toggleMs,
+        contractMs: n.toggleMs
+      }), n.toggleUntil = i + n.toggleMs) : (this.#o(n, r, i), n.toggleUntil = 0));
+    this.#e(e);
   }
   onPanZoom(t, s) {
-    const i = s ?? performance.now(), n = !this.#s;
-    if (this.#a(t.xTarget, i, this.#i.gestureMs), this.#i.gestureUntil = i + 100, t.yAuto) {
-      const e = this.#e({ xTarget: t.xTarget });
-      e !== null && this.#t.transition.retarget(e, {
-        now: i,
-        expandMs: this.#t.gestureMs,
-        contractMs: this.#t.gestureMs
-      });
-    }
-    this.#n(n);
+    const i = s ?? performance.now(), e = !this.#n;
+    if (this.#l(t.xTarget, i, this.#t.gestureMs), this.#t.gestureUntil = i + 100, t.yAuto)
+      for (const { y: n, target: r } of this.#r(t.xTarget))
+        r !== null && this.#g(n, r, {
+          now: i,
+          expandMs: n.gestureMs,
+          contractMs: n.gestureMs
+        });
+    this.#e(e);
   }
   onAxisReconfig(t) {
-    const s = this.#e({ xTarget: this.#i.transition.target });
-    if (s === null) return;
-    const i = t ?? performance.now(), n = !this.#s;
-    this.#t.transition.snap(s, { now: i }), this.#n(n);
+    const s = this.#r(this.#t.transition.target);
+    if (s.every((n) => n.target === null)) return;
+    const i = t ?? performance.now(), e = !this.#n;
+    for (const { y: n, target: r } of s)
+      r !== null && this.#o(n, r, i);
+    this.#e(e);
   }
   onProgrammaticZoom(t, s) {
-    this.#i.gestureUntil = 0;
-    const i = this.#e({ xTarget: t.xTarget }), n = s ?? performance.now(), e = !this.#s;
-    if (t.xEase === !0) {
-      this.#a(t.xTarget, n, this.#i.gestureMs), i !== null && this.#t.transition.retarget(i, {
-        now: n,
-        expandMs: this.#t.settleMs,
-        contractMs: this.#h(this.#t.transition.current, i)
-      }), this.#n(e);
-      return;
-    }
-    this.#o(t.xTarget, n), i !== null && this.#t.transition.retarget(i, {
-      now: n,
-      expandMs: this.#t.settleMs,
-      contractMs: this.#h(this.#t.transition.current, i)
-    }), this.#n(e);
+    this.#t.gestureUntil = 0;
+    const i = this.#r(t.xTarget), e = s ?? performance.now(), n = !this.#n;
+    t.xEase === !0 ? this.#l(t.xTarget, e, this.#t.gestureMs) : this.#c(t.xTarget, e);
+    for (const { y: r, target: o } of i)
+      o !== null && this.#g(r, o, {
+        now: e,
+        expandMs: r.settleMs,
+        contractMs: this.#p(r, o)
+      });
+    this.#e(n);
   }
   onDataReplaced(t) {
-    const s = this.#r(), i = this.#e({ xTarget: s ?? this.#i.transition.target });
-    if (s === null && i === null) return;
-    const n = t ?? performance.now(), e = !this.#s;
-    s !== null && this.#o(s, n), i !== null && this.#t.transition.snap(i, { now: n }), this.#n(e);
+    const s = this.#a(), i = this.#r(s ?? this.#t.transition.target), e = i.some((o) => o.target !== null);
+    if (s === null && !e) return;
+    const n = t ?? performance.now(), r = !this.#n;
+    s !== null && this.#c(s, n);
+    for (const { y: o, target: a } of i)
+      a !== null && this.#o(o, a, n);
+    this.#e(r);
   }
   snap(t, s) {
-    this.#i.gestureUntil = 0;
-    const i = s ?? performance.now(), n = !this.#s;
-    t.x !== void 0 && this.#o(t.x, i), t.y !== void 0 && this.#t.transition.snap(t.y, { now: i }), this.#n(n);
+    this.#t.gestureUntil = 0;
+    const i = s ?? performance.now(), e = !this.#n;
+    t.x !== void 0 && this.#c(t.x, i), t.y !== void 0 && this.#o(this.#i, t.y, i);
+    for (const [n, r] of Object.entries(t.scales ?? {})) {
+      const o = this.#s.get(n);
+      o !== void 0 && this.#o(o, r, i);
+    }
+    this.#e(e);
+  }
+  /**
+   * Keep one Y slot per named scale: add slots for new ids (empty until their
+   * first target, which snaps) and drop slots for ids no longer listed.
+   */
+  setYScales(t) {
+    for (const s of this.#s.keys())
+      t.includes(s) || this.#s.delete(s);
+    for (const s of t)
+      this.#s.has(s) || this.#s.set(s, this.#f({ initial: { min: 0, max: 0 }, primed: !1 }));
   }
   // --- Outputs -------------------------------------------------------------
   tick(t) {
-    this.#i.transition.tick(t), this.#t.transition.tick(t);
-    const s = this.#i.transition.animating || this.#t.transition.animating;
-    return this.#s = s, {
-      xRange: this.#i.transition.current,
-      yRange: this.#t.transition.current,
+    this.#t.transition.tick(t), this.#i.transition.tick(t);
+    for (const i of this.#s.values())
+      i.transition.tick(t);
+    const s = this.#t.transition.animating || this.#M();
+    return this.#n = s, {
+      xRange: this.#t.transition.current,
+      yRange: this.#i.transition.current,
       animating: s
     };
   }
   getAnimationState() {
     return {
-      xRange: this.#i.transition.current,
-      yRange: this.#t.transition.current,
-      animating: this.#i.transition.animating || this.#t.transition.animating
+      xRange: this.#t.transition.current,
+      yRange: this.#i.transition.current,
+      animating: this.animating
     };
   }
+  /** Current (eased) Y of a named scale, `null` for an unknown id. */
+  getScaleYRange(t) {
+    return this.#s.get(t)?.transition.current ?? null;
+  }
   getTarget() {
-    return { x: this.#i.transition.target, y: this.#t.transition.target };
+    return { x: this.#t.transition.target, y: this.#i.transition.target };
   }
   get animating() {
-    return this.#i.transition.animating || this.#t.transition.animating;
+    return this.#t.transition.animating || this.#M();
   }
   get lastXTarget() {
-    return this.#i.lastTarget;
+    return this.#t.lastTarget;
   }
   setXSettleMs(t) {
-    this.#i.settleMs = t;
+    this.#t.settleMs = t;
   }
 }
-function l(o) {
-  return new g(o);
+function u(g) {
+  return new c(g);
 }
 export {
-  g as ViewportEngine,
-  l as createViewportEngine
+  c as ViewportEngine,
+  u as createViewportEngine
 };

package/dist/core/dist/axis/dom-labels.js

@@ -1,72 +1,77 @@
-import { resolveAxisTextColor as I, resolveAxisFontSize as C } from "../theme/resolve.js";
-import { clamp as P } from "../utils/math.js";
-const V = 0.01;
-function E(T) {
-  const { chart: e, container: w, axis: a } = T, r = /* @__PURE__ */ new Map();
-  let p = null, m = null;
-  const x = a === "x" ? e.timeScale.tickTracker : e.yScale.tickTracker;
-  function A() {
-    return a === "x" ? e.timeScale.niceTickValues(e.getDataInterval()) : { ticks: e.yScale.niceTickValues(), tickInterval: 0 };
+import { resolveAxisTextColor as X, resolveAxisFontSize as w } from "../theme/resolve.js";
+import { clamp as z } from "../utils/math.js";
+const E = 0.01;
+function D(A) {
+  const { chart: n, container: F, axis: a, scale: x } = A, s = /* @__PURE__ */ new Map();
+  let g = null, h = null;
+  function c() {
+    return n.getYScale(x);
+  }
+  function m() {
+    return n.getYScaleColumn(x)?.position ?? n.yAxisPosition;
+  }
+  function Y() {
+    return a === "x" ? n.timeScale.niceTickValues(n.getDataInterval()) : { ticks: c().niceTickValues(), tickInterval: 0 };
   }
   function S(t, o) {
-    return a === "x" ? e.timeScale.formatX(t, o) : e.yScale.formatY(t);
+    return a === "x" ? n.timeScale.formatX(t, o) : c().formatY(t);
   }
   function $(t, o) {
     if (a === "x") {
-      t.style.left = `${e.timeScale.timeToSnappedX(o)}px`;
+      t.style.left = `${n.timeScale.timeToSnappedX(o)}px`, n.timeScale.getType() === "category" && (t.style.maxWidth = `${n.timeScale.barWidthMedia(1)}px`);
       return;
     }
-    t.style.top = `${e.yScale.valueToSnappedY(o)}px`;
-  }
-  function h(t, o) {
-    t.style.color = I(o, a), t.style.fontSize = `${C(o, a)}px`, t.style.fontFamily = o.typography.fontFamily;
+    t.style.top = `${c().valueToSnappedY(o)}px`;
   }
   function v(t, o) {
-    const i = o === "left" ? "left" : "right", n = o === "left" ? "right" : "left";
-    t.style[i] = "8px", t.style[n] = "";
+    t.style.color = X(o, a), t.style.fontSize = `${w(o, a)}px`, t.style.fontFamily = o.typography.fontFamily;
   }
-  function F(t, o) {
-    const i = e.headerHeight;
-    if (a !== "y" || i <= 0 || e.yAxisPosition !== "left") return 1;
-    const n = C(o, a), y = e.yScale.valueToSnappedY(t) - n / 2;
-    return P((y - i + n) / n, 0, 1);
+  function d(t, o) {
+    const i = o === "left" ? "left" : "right", e = o === "left" ? "right" : "left";
+    t.style[i] = "8px", t.style[e] = "";
   }
-  function Y(t, o, i) {
-    const n = document.createElement("span");
-    return n.textContent = S(t, o), n.style.position = "absolute", n.style.userSelect = "none", h(n, i), n.style.willChange = "opacity", a === "x" ? (n.style.transform = "translateX(-50%)", n.style.whiteSpace = "nowrap") : (v(n, e.yAxisPosition), n.style.transform = "translateY(-50%)", n.style.fontVariantNumeric = "tabular-nums"), w.appendChild(n), n;
+  function b(t, o) {
+    const i = n.headerHeight;
+    if (a !== "y" || i <= 0 || m() !== "left") return 1;
+    const e = w(o, a), p = c().valueToSnappedY(t) - e / 2;
+    return z((p - i + e) / e, 0, 1);
   }
-  function c() {
-    const t = e.getTheme(), o = t !== p;
-    p = t;
-    const i = e.yAxisPosition, n = a === "y" && i !== m;
-    m = i;
-    const { ticks: y, tickInterval: g } = A();
-    x.setCurrentTicks(y);
-    const { entries: b } = x.snapshot(), k = /* @__PURE__ */ new Set();
-    for (const { value: s, opacity: u } of b) {
-      if (u <= V) continue;
-      k.add(s);
-      let l = r.get(s);
-      if (l === void 0)
-        l = Y(s, g, t), r.set(s, l);
+  function I(t, o, i) {
+    const e = document.createElement("span");
+    return e.textContent = S(t, o), e.style.position = "absolute", e.style.userSelect = "none", v(e, i), e.style.willChange = "opacity", a === "x" ? (e.style.transform = "translateX(-50%)", e.style.whiteSpace = "nowrap", n.timeScale.getType() === "category" && (e.style.overflow = "hidden", e.style.textOverflow = "ellipsis")) : (d(e, m()), e.style.transform = "translateY(-50%)", e.style.fontVariantNumeric = "tabular-nums"), F.appendChild(e), e;
+  }
+  function f() {
+    const t = n.getTheme(), o = t !== g;
+    g = t;
+    const i = m(), e = a === "y" && i !== h;
+    h = i;
+    const p = a === "x" ? n.timeScale.tickTracker : c().tickTracker, { ticks: V, tickInterval: k } = Y();
+    p.setCurrentTicks(V);
+    const { entries: W } = p.snapshot(), C = /* @__PURE__ */ new Set();
+    for (const { value: l, opacity: y } of W) {
+      if (y <= E) continue;
+      C.add(l);
+      let r = s.get(l);
+      if (r === void 0)
+        r = I(l, k, t), s.set(l, r);
       else {
-        const d = S(s, g);
-        l.textContent !== d && (l.textContent = d), o && h(l, t), n && v(l, i);
+        const T = S(l, k);
+        r.textContent !== T && (r.textContent = T), o && v(r, t), e && d(r, i);
       }
-      $(l, s), l.style.opacity = String(u * F(s, t));
+      $(r, l), r.style.opacity = String(y * b(l, t));
     }
-    for (const [s, u] of r)
-      k.has(s) || (u.remove(), r.delete(s));
+    for (const [l, y] of s)
+      C.has(l) || (y.remove(), s.delete(l));
   }
-  function f() {
-    e.getAnimationState().animating || c();
+  function u() {
+    n.getAnimationState().animating || f();
   }
-  return c(), e.on("tickFrame", c), e.on("viewportChange", f), e.on("overlayChange", f), () => {
-    e.off("tickFrame", c), e.off("viewportChange", f), e.off("overlayChange", f);
-    for (const t of r.values()) t.remove();
-    r.clear();
+  return f(), n.on("tickFrame", f), n.on("viewportChange", u), n.on("overlayChange", u), () => {
+    n.off("tickFrame", f), n.off("viewportChange", u), n.off("overlayChange", u);
+    for (const t of s.values()) t.remove();
+    s.clear();
   };
 }
 export {
-  E as mountAxisLabels
+  D as mountAxisLabels
 };

package/dist/core/dist/chart/scale-guards.js

@@ -1,4 +1,4 @@
-function o(a) {
+function c(a) {
   if (!(a.stacking !== "percent" || a.isPlottable(0)))
     throw new Error(
       `[wick-charts] Series '${a.seriesId}' uses stacking: 'percent', which this Y scale can't show — a 0–100% axis starts at 0, and the scale has no position for 0. Use a linear axis, or stacking: 'normal' / 'off'.`
@@ -6,11 +6,11 @@ function o(a) {
 }
 function i(a) {
   if (process.env.NODE_ENV === "production") return;
-  const { y: n, isPlottable: t } = a;
+  const { y: n, isPlottable: o, path: t = "axis.y" } = a;
   for (const e of ["min", "max"]) {
     const s = n?.[e];
-    typeof s != "number" || t(s) || console.warn(
-      `[wick-charts] axis.y.${e} is ${s}, which the Y scale can't place — falling back to 'auto'. Use a bound inside the scale's domain.`
+    typeof s != "number" || o(s) || console.warn(
+      `[wick-charts] ${t}.${e} is ${s}, which the Y scale can't place — falling back to 'auto'. Use a bound inside the scale's domain.`
     );
   }
 }
@@ -19,8 +19,26 @@ function r(a) {
     `[wick-charts] Series '${a.seriesId}' has values in view the Y scale can't place (e.g. ${a.value}; a log axis has no position for values ≤ 0). They are skipped — gaps in a line, no bar or candle. Filter or offset the data, or use a linear axis.`
   );
 }
+function l(a) {
+  process.env.NODE_ENV !== "production" && console.warn(
+    `[wick-charts] Series '${a.seriesId}' uses scale '${a.scaleId}', which \`scales\` doesn't define — it maps through the default Y scale.`
+  );
+}
+function h(a) {
+  process.env.NODE_ENV !== "production" && console.warn(
+    `[wick-charts] Scale '${a.scaleId}' asks for the ${a.side} axis column, which another Y axis already holds — it renders as an overlay scale with no column. One axis column fits on each side.`
+  );
+}
+function u(a) {
+  process.env.NODE_ENV !== "production" && console.warn(
+    `[wick-charts] Series '${a.seriesId}' uses stacking: 'percent' on a Y scale that can't place 0 — a 0–100% axis starts at 0. Put it on a linear scale, or use stacking: 'normal' / 'off'.`
+  );
+}
 export {
-  o as assertStackingFitsScale,
+  c as assertStackingFitsScale,
+  h as warnScaleSideTaken,
+  u as warnStackingOffScale,
+  l as warnUnknownScale,
   i as warnUnplottableBounds,
   r as warnUnplottableValues
 };

package/dist/core/dist/chart/x-guards.js

@@ -0,0 +1,37 @@
+function a(e) {
+  const { seriesType: s, axisType: t, supported: i } = e;
+  if (i.includes(t)) return;
+  const n = i.map((r) => `'${r}'`).join(", ");
+  throw new Error(
+    `[wick-charts] A '${s}' series can't plot on a '${t}' X axis — it supports ${n}. Set axis.x.type to a supported type, or declare \`xTypes\` on a custom series definition.`
+  );
+}
+function o(e) {
+  if (process.env.NODE_ENV === "production") return;
+  const s = e.axisType === "category" ? "a string `x` (the category name)" : "a number `x`";
+  console.warn(
+    `[wick-charts] Series '${e.seriesId}' has a point with x = ${String(e.x)}, which doesn't fit the '${e.axisType}' X axis — it needs ${s}. Such points are skipped.`
+  );
+}
+function c(e) {
+  process.env.NODE_ENV !== "production" && console.warn(
+    `[wick-charts] Series '${e.seriesId}' mixes \`x\` and \`time\` keys. On a numeric or category X axis key every point by \`x\`.`
+  );
+}
+function p(e) {
+  process.env.NODE_ENV !== "production" && console.warn(
+    `[wick-charts] ${e.feature} works on a time X axis only — it is disabled on this '${e.axisType}' axis.`
+  );
+}
+function x(e) {
+  process.env.NODE_ENV !== "production" && console.warn(
+    `[wick-charts] axis.x.type changed from '${e.from}' to '${e.to}' after the chart was created — the change is ignored. Remount the chart (e.g. a React \`key\`) to switch the X axis type.`
+  );
+}
+export {
+  a as assertSeriesFitsXAxis,
+  p as warnTimeOnlyFeature,
+  o as warnXMisfit,
+  c as warnXTimeMixed,
+  x as warnXTypeChange
+};