@wick-charts/vue 0.6.4 → 0.8.0

package/dist/core/dist/series/base-multi-layer.js

@@ -1,12 +1,12 @@
-import { Animator as L } from "../animation/animator.js";
-import { IntroWave as g } from "../animation/intro-wave.js";
-import { ScalarSpring as A } from "../animation/scalar-spring.js";
-import { TimeSeriesStore as b } from "../data/store.js";
-import { resolveColor as k } from "../utils/color.js";
-import { normalizeTimePointArray as p, normalizeTime as v } from "../utils/time.js";
-import { sumStack as y, renderedStackPercentTop as d, renderedStackTop as V } from "./stack-math.js";
-const W = (m, t, e) => m + (t - m) * e;
-class x {
+import { Animator as k } from "../animation/animator.js";
+import { IntroWave as y } from "../animation/intro-wave.js";
+import { ScalarSpring as V } from "../animation/scalar-spring.js";
+import { TimeSeriesStore as M } from "../data/store.js";
+import { resolveColor as W } from "../utils/color.js";
+import { normalizeTimePointArray as d, normalizeTime as L } from "../utils/time.js";
+import { sumStack as A, renderedStackPercentTop as b, renderedStackTop as w } from "./stack-math.js";
+const T = (m, e, t) => m + (e - m) * t;
+class F {
   stores;
   // --- Animation state (per layer) ----------------------------------------
   /**
@@ -30,31 +30,33 @@ class x {
    * very frame a new point arrives (a visible 1–2-frame kink at the line head).
    */
   #e;
+  /** Per-point eases started by {@link morphData}, keyed by time; pruned on settle. */
+  #s;
   /**
    * Per-layer alpha for the visibility cross-fade. `setAlpha` (whole series)
    * fans out across the array; `setLayerAlpha` targets a single index. Render
    * loops multiply the layer's alpha into `globalAlpha` per draw.
    */
-  #s;
+  #i;
   /**
    * Initial-load reveal clock — armed once when the dataset transitions
    * empty → non-empty in {@link setData}, shared across every layer so a
    * multi-layer seed rides one wave. Subclasses read it through
    * {@link introProgressAt} (per-element wave) or directly (line's sweep).
    */
-  introWave = new g();
+  introWave = new y();
   /** History-prepend reveal clock — armed by {@link prependPoints} so newly
    *  loaded older points wave in from the data boundary instead of popping.
    *  Shared across layers: a multi-layer prepend rides one wave. */
-  historyWave = new g();
+  historyWave = new y();
   /** Prepended time span: `from` = deepest new point, `to` = the boundary
    *  (the pre-prepend first point). Stagger position is `0` at the boundary
    *  and `1` at the deepest point. */
   historyRange = null;
-  constructor(t) {
-    this.stores = Array.from({ length: t }, () => new b()), this.entries = Array.from({ length: t }, () => /* @__PURE__ */ new Map()), this.displayedLastValues = new Array(t).fill(null), this.#t = new Array(t).fill(null), this.#e = new Array(t).fill(null), this.#s = Array.from(
-      { length: t },
-      () => new L({ initial: 1, duration: 0, lerp: W })
+  constructor(e) {
+    this.stores = Array.from({ length: e }, () => new M()), this.entries = Array.from({ length: e }, () => /* @__PURE__ */ new Map()), this.displayedLastValues = new Array(e).fill(null), this.#t = new Array(e).fill(null), this.#e = new Array(e).fill(null), this.#s = Array.from({ length: e }, () => /* @__PURE__ */ new Map()), this.#i = Array.from(
+      { length: e },
+      () => new k({ initial: 1, duration: 0, lerp: T })
     );
   }
   // --- Color accessors ------------------------------------------------------
@@ -63,55 +65,91 @@ class x {
    * layer on the theme base in `options.colors`). Kept separate from the base so
    * a theme swap, which rewrites `options.colors`, leaves these untouched.
    */
-  #i = [];
-  setColorOverrides(t) {
-    this.#i = t;
+  #r = [];
+  setColorOverrides(e) {
+    this.#r = e;
   }
   /** The active resolver for a layer — the `data` override if set, else the theme base (cycled). */
-  #r(t) {
-    const e = this.#i[t];
-    if (e !== void 0) return e;
+  #n(e) {
+    const t = this.#r[e];
+    if (t !== void 0) return t;
     const s = this.options.colors;
-    return s[t % s.length];
+    return s[e % s.length];
   }
   /** The first layer's color resolver (string or value-fn). */
   getColor() {
-    return this.#r(0);
+    return this.#n(0);
   }
   getColors() {
     return this.options.colors;
   }
   /** Resolve one layer's color for a given datum value. */
-  resolveLayerColor(t, e) {
-    return k(this.#r(t), e);
+  resolveLayerColor(e, t) {
+    return W(this.#n(e), t);
   }
   // --- Data ingest ----------------------------------------------------------
-  setData(t, e = 0) {
-    const s = this.stores[e];
+  setData(e, t = 0) {
+    const s = this.stores[t];
     if (!s) return;
     let i = !1;
-    for (const n of this.stores)
-      n.length > 0 && (i = !0);
-    const r = p(t ?? []);
+    for (const o of this.stores)
+      o.length > 0 && (i = !0);
+    const r = d(e ?? []);
     s.setData(r), !i && r.length > 0 && this.introWave.arm(this.options.introMs);
-    const o = s.last();
-    this.displayedLastValues[e] = o ? o.value : null, this.#t[e] = null, this.#e[e] = null, this.entries[e].clear(), this.historyWave.finish(), this.historyRange = null;
+    const n = s.last();
+    this.displayedLastValues[t] = n ? n.value : null, this.#t[t] = null, this.#e[t] = null, this.#s[t].clear(), this.entries[t].clear(), this.historyWave.finish(), this.historyRange = null;
   }
-  appendPoint(t, e = 0) {
-    const s = this.stores[e];
+  /**
+   * Replace a layer like {@link setData}, but ease each point that keeps its
+   * `time` from the value on screen to its new one over `smoothMs`; a point
+   * with a new `time` plays its entrance.
+   */
+  morphData(e, t = 0) {
+    const s = this.stores[t];
     if (!s) return;
-    const i = t, r = v(i.time), o = s.last(), n = s.length;
+    if (!this.stores.some((h) => h.length > 0)) {
+      this.setData(e, t);
+      return;
+    }
+    const i = /* @__PURE__ */ new Map();
+    for (const h of s.getAll())
+      i.set(h.time, this.liveValue(t, h.time, h.value));
+    const r = d(e ?? []);
+    s.setData(r);
+    const n = this.options.smoothMs, o = this.isEntryEnabled() && this.options.entryMs > 0, l = this.entries[t], u = this.#s[t], a = /* @__PURE__ */ new Map();
+    for (const h of r) {
+      const g = i.get(h.time);
+      if (g === void 0) {
+        o && l.set(h.time, { startTime: performance.now() });
+        continue;
+      }
+      const p = h.value;
+      if (g === p || n <= 0 || !Number.isFinite(g) || !Number.isFinite(p)) continue;
+      const v = u.get(h.time) ?? new V(g);
+      v.target !== p && v.retarget(p, { settleMs: n }), a.set(h.time, v);
+    }
+    const c = new Set(r.map((h) => h.time));
+    for (const h of l.keys())
+      c.has(h) || l.delete(h);
+    this.#s[t] = a;
+    const f = s.last();
+    this.displayedLastValues[t] = f ? f.value : null, this.#t[t] = null, this.#e[t] = null;
+  }
+  appendPoint(e, t = 0) {
+    const s = this.stores[t];
+    if (!s) return;
+    const i = e, r = L(i.time), n = s.last(), o = s.length;
     s.append({ ...i, time: r });
-    const l = this.#t[e];
-    l !== null && o !== void 0 && s.length > n && (this.#e[e] = { time: o.time, anim: l }), this.displayedLastValues[e] = i.value, this.#t[e] = null;
-    const h = this.options.entryMs;
-    this.isEntryEnabled() && h > 0 && this.entries[e].set(r, { startTime: performance.now() });
+    const l = this.#t[t];
+    l !== null && n !== void 0 && s.length > o && (this.#e[t] = { time: n.time, anim: l }), this.displayedLastValues[t] = i.value, this.#t[t] = null;
+    const u = this.options.entryMs;
+    this.isEntryEnabled() && u > 0 && this.entries[t].set(r, { startTime: performance.now() });
   }
-  prependPoints(t, e = 0) {
-    const s = this.stores[e];
-    if (!s || t.length === 0) return;
-    const i = p(t), r = s.first()?.time;
-    s.prepend(i), this.#n(i[0]?.time, r);
+  prependPoints(e, t = 0) {
+    const s = this.stores[t];
+    if (!s || e.length === 0) return;
+    const i = d(e), r = s.first()?.time;
+    s.prepend(i), this.#o(i[0]?.time, r);
   }
   /**
    * Arm (or extend) the history-reveal wave for freshly prepended points.
@@ -119,69 +157,71 @@ class x {
    * another layer — only the range grows; restarting the clock would snap
    * half-revealed points back to invisible.
    */
-  #n(t, e) {
+  #o(e, t) {
     const s = this.options.historyRevealMs;
-    if (!(this.options.historyReveal === "none" || s <= 0) && !(t === void 0 || e === void 0)) {
+    if (!(this.options.historyReveal === "none" || s <= 0) && !(e === void 0 || t === void 0)) {
       if (this.historyWave.active && this.historyRange !== null) {
-        this.historyRange = { from: Math.min(this.historyRange.from, t), to: this.historyRange.to };
+        this.historyRange = { from: Math.min(this.historyRange.from, e), to: this.historyRange.to };
         return;
       }
-      this.historyRange = { from: t, to: e }, this.historyWave.arm(s);
+      this.historyRange = { from: e, to: t }, this.historyWave.arm(s);
     }
   }
-  updateLastPoint(t, e = 0) {
-    const s = this.stores[e];
+  updateLastPoint(e, t = 0) {
+    const s = this.stores[t];
     if (!s) return;
-    const i = t;
-    s.updateLast({ ...i, time: v(i.time) });
-    const r = i.value, o = this.options.smoothMs;
-    if (o <= 0) {
-      this.displayedLastValues[e] = r, this.#t[e] = null;
+    const i = e, r = s.last()?.time;
+    s.updateLast({ ...i, time: L(i.time) });
+    const n = this.#s[t], o = r === void 0 ? void 0 : n.get(r);
+    r !== void 0 && o !== void 0 && (n.delete(r), this.displayedLastValues[t] = o.current, this.#t[t] = o);
+    const l = i.value, u = this.options.smoothMs;
+    if (u <= 0) {
+      this.displayedLastValues[t] = l, this.#t[t] = null;
       return;
     }
-    let n = this.#t[e];
-    if (n === null) {
-      const l = this.displayedLastValues[e] ?? r;
-      n = new A(l), this.#t[e] = n;
+    let a = this.#t[t];
+    if (a === null) {
+      const c = this.displayedLastValues[t] ?? l;
+      a = new V(c), this.#t[t] = a;
     }
-    n.retarget(r, { settleMs: o });
+    a.retarget(l, { settleMs: u });
   }
-  keepLast(t, e = 0) {
-    const s = this.stores[e];
-    if (!s || t < 0) return;
-    const i = s.length - t;
+  keepLast(e, t = 0) {
+    const s = this.stores[t];
+    if (!s || e < 0) return;
+    const i = s.length - e;
     i <= 0 || s.trimStart(i);
   }
   // --- Layer model ----------------------------------------------------------
   getLayerCount() {
     return this.stores.length;
   }
-  setLayerVisible(t, e) {
-    this.stores[t]?.setVisible(e);
+  setLayerVisible(e, t) {
+    this.stores[e]?.setVisible(t);
   }
-  isLayerVisible(t) {
-    return this.stores[t]?.isVisible() ?? !0;
+  isLayerVisible(e) {
+    return this.stores[e]?.isVisible() ?? !0;
   }
   /** Representative concrete color per layer — value-fns are resolved at the
    *  layer's last value, giving the legend swatch / color-change detection a
    *  stable string. Honors per-layer `data` overrides. */
   getLayerColors() {
-    const t = [];
-    for (let e = 0; e < this.stores.length; e++) {
-      const s = this.stores[e]?.last()?.value ?? 0;
-      t.push(this.resolveLayerColor(e, s));
+    const e = [];
+    for (let t = 0; t < this.stores.length; t++) {
+      const s = this.stores[t]?.last()?.value ?? 0;
+      e.push(this.resolveLayerColor(t, s));
     }
-    return t;
+    return e;
   }
   // --- Lifecycle ------------------------------------------------------------
-  onDataChanged(t) {
-    for (const e of this.stores) e.on("update", t);
+  onDataChanged(e) {
+    for (const t of this.stores) t.on("update", e);
     return () => {
-      for (const e of this.stores) e.off("update", t);
+      for (const t of this.stores) t.off("update", e);
     };
   }
   dispose() {
-    for (const t of this.stores) t.removeAllListeners();
+    for (const e of this.stores) e.removeAllListeners();
   }
   // --- Animation primitives — renderer-owned state --------------------------
   /**
@@ -191,8 +231,8 @@ class x {
    * pure function of wall time — so tooltip/last-value queries (which have
    * no context to hand) can read it too.
    */
-  entranceProgress(t, e) {
-    const s = this.entries[t]?.get(e);
+  entranceProgress(e, t) {
+    const s = this.entries[e]?.get(t);
     if (s === void 0) return 1;
     const i = this.options.entryMs;
     if (i <= 0) return 1;
@@ -207,9 +247,9 @@ class x {
    * (bar) fold this into their {@link entranceProgress} override; the line
    * renders its own continuous sweep instead.
    */
-  introProgressAt(t, e) {
+  introProgressAt(e, t) {
     if (!this.introWave.active) return 1;
-    const s = t.timeScale.getRange(), i = s.to - s.from, r = i > 0 ? (e - s.from) / i : 0;
+    const s = e.timeScale.getRange(), i = s.to - s.from, r = i > 0 ? (t - s.from) / i : 0;
     return this.introWave.progressAt(r);
   }
   /**
@@ -218,10 +258,10 @@ class x {
    * point — so the wave travels into history. `1` for points outside the
    * prepended span or when no reveal is in flight.
    */
-  historyProgressAt(t) {
-    const e = this.historyRange;
-    if (!this.historyWave.active || e === null || t >= e.to) return 1;
-    const s = e.to - e.from, i = s > 0 ? (e.to - t) / s : 0;
+  historyProgressAt(e) {
+    const t = this.historyRange;
+    if (!this.historyWave.active || t === null || e >= t.to) return 1;
+    const s = t.to - t.from, i = s > 0 ? (t.to - e) / s : 0;
     return this.historyWave.progressAt(i);
   }
   /**
@@ -235,26 +275,27 @@ class x {
    * on every append. Renderers lerp each chain link from the previous
    * link's *rendered* position instead, so geometry stays continuous.
    */
-  unsettledTail(t) {
-    const e = this.stores[t]?.getAll();
-    if (!e || e.length < 2) return [];
+  unsettledTail(e) {
+    const t = this.stores[e]?.getAll();
+    if (!t || t.length < 2) return [];
     const s = [];
-    for (let i = e.length - 1; i >= 1; i--) {
-      const r = this.entranceProgress(t, e[i].time);
+    for (let i = t.length - 1; i >= 1; i--) {
+      const r = this.entranceProgress(e, t[i].time);
       if (r >= 1) break;
-      s.unshift({ time: e[i].time, progress: r });
+      s.unshift({ time: t[i].time, progress: r });
     }
     return s;
   }
   /**
-   * Substitute the renderer-smoothed last value for `rawValue` when the
-   * query `time` matches the layer's current last point, or the still-settling
-   * pinned chase (see {@link appendPoint}) when it matches the penultimate.
+   * Substitute the renderer-smoothed value for `rawValue`: a {@link morphData}
+   * ease on the point, the smoothed last value when the query `time` matches the
+   * layer's current last point, or the still-settling pinned chase (see
+   * {@link appendPoint}) when it matches the penultimate.
    * Falls back to `rawValue` when the store is empty or no smoothing has
    * happened yet.
    */
-  effectiveValue(t, e, s, i) {
-    return this.liveValue(e, s, i);
+  effectiveValue(e, t, s, i) {
+    return this.liveValue(t, s, i);
   }
   /**
    * The ctx-independent core of {@link effectiveValue} — used directly by the
@@ -263,12 +304,14 @@ class x {
    * transform). Those queries only need the live smoothing/chase this base
    * method already provides, never the intro's positional transform.
    */
-  liveValue(t, e, s) {
-    const i = this.stores[t]?.last()?.time;
-    if (i !== void 0 && e === i)
-      return this.displayedLastValues[t] ?? s;
-    const r = this.#e[t];
-    return r !== null && r.time === e ? r.anim.current : s;
+  liveValue(e, t, s) {
+    const i = this.#s[e]?.get(t);
+    if (i !== void 0) return i.current;
+    const r = this.stores[e]?.last()?.time;
+    if (r !== void 0 && t === r)
+      return this.displayedLastValues[e] ?? s;
+    const n = this.#e[e];
+    return n !== null && n.time === t ? n.anim.current : s;
   }
   /**
    * Value a last-value/tooltip query should report for `time` — defaults to
@@ -277,8 +320,8 @@ class x {
    * override) without that lerp feeding back into `effectiveValue`, which
    * the renderer's own per-point draws use as an unlerp'd target.
    */
-  snapshotValue(t, e, s) {
-    return this.liveValue(t, e, s);
+  snapshotValue(e, t, s) {
+    return this.liveValue(e, t, s);
   }
   // --- Animation lifecycle --------------------------------------------------
   /**
@@ -287,39 +330,44 @@ class x {
    * subclass passes its own clock so test harnesses (which stub
    * `performance.now`) can drive progression deterministically.
    */
-  tickAnimations(t) {
-    this.introWave.tick(t), this.historyWave.tick(t);
-    for (const e of this.#s) e.tick(t);
-    for (let e = 0; e < this.stores.length; e++) {
-      const s = this.#t[e];
+  tickAnimations(e) {
+    this.introWave.tick(e), this.historyWave.tick(e);
+    for (const t of this.#i) t.tick(e);
+    for (let t = 0; t < this.stores.length; t++) {
+      const s = this.#t[t];
       if (s !== null) {
-        const n = s.tick(t);
-        this.displayedLastValues[e] = s.current, n || (this.#t[e] = null);
+        const l = s.tick(e);
+        this.displayedLastValues[t] = s.current, l || (this.#t[t] = null);
       }
-      const i = this.#e[e];
-      i !== null && !i.anim.tick(t) && (this.#e[e] = null);
-      const r = this.options.entryMs;
-      if (r <= 0) {
-        this.entries[e].clear();
+      const i = this.#e[t];
+      i !== null && !i.anim.tick(e) && (this.#e[t] = null);
+      const r = this.#s[t];
+      for (const [l, u] of r)
+        u.tick(e) || r.delete(l);
+      const n = this.options.entryMs;
+      if (n <= 0) {
+        this.entries[t].clear();
         continue;
       }
-      const o = this.entries[e];
-      for (const [n, l] of o)
-        t - l.startTime >= r && o.delete(n);
+      const o = this.entries[t];
+      for (const [l, u] of o)
+        e - u.startTime >= n && o.delete(l);
     }
   }
   /** True while any layer has an active chase, unsettled entry, alpha fade,
    *  or the initial-load reveal is still sweeping. */
   get needsAnimation() {
     if (this.introWave.active || this.historyWave.active) return !0;
-    for (const t of this.#s)
-      if (t.animating) return !0;
-    for (const t of this.#t)
-      if (t !== null) return !0;
-    for (const t of this.#e)
-      if (t !== null) return !0;
-    for (const t of this.entries)
-      if (t.size > 0) return !0;
+    for (const e of this.#i)
+      if (e.animating) return !0;
+    for (const e of this.#t)
+      if (e !== null) return !0;
+    for (const e of this.#e)
+      if (e !== null) return !0;
+    for (const e of this.#s)
+      if (e.size > 0) return !0;
+    for (const e of this.entries)
+      if (e.size > 0) return !0;
     return !1;
   }
   /** Reveal-front position of the initial-load intro; `1` once settled. */
@@ -334,16 +382,16 @@ class x {
    */
   cancelEntranceAnimations() {
     this.introWave.finish();
-    for (const t of this.entries) t.clear();
+    for (const e of this.entries) e.clear();
   }
   /**
    * Start a series-wide fade toward `target` over `durationMs`. Fans out
    * across every per-layer animator so a `setSeriesVisible` toggle is just
    * "set every layer to the same target". `durationMs <= 0` snaps.
    */
-  setAlpha(t, e) {
-    for (const s of this.#s)
-      s.setTarget(t, { duration: e });
+  setAlpha(e, t) {
+    for (const s of this.#i)
+      s.setTarget(e, { duration: t });
   }
   /**
    * `1` while any layer has alpha > 0 OR is animating, `0` when every layer
@@ -359,8 +407,8 @@ class x {
    * would deadlock at `0`.
    */
   getAlpha() {
-    for (const t of this.#s)
-      if (t.current > 0 || t.animating) return 1;
+    for (const e of this.#i)
+      if (e.current > 0 || e.animating) return 1;
     return 0;
   }
   /**
@@ -368,47 +416,43 @@ class x {
    * Subclass draw loops multiply this into `globalAlpha` per layer so the
    * fade lives next to the geometry it affects.
    */
-  setLayerAlpha(t, e, s) {
-    this.#s[t]?.setTarget(e, { duration: s });
+  setLayerAlpha(e, t, s) {
+    this.#i[e]?.setTarget(t, { duration: s });
   }
   /** Latest rendered per-layer alpha. Defaults to 1 for out-of-range indices. */
-  getLayerAlpha(t) {
-    return this.#s[t]?.current ?? 1;
+  getLayerAlpha(e) {
+    return this.#i[e]?.current ?? 1;
   }
   // --- Data queries ---------------------------------------------------------
   getLastValue() {
-    for (let t = this.stores.length - 1; t >= 0; t--) {
-      const e = this.stores[t].last();
-      if (e) return e.value;
+    for (let e = this.stores.length - 1; e >= 0; e--) {
+      const t = this.stores[e].last();
+      if (t) return t.value;
     }
     return null;
   }
-  getDataAtTime(t, e) {
-    return this.stores[0]?.findNearest(t, e) ?? null;
+  getDataAtTime(e, t) {
+    return this.stores[0]?.findNearest(e, t) ?? null;
   }
-  getLayerSnapshots(t, e) {
+  getLayerSnapshots(e, t) {
     if (this.stores.length <= 1) return null;
     const s = [];
     for (let i = 0; i < this.stores.length; i++) {
       if (!this.stores[i].isVisible()) continue;
-      const r = this.stores[i].getVisibleData(t - e, t + e);
-      if (r.length === 0) continue;
-      let o = r[0], n = Math.abs(r[0].time - t);
-      for (let l = 1; l < r.length; l++) {
-        const h = Math.abs(r[l].time - t);
-        h <= n && (n = h, o = r[l]);
-      }
-      s.push({
+      const r = this.stores[i].findNearest(e, t);
+      if (r === null) continue;
+      const n = {
         layerIndex: i,
-        time: o.time,
+        time: r.time,
         // Routes through the same live/pinned-chase smoothing the renderer
         // paints, so hovering the live edge mid-animation doesn't jump ahead
         // to the raw target before the on-screen marker gets there.
-        value: this.snapshotValue(i, o.time, o.value),
+        value: this.snapshotValue(i, r.time, r.value),
         // Resolve the layer's color at the hovered datum's value so a value-fn
         // colors the tooltip dot to match the bar / segment under the cursor.
-        color: this.resolveLayerColor(i, o.value)
-      });
+        color: this.resolveLayerColor(i, r.value)
+      };
+      r.x !== void 0 && (n.x = r.x), s.push(n);
     }
     return s.length > 0 ? s : null;
   }
@@ -417,78 +461,80 @@ class x {
       const r = this.stores[0]?.last();
       return r ? { value: this.snapshotValue(0, r.time, r.value), isLive: !0 } : null;
     }
-    const t = this.options.stacking;
-    if (t === "off") {
+    const e = this.options.stacking;
+    if (e === "off") {
       for (let r = this.stores.length - 1; r >= 0; r--) {
         if (!this.stores[r].isVisible()) continue;
-        const o = this.stores[r].last();
-        if (o) return { value: this.snapshotValue(r, o.time, o.value), isLive: !0 };
+        const n = this.stores[r].last();
+        if (n) return { value: this.snapshotValue(r, n.time, n.value), isLive: !0 };
       }
       return null;
     }
-    let e = !1;
+    let t = !1;
     const s = [];
     for (let r = 0; r < this.stores.length; r++) {
       if (!this.stores[r].isVisible()) continue;
-      const o = this.stores[r].last();
-      if (!o) {
+      const n = this.stores[r].last();
+      if (!n) {
         s.push(0);
         continue;
       }
-      e = !0, s.push(this.snapshotValue(r, o.time, o.value));
+      t = !0, s.push(this.snapshotValue(r, n.time, n.value));
     }
-    if (!e) return null;
-    const i = y(s);
-    return { value: t === "percent" ? d(i) : V(i), isLive: !0 };
+    if (!t) return null;
+    const i = A(s);
+    return { value: e === "percent" ? b(i) : w(i), isLive: !0 };
   }
-  getStackedValueAtTime(t, e) {
+  getStackedValueAtTime(e, t) {
     if (this.stores.length <= 1) {
-      const n = this.stores[0]?.findNearest(t, e);
-      return n ? this.snapshotValue(0, n.time, n.value) : null;
+      const o = this.stores[0]?.findNearest(e, t);
+      return o ? this.snapshotValue(0, o.time, o.value) : null;
     }
     const s = this.options.stacking;
     if (s === "off") {
-      for (let n = this.stores.length - 1; n >= 0; n--) {
-        if (!this.stores[n].isVisible()) continue;
-        const l = this.stores[n].findNearest(t, e);
-        if (l) return this.snapshotValue(n, l.time, l.value);
+      for (let o = this.stores.length - 1; o >= 0; o--) {
+        if (!this.stores[o].isVisible()) continue;
+        const l = this.stores[o].findNearest(e, t);
+        if (l) return this.snapshotValue(o, l.time, l.value);
       }
       return null;
     }
     let i = !1;
     const r = [];
-    for (let n = 0; n < this.stores.length; n++) {
-      if (!this.stores[n].isVisible()) continue;
-      const l = this.stores[n].findNearest(t, e);
+    for (let o = 0; o < this.stores.length; o++) {
+      if (!this.stores[o].isVisible()) continue;
+      const l = this.stores[o].findNearest(e, t);
       if (!l) {
         r.push(0);
         continue;
       }
-      i = !0, r.push(this.snapshotValue(n, l.time, l.value));
+      i = !0, r.push(this.snapshotValue(o, l.time, l.value));
     }
     if (!i) return null;
-    const o = y(r);
-    return s === "percent" ? d(o) : V(o);
+    const n = A(r);
+    return s === "percent" ? b(n) : w(n);
   }
   getLayerLastSnapshots() {
     if (this.stores.length <= 1) return null;
-    const t = [];
-    for (let e = 0; e < this.stores.length; e++) {
-      if (!this.stores[e].isVisible()) continue;
-      const s = this.stores[e].last();
-      s && t.push({
-        layerIndex: e,
+    const e = [];
+    for (let t = 0; t < this.stores.length; t++) {
+      if (!this.stores[t].isVisible()) continue;
+      const s = this.stores[t].last();
+      if (!s) continue;
+      const i = {
+        layerIndex: t,
         time: s.time,
-        value: this.snapshotValue(e, s.time, s.value),
-        color: this.resolveLayerColor(e, s.value)
-      });
+        value: this.snapshotValue(t, s.time, s.value),
+        color: this.resolveLayerColor(t, s.value)
+      };
+      s.x !== void 0 && (i.x = s.x), e.push(i);
     }
-    return t.length > 0 ? t : null;
+    return e.length > 0 ? e : null;
   }
   getTotalLength() {
-    let t = 0;
-    for (const e of this.stores) t += e.length;
-    return t;
+    let e = 0;
+    for (const t of this.stores) e += t.length;
+    return e;
   }
   // --- TimeSeriesRenderer data queries --------------------------------------
   /** Earliest first-sample / latest last-sample across ALL layers, skipping
@@ -496,14 +542,14 @@ class x {
    *  the multi-layer time-range leak: a populated layer 1 with an empty layer 0
    *  still reports the real bounds. */
   getTimeBounds() {
-    let t = 1 / 0, e = -1 / 0;
+    let e = 1 / 0, t = -1 / 0;
     for (const s of this.stores) {
       const i = s.first();
       if (!i) continue;
       const r = s.last() ?? i;
-      i.time < t && (t = i.time), r.time > e && (e = r.time);
+      i.time < e && (e = i.time), r.time > t && (t = r.time);
     }
-    return t === 1 / 0 ? null : { first: t, last: e };
+    return e === 1 / 0 ? null : { first: e, last: t };
   }
   /**
    * Last data point of **layer 0 (`stores[0]`) only** — preserves the behavior
@@ -517,74 +563,74 @@ class x {
   }
   /** Second-to-last point of layer 0 (`stores[0]`). See {@link getLastDataPoint}. */
   getSecondLastDataPoint() {
-    const t = this.stores[0]?.getAll();
-    return !t || t.length < 2 ? null : t[t.length - 2];
+    const e = this.stores[0]?.getAll();
+    return !e || e.length < 2 ? null : e[e.length - 2];
   }
   /** First `maxCount` sample times from the first populated layer. */
-  sampleTimes(t) {
-    for (const e of this.stores) {
-      const s = e.getAll();
+  sampleTimes(e) {
+    for (const t of this.stores) {
+      const s = t.getAll();
       if (s.length !== 0)
-        return s.slice(0, t).map((i) => i.time);
+        return s.slice(0, e).map((i) => i.time);
     }
     return [];
   }
   /** Visible points of layer 0 (`stores[0]`). See {@link getLastDataPoint}. */
-  getVisibleDataPoints(t, e) {
-    return this.stores[0]?.getVisibleData(t, e) ?? [];
+  getVisibleDataPoints(e, t) {
+    return this.stores[0]?.getVisibleData(e, t) ?? [];
   }
   get stacking() {
     return this.options.stacking;
   }
-  getValueRange(t, e, s) {
+  getValueRange(e, t, s) {
     const i = this.options.stacking;
     if (i === "percent")
       return { min: 0, max: 100 };
-    const r = this.stores.map((a) => a.isVisible() ? a.getVisibleData(t, e) : []), o = s?.plottable;
+    const r = this.stores.map((a) => a.isVisible() ? a.getVisibleData(e, t) : []), n = s?.plottable;
     if (i === "off") {
-      let a = 1 / 0, u = -1 / 0;
+      let a = 1 / 0, c = -1 / 0;
       for (const f of r)
-        for (const c of f)
-          Number.isFinite(c.value) && (o && !o(c.value) || (c.value < a && (a = c.value), c.value > u && (u = c.value)));
-      return a < 1 / 0 ? { min: a, max: u } : null;
+        for (const h of f)
+          Number.isFinite(h.value) && (n && !n(h.value) || (h.value < a && (a = h.value), h.value > c && (c = h.value)));
+      return a < 1 / 0 ? { min: a, max: c } : null;
     }
-    if (o) return w(r, o);
-    const n = /* @__PURE__ */ new Map();
+    if (n) return S(r, n);
+    const o = /* @__PURE__ */ new Map();
     for (let a = 0; a < r.length; a++)
-      for (const u of r[a]) {
-        let f = n.get(u.time);
-        f || (f = new Array(r.length).fill(0), n.set(u.time, f)), f[a] = Number.isFinite(u.value) ? u.value : 0;
+      for (const c of r[a]) {
+        let f = o.get(c.time);
+        f || (f = new Array(r.length).fill(0), o.set(c.time, f)), f[a] = Number.isFinite(c.value) ? c.value : 0;
       }
-    let l = 0, h = 0;
-    for (const a of n.values()) {
-      let u = 0, f = 0;
-      for (const c of a)
-        c > 0 ? u += c : f += c;
-      u > h && (h = u), f < l && (l = f);
+    let l = 0, u = 0;
+    for (const a of o.values()) {
+      let c = 0, f = 0;
+      for (const h of a)
+        h > 0 ? c += h : f += h;
+      c > u && (u = c), f < l && (l = f);
     }
-    return h > l ? { min: l, max: h } : null;
+    return u > l ? { min: l, max: u } : null;
   }
 }
-function w(m, t) {
-  const e = /* @__PURE__ */ new Map();
-  for (let o = 0; o < m.length; o++)
-    for (const n of m[o]) {
-      let l = e.get(n.time);
-      l || (l = new Array(m.length).fill(0), e.set(n.time, l)), l[o] = t(n.value) ? n.value : 0;
+function S(m, e) {
+  const t = /* @__PURE__ */ new Map();
+  for (let n = 0; n < m.length; n++)
+    for (const o of m[n]) {
+      let l = t.get(o.time);
+      l || (l = new Array(m.length).fill(0), t.set(o.time, l)), l[n] = e(o.value) ? o.value : 0;
     }
-  const s = t(0);
+  const s = e(0);
   let i = s ? 0 : 1 / 0, r = s ? 0 : -1 / 0;
-  for (const o of e.values()) {
-    let n = 0, l = 0;
-    for (const h of o) {
-      if (h === 0) continue;
-      h > 0 ? n += h : l += h;
-      const a = h > 0 ? n : l;
-      t(a) && (a < i && (i = a), a > r && (r = a));
+  for (const n of t.values()) {
+    let o = 0, l = 0;
+    for (const u of n) {
+      if (u === 0) continue;
+      u > 0 ? o += u : l += u;
+      const a = u > 0 ? o : l;
+      e(a) && (a < i && (i = a), a > r && (r = a));
     }
   }
   return i < 1 / 0 ? { min: i, max: r } : null;
 }
 export {
-  x as BaseMultiLayerSeries
+  F as BaseMultiLayerSeries
 };