@wick-charts/vue 0.5.0 → 0.6.0

package/dist/core/dist/data/sync.js

@@ -1,47 +1,69 @@
-import { normalizeTime as h } from "../utils/time.js";
-const y = { len: 0, firstTime: null, lastTime: null }, d = 20;
-function f(a) {
-  return typeof a == "object" && a !== null && !Array.isArray(a) && Array.isArray(a.data);
+import { normalizeTime as s } from "../utils/time.js";
+const g = { len: 0, firstTime: null, lastTime: null, data: null }, d = 20;
+function c(t, a) {
+  if (s(t.time) !== s(a.time)) return !1;
+  const r = Object.keys(t), e = Object.keys(a);
+  return r.length !== e.length ? !1 : r.every((n) => n === "time" || t[n] === a[n]);
 }
-function p(a) {
-  if (!Array.isArray(a)) return [a];
-  if (a.length === 0) return [{ data: [] }];
-  const r = a[0];
-  return Array.isArray(r) || f(r) ? a.map((t) => Array.isArray(t) ? { data: t } : t) : [{ data: a }];
+function y(t, a) {
+  if (!t || t.length !== a.length || t === a) return !1;
+  for (let r = 0; r < a.length - 1; r++)
+    if (t[r] !== a[r] && !c(t[r], a[r]))
+      return !1;
+  return !0;
 }
-function A(a) {
-  const { chart: r, id: t } = a, e = p(a.data), l = e.length > 1 ? e.map((n, i) => n.label ?? `Series ${i + 1}`) : [e[0].label];
-  r.setSeriesLabels(t, l), r.setLayerColors(
-    t,
-    e.map((n) => n.color)
+function p(t, a, r) {
+  if (!t || t.length === 0 || r <= 0 || t.length !== a.length - r) return !1;
+  for (let e = 1; e < r; e++)
+    if (s(a[e - 1].time) >= s(a[e].time)) return !1;
+  if (s(a[r - 1].time) >= s(t[0].time)) return !1;
+  for (let e = 0; e < t.length; e++)
+    if (!c(t[e], a[r + e])) return !1;
+  return !0;
+}
+function T(t) {
+  return typeof t == "object" && t !== null && !Array.isArray(t) && Array.isArray(t.data);
+}
+function A(t) {
+  if (!Array.isArray(t)) return [t];
+  if (t.length === 0) return [{ data: [] }];
+  const a = t[0];
+  return Array.isArray(a) || T(a) ? t.map((r) => Array.isArray(r) ? { data: r } : r) : [{ data: t }];
+}
+function D(t) {
+  const { chart: a, id: r } = t, e = A(t.data), n = e.length > 1 ? e.map((l, f) => l.label ?? `Series ${f + 1}`) : [e[0].label];
+  a.setSeriesLabels(r, n), a.setLayerColors(
+    r,
+    e.map((l) => l.color)
   );
-  const s = [];
-  return r.batch(() => {
-    for (let n = 0; n < e.length; n++)
-      s[n] = T({
-        chart: r,
-        id: t,
-        data: e[n].data,
-        prev: a.prev[n] ?? y,
-        layerIndex: n
+  const i = [];
+  return a.batch(() => {
+    for (let l = 0; l < e.length; l++)
+      i[l] = b({
+        chart: a,
+        id: r,
+        data: e[l].data,
+        prev: t.prev[l] ?? g,
+        layerIndex: l
       });
-  }), s;
+  }), i;
 }
-function T(a) {
-  const { chart: r, id: t, data: e, prev: l, layerIndex: s } = a;
+function b(t) {
+  const { chart: a, id: r, data: e, prev: n, layerIndex: i } = t;
   if (e.length === 0)
-    return r.setSeriesData(t, [], s), { len: 0, firstTime: null, lastTime: null };
-  const n = h(e[0].time), i = h(e[e.length - 1].time), c = l.firstTime !== null && l.firstTime !== n, u = e.length - l.len, m = l.lastTime !== null && l.lastTime !== i;
-  return c && u === 0 && m ? r.batch(() => {
-    r.appendData(t, e[e.length - 1], s), r.keepLast(t, e.length, s);
-  }) : l.len === 0 || e.length < l.len || u > d || c ? r.setSeriesData(t, e, s) : e.length === l.len ? r.updateData(t, e[e.length - 1], s) : r.batch(() => {
-    for (let o = l.len; o < e.length; o++)
-      r.appendData(t, e[o], s);
-  }), { len: e.length, firstTime: n, lastTime: i };
+    return a.setSeriesData(r, [], i), { len: 0, firstTime: null, lastTime: null, data: [] };
+  if (n.data === e && n.len === e.length) return n;
+  const l = s(e[0].time), f = s(e[e.length - 1].time), h = n.firstTime !== null && n.firstTime !== l, u = e.length - n.len, m = n.lastTime !== null && n.lastTime !== f;
+  return h && u === 0 && m ? a.batch(() => {
+    a.appendData(r, e[e.length - 1], i), a.keepLast(r, e.length, i);
+  }) : p(n.data, e, u) ? a.prependData(r, e.slice(0, u), i) : n.len === 0 || e.length < n.len || u > d || h ? a.setSeriesData(r, e, i) : e.length === n.len ? y(n.data, e) ? a.updateData(r, e[e.length - 1], i) : a.setSeriesData(r, e, i) : a.batch(() => {
+    for (let o = n.len; o < e.length; o++)
+      a.appendData(r, e[o], i);
+  }), { len: e.length, firstTime: l, lastTime: f, data: e };
 }
 export {
-  y as EMPTY_SYNC_STATE,
-  A as syncLayers,
-  T as syncSeriesLayer,
-  p as toLayers
+  g as EMPTY_SYNC_STATE,
+  D as syncLayers,
+  b as syncSeriesLayer,
+  A as toLayers
 };

package/dist/core/dist/heatmap-tooltip.js

@@ -0,0 +1,16 @@
+import { formatCompact as a } from "./utils/format.js";
+const s = 170, o = 78;
+function i(e) {
+  return Number.isInteger(e) ? e.toString() : a(e);
+}
+function m(e, t) {
+  if (t !== void 0) return t;
+  const r = e.getSeriesIdsByType("heatmap", { visibleOnly: !0 });
+  return r.length > 0 ? r[0] : null;
+}
+export {
+  o as HEATMAP_TOOLTIP_HEIGHT,
+  s as HEATMAP_TOOLTIP_WIDTH,
+  i as defaultHeatmapFormat,
+  m as resolveHeatmapSeriesId
+};

package/dist/core/dist/interactions/handler.js

@@ -1,29 +1,30 @@
-import { EventEmitter as c } from "../events.js";
-import { clamp as u } from "../utils/math.js";
-import { PanHandler as l } from "./pan.js";
+import { EventEmitter as a } from "../events.js";
+import { clamp as l } from "../utils/math.js";
+import { PanHandler as u } from "./pan.js";
 import { ZoomHandler as r } from "./zoom.js";
-function i(n, t) {
-  const e = n.clientX - t.clientX, s = n.clientY - t.clientY;
-  return Math.hypot(e, s);
+function i(o, e) {
+  const t = o.clientX - e.clientX, s = o.clientY - e.clientY;
+  return Math.hypot(t, s);
 }
-class M extends c {
+const d = 5, v = 500;
+class M extends a {
   zoom;
   pan;
   canvas;
   timeScale;
   yScale;
   target;
-  constructor(t, e, s, o) {
-    super(), this.canvas = t, this.target = e, this.timeScale = s, this.yScale = o, this.zoom = new r(e, s), this.pan = new l(e, s, t), t.style.cursor = "crosshair", t.style.touchAction = "none", t.addEventListener("wheel", this.onWheel, { passive: !1 }), t.addEventListener("mousedown", this.onMouseDown), t.addEventListener("mousemove", this.onMouseMove), t.addEventListener("mouseup", this.onMouseUp), t.addEventListener("mouseleave", this.onMouseLeave), t.addEventListener("dblclick", this.onDblClick), t.addEventListener("touchstart", this.onTouchStart, { passive: !1 }), t.addEventListener("touchmove", this.onTouchMove, { passive: !1 }), t.addEventListener("touchend", this.onTouchEnd), t.addEventListener("touchcancel", this.onTouchCancel);
+  constructor(e, t, s, n) {
+    super(), this.canvas = e, this.target = t, this.timeScale = s, this.yScale = n, this.zoom = new r(t, s), this.pan = new u(t, s, e), e.style.cursor = "crosshair", e.style.touchAction = "none", e.addEventListener("wheel", this.onWheel, { passive: !1 }), e.addEventListener("mousedown", this.onMouseDown), e.addEventListener("mousemove", this.onMouseMove), e.addEventListener("mouseup", this.onMouseUp), e.addEventListener("mouseleave", this.onMouseLeave), e.addEventListener("click", this.onClick), e.addEventListener("dblclick", this.onDblClick), e.addEventListener("touchstart", this.onTouchStart, { passive: !1 }), e.addEventListener("touchmove", this.onTouchMove, { passive: !1 }), e.addEventListener("touchend", this.onTouchEnd), e.addEventListener("touchcancel", this.onTouchCancel);
   }
-  onWheel = (t) => {
-    this.zoom.handleWheel(t);
+  onWheel = (e) => {
+    this.zoom.handleWheel(e);
   };
-  onMouseDown = (t) => {
-    this.zoom.cancelPendingRebound(), this.pan.handleMouseDown(t);
+  onMouseDown = (e) => {
+    this.zoom.cancelPendingRebound(), this.pan.handleMouseDown(e), this.downClient = { x: e.clientX, y: e.clientY };
   };
-  onMouseMove = (t) => {
-    this.pan.isDragging() && this.pan.handleMouseMove(t), this.emitCrosshair(t.offsetX, t.offsetY);
+  onMouseMove = (e) => {
+    this.pan.isDragging() && this.pan.handleMouseMove(e), this.emitCrosshair(e.offsetX, e.offsetY);
   };
   onMouseUp = () => {
     this.pan.handleMouseUp();
@@ -31,52 +32,75 @@ class M extends c {
   onMouseLeave = () => {
     this.pan.handleMouseUp(), this.emit("crosshairMove", null);
   };
-  onDblClick = () => {
+  // Pointer-down origin (mouse or the single touch that started a tap),
+  // used to tell a click/tap from a drag that happened to end over the canvas.
+  downClient = null;
+  onClick = (e) => {
+    this.movedBeyondClickTolerance(e.clientX, e.clientY) || e.detail > 1 || this.emit("click", this.posFromOffset(e.offsetX, e.offsetY));
   };
+  onDblClick = (e) => {
+    this.emit("dblclick", this.posFromOffset(e.offsetX, e.offsetY));
+  };
+  movedBeyondClickTolerance(e, t) {
+    return this.downClient ? Math.hypot(e - this.downClient.x, t - this.downClient.y) > d : !1;
+  }
   // Touch handling
   lastTouchDist = 0;
   touchCount = 0;
-  onTouchStart = (t) => {
-    t.preventDefault(), this.zoom.cancelPendingRebound(), this.touchCount = t.touches.length, t.touches.length === 1 ? this.pan.handleMouseDown({
+  touchDownTime = 0;
+  // True once a gesture has ever held two fingers (a pinch). A pinch is never a
+  // tap, even after it decays to one finger, so this gates tap synthesis in
+  // onTouchEnd — otherwise lifting both fingers in quick succession would
+  // synthesize a phantom 'click'.
+  gestureHadTwoFingers = !1;
+  onTouchStart = (e) => {
+    e.preventDefault(), this.zoom.cancelPendingRebound(), this.touchCount = e.touches.length, e.touches.length === 1 ? (this.pan.handleMouseDown({
       button: 0,
-      clientX: t.touches[0].clientX
-    }) : t.touches.length === 2 && (this.lastTouchDist = i(t.touches[0], t.touches[1]));
+      clientX: e.touches[0].clientX
+    }), this.downClient = { x: e.touches[0].clientX, y: e.touches[0].clientY }, this.touchDownTime = Date.now(), this.gestureHadTwoFingers = !1) : e.touches.length === 2 && (this.lastTouchDist = i(e.touches[0], e.touches[1]), this.gestureHadTwoFingers = !0);
   };
-  onTouchMove = (t) => {
-    if (t.preventDefault(), t.touches.length === 1 && this.touchCount === 1)
+  onTouchMove = (e) => {
+    if (e.preventDefault(), e.touches.length === 1 && this.touchCount === 1)
       this.pan.handleMouseMove({
-        clientX: t.touches[0].clientX
+        clientX: e.touches[0].clientX
       });
-    else if (t.touches.length === 2) {
-      const e = i(t.touches[0], t.touches[1]), s = (t.touches[0].clientX + t.touches[1].clientX) / 2, o = this.canvas.getBoundingClientRect();
-      if (e > 0 && this.lastTouchDist > 0) {
-        const h = u(this.lastTouchDist / e, 0.1, 10), a = this.timeScale.xToTime(s - o.left);
-        this.target.zoomAt(a, h, this.timeScale.getMediaWidth());
+    else if (e.touches.length === 2) {
+      const t = i(e.touches[0], e.touches[1]), s = (e.touches[0].clientX + e.touches[1].clientX) / 2, n = this.canvas.getBoundingClientRect();
+      if (t > 0 && this.lastTouchDist > 0) {
+        const h = l(this.lastTouchDist / t, 0.1, 10), c = this.timeScale.xToTime(s - n.left);
+        this.target.zoomAt(c, h, this.timeScale.getMediaWidth());
       }
-      this.lastTouchDist = e;
+      this.lastTouchDist = t;
     }
   };
-  onTouchEnd = (t) => {
-    if (t.touches.length === 0) {
-      this.pan.handleMouseUp(), this.touchCount = 0, this.lastTouchDist = 0, this.emit("crosshairMove", null);
+  onTouchEnd = (e) => {
+    if (e.touches.length === 0) {
+      const t = e.changedTouches[0];
+      if (this.touchCount === 1 && !this.gestureHadTwoFingers && t && !this.movedBeyondClickTolerance(t.clientX, t.clientY) && Date.now() - this.touchDownTime <= v) {
+        const s = this.canvas.getBoundingClientRect();
+        this.emit("click", this.posFromOffset(t.clientX - s.left, t.clientY - s.top));
+      }
+      this.pan.handleMouseUp(), this.touchCount = 0, this.lastTouchDist = 0, this.downClient = null, this.gestureHadTwoFingers = !1, this.emit("crosshairMove", null);
       return;
     }
-    t.touches.length === 1 && (this.touchCount = 1, this.lastTouchDist = 0, this.pan.handleMouseDown({ button: 0, clientX: t.touches[0].clientX }));
+    e.touches.length === 1 && (this.touchCount = 1, this.lastTouchDist = 0, this.pan.handleMouseDown({ button: 0, clientX: e.touches[0].clientX }), this.downClient = { x: e.touches[0].clientX, y: e.touches[0].clientY }, this.touchDownTime = Date.now());
   };
   onTouchCancel = () => {
-    this.pan.handleMouseUp(), this.touchCount = 0, this.lastTouchDist = 0, this.emit("crosshairMove", null);
+    this.pan.handleMouseUp(), this.touchCount = 0, this.lastTouchDist = 0, this.downClient = null, this.gestureHadTwoFingers = !1, this.emit("crosshairMove", null);
   };
-  emitCrosshair(t, e) {
-    const s = this.timeScale.xToTime(t), o = this.yScale.yToValue(e);
-    this.emit("crosshairMove", {
-      mediaX: t,
-      mediaY: e,
-      time: s,
-      y: o
-    });
+  posFromOffset(e, t) {
+    return {
+      mediaX: e,
+      mediaY: t,
+      time: this.timeScale.xToTime(e),
+      y: this.yScale.yToValue(t)
+    };
+  }
+  emitCrosshair(e, t) {
+    this.emit("crosshairMove", this.posFromOffset(e, t));
   }
   destroy() {
-    this.zoom.cancelPendingRebound(), this.canvas.removeEventListener("wheel", this.onWheel), this.canvas.removeEventListener("mousedown", this.onMouseDown), this.canvas.removeEventListener("mousemove", this.onMouseMove), this.canvas.removeEventListener("mouseup", this.onMouseUp), this.canvas.removeEventListener("mouseleave", this.onMouseLeave), this.canvas.removeEventListener("dblclick", this.onDblClick), this.canvas.removeEventListener("touchstart", this.onTouchStart), this.canvas.removeEventListener("touchmove", this.onTouchMove), this.canvas.removeEventListener("touchend", this.onTouchEnd), this.canvas.removeEventListener("touchcancel", this.onTouchCancel), this.removeAllListeners();
+    this.zoom.cancelPendingRebound(), this.canvas.removeEventListener("wheel", this.onWheel), this.canvas.removeEventListener("mousedown", this.onMouseDown), this.canvas.removeEventListener("mousemove", this.onMouseMove), this.canvas.removeEventListener("mouseup", this.onMouseUp), this.canvas.removeEventListener("mouseleave", this.onMouseLeave), this.canvas.removeEventListener("click", this.onClick), this.canvas.removeEventListener("dblclick", this.onDblClick), this.canvas.removeEventListener("touchstart", this.onTouchStart), this.canvas.removeEventListener("touchmove", this.onTouchMove), this.canvas.removeEventListener("touchend", this.onTouchEnd), this.canvas.removeEventListener("touchcancel", this.onTouchCancel), this.removeAllListeners();
   }
 }
 export {

package/dist/core/dist/perf/perf-hud.js

@@ -2,7 +2,7 @@ import { ChartInstance as R } from "../chart.js";
 import { LineSeriesDef as E } from "../series/line.js";
 import { PerfMonitor as g } from "./perf-monitor.js";
 import { createTheme as T } from "../theme/create.js";
-function J(i) {
+function N(i) {
   const e = i instanceof g;
   return {
     monitor: e ? i : new g(i),
@@ -449,5 +449,5 @@ class D {
 }
 export {
   D as PerfHud,
-  J as perfHud
+  N as perfHud
 };

package/dist/core/dist/scales/x-scale.js

@@ -1,13 +1,13 @@
-import { niceTimeIntervals as u } from "../utils/time.js";
-import { AxisTickTracker as m } from "./tick-tracker.js";
-const c = 50, f = 80;
+import { formatTime as m, niceTimeIntervals as c } from "../utils/time.js";
+import { AxisTickTracker as f } from "./tick-tracker.js";
+const o = 50, v = 80;
 class p {
   /**
    * Shared fade state for time ticks. Grid lines (canvas) and DOM tick labels
    * read opacity from the same tracker, so a tick fading in/out looks
    * identical on both surfaces.
    */
-  tickTracker = new m();
+  tickTracker = new f();
   from = 0;
   to = 0;
   width = 1;
@@ -16,6 +16,12 @@ class p {
   // Label density knobs — written by <TimeAxis labelCount=… minLabelSpacing=…>.
   labelCountHintValue = null;
   minSpacingValue = null;
+  /** Custom formatter (driven by `setFormat` / a future `<TimeAxis format=…>`). */
+  customFormat = null;
+  /** Custom tick generator — bypasses tier resolution in `niceTickValues` when set. */
+  customTickGenerator = null;
+  localeValue;
+  timeZoneValue;
   resolvedInterval = null;
   lastInterval = null;
   /**
@@ -31,20 +37,58 @@ class p {
     return this.labelCountHintValue;
   }
   get minLabelSpacing() {
-    return this.minSpacingValue ?? f;
+    return this.minSpacingValue ?? v;
   }
-  update(t, s, a, e) {
-    if (this.from = t.from, this.to = t.to, this.width = s, this.pixelRatio = a, e !== void 0 && e > 0) {
-      const n = h(e);
-      this.lastBucketKey !== null && this.lastBucketKey !== n && this.resetHysteresis(), this.lastBucketKey = n, this.dataInterval = e;
+  update(t, e, n, r) {
+    if (this.from = t.from, this.to = t.to, this.width = e, this.pixelRatio = n, r !== void 0 && r > 0) {
+      const a = h(r);
+      this.lastBucketKey !== null && this.lastBucketKey !== a && this.resetHysteresis(), this.lastBucketKey = a, this.dataInterval = r;
     }
     this.resolveInterval();
   }
   setLabelCount(t) {
-    this.labelCountHintValue = v(t), this.resetHysteresis(), this.resolveInterval();
+    this.labelCountHintValue = d(t), this.resetHysteresis(), this.resolveInterval();
   }
   setMinSpacing(t) {
-    this.minSpacingValue = d(t), this.resetHysteresis(), this.resolveInterval();
+    this.minSpacingValue = I(t), this.resetHysteresis(), this.resolveInterval();
+  }
+  /** Install (or clear) a custom tick-label formatter. */
+  setFormat(t) {
+    this.customFormat = t;
+  }
+  /** Read back the currently installed formatter — null when the built-in is active. */
+  getFormat() {
+    return this.customFormat;
+  }
+  /**
+   * Install (or clear) a custom tick-value generator. When set, it replaces
+   * `niceTimeIntervals` tier resolution entirely — `niceTickValues` calls it
+   * directly with the current range and reports its own tick spacing.
+   */
+  setTickGenerator(t) {
+    this.customTickGenerator = t, this.resetHysteresis();
+  }
+  /** BCP 47 locale applied to the built-in formatter. Ignored while a custom `setFormat` is installed. */
+  setLocale(t) {
+    this.localeValue = t;
+  }
+  getLocale() {
+    return this.localeValue;
+  }
+  /** IANA timezone applied to the built-in formatter. Ignored while a custom `setFormat` is installed. */
+  setTimeZone(t) {
+    this.timeZoneValue = t;
+  }
+  getTimeZone() {
+    return this.timeZoneValue;
+  }
+  /**
+   * Format a tick timestamp for display. A custom formatter (via
+   * {@link setFormat}) wins; otherwise falls back to the built-in
+   * `formatTime`, applying the installed locale/timezone.
+   */
+  formatX(t, e) {
+    return this.customFormat ? this.customFormat(t, e) : m(t, e, { locale: this.localeValue, timeZone: this.timeZoneValue });
   }
   resetHysteresis() {
     this.lastInterval = null, this.lastWant = null;
@@ -74,14 +118,18 @@ class p {
    */
   niceTickValues(t) {
     if (this.to <= this.from) return { ticks: [], tickInterval: 0 };
+    if (this.customTickGenerator) {
+      const i = this.customTickGenerator({ from: this.from, to: this.to }, t).slice(0, o), l = i.length >= 2 ? i[1] - i[0] : t;
+      return { ticks: i, tickInterval: l };
+    }
     if (this.dataInterval !== t) {
-      const r = h(t);
-      this.lastBucketKey !== null && this.lastBucketKey !== r && this.resetHysteresis(), this.lastBucketKey = r, this.dataInterval = t, this.resolveInterval();
+      const i = h(t);
+      this.lastBucketKey !== null && this.lastBucketKey !== i && this.resetHysteresis(), this.lastBucketKey = i, this.dataInterval = t, this.resolveInterval();
     }
     if (this.resolvedInterval == null) return { ticks: [], tickInterval: 0 };
-    const s = this.resolvedInterval, a = Math.ceil(this.from / s) * s, e = Math.max(0, Math.min(c, Math.floor((this.to - a) / s) + 1)), n = [];
-    for (let r = 0; r < e; r++) n.push(a + r * s);
-    return { ticks: n, tickInterval: s };
+    const e = this.resolvedInterval, n = Math.ceil(this.from / e) * e, r = Math.max(0, Math.min(o, Math.floor((this.to - n) / e) + 1)), a = [];
+    for (let i = 0; i < r; i++) a.push(n + i * e);
+    return { ticks: a, tickInterval: e };
   }
   getRange() {
     return { from: this.from, to: this.to };
@@ -99,46 +147,46 @@ class p {
       this.resolvedInterval = null;
       return;
     }
-    const t = u(this.dataInterval), s = this.to - this.from, a = s / this.width * this.minLabelSpacing;
-    let e;
+    const t = c(this.dataInterval), e = this.to - this.from, n = e / this.width * this.minLabelSpacing;
+    let r;
     if (this.labelCountHint != null) {
       const l = Math.max(1, this.labelCountHint);
-      e = Math.max(s / l, a);
+      r = Math.max(e / l, n);
     } else
-      e = a;
+      r = n;
     if (this.lastInterval != null && this.lastWant != null && t.includes(this.lastInterval)) {
-      const l = e >= this.lastWant * 0.8 && e <= this.lastWant * 1.25, o = this.lastInterval >= a;
-      if (l && o) {
+      const l = r >= this.lastWant * 0.8 && r <= this.lastWant * 1.25, u = this.lastInterval >= n;
+      if (l && u) {
         this.resolvedInterval = this.lastInterval;
         return;
       }
     }
-    let n = t[t.length - 1], r = t.length - 1;
+    let a = t[t.length - 1], i = t.length - 1;
     for (let l = 0; l < t.length; l++)
-      if (t[l] >= e) {
-        n = t[l], r = l;
+      if (t[l] >= r) {
+        a = t[l], i = l;
         break;
       }
-    if (this.labelCountHint != null && r > 0 && this.countTicks(n) < this.labelCountHint) {
-      const l = t[r - 1];
-      l >= a && (n = l);
+    if (this.labelCountHint != null && i > 0 && this.countTicks(a) < this.labelCountHint) {
+      const l = t[i - 1];
+      l >= n && (a = l);
     }
-    this.resolvedInterval = n, this.lastInterval = n, this.lastWant = e;
+    this.resolvedInterval = a, this.lastInterval = a, this.lastWant = r;
   }
   countTicks(t) {
     if (!(t > 0)) return 0;
-    const s = Math.ceil(this.from / t) * t;
-    return Math.max(0, Math.floor((this.to - s) / t) + 1);
+    const e = Math.ceil(this.from / t) * t;
+    return Math.max(0, Math.floor((this.to - e) / t) + 1);
   }
 }
-function h(i) {
-  return i < 6e4 ? 0 : i < 36e5 ? 1 : i < 864e5 ? 2 : 3;
+function h(s) {
+  return s < 6e4 ? 0 : s < 36e5 ? 1 : s < 864e5 ? 2 : 3;
 }
-function v(i) {
-  return typeof i == "number" && Number.isFinite(i) && i >= 2 ? Math.floor(i) : null;
+function d(s) {
+  return typeof s == "number" && Number.isFinite(s) && s >= 2 ? Math.floor(s) : null;
 }
-function d(i) {
-  return typeof i == "number" && Number.isFinite(i) && i > 0 ? i : null;
+function I(s) {
+  return typeof s == "number" && Number.isFinite(s) && s > 0 ? s : null;
 }
 export {
   p as XScale

package/dist/core/dist/scales/y-scale.js

@@ -1,19 +1,19 @@
-import { formatCompact as h } from "../utils/format.js";
-import { AxisTickTracker as o } from "./tick-tracker.js";
-function u(n) {
-  if (!Number.isFinite(n) || n <= 0) return 1;
-  const t = 10 ** Math.floor(Math.log10(n)), i = n / t;
+import { formatCompact as o } from "../utils/format.js";
+import { AxisTickTracker as u } from "./tick-tracker.js";
+function m(e) {
+  if (!Number.isFinite(e) || e <= 0) return 1;
+  const t = 10 ** Math.floor(Math.log10(e)), i = e / t;
   return (i <= 1 ? 1 : i <= 2 ? 2 : i <= 5 ? 5 : 10) * t;
 }
-function m(n) {
-  if (!Number.isFinite(n) || n <= 0) return 1;
-  const t = 10 ** Math.floor(Math.log10(n)), i = n / t;
+function c(e) {
+  if (!Number.isFinite(e) || e <= 0) return 1;
+  const t = 10 ** Math.floor(Math.log10(e)), i = e / t;
   return (i >= 5 ? 5 : i >= 2 ? 2 : 1) * t;
 }
-const c = 50, v = 50;
+const r = 50, v = 50;
 class M {
   /** Shared fade state for Y ticks; see {@link TimeScale.tickTracker}. */
-  tickTracker = new o();
+  tickTracker = new u();
   min = 0;
   max = 0;
   height = 1;
@@ -35,6 +35,8 @@ class M {
   lastRawInterval = null;
   /** Custom formatter (driven by `<YAxis format=…>`). */
   customFormat = null;
+  /** Custom tick generator — bypasses {1,2,5}×10^k resolution in `niceTickValues` when set. */
+  customTickGenerator = null;
   get labelCountHint() {
     return this.labelCountHintValue;
   }
@@ -64,6 +66,14 @@ class M {
   getFormat() {
     return this.customFormat;
   }
+  /**
+   * Install (or clear) a custom tick-value generator. When set, it replaces
+   * {1,2,5}×10^k resolution entirely — `niceTickValues` calls it directly
+   * with the current range.
+   */
+  setTickGenerator(t) {
+    this.customTickGenerator = t, this.resetHysteresis();
+  }
   /** Convert a value to a Y position in CSS (media) pixels. */
   valueToY(t) {
     const i = this.max - this.min;
@@ -83,10 +93,11 @@ class M {
    * chart height. Pure read — resolution happens in `update()`.
    */
   niceTickValues() {
+    if (this.customTickGenerator) return this.customTickGenerator({ min: this.min, max: this.max }).slice(0, r);
     if (this.resolvedInterval == null) return [];
-    const t = this.resolvedInterval, i = Math.ceil(this.min / t) * t, a = Math.max(0, Math.min(c, Math.floor((this.max - i) / t) + 1)), e = [];
-    for (let s = 0; s < a; s++) e.push(i + s * t);
-    return e;
+    const t = this.resolvedInterval, i = Math.ceil(this.min / t) * t, a = Math.max(0, Math.min(r, Math.floor((this.max - i) / t) + 1)), s = [];
+    for (let n = 0; n < a; n++) s.push(i + n * t);
+    return s;
   }
   getRange() {
     return { min: this.min, max: this.max };
@@ -103,7 +114,7 @@ class M {
    */
   formatY(t) {
     if (this.customFormat) return this.customFormat(t);
-    if (this.max - this.min >= 1e6) return h(t);
+    if (this.max - this.min >= 1e6) return o(t);
     const i = this.resolvedInterval, a = i != null && i > 0 ? Math.max(0, -Math.floor(Math.log10(i))) : 1;
     return t.toFixed(a);
   }
@@ -124,20 +135,20 @@ class M {
       return;
     }
     const t = this.max - this.min, i = t * this.minLabelSpacing / this.height, a = this.labelCountHint != null ? Math.max(1, this.labelCountHint) : Math.max(1, Math.floor(this.height / this.minLabelSpacing));
-    let e = t / a;
-    if (e < i && (e = i), this.lastInterval != null && this.lastRawInterval != null) {
-      const l = e >= this.lastRawInterval * 0.8 && e <= this.lastRawInterval * 1.25, r = this.lastInterval >= i;
-      if (l && r) {
+    let s = t / a;
+    if (s < i && (s = i), this.lastInterval != null && this.lastRawInterval != null) {
+      const l = s >= this.lastRawInterval * 0.8 && s <= this.lastRawInterval * 1.25, h = this.lastInterval >= i;
+      if (l && h) {
         this.resolvedInterval = this.lastInterval;
         return;
       }
     }
-    let s = u(e);
-    if (this.labelCountHint != null && this.countTicks(s) < this.labelCountHint) {
-      const l = m(e);
-      l >= i && l > 0 && (s = l);
+    let n = m(s);
+    if (this.labelCountHint != null && this.countTicks(n) < this.labelCountHint) {
+      const l = c(s);
+      l >= i && l > 0 && (n = l);
     }
-    this.resolvedInterval = s, this.lastInterval = s, this.lastRawInterval = e;
+    this.resolvedInterval = n, this.lastInterval = n, this.lastRawInterval = s;
   }
   countTicks(t) {
     if (!(t > 0)) return 0;
@@ -145,11 +156,11 @@ class M {
     return Math.max(0, Math.floor((this.max - i) / t) + 1);
   }
 }
-function f(n) {
-  return typeof n == "number" && Number.isFinite(n) && n >= 2 ? Math.floor(n) : null;
+function f(e) {
+  return typeof e == "number" && Number.isFinite(e) && e >= 2 ? Math.floor(e) : null;
 }
-function g(n) {
-  return typeof n == "number" && Number.isFinite(n) && n > 0 ? n : null;
+function g(e) {
+  return typeof e == "number" && Number.isFinite(e) && e > 0 ? e : null;
 }
 export {
   M as YScale

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

@@ -0,0 +1,18 @@
+import { easeOutBack as a } from "../animation/easing.js";
+function t() {
+  return () => ({
+    value: ({ value: e, progress: r }) => e * r,
+    element: (e) => ({ alpha: e.progress })
+  });
+}
+const o = 0.3;
+function n() {
+  return () => ({
+    value: ({ value: e, progress: r }) => e * a(r),
+    element: (e) => ({ alpha: Math.min(1, e.progress / o) })
+  });
+}
+export {
+  t as growIntro,
+  n as springIntro
+};