@wick-charts/vue 0.6.4 → 0.8.0

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

@@ -1,45 +1,45 @@
-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 { ScaleStack as F } from "./scale-stack.js";
-import { fadeIntro as tt } from "./wave-intro.js";
-const G = 2, et = {
+import { DEFAULT_HISTORY_REVEAL as I, DEFAULT_BAR_INTRO as O, DEFAULT_BAR_SMOOTH as C, DEFAULT_BAR_ENTRY as _ } from "../animation/config.js";
+import { growIntro as U } from "./bar-intro.js";
+import { BaseMultiLayerSeries as N } from "./base-multi-layer.js";
+import { resolveBarPainter as $ } from "./painters/resolve.js";
+import { ScaleStack as z } from "./scale-stack.js";
+import { fadeIntro as G } from "./wave-intro.js";
+const F = 2, J = {
   // Single fallback resolver; the definition's `create` swaps in `theme.bar.color`.
   colors: ["#26a69a"],
   barWidthRatio: 0.6,
   stacking: "off",
   anchor: "center",
-  cornerRadius: G,
-  entryMs: q,
-  smoothMs: $,
-  introMs: J,
-  historyRevealMs: N
+  cornerRadius: F,
+  entryMs: _,
+  smoothMs: C,
+  introMs: O,
+  historyRevealMs: I
 };
-function U(y) {
+function D(y) {
   return {
     ...y,
-    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
+    entryMs: y.entryMs === !1 ? 0 : y.entryMs ?? _,
+    smoothMs: y.smoothMs === !1 ? 0 : y.smoothMs ?? C,
+    introMs: y.introMs === !1 ? 0 : y.introMs ?? O,
+    historyRevealMs: y.historyRevealMs === !1 ? 0 : y.historyRevealMs ?? I
   };
 }
-const it = K(), ot = tt(), at = {
+const Q = U(), Z = G(), q = {
   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 }
 };
-function st(y) {
+function K(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;
+  let o = 0, r = 0;
+  for (const i of y) {
+    const l = i > 0 ? o : r;
+    e.push(l), t.push(l + i), i > 0 ? o += i : r += i;
   }
   return { base: e, end: t };
 }
-class rt extends Q {
+class tt extends N {
   kind = "bar";
   /** Resolved drawing context for the in-flight render pass. Set at the top of
    *  {@link render}, read by {@link drawAnimatedBar}. */
@@ -53,10 +53,10 @@ class rt extends Q {
   /** Per-frame history-reveal directives; `null` when no reveal is in flight. */
   #t = null;
   constructor(e, t) {
-    super(e), this.options = U({ ...et, ...t });
+    super(e), this.options = D({ ...J, ...t });
   }
   updateOptions(e) {
-    this.options = U({ ...this.options, ...e });
+    this.options = D({ ...this.options, ...e });
   }
   isEntryEnabled() {
     return (this.options.entryAnimation ?? "fade-grow") !== "none";
@@ -68,8 +68,8 @@ class rt extends Q {
   #a(e) {
     const t = this.#i;
     if (t === null) return null;
-    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) };
+    const o = t.to - t.from, r = o > 0 ? (e - t.from) / o : 0, i = Math.min(1, Math.max(0, r));
+    return { position: i, progress: this.introWave.progressAt(i) };
   }
   /**
    * Stagger position + eased wave progress for the history reveal's
@@ -80,8 +80,8 @@ class rt extends Q {
   #s(e) {
     const t = this.historyRange;
     if (this.#t === null || t === null || e >= t.to) return null;
-    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) };
+    const o = t.to - t.from, r = o > 0 ? (t.to - e) / o : 0, i = Math.min(1, Math.max(0, r));
+    return { position: i, progress: this.historyWave.progressAt(i) };
   }
   /**
    * Apply the intro's `value` directive to one rendered value. Scaling here
@@ -95,17 +95,17 @@ class rt extends Q {
     if (this.isProjectedTime(e.time)) return e.value;
     const t = this.#t?.value;
     if (t !== void 0) {
-      const a = this.#s(e.time);
-      if (a !== null) return t({ ...e, ...a });
+      const i = this.#s(e.time);
+      if (i !== null) return t({ ...e, ...i });
     }
     const o = this.#e?.value;
     if (o === void 0) return e.value;
-    const s = this.#a(e.time);
-    return s === null ? e.value : o({ ...e, ...s });
+    const r = this.#a(e.time);
+    return r === null ? e.value : o({ ...e, ...r });
   }
   applyTheme(e, t) {
-    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 });
+    const o = this.stores.length === 1, r = e.seriesColors[0] ?? "#26a69a", i = o ? [e.bar?.color ?? r] : e.seriesColors.slice(0, this.stores.length);
+    this.updateOptions({ colors: i });
   }
   /** True when `time` is at/after the configured `projectedFrom` forecast cut. */
   isProjectedTime(e) {
@@ -118,70 +118,70 @@ class rt extends Q {
    * each render path.
    */
   applyBarTransform(e, t) {
-    const { baselineY: o, topY: s, barHeight: a, x: n, barWidth: b } = e, d = this.options.entryAnimation ?? "fade-grow";
+    const { baselineY: o, topY: r, barHeight: i, x: l, barWidth: m } = 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;
-      s < o ? p = o - r : p = o, l = Math.max(1, r);
+      return { topY: r, barHeight: i, x: l, barWidth: m, alpha: 1 };
+    let u = r, h = i, s = l, g = 1;
+    if ((d === "fade" || d === "fade-grow") && (g = t), (d === "grow" || d === "fade-grow") && !e.growBaked) {
+      const n = i * t;
+      r < o ? u = o - n : u = o, h = Math.max(1, n);
     }
-    return d === "slide" && (c = n + (1 - t) * b, x = t), { topY: p, barHeight: l, x: c, barWidth: b, alpha: x };
+    return d === "slide" && (s = l + (1 - t) * m, g = t), { topY: u, barHeight: h, x: s, barWidth: m, alpha: g };
   }
   render(e) {
     this.tickAnimations(performance.now());
-    const { scope: t, timeScale: o, yScale: s } = e;
+    const { scope: t, timeScale: o, yScale: r } = e;
     this.#o = {
-      painter: Z(this.options.barPainter),
+      painter: $(this.options.barPainter),
       env: {
         ctx: t.context,
         theme: e.theme,
         horizontalPixelRatio: t.horizontalPixelRatio,
         verticalPixelRatio: t.verticalPixelRatio
       },
-      radius: (this.options.cornerRadius ?? G) * t.horizontalPixelRatio
+      radius: (this.options.cornerRadius ?? F) * t.horizontalPixelRatio
     };
-    const a = {
-      baseline: s.baselineValue(),
-      lerpValue: (l, c, x) => s.lerpValue(l, c, x)
+    const i = {
+      baseline: r.baselineValue(),
+      lerpValue: (h, s, g) => r.lerpValue(h, s, g)
     };
     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({
+      const h = this.options.introAnimation ?? Q, s = o.getRange();
+      this.#i = s, this.#e = h({
         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: s.getMediaHeight() * t.verticalPixelRatio,
-        range: c,
-        timeToX: (x) => o.timeToBitmapX(x),
-        ...a
+        height: r.getMediaHeight() * t.verticalPixelRatio,
+        range: s,
+        timeToX: (g) => o.timeToBitmapX(g),
+        ...i
       });
     }
     this.#t = null;
-    const n = this.historyRange;
-    if (this.historyWave.active && n !== null) {
-      const l = this.options.historyReveal ?? ot;
-      l !== "none" && (this.#t = l({
+    const l = this.historyRange;
+    if (this.historyWave.active && l !== null) {
+      const h = this.options.historyReveal ?? Z;
+      h !== "none" && (this.#t = h({
         progress: this.historyWave.linear(),
-        width: Math.abs(o.timeToBitmapX(n.to) - o.timeToBitmapX(n.from)),
-        height: s.getMediaHeight() * t.verticalPixelRatio,
-        range: n,
-        timeToX: (c) => o.timeToBitmapX(c),
-        ...a
+        width: Math.abs(o.timeToBitmapX(l.to) - o.timeToBitmapX(l.from)),
+        height: r.getMediaHeight() * t.verticalPixelRatio,
+        range: l,
+        timeToX: (s) => o.timeToBitmapX(s),
+        ...i
       }));
     }
-    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 m = this.#e?.clip;
+    if (m !== void 0) {
+      const h = m.fromX ?? 0, s = m.toX ?? t.bitmapSize.width;
+      t.context.save(), t.context.beginPath(), t.context.rect(h, 0, Math.max(0, s - h), t.bitmapSize.height), t.context.clip();
     }
     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;
+    let u = !1;
+    if (d !== void 0 && l !== null) {
+      const h = o.timeToBitmapX(l.to), s = Math.abs(h - o.timeToBitmapX(l.from)), g = o.barWidthBitmap(e.dataInterval), n = d.fromX ?? 0, A = d.toX ?? s;
+      t.context.save(), t.context.beginPath(), t.context.rect(h - A - g, 0, Math.max(0, A - n + g), t.bitmapSize.height), t.context.rect(h, 0, Math.max(0, t.bitmapSize.width - h), t.bitmapSize.height), t.context.clip(), u = !0;
     }
     switch (this.options.stacking) {
       case "normal":
@@ -194,253 +194,258 @@ class rt extends Q {
         this.renderOff(e);
         break;
     }
-    p && t.context.restore(), b !== void 0 && t.context.restore();
+    u && t.context.restore(), m !== void 0 && t.context.restore();
+  }
+  /**
+   * Bar body width in bitmap px. On a category axis a bar fills its band;
+   * elsewhere it takes `barWidthRatio` of the slot, capped only when the
+   * visible range is sparse (≤ 2 points on the most-populated layer) — dense
+   * zooms must keep wide bars. See the matching comment in candlestick.ts.
+   */
+  #r(e) {
+    const { scope: t, timeScale: o, dataInterval: r } = e;
+    if (o.getType() === "category") return o.bandWidthBitmap();
+    const i = o.getRange();
+    let l = 0;
+    for (const h of this.stores) {
+      if (!h.isVisible()) continue;
+      const s = h.getVisibleData(i.from, i.to).length;
+      if (s > l && (l = s), l > 2) break;
+    }
+    const m = o.barWidthBitmap(r), d = Math.round(30 * t.horizontalPixelRatio), u = l <= 2 ? Math.min(d, m) : m;
+    return Math.max(1, Math.round(u * this.options.barWidthRatio) - 2);
   }
   /** Stacking off — each layer drawn independently from zero, overlapping */
   renderOff(e) {
-    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 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;
+    const { scope: t, timeScale: o, yScale: r } = e, { context: i } = t, l = o.getRange(), m = this.#r(e), d = Math.floor(m / 2), u = this.options.anchor === "right" ? m : d, h = r.getRange().min < 0, s = h ? r.valueToBitmapY(0) : t.bitmapSize.height;
     if (this.stores.length === 1) {
       if (!this.stores[0].isVisible()) return;
-      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);
+      const g = this.stores[0].getVisibleData(l.from, l.to);
+      for (const n of g) {
+        if (!r.isPlottable(n.value)) continue;
+        const A = this.effectiveValue(e, 0, n.time, n.value), p = this.introValue({ layerIndex: 0, time: n.time, value: A }), b = this.entranceProgress(0, n.time), v = this.isProjectedTime(n.time), B = o.timeToBitmapX(n.time), M = this.resolveLayerColor(0, A);
+        if (p >= 0) {
+          const a = r.valueToBitmapY(p), f = Math.max(1, s - a);
           this.drawAnimatedBar({
-            context: n,
-            time: f.time,
-            progress: M,
-            baselineY: u,
-            topY: i,
-            barHeight: m,
-            x: R - j,
-            barWidth: r,
-            color: A,
+            context: i,
+            time: n.time,
+            progress: b,
+            baselineY: s,
+            topY: a,
+            barHeight: f,
+            x: B - u,
+            barWidth: m,
+            color: M,
             roundEdge: "top",
-            isProjected: Y
+            isProjected: v
           });
         } else {
-          const i = s.valueToBitmapY(g), m = Math.max(1, i - u);
+          const a = r.valueToBitmapY(p), f = Math.max(1, a - s);
           this.drawAnimatedBar({
-            context: n,
-            time: f.time,
-            progress: M,
-            baselineY: u,
-            topY: u,
-            barHeight: m,
-            x: R - j,
-            barWidth: r,
-            color: A,
+            context: i,
+            time: n.time,
+            progress: b,
+            baselineY: s,
+            topY: s,
+            barHeight: f,
+            x: B - u,
+            barWidth: m,
+            color: M,
             roundEdge: "bottom",
-            isProjected: Y
+            isProjected: v
           });
         }
       }
     } else {
-      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 }),
+      const g = this.stores.map(
+        (p, b) => this.getLayerAlpha(b) > 0 ? p.getVisibleData(l.from, l.to) : []
+      ), n = /* @__PURE__ */ new Map(), A = r.baselineValue();
+      for (let p = 0; p < g.length; p++) {
+        const b = this.getLayerAlpha(p);
+        for (const v of g[p]) {
+          if (!r.isPlottable(v.value)) continue;
+          let B = n.get(v.time);
+          B || (B = [], n.set(v.time, B));
+          const M = this.effectiveValue(e, p, v.time, v.value), a = b === 1 ? M : r.lerpValue(A, M, b);
+          B.push({
+            layer: p,
+            value: this.introValue({ layerIndex: p, time: v.time, value: a }),
             // 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: Y.value
+            colorValue: v.value
           });
         }
       }
-      for (const [g, M] of f) {
-        M.sort(
-          (A, i) => Math.abs(i.value) - Math.abs(A.value)
+      for (const [p, b] of n) {
+        b.sort(
+          (M, a) => Math.abs(a.value) - Math.abs(M.value)
         );
-        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);
+        const v = o.timeToBitmapX(p), B = this.isProjectedTime(p);
+        for (let M = 0; M < b.length; M++) {
+          const { layer: a, value: f, colorValue: c } = b[M], Y = this.resolveLayerColor(a, c), x = this.entranceProgress(a, p);
+          if (f >= 0) {
+            const R = r.valueToBitmapY(f), T = Math.max(1, s - R);
             this.drawAnimatedBar({
-              context: n,
-              time: g,
-              progress: v,
-              baselineY: u,
-              topY: V,
-              barHeight: S,
-              x: Y - j,
-              barWidth: r,
-              color: T,
+              context: i,
+              time: p,
+              progress: x,
+              baselineY: s,
+              topY: R,
+              barHeight: T,
+              x: v - u,
+              barWidth: m,
+              color: Y,
               roundEdge: "top",
-              isProjected: R
+              isProjected: B
             });
           } else {
-            const V = s.valueToBitmapY(m), S = Math.max(1, V - u);
+            const R = r.valueToBitmapY(f), T = Math.max(1, R - s);
             this.drawAnimatedBar({
-              context: n,
-              time: g,
-              progress: v,
-              baselineY: u,
-              topY: u,
-              barHeight: S,
-              x: Y - j,
-              barWidth: r,
-              color: T,
+              context: i,
+              time: p,
+              progress: x,
+              baselineY: s,
+              topY: s,
+              barHeight: T,
+              x: v - u,
+              barWidth: m,
+              color: Y,
               roundEdge: "bottom",
-              isProjected: R
+              isProjected: B
             });
           }
         }
       }
     }
-    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();
+    if (h) {
+      i.strokeStyle = e.theme.grid.color, i.lineWidth = 1;
+      const g = Math.round(s) + 0.5;
+      i.beginPath(), i.moveTo(0, g), i.lineTo(t.bitmapSize.width, g), i.stroke();
     }
   }
   /** Stacked (normal or percent) rendering */
   renderStacked(e, t) {
-    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 m = i.getVisibleData(p.from, p.to).length;
-      if (m > l && (l = m), l > 2) break;
-    }
-    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) : []
+    const { scope: o, timeScale: r, yScale: i } = e, { context: l } = o, m = r.getRange(), d = this.#r(e), u = Math.floor(d / 2), h = this.options.anchor === "right" ? d : u, s = this.stores.map(
+      (a, f) => this.getLayerAlpha(f) > 0 ? a.getVisibleData(m.from, m.to) : []
     );
-    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 (s.every((a) => a.length === 0)) return;
+    const g = this.options.entryAnimation ?? "fade-grow", n = g === "grow" || g === "fade-grow", A = i.getTransform() !== null && !t, p = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Map();
+    for (let a = 0; a < s.length; a++) {
+      const f = this.getLayerAlpha(a);
+      for (const c of s[a]) {
+        let Y = b.get(c.time);
+        Y || (Y = new Array(s.length).fill(0), b.set(c.time, Y));
+        const x = i.isPlottable(c.value) ? c.value : 0, R = this.effectiveValue(e, a, c.time, x);
+        let T = R * f, V = f;
+        if (n && !this.isProjectedTime(c.time)) {
+          const P = this.entranceProgress(a, c.time);
+          T *= P, V *= P;
         }
-        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;
+        if (A) {
+          Y[a] = T;
+          let P = p.get(c.time);
+          P || (P = { settled: new Array(s.length).fill(0), weights: new Array(s.length).fill(0) }, p.set(c.time, P)), P.settled[a] = R, P.weights[a] = V;
           continue;
         }
-        T[i] = this.introValue({ layerIndex: i, time: h.time, value: S });
+        Y[a] = this.introValue({ layerIndex: a, time: c.time, value: T });
       }
     }
-    const Y = /* @__PURE__ */ new Map();
+    const v = /* @__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 }));
+      for (const [a, f] of b) {
+        const c = p.get(a);
+        v.set(a, c === void 0 ? K(f) : this.scaleEdges({ time: a, share: c, yScale: i }));
       }
-    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);
+    const B = /* @__PURE__ */ new Map(), M = /* @__PURE__ */ new Map();
+    for (const [a, f] of b) {
+      let c = -1, Y = -1;
+      for (let x = 0; x < f.length; x++)
+        f[x] > 0 && (c = x), f[x] < 0 && (Y = x);
+      c >= 0 && B.set(a, c), Y >= 0 && M.set(a, Y);
     }
-    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";
+    for (let a = 0; a < s.length; a++) {
+      const f = this.resolveLayerColor(a, this.stores[a].last()?.value ?? 0);
+      for (const [c, Y] of b) {
+        const x = Y[a];
+        if (x === 0) continue;
+        const R = r.timeToBitmapX(c), T = this.entranceProgress(a, c), V = this.isProjectedTime(c), P = x > 0 ? B.get(c) === a ? "top" : "none" : M.get(c) === a ? "bottom" : "none";
         if (t) {
-          let L = 0, D = 0;
-          for (let P = 0; P < i; P++) {
-            const H = T[P];
-            H > 0 ? L += H : D += H;
+          let E = 0, k = 0;
+          for (let w = 0; w < a; w++) {
+            const S = Y[w];
+            S > 0 ? E += S : k += S;
           }
-          let z = 0, k = 0;
-          for (const P of T)
-            P > 0 ? z += P : k += P;
-          if (v > 0 && z > 0) {
-            const P = L / z * 100, H = (L + v) / z * 100, C = a.valueToBitmapY(H), O = a.valueToBitmapY(P), _ = Math.max(1, O - C);
+          let H = 0, W = 0;
+          for (const w of Y)
+            w > 0 ? H += w : W += w;
+          if (x > 0 && H > 0) {
+            const w = E / H * 100, S = (E + x) / H * 100, j = i.valueToBitmapY(S), X = i.valueToBitmapY(w), L = Math.max(1, X - j);
             this.drawAnimatedBar({
-              context: b,
-              time: h,
-              progress: S,
-              baselineY: O,
-              topY: C,
-              barHeight: _,
-              x: V - E,
-              barWidth: w,
-              color: m,
-              roundEdge: W,
-              isProjected: X,
+              context: l,
+              time: c,
+              progress: T,
+              baselineY: X,
+              topY: j,
+              barHeight: L,
+              x: R - h,
+              barWidth: d,
+              color: f,
+              roundEdge: P,
+              isProjected: V,
               growBaked: !0
             });
-          } else if (v < 0 && k < 0) {
-            const P = D / k * -100, H = (D + v) / k * -100, C = a.valueToBitmapY(P), O = a.valueToBitmapY(H), _ = Math.max(1, O - C);
+          } else if (x < 0 && W < 0) {
+            const w = k / W * -100, S = (k + x) / W * -100, j = i.valueToBitmapY(w), X = i.valueToBitmapY(S), L = Math.max(1, X - j);
             this.drawAnimatedBar({
-              context: b,
-              time: h,
-              progress: S,
-              baselineY: C,
-              topY: C,
-              barHeight: _,
-              x: V - E,
-              barWidth: w,
-              color: m,
-              roundEdge: W,
-              isProjected: X,
+              context: l,
+              time: c,
+              progress: T,
+              baselineY: j,
+              topY: j,
+              barHeight: L,
+              x: R - h,
+              barWidth: d,
+              color: f,
+              roundEdge: P,
+              isProjected: V,
               growBaked: !0
             });
           }
         } else {
-          const L = Y.get(h);
-          if (L === void 0) continue;
-          const D = L.base[i], z = L.end[i];
-          if (v > 0) {
-            const k = a.valueToBitmapY(z), P = a.valueToBitmapY(D), H = Math.max(1, P - k);
+          const E = v.get(c);
+          if (E === void 0) continue;
+          const k = E.base[a], H = E.end[a];
+          if (x > 0) {
+            const W = i.valueToBitmapY(H), w = i.valueToBitmapY(k), S = Math.max(1, w - W);
             this.drawAnimatedBar({
-              context: b,
-              time: h,
-              progress: S,
-              baselineY: P,
-              topY: k,
-              barHeight: H,
-              x: V - E,
-              barWidth: w,
-              color: m,
-              roundEdge: W,
-              isProjected: X,
+              context: l,
+              time: c,
+              progress: T,
+              baselineY: w,
+              topY: W,
+              barHeight: S,
+              x: R - h,
+              barWidth: d,
+              color: f,
+              roundEdge: P,
+              isProjected: V,
               growBaked: !0
             });
           } else {
-            const k = a.valueToBitmapY(D), P = a.valueToBitmapY(z), H = Math.max(1, P - k);
+            const W = i.valueToBitmapY(k), w = i.valueToBitmapY(H), S = Math.max(1, w - W);
             this.drawAnimatedBar({
-              context: b,
-              time: h,
-              progress: S,
-              baselineY: k,
-              topY: k,
-              barHeight: H,
-              x: V - E,
-              barWidth: w,
-              color: m,
-              roundEdge: W,
-              isProjected: X,
+              context: l,
+              time: c,
+              progress: T,
+              baselineY: W,
+              topY: W,
+              barHeight: S,
+              x: R - h,
+              barWidth: d,
+              color: f,
+              roundEdge: P,
+              isProjected: V,
               growBaked: !0
             });
           }
@@ -454,12 +459,12 @@ class rt extends Q {
    * 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;
+    const { time: t, share: o, yScale: r } = e, i = { positive: new z(r), negative: new z(r) }, l = { positive: i.positive.edge, negative: i.negative.edge }, m = [], d = [];
+    for (let u = 0; u < o.settled.length; u++) {
+      const h = o.settled[u], s = h < 0 ? "negative" : "positive", g = i[s].push(h, o.weights[u]), n = this.introValue({ layerIndex: u, time: t, value: g });
+      m.push(l[s]), d.push(n), l[s] = n;
     }
-    return { base: b, end: d };
+    return { base: m, end: d };
   }
   /**
    * Paint one bar through the resolved painter, applying any entrance transform
@@ -470,54 +475,55 @@ class rt extends Q {
   drawAnimatedBar(e) {
     const t = this.#o;
     if (t === null) return;
-    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);
+    const { context: o, baselineY: r, topY: i, barHeight: l, x: m, barWidth: d, color: u, roundEdge: h } = e, s = e.isProjected ? 1 : e.progress, g = this.options.entryAnimation ?? "fade-grow";
+    let n = s >= 1 || g === "none" ? { x: m, topY: i, barWidth: d, barHeight: l, alpha: 1 } : this.applyBarTransform(e, s);
     if (!e.isProjected) {
-      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({
+      const p = this.#t?.element, b = p !== void 0 ? this.#s(e.time) : null, v = b !== null ? p : this.#e?.element, B = b ?? (v !== void 0 ? this.#a(e.time) : null);
+      if (v !== void 0 && B !== null) {
+        const M = v({
           ...B,
           time: e.time,
-          x: r.x,
-          topY: r.topY,
-          barHeight: r.barHeight,
-          baselineY: s,
-          barWidth: r.barWidth
+          x: n.x,
+          topY: n.topY,
+          barHeight: n.barHeight,
+          baselineY: r,
+          barWidth: n.barWidth
         });
-        r = {
-          ...r,
-          x: r.x + (f.offsetX ?? 0),
-          topY: r.topY + (f.offsetY ?? 0),
-          alpha: r.alpha * (f.alpha ?? 1)
+        n = {
+          ...n,
+          x: n.x + (M.offsetX ?? 0),
+          topY: n.topY + (M.offsetY ?? 0),
+          alpha: n.alpha * (M.alpha ?? 1)
         };
       }
     }
-    const w = {
-      geom: { x: r.x, y: r.topY, width: r.barWidth, height: r.barHeight, baselineY: s },
-      color: p,
-      corners: at[l],
+    const A = {
+      geom: { x: n.x, y: n.topY, width: n.barWidth, height: n.barHeight, baselineY: r },
+      color: u,
+      corners: q[h],
       // 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: c,
+      radius: Math.min(t.radius, n.barWidth / 2, n.barHeight / 2),
+      progress: s,
       isProjected: e.isProjected
     };
-    if (r.alpha < 1) {
-      o.save(), o.globalAlpha = r.alpha, t.painter(t.env, w), o.restore();
+    if (n.alpha < 1) {
+      o.save(), o.globalAlpha = n.alpha, t.painter(t.env, A), o.restore();
       return;
     }
-    t.painter(t.env, w);
+    t.painter(t.env, A);
   }
 }
-const pt = {
+const nt = {
   type: "bar",
+  xTypes: ["time", "numeric", "category"],
   create: ({ theme: y, layerCount: e }, t) => {
     const o = e === 1 ? [y.bar?.color ?? y.seriesColors[0] ?? "#26a69a"] : y.seriesColors.slice(0, e);
-    return new rt(e, { colors: o, ...t });
+    return new tt(e, { colors: o, ...t });
   }
 };
 export {
-  rt as BarRenderer,
-  pt as BarSeriesDef
+  tt as BarRenderer,
+  nt as BarSeriesDef
 };