@wick-charts/vue 0.8.0 → 0.8.2

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

@@ -1,12 +1,12 @@
-import { Animator as k } from "../animation/animator.js";
+import { Animator as b } 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 {
+import { TimeSeriesStore as P } from "../data/store.js";
+import { resolveColor as S } from "../utils/color.js";
+import { normalizeTimePointArray as d, normalizeTime as L, sliceSample as M } from "../utils/time.js";
+import { sumStack as w, renderedStackPercentTop as A, renderedStackTop as k } from "./stack-math.js";
+const F = (m, t, e) => m + (t - m) * e;
+class I {
   stores;
   // --- Animation state (per layer) ----------------------------------------
   /**
@@ -53,10 +53,10 @@ class F {
    *  (the pre-prepend first point). Stagger position is `0` at the boundary
    *  and `1` at the deepest point. */
   historyRange = null;
-  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 })
+  constructor(t) {
+    this.stores = Array.from({ length: t }, () => new P()), 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 }, () => /* @__PURE__ */ new Map()), this.#i = Array.from(
+      { length: t },
+      () => new b({ initial: 1, duration: 0, lerp: F })
     );
   }
   // --- Color accessors ------------------------------------------------------
@@ -65,91 +65,91 @@ class F {
    * layer on the theme base in `options.colors`). Kept separate from the base so
    * a theme swap, which rewrites `options.colors`, leaves these untouched.
    */
-  #r = [];
-  setColorOverrides(e) {
-    this.#r = e;
+  #n = [];
+  setColorOverrides(t) {
+    this.#n = t;
   }
   /** The active resolver for a layer — the `data` override if set, else the theme base (cycled). */
-  #n(e) {
-    const t = this.#r[e];
-    if (t !== void 0) return t;
+  #r(t) {
+    const e = this.#n[t];
+    if (e !== void 0) return e;
     const s = this.options.colors;
-    return s[e % s.length];
+    return s[t % s.length];
   }
   /** The first layer's color resolver (string or value-fn). */
   getColor() {
-    return this.#n(0);
+    return this.#r(0);
   }
   getColors() {
     return this.options.colors;
   }
   /** Resolve one layer's color for a given datum value. */
-  resolveLayerColor(e, t) {
-    return W(this.#n(e), t);
+  resolveLayerColor(t, e) {
+    return S(this.#r(t), e);
   }
   // --- Data ingest ----------------------------------------------------------
-  setData(e, t = 0) {
-    const s = this.stores[t];
+  setData(t, e = 0) {
+    const s = this.stores[e];
     if (!s) return;
     let i = !1;
     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 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;
+    const n = d(t ?? []);
+    !i && n.length > 0 && this.introWave.arm(this.options.introMs), s.setData(n);
+    const r = s.last();
+    this.displayedLastValues[e] = r ? r.value : null, this.#t[e] = null, this.#e[e] = null, this.#s[e].clear(), this.entries[e].clear(), this.historyWave.finish(), this.historyRange = null;
   }
   /**
    * 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];
+  morphData(t, e = 0) {
+    const s = this.stores[e];
     if (!s) return;
     if (!this.stores.some((h) => h.length > 0)) {
-      this.setData(e, t);
+      this.setData(t, e);
       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) {
+      i.set(h.time, this.liveValue(e, h.time, h.value));
+    const n = d(t ?? []);
+    s.setData(n);
+    const r = this.options.smoothMs, o = this.isEntryEnabled() && this.options.entryMs > 0, l = this.entries[e], u = this.#s[e], a = /* @__PURE__ */ new Map();
+    for (const h of n) {
       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;
+      if (g === p || r <= 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);
+      v.target !== p && v.retarget(p, { settleMs: r }), a.set(h.time, v);
     }
-    const c = new Set(r.map((h) => h.time));
+    const c = new Set(n.map((h) => h.time));
     for (const h of l.keys())
       c.has(h) || l.delete(h);
-    this.#s[t] = a;
+    this.#s[e] = a;
     const f = s.last();
-    this.displayedLastValues[t] = f ? f.value : null, this.#t[t] = null, this.#e[t] = null;
+    this.displayedLastValues[e] = f ? f.value : null, this.#t[e] = null, this.#e[e] = null;
   }
-  appendPoint(e, t = 0) {
-    const s = this.stores[t];
+  appendPoint(t, e = 0) {
+    const s = this.stores[e];
     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[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 i = t, n = L(i.time), r = s.last(), o = s.length;
+    s.append({ ...i, time: n });
+    const l = this.#t[e];
+    l !== null && r !== void 0 && s.length > o && (this.#e[e] = { time: r.time, anim: l }), this.displayedLastValues[e] = i.value, this.#t[e] = null;
     const u = this.options.entryMs;
-    this.isEntryEnabled() && u > 0 && this.entries[t].set(r, { startTime: performance.now() });
+    this.isEntryEnabled() && u > 0 && this.entries[e].set(n, { startTime: performance.now() });
   }
-  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);
+  prependPoints(t, e = 0) {
+    const s = this.stores[e];
+    if (!s || t.length === 0) return;
+    const i = d(t), n = s.first()?.time;
+    s.prepend(i), this.#o(i[0]?.time, n);
   }
   /**
    * Arm (or extend) the history-reveal wave for freshly prepended points.
@@ -157,71 +157,71 @@ class F {
    * another layer — only the range grows; restarting the clock would snap
    * half-revealed points back to invisible.
    */
-  #o(e, t) {
+  #o(t, e) {
     const s = this.options.historyRevealMs;
-    if (!(this.options.historyReveal === "none" || s <= 0) && !(e === void 0 || t === void 0)) {
+    if (!(this.options.historyReveal === "none" || s <= 0) && !(t === void 0 || e === void 0)) {
       if (this.historyWave.active && this.historyRange !== null) {
-        this.historyRange = { from: Math.min(this.historyRange.from, e), to: this.historyRange.to };
+        this.historyRange = { from: Math.min(this.historyRange.from, t), to: this.historyRange.to };
         return;
       }
-      this.historyRange = { from: e, to: t }, this.historyWave.arm(s);
+      this.historyRange = { from: t, to: e }, this.historyWave.arm(s);
     }
   }
-  updateLastPoint(e, t = 0) {
-    const s = this.stores[t];
+  updateLastPoint(t, e = 0) {
+    const s = this.stores[e];
     if (!s) return;
-    const i = e, r = s.last()?.time;
+    const i = t, n = 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 r = this.#s[e], o = n === void 0 ? void 0 : r.get(n);
+    n !== void 0 && o !== void 0 && (r.delete(n), this.displayedLastValues[e] = o.current, this.#t[e] = o);
     const l = i.value, u = this.options.smoothMs;
     if (u <= 0) {
-      this.displayedLastValues[t] = l, this.#t[t] = null;
+      this.displayedLastValues[e] = l, this.#t[e] = null;
       return;
     }
-    let a = this.#t[t];
+    let a = this.#t[e];
     if (a === null) {
-      const c = this.displayedLastValues[t] ?? l;
-      a = new V(c), this.#t[t] = a;
+      const c = this.displayedLastValues[e] ?? l;
+      a = new V(c), this.#t[e] = a;
     }
     a.retarget(l, { settleMs: u });
   }
-  keepLast(e, t = 0) {
-    const s = this.stores[t];
-    if (!s || e < 0) return;
-    const i = s.length - e;
+  keepLast(t, e = 0) {
+    const s = this.stores[e];
+    if (!s || t < 0) return;
+    const i = s.length - t;
     i <= 0 || s.trimStart(i);
   }
   // --- Layer model ----------------------------------------------------------
   getLayerCount() {
     return this.stores.length;
   }
-  setLayerVisible(e, t) {
-    this.stores[e]?.setVisible(t);
+  setLayerVisible(t, e) {
+    this.stores[t]?.setVisible(e);
   }
-  isLayerVisible(e) {
-    return this.stores[e]?.isVisible() ?? !0;
+  isLayerVisible(t) {
+    return this.stores[t]?.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 e = [];
-    for (let t = 0; t < this.stores.length; t++) {
-      const s = this.stores[t]?.last()?.value ?? 0;
-      e.push(this.resolveLayerColor(t, s));
+    const t = [];
+    for (let e = 0; e < this.stores.length; e++) {
+      const s = this.lastFinitePoint(e)?.value ?? 0;
+      t.push(this.resolveLayerColor(e, s));
     }
-    return e;
+    return t;
   }
   // --- Lifecycle ------------------------------------------------------------
-  onDataChanged(e) {
-    for (const t of this.stores) t.on("update", e);
+  onDataChanged(t) {
+    for (const e of this.stores) e.on("update", t);
     return () => {
-      for (const t of this.stores) t.off("update", e);
+      for (const e of this.stores) e.off("update", t);
     };
   }
   dispose() {
-    for (const e of this.stores) e.removeAllListeners();
+    for (const t of this.stores) t.removeAllListeners();
   }
   // --- Animation primitives — renderer-owned state --------------------------
   /**
@@ -231,13 +231,13 @@ class F {
    * pure function of wall time — so tooltip/last-value queries (which have
    * no context to hand) can read it too.
    */
-  entranceProgress(e, t) {
-    const s = this.entries[e]?.get(t);
+  entranceProgress(t, e) {
+    const s = this.entries[t]?.get(e);
     if (s === void 0) return 1;
     const i = this.options.entryMs;
     if (i <= 0) return 1;
-    const r = performance.now() - s.startTime;
-    return r <= 0 ? 0 : r >= i ? 1 : r / i;
+    const n = performance.now() - s.startTime;
+    return n <= 0 ? 0 : n >= i ? 1 : n / i;
   }
   /**
    * Initial-load reveal progress for a datum, keyed by its normalized
@@ -247,10 +247,10 @@ class F {
    * (bar) fold this into their {@link entranceProgress} override; the line
    * renders its own continuous sweep instead.
    */
-  introProgressAt(e, t) {
+  introProgressAt(t, e) {
     if (!this.introWave.active) return 1;
-    const s = e.timeScale.getRange(), i = s.to - s.from, r = i > 0 ? (t - s.from) / i : 0;
-    return this.introWave.progressAt(r);
+    const s = t.timeScale.getRange(), i = s.to - s.from, n = i > 0 ? (e - s.from) / i : 0;
+    return this.introWave.progressAt(n);
   }
   /**
    * History-prepend reveal progress for a datum. Stagger position is
@@ -258,10 +258,10 @@ class F {
    * point — so the wave travels into history. `1` for points outside the
    * prepended span or when no reveal is in flight.
    */
-  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;
+  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;
     return this.historyWave.progressAt(i);
   }
   /**
@@ -275,14 +275,14 @@ class F {
    * on every append. Renderers lerp each chain link from the previous
    * link's *rendered* position instead, so geometry stays continuous.
    */
-  unsettledTail(e) {
-    const t = this.stores[e]?.getAll();
-    if (!t || t.length < 2) return [];
+  unsettledTail(t) {
+    const e = this.stores[t]?.getAll();
+    if (!e || e.length < 2) return [];
     const s = [];
-    for (let i = t.length - 1; i >= 1; i--) {
-      const r = this.entranceProgress(e, t[i].time);
-      if (r >= 1) break;
-      s.unshift({ time: t[i].time, progress: r });
+    for (let i = e.length - 1; i >= 1; i--) {
+      const n = this.entranceProgress(t, e[i].time);
+      if (n >= 1) break;
+      s.unshift({ time: e[i].time, progress: n });
     }
     return s;
   }
@@ -294,8 +294,8 @@ class F {
    * Falls back to `rawValue` when the store is empty or no smoothing has
    * happened yet.
    */
-  effectiveValue(e, t, s, i) {
-    return this.liveValue(t, s, i);
+  effectiveValue(t, e, s, i) {
+    return this.liveValue(e, s, i);
   }
   /**
    * The ctx-independent core of {@link effectiveValue} — used directly by the
@@ -304,14 +304,14 @@ class F {
    * transform). Those queries only need the live smoothing/chase this base
    * method already provides, never the intro's positional transform.
    */
-  liveValue(e, t, s) {
-    const i = this.#s[e]?.get(t);
+  liveValue(t, e, s) {
+    const i = this.#s[t]?.get(e);
     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;
+    const n = this.stores[t]?.last()?.time;
+    if (n !== void 0 && e === n)
+      return this.displayedLastValues[t] ?? s;
+    const r = this.#e[t];
+    return r !== null && r.time === e ? r.anim.current : s;
   }
   /**
    * Value a last-value/tooltip query should report for `time` — defaults to
@@ -320,8 +320,8 @@ class F {
    * override) without that lerp feeding back into `effectiveValue`, which
    * the renderer's own per-point draws use as an unlerp'd target.
    */
-  snapshotValue(e, t, s) {
-    return this.liveValue(e, t, s);
+  snapshotValue(t, e, s) {
+    return this.liveValue(t, e, s);
   }
   // --- Animation lifecycle --------------------------------------------------
   /**
@@ -330,44 +330,44 @@ class F {
    * subclass passes its own clock so test harnesses (which stub
    * `performance.now`) can drive progression deterministically.
    */
-  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];
+  tickAnimations(t) {
+    this.introWave.tick(t), this.historyWave.tick(t);
+    for (const e of this.#i) e.tick(t);
+    for (let e = 0; e < this.stores.length; e++) {
+      const s = this.#t[e];
       if (s !== null) {
-        const l = s.tick(e);
-        this.displayedLastValues[t] = s.current, l || (this.#t[t] = null);
+        const l = s.tick(t);
+        this.displayedLastValues[e] = s.current, l || (this.#t[e] = null);
       }
-      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();
+      const i = this.#e[e];
+      i !== null && !i.anim.tick(t) && (this.#e[e] = null);
+      const n = this.#s[e];
+      for (const [l, u] of n)
+        u.tick(t) || n.delete(l);
+      const r = this.options.entryMs;
+      if (r <= 0) {
+        this.entries[e].clear();
         continue;
       }
-      const o = this.entries[t];
+      const o = this.entries[e];
       for (const [l, u] of o)
-        e - u.startTime >= n && o.delete(l);
+        t - u.startTime >= r && 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 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;
+    for (const t of this.#i)
+      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.#s)
+      if (t.size > 0) return !0;
+    for (const t of this.entries)
+      if (t.size > 0) return !0;
     return !1;
   }
   /** Reveal-front position of the initial-load intro; `1` once settled. */
@@ -382,16 +382,16 @@ class F {
    */
   cancelEntranceAnimations() {
     this.introWave.finish();
-    for (const e of this.entries) e.clear();
+    for (const t of this.entries) t.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(e, t) {
+  setAlpha(t, e) {
     for (const s of this.#i)
-      s.setTarget(e, { duration: t });
+      s.setTarget(t, { duration: e });
   }
   /**
    * `1` while any layer has alpha > 0 OR is animating, `0` when every layer
@@ -407,8 +407,8 @@ class F {
    * would deadlock at `0`.
    */
   getAlpha() {
-    for (const e of this.#i)
-      if (e.current > 0 || e.animating) return 1;
+    for (const t of this.#i)
+      if (t.current > 0 || t.animating) return 1;
     return 0;
   }
   /**
@@ -416,125 +416,174 @@ class F {
    * Subclass draw loops multiply this into `globalAlpha` per layer so the
    * fade lives next to the geometry it affects.
    */
-  setLayerAlpha(e, t, s) {
-    this.#i[e]?.setTarget(t, { duration: s });
+  setLayerAlpha(t, e, s) {
+    this.#i[t]?.setTarget(e, { duration: s });
   }
   /** Latest rendered per-layer alpha. Defaults to 1 for out-of-range indices. */
-  getLayerAlpha(e) {
-    return this.#i[e]?.current ?? 1;
+  getLayerAlpha(t) {
+    return this.#i[t]?.current ?? 1;
   }
   // --- Data queries ---------------------------------------------------------
+  /**
+   * The layer's newest point with a finite value, after skipping `skip` such
+   * points — a trailing `null` / `NaN` is a gap, not the latest reading.
+   */
+  lastFinitePoint(t, e = 0) {
+    const s = this.stores[t]?.getAll() ?? [];
+    let i = e;
+    for (let n = s.length - 1; n >= 0; n--)
+      if (Number.isFinite(s[n].value)) {
+        if (i === 0) return s[n];
+        i--;
+      }
+    return null;
+  }
   getLastValue() {
-    for (let e = this.stores.length - 1; e >= 0; e--) {
-      const t = this.stores[e].last();
-      if (t) return t.value;
+    for (let t = this.stores.length - 1; t >= 0; t--) {
+      const e = this.lastFinitePoint(t);
+      if (e) return e.value;
     }
     return null;
   }
-  getDataAtTime(e, t) {
-    return this.stores[0]?.findNearest(e, t) ?? null;
+  getDataAtTime(t, e) {
+    return this.stores[0]?.findNearest(t, e) ?? null;
   }
-  getLayerSnapshots(e, t) {
+  getLayerSnapshots(t, e) {
     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].findNearest(e, t);
+    for (let n = 0; n < this.stores.length; n++) {
+      if (!this.stores[n].isVisible()) continue;
+      const r = this.stores[n].findNearest(t, e);
       if (r === null) continue;
-      const n = {
-        layerIndex: i,
+      const o = {
+        layerIndex: n,
         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, r.time, r.value),
+        value: this.snapshotValue(n, 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, r.value)
+        color: this.resolveLayerColor(n, r.value)
       };
-      r.x !== void 0 && (n.x = r.x), s.push(n);
+      r.x !== void 0 && (o.x = r.x), s.push(o);
     }
-    return s.length > 0 ? s : null;
+    const i = this.withShares({ rows: s, keepGaps: !1 });
+    return i.length > 0 ? i : null;
   }
   getStackedLastValue() {
     if (this.stores.length <= 1) {
-      const r = this.stores[0]?.last();
-      return r ? { value: this.snapshotValue(0, r.time, r.value), isLive: !0 } : null;
+      const i = this.lastFinitePoint(0);
+      return i ? { value: this.snapshotValue(0, i.time, i.value), isLive: !0 } : null;
     }
-    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 n = this.stores[r].last();
-        if (n) return { value: this.snapshotValue(r, n.time, n.value), isLive: !0 };
+    const t = this.options.stacking;
+    if (t === "off") {
+      for (let i = this.stores.length - 1; i >= 0; i--) {
+        if (!this.stores[i].isVisible()) continue;
+        const n = this.lastFinitePoint(i);
+        if (n) return { value: this.snapshotValue(i, n.time, n.value), isLive: !0 };
       }
       return null;
     }
-    let t = !1;
+    const e = this.stackHeadValues((i) => this.stores[i].last() ?? null) ?? this.lastDrawnRowValues();
+    if (!e) return null;
+    const s = w(e);
+    return { value: t === "percent" ? A(s) : k(s), isLive: !0 };
+  }
+  /** Stack contributions at the newest time any visible layer has a finite point. */
+  lastDrawnRowValues() {
+    let t = null;
+    for (let s = 0; s < this.stores.length; s++) {
+      if (!this.stores[s].isVisible()) continue;
+      const i = this.lastFinitePoint(s);
+      i !== null && (t === null || i.time > t) && (t = i.time);
+    }
+    if (t === null) return null;
+    const e = t;
+    return this.stackHeadValues((s) => this.stores[s].findNearest(e, 0));
+  }
+  /** Each visible layer's stack contribution at `pick(layer)`, or `null` when none is finite. */
+  stackHeadValues(t) {
+    let e = !1;
     const s = [];
-    for (let r = 0; r < this.stores.length; r++) {
-      if (!this.stores[r].isVisible()) continue;
-      const n = this.stores[r].last();
-      if (!n) {
+    for (let i = 0; i < this.stores.length; i++) {
+      if (!this.stores[i].isVisible()) continue;
+      const n = t(i);
+      if (!n || !Number.isFinite(n.value)) {
         s.push(0);
         continue;
       }
-      t = !0, s.push(this.snapshotValue(r, n.time, n.value));
+      e = !0, s.push(this.snapshotValue(i, n.time, n.value));
     }
-    if (!t) return null;
-    const i = A(s);
-    return { value: e === "percent" ? b(i) : w(i), isLive: !0 };
+    return e ? s : null;
   }
-  getStackedValueAtTime(e, t) {
+  getStackedValueAtTime(t, e) {
     if (this.stores.length <= 1) {
-      const o = this.stores[0]?.findNearest(e, t);
+      const o = this.stores[0]?.findNearest(t, e);
       return o ? this.snapshotValue(0, o.time, o.value) : null;
     }
     const s = this.options.stacking;
     if (s === "off") {
       for (let o = this.stores.length - 1; o >= 0; o--) {
         if (!this.stores[o].isVisible()) continue;
-        const l = this.stores[o].findNearest(e, t);
+        const l = this.stores[o].findNearest(t, e);
         if (l) return this.snapshotValue(o, l.time, l.value);
       }
       return null;
     }
     let i = !1;
-    const r = [];
+    const n = [];
     for (let o = 0; o < this.stores.length; o++) {
       if (!this.stores[o].isVisible()) continue;
-      const l = this.stores[o].findNearest(e, t);
+      const l = this.stores[o].findNearest(t, e);
       if (!l) {
-        r.push(0);
+        n.push(0);
         continue;
       }
-      i = !0, r.push(this.snapshotValue(o, l.time, l.value));
+      i = !0, n.push(this.snapshotValue(o, l.time, l.value));
     }
     if (!i) return null;
-    const n = A(r);
-    return s === "percent" ? b(n) : w(n);
+    const r = w(n);
+    return s === "percent" ? A(r) : k(r);
   }
   getLayerLastSnapshots() {
     if (this.stores.length <= 1) return null;
-    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(t, s.time, s.value),
-        color: this.resolveLayerColor(t, s.value)
+    const t = [];
+    for (let s = 0; s < this.stores.length; s++) {
+      if (!this.stores[s].isVisible()) continue;
+      const i = this.lastFinitePoint(s);
+      if (!i) continue;
+      const n = {
+        layerIndex: s,
+        time: i.time,
+        value: this.snapshotValue(s, i.time, i.value),
+        color: this.resolveLayerColor(s, i.value)
       };
-      s.x !== void 0 && (i.x = s.x), e.push(i);
+      i.x !== void 0 && (n.x = i.x), t.push(n);
     }
+    const e = this.withShares({ rows: t, keepGaps: !0 });
     return e.length > 0 ? e : null;
   }
+  /**
+   * On a percent stack, give each row its share of the column at the row's own
+   * time — ragged layers end at different columns. A row whose column is a gap
+   * is dropped, or kept without a share when `keepGaps`.
+   */
+  withShares(t) {
+    if (this.options.stacking !== "percent") return t.rows;
+    const e = /* @__PURE__ */ new Map(), s = [];
+    for (const i of t.rows) {
+      let n = e.get(i.time);
+      n === void 0 && (n = this.percentShares(i.time), e.set(i.time, n));
+      const r = n?.get(i.layerIndex);
+      r !== void 0 && (i.share = r), (r !== void 0 || t.keepGaps) && s.push(i);
+    }
+    return s;
+  }
   getTotalLength() {
-    let e = 0;
-    for (const t of this.stores) e += t.length;
-    return e;
+    let t = 0;
+    for (const e of this.stores) t += e.length;
+    return t;
   }
   // --- TimeSeriesRenderer data queries --------------------------------------
   /** Earliest first-sample / latest last-sample across ALL layers, skipping
@@ -542,64 +591,63 @@ class F {
    *  the multi-layer time-range leak: a populated layer 1 with an empty layer 0
    *  still reports the real bounds. */
   getTimeBounds() {
-    let e = 1 / 0, t = -1 / 0;
+    let t = 1 / 0, e = -1 / 0;
     for (const s of this.stores) {
       const i = s.first();
       if (!i) continue;
-      const r = s.last() ?? i;
-      i.time < e && (e = i.time), r.time > t && (t = r.time);
+      const n = s.last() ?? i;
+      i.time < t && (t = i.time), n.time > e && (e = n.time);
     }
-    return e === 1 / 0 ? null : { first: e, last: t };
+    return t === 1 / 0 ? null : { first: t, last: e };
   }
   /**
-   * Last data point of **layer 0 (`stores[0]`) only** — preserves the behavior
+   * Last finite data point of **layer 0 (`stores[0]`) only** — preserves the behavior
    * of the deleted `get store()` getter. NOTE: this is intentionally NOT the
    * same as {@link getStackedLastValue}, which for non-stacked multi-layer
    * reports the top visible layer and for stacked reports the cumulative sum.
    * Last-data / previous-close semantics stay pinned to layer 0 for back-compat.
    */
   getLastDataPoint() {
-    return this.stores[0]?.last() ?? null;
+    return this.lastFinitePoint(0);
   }
   /** Second-to-last point of layer 0 (`stores[0]`). See {@link getLastDataPoint}. */
   getSecondLastDataPoint() {
-    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(e) {
-    for (const t of this.stores) {
-      const s = t.getAll();
-      if (s.length !== 0)
-        return s.slice(0, e).map((i) => i.time);
+    return this.lastFinitePoint(0, 1);
+  }
+  /** First (or with `'end'`, last) `maxCount` sample times from the first populated layer. */
+  sampleTimes(t, e = "start") {
+    for (const s of this.stores) {
+      const i = s.getAll();
+      if (i.length !== 0)
+        return M(i, { maxCount: t, from: e }).map((n) => n.time);
     }
     return [];
   }
   /** Visible points of layer 0 (`stores[0]`). See {@link getLastDataPoint}. */
-  getVisibleDataPoints(e, t) {
-    return this.stores[0]?.getVisibleData(e, t) ?? [];
+  getVisibleDataPoints(t, e) {
+    return this.stores[0]?.getVisibleData(t, e) ?? [];
   }
   get stacking() {
     return this.options.stacking;
   }
-  getValueRange(e, t, s) {
+  getValueRange(t, e, s) {
     const i = this.options.stacking;
     if (i === "percent")
       return { min: 0, max: 100 };
-    const r = this.stores.map((a) => a.isVisible() ? a.getVisibleData(e, t) : []), n = s?.plottable;
+    const n = this.stores.map((a) => a.isVisible() ? a.getVisibleData(t, e) : []), r = s?.plottable;
     if (i === "off") {
       let a = 1 / 0, c = -1 / 0;
-      for (const f of r)
+      for (const f of n)
         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)));
+          Number.isFinite(h.value) && (r && !r(h.value) || (h.value < a && (a = h.value), h.value > c && (c = h.value)));
       return a < 1 / 0 ? { min: a, max: c } : null;
     }
-    if (n) return S(r, n);
+    if (r) return T(n, r);
     const o = /* @__PURE__ */ new Map();
-    for (let a = 0; a < r.length; a++)
-      for (const c of r[a]) {
+    for (let a = 0; a < n.length; a++)
+      for (const c of n[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;
+        f || (f = new Array(n.length).fill(0), o.set(c.time, f)), f[a] = Number.isFinite(c.value) ? c.value : 0;
       }
     let l = 0, u = 0;
     for (const a of o.values()) {
@@ -611,26 +659,26 @@ class F {
     return u > l ? { min: l, max: u } : null;
   }
 }
-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;
+function T(m, t) {
+  const e = /* @__PURE__ */ new Map();
+  for (let r = 0; r < m.length; r++)
+    for (const o of m[r]) {
+      let l = e.get(o.time);
+      l || (l = new Array(m.length).fill(0), e.set(o.time, l)), l[r] = t(o.value) ? o.value : 0;
     }
-  const s = e(0);
-  let i = s ? 0 : 1 / 0, r = s ? 0 : -1 / 0;
-  for (const n of t.values()) {
+  const s = t(0);
+  let i = s ? 0 : 1 / 0, n = s ? 0 : -1 / 0;
+  for (const r of e.values()) {
     let o = 0, l = 0;
-    for (const u of n) {
+    for (const u of r) {
       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));
+      t(a) && (a < i && (i = a), a > n && (n = a));
     }
   }
-  return i < 1 / 0 ? { min: i, max: r } : null;
+  return i < 1 / 0 ? { min: i, max: n } : null;
 }
 export {
-  F as BaseMultiLayerSeries
+  I as BaseMultiLayerSeries
 };