@wick-charts/vue 0.4.2 → 0.5.1

package/dist/core/dist/series/pie.js

@@ -0,0 +1,545 @@
+import { lighten as st } from "../utils/color.js";
+import { smoothToward as K, clamp as E } from "../utils/math.js";
+const tt = {
+  mode: "outside",
+  content: "both",
+  fontSize: 11,
+  // 2.5° ≈ 0.7% of the pie. The PAV pass handles the resulting vertical
+  // crowding; raise when labels-per-slice still crosses into illegible.
+  minSliceAngle: 2.5,
+  elbowLen: 12,
+  legPad: 6,
+  // Radial distance from the pie edge to the label ring. The label then
+  // extends horizontally outward by `railWidth` so the text anchor sits
+  // past a consistent-length horizontal tail.
+  distance: 14,
+  railWidth: 16,
+  // Multiplier on fontSize for min vertical gap between same-side labels.
+  // 1.8 gives each label room to breathe without spreading so aggressively
+  // that PAV collapses into a centered block on dense datasets.
+  labelGap: 1.8
+}, ot = {
+  innerRadiusRatio: 0,
+  // 1.15° ≈ 0.02 rad — same visual default as before the radians→degrees switch.
+  padAngle: 1.15,
+  sliceLabels: { ...tt },
+  // Motion off by default: label draw-in + hover explode both skipped.
+  animate: !1,
+  // Small-slice grouping on by default: dense datasets collapse into the top
+  // slices plus a single "Other" so outside labels stay legible.
+  other: !0,
+  // Radial depth gradient (lighter center → flat edge) on by default. Set
+  // false for flat, solid-color slices.
+  gradient: !0
+}, Q = {
+  maxSlices: 8,
+  label: "Other"
+};
+function nt(l) {
+  return l === !1 ? null : l === !0 || l === void 0 ? Q : { ...Q, ...l };
+}
+const U = Math.PI / 180;
+function lt(l, e) {
+  return { ...l ?? {}, ...e };
+}
+function it(l) {
+  return { ...tt, ...l ?? {} };
+}
+function at(l) {
+  const e = { color: "rgba(0, 0, 0, 0.22)", blur: 24, offsetX: 0, offsetY: 10 };
+  return l === !0 || l === !1 ? e : { ...e, ...l };
+}
+function rt(l) {
+  const e = { color: "rgba(0, 0, 0, 0.1)", depth: 0.3 };
+  return l === !0 || l === !1 ? e : { ...e, ...l };
+}
+const N = Math.PI * 2, et = 0.85;
+function Z(l) {
+  const { bitmapWidth: e, bitmapHeight: t, padTop: o, padBottom: i } = l, s = Math.max(0, l.labelReserve ?? 0), d = Math.min(Math.max(0, o), t), r = Math.min(Math.max(0, i), t - d), c = t - d - r, g = Math.max(0, e - 2 * s), C = e / 2, x = d + c / 2, R = Math.max(0, Math.min(g, c) / 2 * et);
+  return { cx: C, cy: x, maxR: R };
+}
+function ht(l) {
+  if (!l.startsWith("#")) return !1;
+  const e = parseInt(l.slice(1, 3), 16), t = parseInt(l.slice(3, 5), 16), o = parseInt(l.slice(5, 7), 16);
+  return e * 0.299 + t * 0.587 + o * 0.114 > 150;
+}
+function ct(l, e) {
+  if (!l.startsWith("#")) return l;
+  const t = l.length === 4 ? `#${l[1]}${l[1]}${l[2]}${l[2]}${l[3]}${l[3]}` : l;
+  return st(t, e);
+}
+function J(l) {
+  if (l.startsWith("#"))
+    return {
+      r: parseInt(l.slice(1, 3), 16) || 0,
+      g: parseInt(l.slice(3, 5), 16) || 0,
+      b: parseInt(l.slice(5, 7), 16) || 0,
+      a: 1
+    };
+  const e = l.match(/^rgba?\s*\(([^)]+)\)$/i);
+  if (e) {
+    const t = e[1].split(",").map((o) => o.trim());
+    return {
+      r: Number.parseFloat(t[0]) || 0,
+      g: Number.parseFloat(t[1]) || 0,
+      b: Number.parseFloat(t[2]) || 0,
+      a: t[3] === void 0 ? 1 : Number.parseFloat(t[3])
+    };
+  }
+  return { r: 0, g: 0, b: 0, a: 1 };
+}
+function ut(l, e) {
+  const t = J(l), o = J(e), i = o.a, s = Math.round(o.r * i + t.r * (1 - i)), d = Math.round(o.g * i + t.g * (1 - i)), r = Math.round(o.b * i + t.b * (1 - i));
+  return `#${s.toString(16).padStart(2, "0")}${d.toString(16).padStart(2, "0")}${r.toString(16).padStart(2, "0")}`;
+}
+class ft {
+  kind = "pie";
+  #n = [];
+  /**
+   * Slices actually rendered. Equals {@link #data} unless "other" grouping is
+   * active and the dataset exceeds `maxSlices` — then the smallest slices are
+   * summed into a synthetic "Other" slice appended at the end. Every read
+   * path (render, hit-test, hover / slice info, label reserve) goes through
+   * this array so the grouped view is consistent across all surfaces.
+   */
+  #t = [];
+  /**
+   * Index of the synthetic "Other" slice in {@link #display}, or -1 when
+   * grouping didn't apply. Lets the color resolution pick the theme's muted
+   * `pie.otherColor` for the aggregate instead of the next palette color.
+   */
+  #c = -1;
+  #e;
+  /** Index of the hovered slice (-1 = none). Set via {@link setHoverIndex}. */
+  #i = -1;
+  /** Animated offset per slice (0..1), smoothly interpolated toward target. */
+  #s = [];
+  #u = 0;
+  /**
+   * Outside-label reveal progress (0..1). Eased toward 1 on mount / data-swap
+   * when `animate` is on; drives the leader-line draw-in and label fade-in
+   * stagger. When `animate` is off (the default) this stays pinned at 1 so
+   * labels paint fully-revealed on the first frame.
+   */
+  #a = 1;
+  /**
+   * Cached horizontal bitmap-pixel reserve for outside labels. Invalidated on
+   * `setData` / `updateOptions`; computed lazily on first `render` call per
+   * frame using the live canvas context for accurate `measureText`.
+   */
+  #l = null;
+  /** Subscribers notified on setData (pie has no TimeSeriesStore to piggy-back on). */
+  #r = [];
+  constructor(e) {
+    this.#e = this.#m(ot, e ?? {});
+  }
+  /**
+   * Merge partial options onto a base, deep-merging `sliceLabels` and `other`
+   * so callers can override one field (e.g. `mode` or `maxSlices`) without
+   * dropping sibling defaults.
+   */
+  #m(e, t) {
+    const o = { ...e, ...t };
+    return t.sliceLabels !== void 0 && (o.sliceLabels = lt(e.sliceLabels, t.sliceLabels)), typeof t.other == "object" && typeof e.other == "object" && (o.other = { ...e.other, ...t.other }), o;
+  }
+  /**
+   * Build the display array from the raw data. When grouping applies, the
+   * largest `maxSlices - 1` slices are kept in their original order; the rest
+   * are summed into one "Other" slice appended at the end. Ranking uses the
+   * layout-sanitized value so negative / non-finite entries can never outrank
+   * a real slice.
+   */
+  #p() {
+    this.#c = -1;
+    const e = nt(this.#e.other);
+    if (!e || this.#n.length <= e.maxSlices) return this.#n;
+    const t = Math.max(1, e.maxSlices - 1), o = this.#n.map((r, c) => ({ index: c, value: this.#o(r.value) })).sort((r, c) => c.value - r.value), i = /* @__PURE__ */ new Set();
+    for (const r of o.slice(0, t))
+      i.add(r.index);
+    const s = [];
+    let d = 0;
+    for (let r = 0; r < this.#n.length; r++)
+      i.has(r) ? s.push(this.#n[r]) : d += this.#o(this.#n[r].value);
+    return s.push({ label: e.label, value: d, color: e.color }), this.#c = s.length - 1, s;
+  }
+  /**
+   * Paint color for one display slice: explicit slice color → theme-driven
+   * "Other" color for the synthetic aggregate → palette by index. The
+   * `axis.textColor` fallback matches what {@link createTheme} derives for
+   * `pie.otherColor`, so hand-built theme literals without the `pie` block
+   * get the same muted tone.
+   */
+  #h(e) {
+    const { index: t, palette: o, theme: i } = e, s = this.#t[t];
+    return s?.color ? s.color : t === this.#c ? i.pie?.otherColor ?? i.axis.textColor : o[t % o.length];
+  }
+  getData() {
+    return this.#n;
+  }
+  setData(e) {
+    const t = e ?? [];
+    this.#n = t, this.#t = this.#p(), this.#s = new Array(this.#t.length).fill(0), this.#a = this.#e.animate ? 0 : 1, this.#l = null;
+    for (const o of this.#r)
+      o();
+  }
+  onDataChanged(e) {
+    return this.#r.push(e), () => {
+      const t = this.#r.indexOf(e);
+      t >= 0 && this.#r.splice(t, 1);
+    };
+  }
+  updateOptions(e) {
+    const t = this.#e.sliceLabels?.mode;
+    this.#e = this.#m(this.#e, e ?? {}), this.#e.sliceLabels?.mode === "outside" && t !== "outside" && (this.#a = this.#e.animate ? 0 : 1), this.#t = this.#p(), this.#s.length !== this.#t.length && (this.#s = new Array(this.#t.length).fill(0)), this.#l = null;
+  }
+  getColor() {
+    return this.#t[0]?.color ?? this.#e.colors?.[0] ?? "#888";
+  }
+  getLayerCount() {
+    return 1;
+  }
+  setLayerVisible(e, t) {
+  }
+  isLayerVisible(e) {
+    return !0;
+  }
+  getLayerColors() {
+    return [this.getColor()];
+  }
+  applyTheme(e, t) {
+    e.typography.fontFamily !== t.typography.fontFamily && (this.#l = null);
+  }
+  /** Hit-test: which slice is at this bitmap coordinate? Returns index or -1. */
+  hitTest(e, t, o, i, s) {
+    if (this.#t.length === 0) return -1;
+    const d = this.#f();
+    if (d <= 0) return -1;
+    const r = this.#l?.reserve ?? 0, { cx: c, cy: g, maxR: C } = Z({
+      bitmapWidth: o,
+      bitmapHeight: i,
+      padTop: s?.top ?? 0,
+      padBottom: s?.bottom ?? 0,
+      labelReserve: r
+    }), x = C, R = x * this.#e.innerRadiusRatio, M = e - c, X = t - g, $ = Math.sqrt(M * M + X * X);
+    if ($ > x || $ < R) return -1;
+    let L = Math.atan2(X, M) + Math.PI / 2;
+    L < 0 && (L += N);
+    let A = 0;
+    for (let b = 0; b < this.#t.length; b++) {
+      const I = this.#o(this.#t[b].value) / d * N;
+      if (L >= A && L < A + I) return b;
+      A += I;
+    }
+    return -1;
+  }
+  setHoverIndex(e) {
+    return this.#i === e ? !1 : (this.#i = e, !0);
+  }
+  getHoverIndex() {
+    return this.#i;
+  }
+  getHoverInfo(e) {
+    if (this.#i < 0) return null;
+    const t = this.#t[this.#i];
+    if (!t) return null;
+    const o = this.#f(), i = this.#e.colors ?? e.seriesColors;
+    return {
+      label: t.label,
+      value: t.value,
+      percent: o > 0 ? this.#o(t.value) / o * 100 : 0,
+      color: this.#h({ index: this.#i, palette: i, theme: e })
+    };
+  }
+  getSliceInfo(e) {
+    if (this.#t.length === 0) return null;
+    const t = this.#f(), o = this.#e.colors ?? e.seriesColors;
+    return this.#t.map((i, s) => ({
+      label: i.label,
+      value: i.value,
+      percent: t > 0 ? this.#o(i.value) / t * 100 : 0,
+      color: this.#h({ index: s, palette: o, theme: e })
+    }));
+  }
+  /** Returns true if animation is still in progress. */
+  get needsAnimation() {
+    if (!this.#e.animate) return !1;
+    for (let e = 0; e < this.#s.length; e++) {
+      const t = e === this.#i ? 1 : 0;
+      if (Math.abs(this.#s[e] - t) > 0.01) return !0;
+    }
+    return this.#e.sliceLabels?.mode === "outside" && this.#a < 0.99;
+  }
+  dispose() {
+    this.#r = [], this.#n = [], this.#t = [], this.#c = -1, this.#s = [], this.#u = 0;
+  }
+  /**
+   * @internal Test-only accessor for the animated slice offsets. The backing
+   * `#sliceOffsets` field is ECMAScript-private and can't be reached via a
+   * type-cast escape hatch, so the pie-animation regression tests use this
+   * method to assert convergence behavior. Do not call from production code.
+   */
+  _inspectSliceOffsets() {
+    return this.#s;
+  }
+  /**
+   * Layout-only sanitized slice value: finite and positive, else 0. Negative
+   * and non-finite values would corrupt the arc sweep (a negative slice drags
+   * the running angle backwards, desyncing fills / labels / hit-test, and a
+   * `NaN` slips past the `total <= 0` guard since `NaN <= 0` is false), so they
+   * contribute nothing to the geometry. The original value is still surfaced
+   * verbatim in reported SliceInfo / HoverInfo.
+   */
+  #o(e) {
+    return Number.isFinite(e) && e > 0 ? e : 0;
+  }
+  /** Sum of layout-sanitized slice values — the denominator for every arc
+   *  sweep and percentage. Always finite and ≥ 0. */
+  #f() {
+    let e = 0;
+    for (const t of this.#t)
+      e += this.#o(t.value);
+    return e;
+  }
+  /** Build the text shown for one slice given the resolved content mode. */
+  #d(e, t, o) {
+    const i = t > 0 ? this.#o(e.value) / t * 100 : 0, s = `${i.toFixed(i >= 10 ? 0 : 1)}%`;
+    return o === "percent" ? s : o === "label" ? e.label : `${e.label}  ${s}`;
+  }
+  /**
+   * Bitmap-pixel horizontal reserve needed for outside labels. Measured using
+   * the live `context` so font metrics match the paint path exactly. Cached
+   * until `setData` / `updateOptions` fires (`#labelReserveCache` is cleared).
+   *
+   * Keyed by both `fontScale` (= `horizontalPixelRatio` — HiDPI changes) and
+   * the active `context.font` string so a theme swap that changes the font
+   * family / size busts the cache and triggers a fresh measurement.
+   */
+  #b(e, t, o, i) {
+    const s = e.font;
+    if (this.#l && this.#l.fontScale === i && this.#l.font === s)
+      return this.#l.reserve;
+    let d = 0;
+    for (const g of this.#t) {
+      const C = this.#d(g, o, t.content), x = e.measureText(C).width;
+      x > d && (d = x);
+    }
+    const r = Math.max(t.distance, t.elbowLen), c = (d + (r + Math.max(0, t.railWidth) + t.legPad + 4) * i) / et;
+    return this.#l = { fontScale: i, font: s, reserve: c }, c;
+  }
+  /**
+   * Draw one outside label: anchor dot → radial elbow (per-slice, at slice
+   * midangle) → short diagonal to the de-cluster-adjusted rail y → horizontal
+   * rail → text. Keeping the elbow local to each slice is what stops leader
+   * lines from cutting across the pie when several small slices cluster near
+   * 12 o'clock or 6 o'clock.
+   */
+  #g(e) {
+    const { context: t, entry: o, textColor: i, labels: s, hpr: d, progress: r } = e;
+    if (r <= 0) return;
+    const { anchorX: c, anchorY: g, elbowX: C, elbowY: x, side: R, text: M, color: X, labelX: $, labelY: L } = o, A = $ + R * s.legPad * d, b = E(r / 0.15, 0, 1), I = E((r - 0.15) / 0.45, 0, 1), S = E((r - 0.6) / 0.4, 0, 1);
+    if (t.save(), t.globalAlpha = b, t.fillStyle = X, t.beginPath(), t.arc(c, g, 2.5 * d, 0, N), t.fill(), t.restore(), I > 0) {
+      t.save(), t.globalAlpha = I, t.strokeStyle = X, t.lineWidth = 1 * d, t.lineCap = "round", t.beginPath(), t.moveTo(c, g);
+      const v = c + (C - c) * I, u = g + (x - g) * I;
+      if (t.lineTo(v, u), S > 0) {
+        const a = C + ($ - C) * S, w = x + (L - x) * S;
+        t.lineTo(a, w);
+      }
+      t.stroke(), t.restore();
+    }
+    S > 0 && (t.save(), t.globalAlpha = S, t.fillStyle = i, t.textAlign = R >= 0 ? "left" : "right", t.textBaseline = "middle", t.fillText(M, A, L), t.restore());
+  }
+  /**
+   * Lay out one outside label per eligible slice. Returns entries in original
+   * slice order so the caller can map by index to reveal progress / explode.
+   *
+   * Radial per-slice layout: each label sits on its own slice's radial ray at
+   * radius `outerR + distance`. Rails stay short regardless of slice angle
+   * because the label is placed next to its slice, not at a canvas-wide
+   * column. PAV resolves vertical crowding by adjusting Y (labelX stays
+   * pinned to the slice's midangle ray).
+   *
+   * Side assignment is purely geometric (sign of cos). `balanceSides` is a
+   * no-op here because each label's X is tied to its slice — forcing a slice
+   * to the opposite side would mean flipping text direction without moving
+   * the label, which would push text across the pie.
+   */
+  #x(e) {
+    const { cx: t, cy: o, outerR: i, total: s, palette: d, theme: r, labels: c, hpr: g, bitmapHeight: C } = e, x = new Array(this.#t.length).fill(null), R = c.elbowLen * g, M = Math.max(c.distance, c.elbowLen) * g, X = Math.max(0, c.railWidth) * g, $ = [];
+    let L = -Math.PI / 2;
+    const A = c.minSliceAngle * U;
+    for (let v = 0; v < this.#t.length; v++) {
+      const u = this.#t[v], a = this.#o(u.value) / s * N;
+      if (a >= A) {
+        const w = L + a / 2, n = this.#s[v] * (8 * g), f = Math.cos(w), h = Math.sin(w), m = f >= 0 ? 1 : -1, O = t + f * (i + n), P = o + h * (i + n), H = t + f * (i + n + R), p = o + h * (i + n + R), W = t + f * (i + n + M) + m * X, y = o + h * (i + n + M), Y = {
+          anchorX: O,
+          anchorY: P,
+          elbowX: H,
+          elbowY: p,
+          side: m,
+          labelX: W,
+          labelY: y,
+          text: this.#d(u, s, c.content),
+          color: this.#h({ index: v, palette: d, theme: r })
+        };
+        x[v] = Y, $.push({ entry: Y });
+      }
+      L += a;
+    }
+    const b = Math.max(1, c.fontSize * c.labelGap) * g, I = c.fontSize * g, S = C - c.fontSize * g;
+    for (const v of [1, -1]) {
+      const u = [];
+      for (const n of $)
+        n.entry.side === v && u.push(n.entry);
+      if (u.length === 0) continue;
+      u.sort((n, f) => n.labelY - f.labelY);
+      const a = [];
+      for (let n = 0; n < u.length; n++)
+        for (a.push({ count: 1, sumIdeal: u[n].labelY, startIdx: n }); a.length >= 2; ) {
+          const f = a[a.length - 2], h = a[a.length - 1], m = f.sumIdeal / f.count, O = h.sumIdeal / h.count, P = m + (f.count - 1) * b / 2;
+          if (O - (h.count - 1) * b / 2 >= P + b) break;
+          f.count += h.count, f.sumIdeal += h.sumIdeal, a.pop();
+        }
+      if (a.length > 0) {
+        const n = a[0], f = n.sumIdeal / n.count - (n.count - 1) * b / 2;
+        if (f < I)
+          for (n.sumIdeal += (I - f) * n.count; a.length >= 2; ) {
+            const h = a[0], m = a[1], O = h.sumIdeal / h.count, P = m.sumIdeal / m.count, H = O + (h.count - 1) * b / 2;
+            if (P - (m.count - 1) * b / 2 >= H + b) break;
+            h.count += m.count, h.sumIdeal += m.sumIdeal, a.splice(1, 1);
+          }
+      }
+      if (a.length > 0) {
+        const n = a[a.length - 1], f = n.sumIdeal / n.count + (n.count - 1) * b / 2;
+        if (f > S)
+          for (n.sumIdeal -= (f - S) * n.count; a.length >= 2; ) {
+            const h = a[a.length - 2], m = a[a.length - 1], O = h.sumIdeal / h.count, P = m.sumIdeal / m.count, H = O + (h.count - 1) * b / 2;
+            if (P - (m.count - 1) * b / 2 >= H + b) break;
+            h.count += m.count, h.sumIdeal += m.sumIdeal, a.pop();
+          }
+      }
+      const w = (I + S) / 2;
+      for (const n of a) {
+        const f = (n.count - 1) * b, h = n.sumIdeal / n.count;
+        f > S - I && h - f / 2 < I && (n.sumIdeal = w * n.count);
+      }
+      for (const n of a) {
+        const f = n.sumIdeal / n.count;
+        for (let h = 0; h < n.count; h++)
+          u[n.startIdx + h].labelY = f + (h - (n.count - 1) / 2) * b;
+      }
+    }
+    for (const v of $) {
+      const u = v.entry, a = u.labelY - u.anchorY;
+      let w;
+      if (Math.abs(a) <= R) {
+        const h = u.side * Math.sqrt(Math.max(0, R * R - a * a));
+        w = u.anchorX + h;
+      } else
+        w = (u.anchorX + u.labelX) / 2;
+      const n = Math.min(u.anchorX, u.labelX), f = Math.max(u.anchorX, u.labelX);
+      u.elbowX = Math.max(n, Math.min(f, w)), u.elbowY = u.labelY;
+    }
+    return x;
+  }
+  render(e) {
+    if (this.#t.length === 0) return;
+    const { scope: t, theme: o, padding: i } = e, { context: s, bitmapSize: d, horizontalPixelRatio: r, verticalPixelRatio: c } = t, g = performance.now(), C = this.#u ? Math.min(0.05, (g - this.#u) / 1e3) : 0;
+    this.#u = g;
+    const x = this.#f();
+    if (x <= 0) return;
+    const R = 12;
+    for (; this.#s.length < this.#t.length; )
+      this.#s.push(0);
+    if (this.#e.animate)
+      for (let p = 0; p < this.#t.length; p++) {
+        const W = p === this.#i ? 1 : 0;
+        this.#s[p] = K(this.#s[p], W, R, C);
+      }
+    const M = it(this.#e.sliceLabels);
+    s.font = `${M.fontSize * r}px ${o.typography.fontFamily}`, M.mode === "outside" && this.#e.animate && (this.#a = K(this.#a, 1, 6, C));
+    const X = this.#e.colors ?? o.seriesColors, $ = M.mode === "outside" ? this.#b(s, M, x, r) : 0, { cx: L, cy: A, maxR: b } = Z({
+      bitmapWidth: d.width,
+      bitmapHeight: d.height,
+      padTop: i.top * c,
+      padBottom: i.bottom * c,
+      labelReserve: $
+    }), I = b, S = I * this.#e.innerRadiusRatio, v = this.#e.padAngle * U, u = 8 * r, a = this.#e.shadow ?? !1, w = at(a), n = this.#e.innerShadow ?? !1, f = rt(n), h = this.#e.gradient !== !1;
+    let m = -Math.PI / 2;
+    for (let p = 0; p < this.#t.length; p++) {
+      const W = this.#t[p], y = this.#o(W.value) / x * N, Y = m + v / 2, B = m + y - v / 2, D = m + y / 2, F = this.#h({ index: p, palette: X, theme: o });
+      if (B <= Y) {
+        m += y;
+        continue;
+      }
+      const V = this.#s[p] * u, q = Math.cos(D) * V, _ = Math.sin(D) * V, z = L + q, k = A + _;
+      if (s.beginPath(), s.arc(z, k, I, Y, B), S > 0 ? s.arc(z, k, S, B, Y, !0) : s.lineTo(z, k), s.closePath(), h || n) {
+        const T = s.createRadialGradient(z, k, S || 0, z, k, I);
+        if (T.addColorStop(0, h ? ct(F, 0.15) : F), n) {
+          const G = Math.max(0, Math.min(0.999, 1 - f.depth));
+          T.addColorStop(G, F), T.addColorStop(1, ut(F, f.color));
+        } else
+          T.addColorStop(1, F);
+        s.fillStyle = T;
+      } else
+        s.fillStyle = F;
+      const j = this.#s[p];
+      if (a || j > 0.01) {
+        const T = a ? 1 : 0, G = j;
+        s.shadowColor = a ? w.color : "rgba(0,0,0,0.25)", s.shadowBlur = (w.blur * T + 12 * G) * r, s.shadowOffsetX = w.offsetX * T * r + q * 0.3 * G, s.shadowOffsetY = w.offsetY * T * c + _ * 0.3 * G;
+      }
+      s.fill(), s.shadowColor = "transparent", s.shadowBlur = 0, s.shadowOffsetX = 0, s.shadowOffsetY = 0, m += y;
+    }
+    if (M.mode === "none") return;
+    m = -Math.PI / 2;
+    const O = o.tooltip.textColor;
+    if (M.mode === "outside") {
+      const p = this.#x({
+        cx: L,
+        cy: A,
+        outerR: I,
+        total: x,
+        palette: X,
+        theme: o,
+        labels: M,
+        hpr: r,
+        bitmapHeight: d.height
+      }), W = p.length > 1 ? Math.min(0.06, 0.9 / (p.length - 1)) : 0;
+      for (let y = 0; y < p.length; y++) {
+        const Y = p[y];
+        if (Y === null) continue;
+        const B = y * W, D = E((this.#a - B) / (1 - B), 0, 1);
+        this.#g({
+          context: s,
+          entry: Y,
+          textColor: O,
+          labels: M,
+          hpr: r,
+          progress: D
+        });
+      }
+      return;
+    }
+    const P = S > 0 ? (I + S) / 2 : I * 0.65;
+    s.textAlign = "center", s.textBaseline = "middle";
+    const H = M.minSliceAngle * U;
+    for (let p = 0; p < this.#t.length; p++) {
+      const W = this.#t[p], y = this.#o(W.value) / x * N;
+      if (y >= H) {
+        const Y = m + y / 2, B = this.#s[p] * u, D = this.#h({ index: p, palette: X, theme: o }), F = this.#d(W, x, M.content), V = s.measureText(F).width, q = M.fontSize * 1.2 * r, _ = y < Math.PI ? 2 * P * Math.sin(y / 2) : 2 * P, z = V > _ - 4 * r, k = S > 0 && P - S < q;
+        if (!z && !k) {
+          const j = L + Math.cos(Y) * (P + B), T = A + Math.sin(Y) * (P + B);
+          s.fillStyle = ht(D) ? "#000000" : "#ffffff", s.fillText(F, j, T);
+        }
+      }
+      m += y;
+    }
+  }
+}
+const pt = {
+  type: "pie",
+  create: (l, e) => new ft({ ...e })
+};
+export {
+  ft as PieRenderer,
+  pt as PieSeriesDef
+};

package/dist/core/dist/series/register-builtins.js

@@ -0,0 +1,11 @@
+import { BarSeriesDef as i } from "./bar.js";
+import { CandlestickSeriesDef as r } from "./candlestick.js";
+import { registerSeriesDefinition as e } from "./definition.js";
+import { LineSeriesDef as t } from "./line.js";
+import { PieSeriesDef as s } from "./pie.js";
+function S() {
+  e(r), e(t), e(i), e(s);
+}
+export {
+  S as registerBuiltinSeries
+};

package/dist/core/dist/series/stack-math.js

@@ -0,0 +1,17 @@
+function r(t) {
+  let n = 0, i = 0;
+  for (const e of t)
+    e > 0 ? n += e : e < 0 && (i += e);
+  return { positive: n, negative: i };
+}
+function o(t) {
+  return t.positive > 0 ? t.positive : t.negative < 0 ? t.negative : 0;
+}
+function a(t) {
+  return t.positive > 0 ? 100 : t.negative < 0 ? -100 : 0;
+}
+export {
+  a as renderedStackPercentTop,
+  o as renderedStackTop,
+  r as sumStack
+};

package/dist/core/dist/snapshots.js

@@ -0,0 +1,107 @@
+const f = /* @__PURE__ */ new WeakMap();
+function b(e, r) {
+  return f.get(e)?.get(r);
+}
+function g(e, r, o) {
+  let n = f.get(e);
+  n || (n = /* @__PURE__ */ new Map(), f.set(e, n)), n.set(r, o);
+}
+function y(e) {
+  return "close" in e ? e.close : e.value;
+}
+function I(e, r) {
+  if (r === "none" || e.length <= 1) return e;
+  const o = [...e];
+  return o.sort((n, s) => {
+    const i = y(n.data), l = y(s.data);
+    return r === "asc" ? i - l : l - i;
+  }), o;
+}
+function u(e) {
+  const r = Object.freeze({ ...e.data }), o = {
+    id: e.id,
+    seriesId: e.seriesId,
+    layerIndex: e.layerIndex,
+    label: e.label,
+    data: r,
+    color: e.color
+  };
+  return Object.freeze(o);
+}
+function m(e, r) {
+  const o = r.sort ?? "none", n = e.getOverlayVersion(), s = b(e, r.cacheKey);
+  if (s && s.version === n && s.time === r.time && s.sort === o)
+    return s.data;
+  const i = [];
+  for (const t of e.getSeriesIds()) {
+    if (!e.isSeriesVisible(t)) continue;
+    if (e.getSeriesLayers(t) !== null) {
+      const d = e.getLayerSnapshots(t, r.time);
+      if (!d) continue;
+      for (const a of d)
+        i.push(
+          u({
+            id: `${t}_layer${a.layerIndex}`,
+            seriesId: t,
+            layerIndex: a.layerIndex,
+            label: e.getLayerLabel(t, a.layerIndex),
+            data: { time: a.time, value: a.value },
+            color: a.color
+          })
+        );
+      continue;
+    }
+    const c = e.getDataAtTime(t, r.time);
+    c && i.push(
+      u({
+        id: t,
+        seriesId: t,
+        label: e.getSeriesLabel(t),
+        data: c,
+        color: e.getSeriesColor(t) ?? "#888"
+      })
+    );
+  }
+  const l = Object.freeze(I(i, o));
+  return g(e, r.cacheKey, { version: n, time: r.time, sort: o, data: l }), l;
+}
+function S(e, r) {
+  const o = r.sort ?? "none", n = e.getOverlayVersion(), s = b(e, r.cacheKey);
+  if (s && s.version === n && s.time === null && s.sort === o)
+    return s.data;
+  const i = [];
+  for (const t of e.getSeriesIds()) {
+    if (!e.isSeriesVisible(t)) continue;
+    const c = e.getLayerLastSnapshots(t);
+    if (c) {
+      for (const a of c)
+        i.push(
+          u({
+            id: `${t}_layer${a.layerIndex}`,
+            seriesId: t,
+            layerIndex: a.layerIndex,
+            label: e.getLayerLabel(t, a.layerIndex),
+            data: { time: a.time, value: a.value },
+            color: a.color
+          })
+        );
+      continue;
+    }
+    const d = e.getLastData(t);
+    d && i.push(
+      u({
+        id: t,
+        seriesId: t,
+        label: e.getSeriesLabel(t),
+        data: d,
+        color: e.getSeriesColor(t) ?? "#888"
+      })
+    );
+  }
+  const l = Object.freeze(I(i, o));
+  return g(e, r.cacheKey, { version: n, time: null, sort: o, data: l }), l;
+}
+export {
+  m as buildHoverSnapshots,
+  S as buildLastSnapshots
+};