@wick-charts/vue 0.6.1 → 0.6.3

package/dist/core/dist/series/bar.js

@@ -1,35 +1,45 @@
-import { DEFAULT_HISTORY_REVEAL as _, DEFAULT_BAR_INTRO as C, DEFAULT_BAR_SMOOTH as F, DEFAULT_BAR_ENTRY as N } from "../animation/config.js";
-import { growIntro as Q } from "./bar-intro.js";
-import { BaseMultiLayerSeries as $ } from "./base-multi-layer.js";
+import { DEFAULT_HISTORY_REVEAL as N, DEFAULT_BAR_INTRO as J, DEFAULT_BAR_SMOOTH as $, DEFAULT_BAR_ENTRY as q } from "../animation/config.js";
+import { growIntro as K } from "./bar-intro.js";
+import { BaseMultiLayerSeries as Q } from "./base-multi-layer.js";
 import { resolveBarPainter as Z } from "./painters/resolve.js";
-import { fadeIntro as q } from "./wave-intro.js";
-const U = 2, G = {
+import { ScaleStack as F } from "./scale-stack.js";
+import { fadeIntro as tt } from "./wave-intro.js";
+const G = 2, et = {
   // Single fallback resolver; the definition's `create` swaps in `theme.bar.color`.
   colors: ["#26a69a"],
   barWidthRatio: 0.6,
   stacking: "off",
   anchor: "center",
-  cornerRadius: U,
-  entryMs: N,
-  smoothMs: F,
-  introMs: C,
-  historyRevealMs: _
+  cornerRadius: G,
+  entryMs: q,
+  smoothMs: $,
+  introMs: J,
+  historyRevealMs: N
 };
-function I(y) {
+function U(y) {
   return {
     ...y,
-    entryMs: y.entryMs === !1 ? 0 : y.entryMs ?? N,
-    smoothMs: y.smoothMs === !1 ? 0 : y.smoothMs ?? F,
-    introMs: y.introMs === !1 ? 0 : y.introMs ?? C,
-    historyRevealMs: y.historyRevealMs === !1 ? 0 : y.historyRevealMs ?? _
+    entryMs: y.entryMs === !1 ? 0 : y.entryMs ?? q,
+    smoothMs: y.smoothMs === !1 ? 0 : y.smoothMs ?? $,
+    introMs: y.introMs === !1 ? 0 : y.introMs ?? J,
+    historyRevealMs: y.historyRevealMs === !1 ? 0 : y.historyRevealMs ?? N
   };
 }
-const J = Q(), K = q(), tt = {
+const it = K(), ot = tt(), at = {
   top: { tl: !0, tr: !0, br: !1, bl: !1 },
   bottom: { tl: !1, tr: !1, br: !0, bl: !0 },
   none: { tl: !1, tr: !1, br: !1, bl: !1 }
 };
-class et extends $ {
+function st(y) {
+  const e = [], t = [];
+  let o = 0, s = 0;
+  for (const a of y) {
+    const n = a > 0 ? o : s;
+    e.push(n), t.push(n + a), a > 0 ? o += a : s += a;
+  }
+  return { base: e, end: t };
+}
+class rt extends Q {
   kind = "bar";
   /** Resolved drawing context for the in-flight render pass. Set at the top of
    *  {@link render}, read by {@link drawAnimatedBar}. */
@@ -43,10 +53,10 @@ class et extends $ {
   /** Per-frame history-reveal directives; `null` when no reveal is in flight. */
   #t = null;
   constructor(e, t) {
-    super(e), this.options = I({ ...G, ...t });
+    super(e), this.options = U({ ...et, ...t });
   }
   updateOptions(e) {
-    this.options = I({ ...this.options, ...e });
+    this.options = U({ ...this.options, ...e });
   }
   isEntryEnabled() {
     return (this.options.entryAnimation ?? "fade-grow") !== "none";
@@ -58,7 +68,7 @@ class et extends $ {
   #a(e) {
     const t = this.#i;
     if (t === null) return null;
-    const o = t.to - t.from, n = o > 0 ? (e - t.from) / o : 0, a = Math.min(1, Math.max(0, n));
+    const o = t.to - t.from, s = o > 0 ? (e - t.from) / o : 0, a = Math.min(1, Math.max(0, s));
     return { position: a, progress: this.introWave.progressAt(a) };
   }
   /**
@@ -67,10 +77,10 @@ class et extends $ {
    * the deepest prepended point). `null` for bars outside the prepended
    * span or when no reveal is in flight this frame.
    */
-  #r(e) {
+  #s(e) {
     const t = this.historyRange;
     if (this.#t === null || t === null || e >= t.to) return null;
-    const o = t.to - t.from, n = o > 0 ? (t.to - e) / o : 0, a = Math.min(1, Math.max(0, n));
+    const o = t.to - t.from, s = o > 0 ? (t.to - e) / o : 0, a = Math.min(1, Math.max(0, s));
     return { position: a, progress: this.historyWave.progressAt(a) };
   }
   /**
@@ -85,16 +95,16 @@ class et extends $ {
     if (this.isProjectedTime(e.time)) return e.value;
     const t = this.#t?.value;
     if (t !== void 0) {
-      const a = this.#r(e.time);
+      const a = this.#s(e.time);
       if (a !== null) return t({ ...e, ...a });
     }
     const o = this.#e?.value;
     if (o === void 0) return e.value;
-    const n = this.#a(e.time);
-    return n === null ? e.value : o({ ...e, ...n });
+    const s = this.#a(e.time);
+    return s === null ? e.value : o({ ...e, ...s });
   }
   applyTheme(e, t) {
-    const o = this.stores.length === 1, n = e.seriesColors[0] ?? "#26a69a", a = o ? [e.bar?.color ?? n] : e.seriesColors.slice(0, this.stores.length);
+    const o = this.stores.length === 1, s = e.seriesColors[0] ?? "#26a69a", a = o ? [e.bar?.color ?? s] : e.seriesColors.slice(0, this.stores.length);
     this.updateOptions({ colors: a });
   }
   /** True when `time` is at/after the configured `projectedFrom` forecast cut. */
@@ -108,20 +118,20 @@ class et extends $ {
    * each render path.
    */
   applyBarTransform(e, t) {
-    const { baselineY: o, topY: n, barHeight: a, x: m, barWidth: v } = e, b = this.options.entryAnimation ?? "fade-grow";
-    if (t >= 1 || b === "none")
-      return { topY: n, barHeight: a, x: m, barWidth: v, alpha: 1 };
-    let l = n, u = a, x = m, R = 1;
-    if ((b === "fade" || b === "fade-grow") && (R = t), (b === "grow" || b === "fade-grow") && !e.growBaked) {
+    const { baselineY: o, topY: s, barHeight: a, x: n, barWidth: b } = e, d = this.options.entryAnimation ?? "fade-grow";
+    if (t >= 1 || d === "none")
+      return { topY: s, barHeight: a, x: n, barWidth: b, alpha: 1 };
+    let p = s, l = a, c = n, x = 1;
+    if ((d === "fade" || d === "fade-grow") && (x = t), (d === "grow" || d === "fade-grow") && !e.growBaked) {
       const r = a * t;
-      n < o ? l = o - r : l = o, u = Math.max(1, r);
+      s < o ? p = o - r : p = o, l = Math.max(1, r);
     }
-    return b === "slide" && (x = m + (1 - t) * v, R = t), { topY: l, barHeight: u, x, barWidth: v, alpha: R };
+    return d === "slide" && (c = n + (1 - t) * b, x = t), { topY: p, barHeight: l, x: c, barWidth: b, alpha: x };
   }
   render(e) {
     this.tickAnimations(performance.now());
-    const { scope: t, timeScale: o, yScale: n } = e;
-    if (this.#o = {
+    const { scope: t, timeScale: o, yScale: s } = e;
+    this.#o = {
       painter: Z(this.options.barPainter),
       env: {
         ctx: t.context,
@@ -129,42 +139,49 @@ class et extends $ {
         horizontalPixelRatio: t.horizontalPixelRatio,
         verticalPixelRatio: t.verticalPixelRatio
       },
-      radius: (this.options.cornerRadius ?? U) * t.horizontalPixelRatio
-    }, this.#e = null, this.#i = null, this.introWave.active) {
-      const l = this.options.introAnimation ?? J, u = o.getRange();
-      this.#i = u, this.#e = l({
+      radius: (this.options.cornerRadius ?? G) * t.horizontalPixelRatio
+    };
+    const a = {
+      baseline: s.baselineValue(),
+      lerpValue: (l, c, x) => s.lerpValue(l, c, x)
+    };
+    if (this.#e = null, this.#i = null, this.introWave.active) {
+      const l = this.options.introAnimation ?? it, c = o.getRange();
+      this.#i = c, this.#e = l({
         progress: this.introWave.linear(),
         // Plot-area extent, not the canvas bitmap — the canvas also carries
         // the axis strips, so a width-based front (wipeIntro) would overshoot
         // the data area.
         width: o.getMediaWidth() * t.horizontalPixelRatio,
-        height: n.getMediaHeight() * t.verticalPixelRatio,
-        range: u,
-        timeToX: (x) => o.timeToBitmapX(x)
+        height: s.getMediaHeight() * t.verticalPixelRatio,
+        range: c,
+        timeToX: (x) => o.timeToBitmapX(x),
+        ...a
       });
     }
     this.#t = null;
-    const a = this.historyRange;
-    if (this.historyWave.active && a !== null) {
-      const l = this.options.historyReveal ?? K;
+    const n = this.historyRange;
+    if (this.historyWave.active && n !== null) {
+      const l = this.options.historyReveal ?? ot;
       l !== "none" && (this.#t = l({
         progress: this.historyWave.linear(),
-        width: Math.abs(o.timeToBitmapX(a.to) - o.timeToBitmapX(a.from)),
-        height: n.getMediaHeight() * t.verticalPixelRatio,
-        range: a,
-        timeToX: (u) => o.timeToBitmapX(u)
+        width: Math.abs(o.timeToBitmapX(n.to) - o.timeToBitmapX(n.from)),
+        height: s.getMediaHeight() * t.verticalPixelRatio,
+        range: n,
+        timeToX: (c) => o.timeToBitmapX(c),
+        ...a
       }));
     }
-    const m = this.#e?.clip;
-    if (m !== void 0) {
-      const l = m.fromX ?? 0, u = m.toX ?? t.bitmapSize.width;
-      t.context.save(), t.context.beginPath(), t.context.rect(l, 0, Math.max(0, u - l), t.bitmapSize.height), t.context.clip();
+    const b = this.#e?.clip;
+    if (b !== void 0) {
+      const l = b.fromX ?? 0, c = b.toX ?? t.bitmapSize.width;
+      t.context.save(), t.context.beginPath(), t.context.rect(l, 0, Math.max(0, c - l), t.bitmapSize.height), t.context.clip();
     }
-    const v = this.#t?.clip;
-    let b = !1;
-    if (v !== void 0 && a !== null) {
-      const l = o.timeToBitmapX(a.to), u = Math.abs(l - o.timeToBitmapX(a.from)), x = o.barWidthBitmap(e.dataInterval), R = v.fromX ?? 0, r = v.toX ?? u;
-      t.context.save(), t.context.beginPath(), t.context.rect(l - r - x, 0, Math.max(0, r - R + x), t.bitmapSize.height), t.context.rect(l, 0, Math.max(0, t.bitmapSize.width - l), t.bitmapSize.height), t.context.clip(), b = !0;
+    const d = this.#t?.clip;
+    let p = !1;
+    if (d !== void 0 && n !== null) {
+      const l = o.timeToBitmapX(n.to), c = Math.abs(l - o.timeToBitmapX(n.from)), x = o.barWidthBitmap(e.dataInterval), r = d.fromX ?? 0, w = d.toX ?? c;
+      t.context.save(), t.context.beginPath(), t.context.rect(l - w - x, 0, Math.max(0, w - r + x), t.bitmapSize.height), t.context.rect(l, 0, Math.max(0, t.bitmapSize.width - l), t.bitmapSize.height), t.context.clip(), p = !0;
     }
     switch (this.options.stacking) {
       case "normal":
@@ -177,240 +194,273 @@ class et extends $ {
         this.renderOff(e);
         break;
     }
-    b && t.context.restore(), m !== void 0 && t.context.restore();
+    p && t.context.restore(), b !== void 0 && t.context.restore();
   }
   /** Stacking off — each layer drawn independently from zero, overlapping */
   renderOff(e) {
-    const { scope: t, timeScale: o, yScale: n, dataInterval: a } = e, { context: m, horizontalPixelRatio: v } = t, b = o.getRange();
-    let l = 0;
-    for (const M of this.stores) {
-      if (!M.isVisible()) continue;
-      const p = M.getVisibleData(b.from, b.to).length;
-      if (p > l && (l = p), l > 2) break;
+    const { scope: t, timeScale: o, yScale: s, dataInterval: a } = e, { context: n, horizontalPixelRatio: b } = t, d = o.getRange();
+    let p = 0;
+    for (const B of this.stores) {
+      if (!B.isVisible()) continue;
+      const f = B.getVisibleData(d.from, d.to).length;
+      if (f > p && (p = f), p > 2) break;
     }
-    const u = o.barWidthBitmap(a), x = Math.round(30 * v), R = l <= 2 ? Math.min(x, u) : u, r = Math.max(1, Math.round(R * this.options.barWidthRatio) - 2), W = Math.floor(r / 2), H = this.options.anchor === "right" ? r : W, T = n.getRange().min < 0, f = T ? n.valueToBitmapY(0) : t.bitmapSize.height;
+    const l = o.barWidthBitmap(a), c = Math.round(30 * b), x = p <= 2 ? Math.min(c, l) : l, r = Math.max(1, Math.round(x * this.options.barWidthRatio) - 2), w = Math.floor(r / 2), j = this.options.anchor === "right" ? r : w, E = s.getRange().min < 0, u = E ? s.valueToBitmapY(0) : t.bitmapSize.height;
     if (this.stores.length === 1) {
       if (!this.stores[0].isVisible()) return;
-      const M = this.stores[0].getVisibleData(b.from, b.to);
-      for (const p of M) {
-        if (!Number.isFinite(p.value)) continue;
-        const d = this.effectiveValue(e, 0, p.time, p.value), P = this.introValue({ layerIndex: 0, time: p.time, value: d }), B = this.entranceProgress(0, p.time), i = this.isProjectedTime(p.time), h = o.timeToBitmapX(p.time), s = this.resolveLayerColor(0, d);
-        if (P >= 0) {
-          const g = n.valueToBitmapY(P), c = Math.max(1, f - g);
+      const B = this.stores[0].getVisibleData(d.from, d.to);
+      for (const f of B) {
+        if (!s.isPlottable(f.value)) continue;
+        const I = this.effectiveValue(e, 0, f.time, f.value), g = this.introValue({ layerIndex: 0, time: f.time, value: I }), M = this.entranceProgress(0, f.time), Y = this.isProjectedTime(f.time), R = o.timeToBitmapX(f.time), A = this.resolveLayerColor(0, I);
+        if (g >= 0) {
+          const i = s.valueToBitmapY(g), m = Math.max(1, u - i);
           this.drawAnimatedBar({
-            context: m,
-            time: p.time,
-            progress: B,
-            baselineY: f,
-            topY: g,
-            barHeight: c,
-            x: h - H,
+            context: n,
+            time: f.time,
+            progress: M,
+            baselineY: u,
+            topY: i,
+            barHeight: m,
+            x: R - j,
             barWidth: r,
-            color: s,
+            color: A,
             roundEdge: "top",
-            isProjected: i
+            isProjected: Y
           });
         } else {
-          const g = n.valueToBitmapY(P), c = Math.max(1, g - f);
+          const i = s.valueToBitmapY(g), m = Math.max(1, i - u);
           this.drawAnimatedBar({
-            context: m,
-            time: p.time,
-            progress: B,
-            baselineY: f,
-            topY: f,
-            barHeight: c,
-            x: h - H,
+            context: n,
+            time: f.time,
+            progress: M,
+            baselineY: u,
+            topY: u,
+            barHeight: m,
+            x: R - j,
             barWidth: r,
-            color: s,
+            color: A,
             roundEdge: "bottom",
-            isProjected: i
+            isProjected: Y
           });
         }
       }
     } else {
-      const M = this.stores.map(
-        (d, P) => this.getLayerAlpha(P) > 0 ? d.getVisibleData(b.from, b.to) : []
-      ), p = /* @__PURE__ */ new Map();
-      for (let d = 0; d < M.length; d++) {
-        const P = this.getLayerAlpha(d);
-        for (const B of M[d]) {
-          if (!Number.isFinite(B.value)) continue;
-          let i = p.get(B.time);
-          i || (i = [], p.set(B.time, i));
-          const h = this.effectiveValue(e, d, B.time, B.value) * P;
-          i.push({
-            layer: d,
-            value: this.introValue({ layerIndex: d, time: B.time, value: h }),
+      const B = this.stores.map(
+        (g, M) => this.getLayerAlpha(M) > 0 ? g.getVisibleData(d.from, d.to) : []
+      ), f = /* @__PURE__ */ new Map(), I = s.baselineValue();
+      for (let g = 0; g < B.length; g++) {
+        const M = this.getLayerAlpha(g);
+        for (const Y of B[g]) {
+          if (!s.isPlottable(Y.value)) continue;
+          let R = f.get(Y.time);
+          R || (R = [], f.set(Y.time, R));
+          const A = this.effectiveValue(e, g, Y.time, Y.value), i = M === 1 ? A : s.lerpValue(I, A, M);
+          R.push({
+            layer: g,
+            value: this.introValue({ layerIndex: g, time: Y.time, value: i }),
             // Color resolves from the settled data value — same contract as
             // the single-layer path — so a threshold value-fn doesn't flicker
             // hues while the intro sweeps the drawn value from 0 to final.
-            colorValue: B.value
+            colorValue: Y.value
           });
         }
       }
-      for (const [d, P] of p) {
-        P.sort(
-          (h, s) => Math.abs(s.value) - Math.abs(h.value)
+      for (const [g, M] of f) {
+        M.sort(
+          (A, i) => Math.abs(i.value) - Math.abs(A.value)
         );
-        const B = o.timeToBitmapX(d), i = this.isProjectedTime(d);
-        for (let h = 0; h < P.length; h++) {
-          const { layer: s, value: g, colorValue: c } = P[h], S = this.resolveLayerColor(s, c), E = this.entranceProgress(s, d);
-          if (g >= 0) {
-            const k = n.valueToBitmapY(g), V = Math.max(1, f - k);
+        const Y = o.timeToBitmapX(g), R = this.isProjectedTime(g);
+        for (let A = 0; A < M.length; A++) {
+          const { layer: i, value: m, colorValue: h } = M[A], T = this.resolveLayerColor(i, h), v = this.entranceProgress(i, g);
+          if (m >= 0) {
+            const V = s.valueToBitmapY(m), S = Math.max(1, u - V);
             this.drawAnimatedBar({
-              context: m,
-              time: d,
-              progress: E,
-              baselineY: f,
-              topY: k,
-              barHeight: V,
-              x: B - H,
+              context: n,
+              time: g,
+              progress: v,
+              baselineY: u,
+              topY: V,
+              barHeight: S,
+              x: Y - j,
               barWidth: r,
-              color: S,
+              color: T,
               roundEdge: "top",
-              isProjected: i
+              isProjected: R
             });
           } else {
-            const k = n.valueToBitmapY(g), V = Math.max(1, k - f);
+            const V = s.valueToBitmapY(m), S = Math.max(1, V - u);
             this.drawAnimatedBar({
-              context: m,
-              time: d,
-              progress: E,
-              baselineY: f,
-              topY: f,
-              barHeight: V,
-              x: B - H,
+              context: n,
+              time: g,
+              progress: v,
+              baselineY: u,
+              topY: u,
+              barHeight: S,
+              x: Y - j,
               barWidth: r,
-              color: S,
+              color: T,
               roundEdge: "bottom",
-              isProjected: i
+              isProjected: R
             });
           }
         }
       }
     }
-    if (T) {
-      m.strokeStyle = e.theme.grid.color, m.lineWidth = 1;
-      const M = Math.round(f) + 0.5;
-      m.beginPath(), m.moveTo(0, M), m.lineTo(t.bitmapSize.width, M), m.stroke();
+    if (E) {
+      n.strokeStyle = e.theme.grid.color, n.lineWidth = 1;
+      const B = Math.round(u) + 0.5;
+      n.beginPath(), n.moveTo(0, B), n.lineTo(t.bitmapSize.width, B), n.stroke();
     }
   }
   /** Stacked (normal or percent) rendering */
   renderStacked(e, t) {
-    const { scope: o, timeScale: n, yScale: a, dataInterval: m } = e, { context: v, horizontalPixelRatio: b } = o, l = n.getRange();
-    let u = 0;
+    const { scope: o, timeScale: s, yScale: a, dataInterval: n } = e, { context: b, horizontalPixelRatio: d } = o, p = s.getRange();
+    let l = 0;
     for (const i of this.stores) {
       if (!i.isVisible()) continue;
-      const h = i.getVisibleData(l.from, l.to).length;
-      if (h > u && (u = h), u > 2) break;
+      const m = i.getVisibleData(p.from, p.to).length;
+      if (m > l && (l = m), l > 2) break;
     }
-    const x = n.barWidthBitmap(m), R = Math.round(30 * b), r = u <= 2 ? Math.min(R, x) : x, W = Math.max(1, Math.round(r * this.options.barWidthRatio) - 2), H = Math.floor(W / 2), T = this.options.anchor === "right" ? W : H, f = this.stores.map(
-      (i, h) => this.getLayerAlpha(h) > 0 ? i.getVisibleData(l.from, l.to) : []
+    const c = s.barWidthBitmap(n), x = Math.round(30 * d), r = l <= 2 ? Math.min(x, c) : c, w = Math.max(1, Math.round(r * this.options.barWidthRatio) - 2), j = Math.floor(w / 2), E = this.options.anchor === "right" ? w : j, u = this.stores.map(
+      (i, m) => this.getLayerAlpha(m) > 0 ? i.getVisibleData(p.from, p.to) : []
     );
-    if (f.every((i) => i.length === 0)) return;
-    const M = this.options.entryAnimation ?? "fade-grow", p = M === "grow" || M === "fade-grow", d = /* @__PURE__ */ new Map();
-    for (let i = 0; i < f.length; i++) {
-      const h = this.getLayerAlpha(i);
-      for (const s of f[i]) {
-        let g = d.get(s.time);
-        g || (g = new Array(f.length).fill(0), d.set(s.time, g));
-        const c = Number.isFinite(s.value) ? s.value : 0;
-        let S = this.effectiveValue(e, i, s.time, c) * h;
-        p && !this.isProjectedTime(s.time) && (S *= this.entranceProgress(i, s.time)), g[i] = this.introValue({ layerIndex: i, time: s.time, value: S });
+    if (u.every((i) => i.length === 0)) return;
+    const B = this.options.entryAnimation ?? "fade-grow", f = B === "grow" || B === "fade-grow", I = a.getTransform() !== null && !t, g = /* @__PURE__ */ new Map(), M = /* @__PURE__ */ new Map();
+    for (let i = 0; i < u.length; i++) {
+      const m = this.getLayerAlpha(i);
+      for (const h of u[i]) {
+        let T = M.get(h.time);
+        T || (T = new Array(u.length).fill(0), M.set(h.time, T));
+        const v = a.isPlottable(h.value) ? h.value : 0, V = this.effectiveValue(e, i, h.time, v);
+        let S = V * m, X = m;
+        if (f && !this.isProjectedTime(h.time)) {
+          const W = this.entranceProgress(i, h.time);
+          S *= W, X *= W;
+        }
+        if (I) {
+          T[i] = S;
+          let W = g.get(h.time);
+          W || (W = { settled: new Array(u.length).fill(0), weights: new Array(u.length).fill(0) }, g.set(h.time, W)), W.settled[i] = V, W.weights[i] = X;
+          continue;
+        }
+        T[i] = this.introValue({ layerIndex: i, time: h.time, value: S });
       }
     }
-    const P = /* @__PURE__ */ new Map(), B = /* @__PURE__ */ new Map();
-    for (const [i, h] of d) {
-      let s = -1, g = -1;
-      for (let c = 0; c < h.length; c++)
-        h[c] > 0 && (s = c), h[c] < 0 && (g = c);
-      s >= 0 && P.set(i, s), g >= 0 && B.set(i, g);
+    const Y = /* @__PURE__ */ new Map();
+    if (!t)
+      for (const [i, m] of M) {
+        const h = g.get(i);
+        Y.set(i, h === void 0 ? st(m) : this.scaleEdges({ time: i, share: h, yScale: a }));
+      }
+    const R = /* @__PURE__ */ new Map(), A = /* @__PURE__ */ new Map();
+    for (const [i, m] of M) {
+      let h = -1, T = -1;
+      for (let v = 0; v < m.length; v++)
+        m[v] > 0 && (h = v), m[v] < 0 && (T = v);
+      h >= 0 && R.set(i, h), T >= 0 && A.set(i, T);
     }
-    for (let i = 0; i < f.length; i++) {
-      const h = this.resolveLayerColor(i, this.stores[i].last()?.value ?? 0);
-      for (const [s, g] of d) {
-        const c = g[i];
-        if (c === 0) continue;
-        const S = n.timeToBitmapX(s);
-        let E = 0, k = 0;
-        for (let Y = 0; Y < i; Y++) {
-          const w = g[Y];
-          w > 0 ? E += w : k += w;
-        }
-        const V = this.entranceProgress(i, s), X = this.isProjectedTime(s), z = c > 0 ? P.get(s) === i ? "top" : "none" : B.get(s) === i ? "bottom" : "none";
+    for (let i = 0; i < u.length; i++) {
+      const m = this.resolveLayerColor(i, this.stores[i].last()?.value ?? 0);
+      for (const [h, T] of M) {
+        const v = T[i];
+        if (v === 0) continue;
+        const V = s.timeToBitmapX(h), S = this.entranceProgress(i, h), X = this.isProjectedTime(h), W = v > 0 ? R.get(h) === i ? "top" : "none" : A.get(h) === i ? "bottom" : "none";
         if (t) {
-          let Y = 0, w = 0;
-          for (const A of g)
-            A > 0 ? Y += A : w += A;
-          if (c > 0 && Y > 0) {
-            const A = E / Y * 100, D = (E + c) / Y * 100, j = a.valueToBitmapY(D), L = a.valueToBitmapY(A), O = Math.max(1, L - j);
+          let L = 0, D = 0;
+          for (let P = 0; P < i; P++) {
+            const k = T[P];
+            k > 0 ? L += k : D += k;
+          }
+          let z = 0, H = 0;
+          for (const P of T)
+            P > 0 ? z += P : H += P;
+          if (v > 0 && z > 0) {
+            const P = L / z * 100, k = (L + v) / z * 100, C = a.valueToBitmapY(k), O = a.valueToBitmapY(P), _ = Math.max(1, O - C);
             this.drawAnimatedBar({
-              context: v,
-              time: s,
-              progress: V,
-              baselineY: L,
-              topY: j,
-              barHeight: O,
-              x: S - T,
-              barWidth: W,
-              color: h,
-              roundEdge: z,
+              context: b,
+              time: h,
+              progress: S,
+              baselineY: O,
+              topY: C,
+              barHeight: _,
+              x: V - E,
+              barWidth: w,
+              color: m,
+              roundEdge: W,
               isProjected: X,
               growBaked: !0
             });
-          } else if (c < 0 && w < 0) {
-            const A = k / w * -100, D = (k + c) / w * -100, j = a.valueToBitmapY(A), L = a.valueToBitmapY(D), O = Math.max(1, L - j);
+          } else if (v < 0 && H < 0) {
+            const P = D / H * -100, k = (D + v) / H * -100, C = a.valueToBitmapY(P), O = a.valueToBitmapY(k), _ = Math.max(1, O - C);
             this.drawAnimatedBar({
-              context: v,
-              time: s,
-              progress: V,
-              baselineY: j,
-              topY: j,
-              barHeight: O,
-              x: S - T,
-              barWidth: W,
-              color: h,
-              roundEdge: z,
+              context: b,
+              time: h,
+              progress: S,
+              baselineY: C,
+              topY: C,
+              barHeight: _,
+              x: V - E,
+              barWidth: w,
+              color: m,
+              roundEdge: W,
               isProjected: X,
               growBaked: !0
             });
           }
-        } else if (c > 0) {
-          const Y = a.valueToBitmapY(E + c), w = a.valueToBitmapY(E), A = Math.max(1, w - Y);
-          this.drawAnimatedBar({
-            context: v,
-            time: s,
-            progress: V,
-            baselineY: w,
-            topY: Y,
-            barHeight: A,
-            x: S - T,
-            barWidth: W,
-            color: h,
-            roundEdge: z,
-            isProjected: X,
-            growBaked: !0
-          });
         } else {
-          const Y = a.valueToBitmapY(k), w = a.valueToBitmapY(k + c), A = Math.max(1, w - Y);
-          this.drawAnimatedBar({
-            context: v,
-            time: s,
-            progress: V,
-            baselineY: Y,
-            topY: Y,
-            barHeight: A,
-            x: S - T,
-            barWidth: W,
-            color: h,
-            roundEdge: z,
-            isProjected: X,
-            growBaked: !0
-          });
+          const L = Y.get(h);
+          if (L === void 0) continue;
+          const D = L.base[i], z = L.end[i];
+          if (v > 0) {
+            const H = a.valueToBitmapY(z), P = a.valueToBitmapY(D), k = Math.max(1, P - H);
+            this.drawAnimatedBar({
+              context: b,
+              time: h,
+              progress: S,
+              baselineY: P,
+              topY: H,
+              barHeight: k,
+              x: V - E,
+              barWidth: w,
+              color: m,
+              roundEdge: W,
+              isProjected: X,
+              growBaked: !0
+            });
+          } else {
+            const H = a.valueToBitmapY(D), P = a.valueToBitmapY(z), k = Math.max(1, P - H);
+            this.drawAnimatedBar({
+              context: b,
+              time: h,
+              progress: S,
+              baselineY: H,
+              topY: H,
+              barHeight: k,
+              x: V - E,
+              barWidth: w,
+              color: m,
+              roundEdge: W,
+              isProjected: X,
+              growBaked: !0
+            });
+          }
         }
       }
     }
   }
+  /**
+   * Segment edges of one column on a non-linear axis. Fades and entrances
+   * stack through {@link ScaleStack}; the intro then moves each drawn edge,
+   * so the column grows from the floor as one unit at an even pixel speed.
+   */
+  scaleEdges(e) {
+    const { time: t, share: o, yScale: s } = e, a = { positive: new F(s), negative: new F(s) }, n = { positive: a.positive.edge, negative: a.negative.edge }, b = [], d = [];
+    for (let p = 0; p < o.settled.length; p++) {
+      const l = o.settled[p], c = l < 0 ? "negative" : "positive", x = a[c].push(l, o.weights[p]), r = this.introValue({ layerIndex: p, time: t, value: x });
+      b.push(n[c]), d.push(r), n[c] = r;
+    }
+    return { base: b, end: d };
+  }
   /**
    * Paint one bar through the resolved painter, applying any entrance transform
    * and per-bar alpha first. The painter owns the fill (and the rounded-corner
@@ -420,54 +470,54 @@ class et extends $ {
   drawAnimatedBar(e) {
     const t = this.#o;
     if (t === null) return;
-    const { context: o, baselineY: n, topY: a, barHeight: m, x: v, barWidth: b, color: l, roundEdge: u } = e, x = e.isProjected ? 1 : e.progress, R = this.options.entryAnimation ?? "fade-grow";
-    let r = x >= 1 || R === "none" ? { x: v, topY: a, barWidth: b, barHeight: m, alpha: 1 } : this.applyBarTransform(e, x);
+    const { context: o, baselineY: s, topY: a, barHeight: n, x: b, barWidth: d, color: p, roundEdge: l } = e, c = e.isProjected ? 1 : e.progress, x = this.options.entryAnimation ?? "fade-grow";
+    let r = c >= 1 || x === "none" ? { x: b, topY: a, barWidth: d, barHeight: n, alpha: 1 } : this.applyBarTransform(e, c);
     if (!e.isProjected) {
-      const H = this.#t?.element, T = H !== void 0 ? this.#r(e.time) : null, f = T !== null ? H : this.#e?.element, M = T ?? (f !== void 0 ? this.#a(e.time) : null);
-      if (f !== void 0 && M !== null) {
-        const p = f({
-          ...M,
+      const j = this.#t?.element, E = j !== void 0 ? this.#s(e.time) : null, u = E !== null ? j : this.#e?.element, B = E ?? (u !== void 0 ? this.#a(e.time) : null);
+      if (u !== void 0 && B !== null) {
+        const f = u({
+          ...B,
           time: e.time,
           x: r.x,
           topY: r.topY,
           barHeight: r.barHeight,
-          baselineY: n,
+          baselineY: s,
           barWidth: r.barWidth
         });
         r = {
           ...r,
-          x: r.x + (p.offsetX ?? 0),
-          topY: r.topY + (p.offsetY ?? 0),
-          alpha: r.alpha * (p.alpha ?? 1)
+          x: r.x + (f.offsetX ?? 0),
+          topY: r.topY + (f.offsetY ?? 0),
+          alpha: r.alpha * (f.alpha ?? 1)
         };
       }
     }
-    const W = {
-      geom: { x: r.x, y: r.topY, width: r.barWidth, height: r.barHeight, baselineY: n },
-      color: l,
-      corners: tt[u],
+    const w = {
+      geom: { x: r.x, y: r.topY, width: r.barWidth, height: r.barHeight, baselineY: s },
+      color: p,
+      corners: at[l],
       // Clamp to this bar's geometry so `radius` honors its pre-clamped contract
       // for custom painters; `fillRoundedRect` re-clamps to the same bound, so
       // the built-in output is unchanged.
       radius: Math.min(t.radius, r.barWidth / 2, r.barHeight / 2),
-      progress: x,
+      progress: c,
       isProjected: e.isProjected
     };
     if (r.alpha < 1) {
-      o.save(), o.globalAlpha = r.alpha, t.painter(t.env, W), o.restore();
+      o.save(), o.globalAlpha = r.alpha, t.painter(t.env, w), o.restore();
       return;
     }
-    t.painter(t.env, W);
+    t.painter(t.env, w);
   }
 }
-const nt = {
+const pt = {
   type: "bar",
   create: ({ theme: y, layerCount: e }, t) => {
     const o = e === 1 ? [y.bar?.color ?? y.seriesColors[0] ?? "#26a69a"] : y.seriesColors.slice(0, e);
-    return new et(e, { colors: o, ...t });
+    return new rt(e, { colors: o, ...t });
   }
 };
 export {
-  et as BarRenderer,
-  nt as BarSeriesDef
+  rt as BarRenderer,
+  pt as BarSeriesDef
 };