@wick-charts/vue 0.4.1 → 0.5.0

package/dist/core/dist/animation/scalar-spring.js

@@ -0,0 +1,57 @@
+class o {
+  #r;
+  #e = 0;
+  #t;
+  #h = 18.4;
+  #s = -1;
+  #i;
+  constructor(t) {
+    this.#r = t, this.#t = t, this.#i = t;
+  }
+  get current() {
+    return this.#i;
+  }
+  get target() {
+    return this.#t;
+  }
+  /**
+   * Begin a fresh spring toward `value`. Carries the current velocity over so
+   * mid-flight retargets stay continuous. `settleMs <= 0` is left to the
+   * caller to short-circuit (snap); a bare call falls back to {@link FALLBACK_MS}.
+   */
+  retarget(t, s = {}) {
+    const h = s.now ?? performance.now(), i = s.settleMs ?? 250, r = i > 0 ? 4.6 / (i / 1e3) : 18.4;
+    if (this.#s < 0) {
+      this.#t = t, this.#h = r, this.#s = h;
+      return;
+    }
+    const { x: e, v: n } = this.#n(h);
+    this.#r = e, this.#e = n, this.#h = r, this.#t = t, this.#s = h, this.#i = e;
+  }
+  /** Land at `value` immediately; velocity resets to zero. */
+  snap(t, s = {}) {
+    const h = s.now ?? performance.now();
+    this.#r = t, this.#t = t, this.#e = 0, this.#s = h, this.#i = t;
+  }
+  /** Advance the analytic solution to `now`. Returns `true` while still
+   *  perceptibly moving; `false` once settled within ε of the target (where it
+   *  snaps to the exact target so readers see a clean final value). */
+  tick(t) {
+    if (this.#s < 0)
+      return this.#s = t, !1;
+    const { x: s, v: h } = this.#n(t);
+    this.#i = s;
+    const i = this.#a();
+    return Math.abs(s - this.#t) < i && Math.abs(h) < i * this.#h ? (this.#i = this.#t, this.#r = this.#t, this.#e = 0, this.#s = t, !1) : !0;
+  }
+  #n(t) {
+    const s = Math.max(0, (t - this.#s) / 1e3), h = Math.exp(-this.#h * s), i = this.#r - this.#t, r = this.#e + this.#h * i, e = this.#t + (i + r * s) * h, n = (r - this.#h * (i + r * s)) * h;
+    return { x: e, v: n };
+  }
+  #a() {
+    return Math.max(Math.abs(this.#t), 1) * 1e-4;
+  }
+}
+export {
+  o as ScalarSpring
+};

package/dist/core/dist/animation/spring.js

@@ -0,0 +1,11 @@
+import { VisibleRangeSpring as n } from "./visible-range-spring.js";
+import { YRangeSpring as r } from "./y-range-spring.js";
+function g() {
+  return ({ initial: i }) => t(i) ? new r({ initial: i }) : new n({ initial: i });
+}
+function t(i) {
+  return "min" in i && "max" in i;
+}
+export {
+  g as spring
+};

package/dist/core/dist/animation/time.js

@@ -0,0 +1,19 @@
+const t = /^(\d+(?:\.\d+)?)(ms|s)$/;
+function n(i) {
+  if (i === !1) return 0;
+  if (typeof i == "number") return i;
+  if (typeof i == "string") {
+    const r = t.exec(i);
+    if (!r) throw new Error(`Invalid AnimationTime: ${JSON.stringify(i)}`);
+    const e = Number.parseFloat(r[1]);
+    return r[2] === "s" ? e * 1e3 : e;
+  }
+  throw new Error(`Invalid AnimationTime: ${String(i)}`);
+}
+function o(i, r) {
+  return i === void 0 ? r : n(i);
+}
+export {
+  n as parseAnimationTime,
+  o as resolveAnimationTime
+};

package/dist/core/dist/animation/viewport-engine.js

@@ -0,0 +1,174 @@
+class g {
+  #t;
+  #i;
+  #r;
+  #e;
+  #g;
+  /** Per-frame `animating` snapshot — updated by `tick` so `get animating()`
+   *  is O(1). Spans both axes; lives at the engine root rather than in
+   *  XState/YState because it's a cross-axis flag. */
+  #s = !1;
+  constructor(t) {
+    this.#t = {
+      transition: t.y.curve({ initial: t.initial.yRange }),
+      settleMs: t.y.settleMs,
+      stickyMs: t.y.stickyMs,
+      stickyFloorMs: t.y.stickyFloorMs,
+      gestureMs: t.y.gestureMs,
+      toggleMs: t.y.toggleMs,
+      toggleUntil: 0
+    }, this.#i = {
+      transition: t.x.curve({ initial: t.initial.xRange }),
+      settleMs: t.x.settleMs,
+      gestureMs: t.x.gestureMs,
+      lastTarget: null,
+      gestureUntil: 0
+    }, this.#r = t.computeXTarget, this.#e = t.computeYTarget, this.#g = t.onWake;
+  }
+  // --- Helpers -------------------------------------------------------------
+  /**
+   * Retarget X and record `#x.lastTarget` — autoscroll consults that field for
+   * the logical destination, not the in-flight visual.
+   *
+   * `settleMs` is the per-call settle time. Gestures pass `#x.gestureMs`
+   * (fast — responsive feel) while stream ticks pass `#x.settleMs` (the
+   * cadence-tuned baseline).
+   */
+  #a(t, s, i) {
+    this.#i.transition.retarget(t, { now: s, expandMs: i }), this.#i.lastTarget = { from: t.from, to: t.to };
+  }
+  #o(t, s) {
+    this.#i.transition.snap({ from: t.from, to: t.to }, { now: s }), this.#i.lastTarget = { from: t.from, to: t.to };
+  }
+  /** Fire `onWake` once when an idle engine receives a new retarget. */
+  #n(t) {
+    t && this.#g?.();
+  }
+  /**
+   * Magnitude-scaled inward (sticky) settle time. The configured `stickyMs`
+   * is the budget for contracting a *full range* worth; the duration handed
+   * to the curve scales with how far the bound actually recedes, so the
+   * inward speed stays roughly constant: a big outlier easing off uses the
+   * full sticky hold while a small recede finishes near the floor instead of
+   * crawling over the whole budget.
+   *
+   * The magnitude is the larger of the two sides' inward deltas (the side
+   * that contracts most sets the pace), normalized by the current visible
+   * range. The curve applies the returned duration only to sides that are
+   * actually contracting — expanding sides always use `settleMs` — so a
+   * single value here is correct even when one bound expands while the other
+   * contracts. `stickyFloorMs === stickyMs` collapses this back to a fixed
+   * duration.
+   */
+  #h(t, s) {
+    const i = this.#t.stickyMs;
+    if (i <= 0) return i;
+    const n = Math.max(t.max - t.min, Number.EPSILON), e = Math.max(0, s.min - t.min), r = Math.max(0, t.max - s.max), a = Math.min(1, Math.max(e, r) / n), h = Math.min(this.#t.stickyFloorMs, i);
+    return Math.max(h, i * a);
+  }
+  // --- Inputs --------------------------------------------------------------
+  onPointAppended(t) {
+    const s = t ?? performance.now();
+    if (s < this.#i.gestureUntil) return;
+    const i = this.#r(), n = i ?? this.#i.transition.target, e = this.#e({ xTarget: n });
+    if (i === null && e === null) return;
+    const r = !this.#s, a = s < this.#t.toggleUntil;
+    i !== null && this.#a(i, s, this.#i.settleMs), e !== null && !a && this.#t.transition.retarget(e, {
+      now: s,
+      expandMs: this.#t.settleMs,
+      contractMs: this.#h(this.#t.transition.current, e)
+    }), this.#n(r);
+  }
+  onSeriesVisibilityChanged(t) {
+    const s = this.#e({ xTarget: this.#i.transition.target });
+    if (s === null) return;
+    const i = t ?? performance.now(), n = !this.#s;
+    this.#t.toggleMs > 0 ? (this.#t.transition.snap(this.#t.transition.current, { now: i }), this.#t.transition.retarget(s, {
+      now: i,
+      expandMs: this.#t.toggleMs,
+      contractMs: this.#t.toggleMs
+    }), this.#t.toggleUntil = i + this.#t.toggleMs) : (this.#t.transition.snap(s, { now: i }), this.#t.toggleUntil = 0), this.#n(n);
+  }
+  onPanZoom(t, s) {
+    const i = s ?? performance.now(), n = !this.#s;
+    if (this.#a(t.xTarget, i, this.#i.gestureMs), this.#i.gestureUntil = i + 100, t.yAuto) {
+      const e = this.#e({ xTarget: t.xTarget });
+      e !== null && this.#t.transition.retarget(e, {
+        now: i,
+        expandMs: this.#t.gestureMs,
+        contractMs: this.#t.gestureMs
+      });
+    }
+    this.#n(n);
+  }
+  onAxisReconfig(t) {
+    const s = this.#e({ xTarget: this.#i.transition.target });
+    if (s === null) return;
+    const i = t ?? performance.now(), n = !this.#s;
+    this.#t.transition.snap(s, { now: i }), this.#n(n);
+  }
+  onProgrammaticZoom(t, s) {
+    this.#i.gestureUntil = 0;
+    const i = this.#e({ xTarget: t.xTarget }), n = s ?? performance.now(), e = !this.#s;
+    if (t.xEase === !0) {
+      this.#a(t.xTarget, n, this.#i.gestureMs), i !== null && this.#t.transition.retarget(i, {
+        now: n,
+        expandMs: this.#t.settleMs,
+        contractMs: this.#h(this.#t.transition.current, i)
+      }), this.#n(e);
+      return;
+    }
+    this.#o(t.xTarget, n), i !== null && this.#t.transition.retarget(i, {
+      now: n,
+      expandMs: this.#t.settleMs,
+      contractMs: this.#h(this.#t.transition.current, i)
+    }), this.#n(e);
+  }
+  onDataReplaced(t) {
+    const s = this.#r(), i = this.#e({ xTarget: s ?? this.#i.transition.target });
+    if (s === null && i === null) return;
+    const n = t ?? performance.now(), e = !this.#s;
+    s !== null && this.#o(s, n), i !== null && this.#t.transition.snap(i, { now: n }), this.#n(e);
+  }
+  snap(t, s) {
+    this.#i.gestureUntil = 0;
+    const i = s ?? performance.now(), n = !this.#s;
+    t.x !== void 0 && this.#o(t.x, i), t.y !== void 0 && this.#t.transition.snap(t.y, { now: i }), this.#n(n);
+  }
+  // --- Outputs -------------------------------------------------------------
+  tick(t) {
+    this.#i.transition.tick(t), this.#t.transition.tick(t);
+    const s = this.#i.transition.animating || this.#t.transition.animating;
+    return this.#s = s, {
+      xRange: this.#i.transition.current,
+      yRange: this.#t.transition.current,
+      animating: s
+    };
+  }
+  getAnimationState() {
+    return {
+      xRange: this.#i.transition.current,
+      yRange: this.#t.transition.current,
+      animating: this.#i.transition.animating || this.#t.transition.animating
+    };
+  }
+  getTarget() {
+    return { x: this.#i.transition.target, y: this.#t.transition.target };
+  }
+  get animating() {
+    return this.#i.transition.animating || this.#t.transition.animating;
+  }
+  get lastXTarget() {
+    return this.#i.lastTarget;
+  }
+  setXSettleMs(t) {
+    this.#i.settleMs = t;
+  }
+}
+function l(o) {
+  return new g(o);
+}
+export {
+  g as ViewportEngine,
+  l as createViewportEngine
+};

package/dist/core/dist/animation/visible-range-spring.js

@@ -0,0 +1,64 @@
+const c = 22.999999999999996;
+class M {
+  #h;
+  #r = 0;
+  #a = 0;
+  #t;
+  /** Active natural frequency for the current animation. Set on each
+   *  `retarget` from the per-call `expandMs`. */
+  #i = c;
+  #s = -1;
+  #o;
+  constructor(t) {
+    this.#h = { from: t.initial.from, to: t.initial.to }, this.#t = { from: t.initial.from, to: t.initial.to }, this.#o = { from: t.initial.from, to: t.initial.to };
+  }
+  get current() {
+    return this.#o;
+  }
+  get target() {
+    return this.#t;
+  }
+  get animating() {
+    const t = this.#m();
+    return Math.abs(this.#o.from - this.#t.from) > t || Math.abs(this.#o.to - this.#t.to) > t || Math.abs(this.#r) > t * this.#i || Math.abs(this.#a) > t * this.#i;
+  }
+  retarget(t, i = {}) {
+    const s = i.expandMs ?? 200;
+    if (s <= 0) {
+      this.snap(t, i);
+      return;
+    }
+    const h = i.now ?? performance.now(), o = 4.6 / (s / 1e3);
+    if (this.#s < 0) {
+      this.#t = { from: t.from, to: t.to }, this.#i = o, this.#s = h;
+      return;
+    }
+    const { x: a, vFrom: n, vTo: r } = this.#n(h);
+    this.#h = a, this.#r = n, this.#a = r, this.#i = o, this.#t = { from: t.from, to: t.to }, this.#s = h, this.#o = a;
+  }
+  /** Land at `value` immediately. Velocity is reset to zero. */
+  snap(t, i = {}) {
+    const s = i.now ?? performance.now();
+    this.#h = { from: t.from, to: t.to }, this.#t = { from: t.from, to: t.to }, this.#r = 0, this.#a = 0, this.#s = s, this.#o = { from: t.from, to: t.to };
+  }
+  /** Advance the analytic solution to `now`. Returns `true` while still
+   *  perceptibly moving (animating); `false` when settled within ε of target. */
+  tick(t) {
+    if (this.#s < 0)
+      return this.#s = t, !1;
+    const { x: i, vFrom: s, vTo: h } = this.#n(t);
+    this.#o = i;
+    const o = this.#m();
+    return Math.abs(i.from - this.#t.from) < o && Math.abs(i.to - this.#t.to) < o && Math.abs(s) < o * this.#i && Math.abs(h) < o * this.#i ? (this.#o = { from: this.#t.from, to: this.#t.to }, this.#h = { from: this.#t.from, to: this.#t.to }, this.#r = 0, this.#a = 0, this.#s = t, !1) : !0;
+  }
+  #n(t) {
+    const i = Math.max(0, (t - this.#s) / 1e3), s = Math.exp(-this.#i * i), h = this.#h.from - this.#t.from, o = this.#r + this.#i * h, a = this.#t.from + (h + o * i) * s, n = (o - this.#i * (h + o * i)) * s, r = this.#h.to - this.#t.to, m = this.#a + this.#i * r, f = this.#t.to + (r + m * i) * s, e = (m - this.#i * (r + m * i)) * s;
+    return { x: { from: a, to: f }, vFrom: n, vTo: e };
+  }
+  #m() {
+    return Math.max(this.#t.to - this.#t.from, 1) * 1e-4;
+  }
+}
+export {
+  M as VisibleRangeSpring
+};

package/dist/core/dist/animation/y-range-hermite.js

@@ -0,0 +1,72 @@
+class c {
+  #t;
+  #m = 0;
+  #r = 0;
+  #i;
+  #n = -1;
+  /** Per-side active duration in seconds. */
+  #h = 250 / 1e3;
+  #a = 250 / 1e3;
+  #s;
+  constructor(i) {
+    this.#t = { min: i.initial.min, max: i.initial.max }, this.#i = { min: i.initial.min, max: i.initial.max }, this.#s = { min: i.initial.min, max: i.initial.max };
+  }
+  get current() {
+    return this.#s;
+  }
+  get target() {
+    return this.#i;
+  }
+  get animating() {
+    if (this.#n < 0) return !1;
+    const i = this.#c();
+    return Math.abs(this.#s.min - this.#i.min) > i || Math.abs(this.#s.max - this.#i.max) > i;
+  }
+  retarget(i, h = {}) {
+    const s = h.now ?? performance.now(), t = h.expandMs ?? 250, a = h.contractMs ?? 250;
+    if (this.#n < 0) {
+      this.#i = { min: i.min, max: i.max }, this.#h = (i.min < this.#s.min ? t : a) / 1e3, this.#a = (i.max > this.#s.max ? t : a) / 1e3, this.#n = s;
+      return;
+    }
+    const { x: n, vMin: m, vMax: r } = this.#e(s);
+    this.#t = n, this.#m = Math.sign(m) === Math.sign(i.min - n.min) ? m : 0, this.#r = Math.sign(r) === Math.sign(i.max - n.max) ? r : 0, this.#h = (i.min < n.min ? t : a) / 1e3, this.#a = (i.max > n.max ? t : a) / 1e3, this.#i = { min: i.min, max: i.max }, this.#n = s, this.#s = n;
+  }
+  snap(i, h = {}) {
+    const s = h.now ?? performance.now();
+    this.#t = { min: i.min, max: i.max }, this.#i = { min: i.min, max: i.max }, this.#m = 0, this.#r = 0, this.#n = s, this.#s = { min: i.min, max: i.max };
+  }
+  tick(i) {
+    if (this.#n < 0)
+      return this.#n = i, !1;
+    if (this.#t.min === this.#i.min && this.#t.max === this.#i.max && this.#m === 0 && this.#r === 0)
+      return !1;
+    const { x: h } = this.#e(i);
+    this.#s = h;
+    const s = (i - this.#n) / 1e3;
+    return s >= this.#h && s >= this.#a ? (this.#s = { min: this.#i.min, max: this.#i.max }, this.#t = { min: this.#i.min, max: this.#i.max }, this.#m = 0, this.#r = 0, !1) : !0;
+  }
+  #e(i) {
+    const h = Math.max(0, (i - this.#n) / 1e3), s = this.#h > 0 ? Math.min(1, h / this.#h) : 1, t = this.#a > 0 ? Math.min(1, h / this.#a) : 1, a = this.#x(this.#t.min, this.#m, this.#i.min, s, this.#h), n = s >= 1 ? 0 : this.#o(this.#t.min, this.#m, this.#i.min, s, this.#h), m = this.#x(this.#t.max, this.#r, this.#i.max, t, this.#a), r = t >= 1 ? 0 : this.#o(this.#t.max, this.#r, this.#i.max, t, this.#a);
+    return { x: { min: a, max: m }, vMin: n, vMax: r };
+  }
+  #x(i, h, s, t, a) {
+    if (t >= 1) return s;
+    const n = t * t, m = n * t, r = 2 * m - 3 * n + 1, e = m - 2 * n + t, o = -2 * m + 3 * n;
+    return r * i + e * a * h + o * s;
+  }
+  #o(i, h, s, t, a) {
+    if (a <= 0) return 0;
+    const n = t * t, m = 6 * n - 6 * t, r = 3 * n - 4 * t + 1, e = -6 * n + 6 * t;
+    return (m * i + r * a * h + e * s) / a;
+  }
+  #c() {
+    return Math.max(this.#i.max - this.#i.min, 1) * 1e-4;
+  }
+}
+function u() {
+  return ({ initial: x }) => new c({ initial: x });
+}
+export {
+  c as YRangeHermite,
+  u as hermite
+};

package/dist/core/dist/animation/y-range-snap.js

@@ -0,0 +1,31 @@
+class r {
+  #t;
+  constructor(t) {
+    this.#t = { ...t.initial };
+  }
+  get current() {
+    return this.#t;
+  }
+  get target() {
+    return this.#t;
+  }
+  get animating() {
+    return !1;
+  }
+  retarget(t) {
+    this.#t = { ...t };
+  }
+  snap(t) {
+    this.#t = { ...t };
+  }
+  tick() {
+    return !1;
+  }
+}
+function i() {
+  return ({ initial: n }) => new r({ initial: n });
+}
+export {
+  r as RangeSnap,
+  i as snap
+};

package/dist/core/dist/animation/y-range-spring.js

@@ -0,0 +1,59 @@
+class u {
+  #n;
+  #m = 0;
+  #x = 0;
+  #i;
+  /** Per-side ω selected at the most recent retarget call. Sample uses
+   *  these — sides can run at different speeds during the same chase. */
+  #h = 18.4;
+  #a = 18.4;
+  #t = -1;
+  #s;
+  constructor(i) {
+    this.#n = { min: i.initial.min, max: i.initial.max }, this.#i = { min: i.initial.min, max: i.initial.max }, this.#s = { min: i.initial.min, max: i.initial.max };
+  }
+  get current() {
+    return this.#s;
+  }
+  get target() {
+    return this.#i;
+  }
+  get animating() {
+    const i = this.#r(), t = Math.min(this.#h, this.#a);
+    return Math.abs(this.#s.min - this.#i.min) > i || Math.abs(this.#s.max - this.#i.max) > i || Math.abs(this.#m) > i * t || Math.abs(this.#x) > i * t;
+  }
+  retarget(i, t = {}) {
+    const h = t.now ?? performance.now(), n = t.expandMs ?? 250, a = t.contractMs ?? 250, s = 4.6 / (n / 1e3), r = 4.6 / (a / 1e3);
+    if (this.#t < 0) {
+      this.#i = { min: i.min, max: i.max }, this.#h = s, this.#a = s, this.#t = h;
+      return;
+    }
+    const { x: m, vMin: x, vMax: e } = this.#e(h);
+    this.#n = m, this.#m = x, this.#x = e, this.#h = i.min < m.min ? s : r, this.#a = i.max > m.max ? s : r, this.#i = { min: i.min, max: i.max }, this.#t = h, this.#s = m;
+  }
+  /** Land at `value` immediately. Velocity is reset to zero. */
+  snap(i, t = {}) {
+    const h = t.now ?? performance.now();
+    this.#n = { min: i.min, max: i.max }, this.#i = { min: i.min, max: i.max }, this.#m = 0, this.#x = 0, this.#t = h, this.#s = { min: i.min, max: i.max };
+  }
+  /** Advance the analytic solution to `now`. Returns `true` while still
+   *  perceptibly moving (animating); `false` when settled within ε of target. */
+  tick(i) {
+    if (this.#t < 0)
+      return this.#t = i, !1;
+    const { x: t, vMin: h, vMax: n } = this.#e(i);
+    this.#s = t;
+    const a = this.#r(), s = Math.min(this.#h, this.#a);
+    return Math.abs(t.min - this.#i.min) < a && Math.abs(t.max - this.#i.max) < a && Math.abs(h) < a * s && Math.abs(n) < a * s ? (this.#s = { min: this.#i.min, max: this.#i.max }, this.#n = { min: this.#i.min, max: this.#i.max }, this.#m = 0, this.#x = 0, this.#t = i, !1) : !0;
+  }
+  #e(i) {
+    const t = Math.max(0, (i - this.#t) / 1e3), h = Math.exp(-this.#h * t), n = Math.exp(-this.#a * t), a = this.#n.min - this.#i.min, s = this.#m + this.#h * a, r = this.#i.min + (a + s * t) * h, m = (s - this.#h * (a + s * t)) * h, x = this.#n.max - this.#i.max, e = this.#x + this.#a * x, M = this.#i.max + (x + e * t) * n, c = (e - this.#a * (x + e * t)) * n;
+    return { x: { min: r, max: M }, vMin: m, vMax: c };
+  }
+  #r() {
+    return Math.max(this.#i.max - this.#i.min, 1) * 1e-4;
+  }
+}
+export {
+  u as YRangeSpring
+};

package/dist/core/dist/axis/dom-labels.js

@@ -0,0 +1,60 @@
+import { resolveAxisTextColor as w, resolveAxisFontSize as F } from "../theme/resolve.js";
+import { formatTime as $ } from "../utils/time.js";
+const A = 0.01;
+function I(g) {
+  const { chart: e, container: h, axis: r } = g, s = /* @__PURE__ */ new Map();
+  let m = null;
+  const y = r === "x" ? e.timeScale.tickTracker : e.yScale.tickTracker;
+  function k() {
+    return r === "x" ? e.timeScale.niceTickValues(e.getDataInterval()) : { ticks: e.yScale.niceTickValues(), tickInterval: 0 };
+  }
+  function p(t, o) {
+    return r === "x" ? $(t, o) : e.yScale.formatY(t);
+  }
+  function C(t, o) {
+    if (r === "x") {
+      t.style.left = `${e.timeScale.timeToX(o)}px`;
+      return;
+    }
+    t.style.top = `${e.yScale.valueToY(o)}px`;
+  }
+  function x(t, o) {
+    t.style.color = w(o, r), t.style.fontSize = `${F(o, r)}px`, t.style.fontFamily = o.typography.fontFamily;
+  }
+  function T(t, o, u) {
+    const n = document.createElement("span");
+    return n.textContent = p(t, o), n.style.position = "absolute", n.style.userSelect = "none", x(n, u), n.style.willChange = "opacity", r === "x" ? (n.style.transform = "translateX(-50%)", n.style.whiteSpace = "nowrap") : (n.style.right = "8px", n.style.transform = "translateY(-50%)", n.style.fontVariantNumeric = "tabular-nums"), h.appendChild(n), n;
+  }
+  function l() {
+    const t = e.getTheme(), o = t !== m;
+    m = t;
+    const { ticks: u, tickInterval: n } = k();
+    y.setCurrentTicks(u);
+    const { entries: d } = y.snapshot(), v = /* @__PURE__ */ new Set();
+    for (const { value: a, opacity: f } of d) {
+      if (f <= A) continue;
+      v.add(a);
+      let i = s.get(a);
+      if (i === void 0)
+        i = T(a, n, t), s.set(a, i);
+      else {
+        const S = p(a, n);
+        i.textContent !== S && (i.textContent = S), o && x(i, t);
+      }
+      C(i, a), i.style.opacity = String(f);
+    }
+    for (const [a, f] of s)
+      v.has(a) || (f.remove(), s.delete(a));
+  }
+  function c() {
+    e.getAnimationState().animating || l();
+  }
+  return l(), e.on("tickFrame", l), e.on("viewportChange", c), e.on("overlayChange", c), () => {
+    e.off("tickFrame", l), e.off("viewportChange", c), e.off("overlayChange", c);
+    for (const t of s.values()) t.remove();
+    s.clear();
+  };
+}
+export {
+  I as mountAxisLabels
+};

package/dist/core/dist/canvas-manager.js

@@ -0,0 +1,109 @@
+import { EventEmitter as x } from "./events.js";
+function c(v, i, t) {
+  const e = document.createElement("canvas");
+  return e.style.position = "absolute", e.style.inset = "0", e.style.width = "100%", e.style.height = "100%", e.style.display = "block", e.style.zIndex = String(i), v.appendChild(e), e;
+}
+class z extends x {
+  /** Bottom layer: background, grid, series (redraws only on data/viewport change) */
+  mainCanvas;
+  mainCtx;
+  /** Top layer: crosshair (redraws on mousemove, cheap) */
+  overlayCanvas;
+  overlayCtx;
+  resizeObserver;
+  _size;
+  supportsDevicePixelContentBox = !1;
+  constructor(i, t) {
+    super(), this.mainCanvas = c(i, 0), this.overlayCanvas = c(i, 1);
+    const e = this.mainCanvas.getContext("2d", { alpha: !0 }), a = this.overlayCanvas.getContext("2d", { alpha: !0 });
+    if (!e || !a)
+      throw new Error("CanvasManager: failed to acquire 2D rendering context");
+    this.mainCtx = t ? t.wrapContext(e, "main") : e, this.overlayCtx = t ? t.wrapContext(a, "overlay") : a;
+    const o = window.devicePixelRatio || 1;
+    this._size = {
+      media: { width: 0, height: 0 },
+      bitmap: { width: 0, height: 0 },
+      horizontalPixelRatio: o,
+      verticalPixelRatio: o
+    }, this.resizeObserver = new ResizeObserver((l) => {
+      this.handleResize(l[0]);
+    });
+    try {
+      this.resizeObserver.observe(i, { box: "device-pixel-content-box" }), this.supportsDevicePixelContentBox = !0;
+    } catch {
+      this.resizeObserver.observe(i, { box: "content-box" });
+    }
+    const s = i.getBoundingClientRect();
+    if (s.width > 0 && s.height > 0) {
+      const l = window.devicePixelRatio || 1, h = l, n = Math.round(s.width * l), r = Math.round(s.height * h);
+      this.mainCanvas.width = n, this.mainCanvas.height = r, this.overlayCanvas.width = n, this.overlayCanvas.height = r, this._size = {
+        media: { width: s.width, height: s.height },
+        bitmap: { width: n, height: r },
+        horizontalPixelRatio: n / s.width,
+        verticalPixelRatio: r / s.height
+      };
+    }
+  }
+  handleResize(i) {
+    let t, e, a, o;
+    if (this.supportsDevicePixelContentBox && i.devicePixelContentBoxSize?.[0]) {
+      const h = i.devicePixelContentBoxSize[0];
+      t = h.inlineSize, e = h.blockSize;
+      const n = i.contentBoxSize[0];
+      a = n.inlineSize, o = n.blockSize;
+    } else {
+      const h = i.contentBoxSize?.[0];
+      if (h)
+        a = h.inlineSize, o = h.blockSize;
+      else {
+        const r = i.contentRect;
+        a = r.width, o = r.height;
+      }
+      const n = window.devicePixelRatio || 1;
+      t = Math.round(a * n), e = Math.round(o * n);
+    }
+    if (t === 0 || e === 0) return;
+    this.mainCanvas.width = t, this.mainCanvas.height = e, this.overlayCanvas.width = t, this.overlayCanvas.height = e;
+    const s = t / a, l = e / o;
+    this._size = {
+      media: { width: a, height: o },
+      bitmap: { width: t, height: e },
+      horizontalPixelRatio: s,
+      verticalPixelRatio: l
+    }, this.emit("resize", this._size);
+  }
+  get size() {
+    return this._size;
+  }
+  /** Draw on the main (bottom) layer — series, grid, background */
+  useMainLayer(i) {
+    this.mainCtx.save(), i({
+      context: this.mainCtx,
+      bitmapSize: this._size.bitmap,
+      mediaSize: this._size.media,
+      horizontalPixelRatio: this._size.horizontalPixelRatio,
+      verticalPixelRatio: this._size.verticalPixelRatio
+    }), this.mainCtx.restore();
+  }
+  /** Draw on the overlay (top) layer — crosshair */
+  useOverlayLayer(i) {
+    const { width: t, height: e } = this._size.bitmap;
+    this.overlayCtx.clearRect(0, 0, t, e), this.overlayCtx.save(), i({
+      context: this.overlayCtx,
+      bitmapSize: this._size.bitmap,
+      mediaSize: this._size.media,
+      horizontalPixelRatio: this._size.horizontalPixelRatio,
+      verticalPixelRatio: this._size.verticalPixelRatio
+    }), this.overlayCtx.restore();
+  }
+  // Keep backward compat for now
+  get canvas() {
+    return this.overlayCanvas;
+  }
+  destroy() {
+    this.resizeObserver.disconnect(), this.mainCanvas.remove(), this.overlayCanvas.remove(), this.removeAllListeners();
+  }
+}
+export {
+  z as CanvasManager
+};

package/dist/core/dist/chart/edge-indicators.js

@@ -0,0 +1,26 @@
+import { renderEdgeIndicator as a } from "../components/edge-indicator.js";
+function i(e) {
+  const o = performance.now();
+  for (const t of ["left", "right"]) {
+    const n = e.edgeStates[t];
+    if (n === "idle" || n === "has-more") continue;
+    const r = e.resolveBoundary(t);
+    r !== null && a({
+      scope: e.scope,
+      timeScale: e.timeScale,
+      theme: e.theme,
+      chartMediaHeight: e.chartMediaHeight,
+      boundaryTime: r,
+      side: t,
+      state: n,
+      now: o
+    });
+  }
+}
+function c(e, o, t) {
+  return o !== null ? o : e === "left" ? t.first ?? null : t.last ?? null;
+}
+export {
+  i as drawEdgeIndicators,
+  c as resolveEdgeBoundary
+};