@wick-charts/vue 0.5.1 → 0.6.1

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

@@ -1,6 +1,8 @@
-import { lighten as st } from "../utils/color.js";
-import { smoothToward as K, clamp as E } from "../utils/math.js";
-const tt = {
+import { DEFAULT_PIE_ENTRY as ct } from "../animation/config.js";
+import { IntroWave as ut } from "../animation/intro-wave.js";
+import { isLightColor as ft, lighten as dt } from "../utils/color.js";
+import { smoothToward as nt, clamp as U } from "../utils/math.js";
+const lt = {
   mode: "outside",
   content: "both",
   fontSize: 11,
@@ -18,11 +20,15 @@ const tt = {
   // 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 = {
+}, mt = {
   innerRadiusRatio: 0,
   // 1.15° ≈ 0.02 rad — same visual default as before the radians→degrees switch.
   padAngle: 1.15,
-  sliceLabels: { ...tt },
+  // Softly rounded slice corners by default, matching the bar/candlestick
+  // families. Pass 0 for sharp wedges. Thin rings and narrow slices clamp it
+  // down automatically.
+  cornerRadius: 3,
+  sliceLabels: { ...lt },
   // 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
@@ -31,54 +37,72 @@ const tt = {
   // Radial depth gradient (lighter center → flat edge) on by default. Set
   // false for flat, solid-color slices.
   gradient: !0
-}, Q = {
+}, ot = {
   maxSlices: 8,
   label: "Other"
 };
-function nt(l) {
-  return l === !1 ? null : l === !0 || l === void 0 ? Q : { ...Q, ...l };
+function gt(a) {
+  return a === !1 ? null : a === !0 || a === void 0 ? ot : { ...ot, ...a };
 }
-const U = Math.PI / 180;
-function lt(l, e) {
-  return { ...l ?? {}, ...e };
+const et = Math.PI / 180;
+function pt(a, e) {
+  return { ...a ?? {}, ...e };
 }
-function it(l) {
-  return { ...tt, ...l ?? {} };
+function it(a) {
+  return { ...lt, ...a ?? {} };
 }
-function at(l) {
+function bt(a) {
   const e = { color: "rgba(0, 0, 0, 0.22)", blur: 24, offsetX: 0, offsetY: 10 };
-  return l === !0 || l === !1 ? e : { ...e, ...l };
+  return a === !0 || a === !1 ? e : { ...e, ...a };
 }
-function rt(l) {
+function xt(a) {
   const e = { color: "rgba(0, 0, 0, 0.1)", depth: 0.3 };
-  return l === !0 || l === !1 ? e : { ...e, ...l };
+  return a === !0 || a === !1 ? e : { ...e, ...a };
+}
+const H = Math.PI * 2, rt = 0.85, Mt = 0.5, yt = 20;
+function st(a) {
+  const { bitmapWidth: e, bitmapHeight: t, padTop: n, padBottom: o } = a, s = Math.max(0, a.labelReserve ?? 0), h = Math.min(Math.max(0, n), t), r = Math.min(Math.max(0, o), t - h), u = t - h - r, m = Math.max(0, e - 2 * s), R = e / 2, g = Math.min(m, u) / 2, y = Math.min(e, t) / 2, p = Math.max(0, Math.max(g, y * Mt) * rt), T = Math.min(2, Math.max(0, t / 2 - p)), b = h + u / 2, C = Math.min(Math.max(b, p + T), t - p - T);
+  return { cx: R, cy: C, maxR: p };
+}
+function Z(a) {
+  const { ringR: e, theta: t, radius: n, outward: o, angleSign: s } = a, h = o ? e - n : e + n, r = Math.asin(U(n / h, 0, 1)) * s, u = t + r;
+  return {
+    fx: h * Math.cos(u),
+    fy: h * Math.sin(u),
+    lineR: h * Math.cos(r),
+    archAngle: u
+  };
 }
-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 vt(a) {
+  const { outerR: e, innerR: t, halfSpan: n } = a, o = Math.sin(Math.min(n, Math.PI / 2 - 1e-3)), s = e * o / (1 + o), h = t > 0 ? t * o / (1 - o) : 1 / 0, r = (e - t) / 2;
+  return Math.max(0, Math.min(s, h, 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 St(a, e, t) {
+  if (t <= 0) return "";
+  if (a.measureText(e).width <= t) return e;
+  let n = e.length - 1;
+  for (; n > 0 && a.measureText(`${e.slice(0, n)}…`).width > t; )
+    n--;
+  return n <= 0 ? "" : `${e.slice(0, n)}…`;
 }
-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 Rt(a, e) {
+  if (!a.startsWith("#")) return a;
+  const t = a.length === 4 ? `#${a[1]}${a[1]}${a[2]}${a[2]}${a[3]}${a[3]}` : a;
+  return dt(t, e);
 }
-function J(l) {
-  if (l.startsWith("#"))
+function at(a) {
+  if (a.startsWith("#")) {
+    const t = a.length === 4 ? `#${a[1]}${a[1]}${a[2]}${a[2]}${a[3]}${a[3]}` : a;
     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,
+      r: parseInt(t.slice(1, 3), 16) || 0,
+      g: parseInt(t.slice(3, 5), 16) || 0,
+      b: parseInt(t.slice(5, 7), 16) || 0,
       a: 1
     };
-  const e = l.match(/^rgba?\s*\(([^)]+)\)$/i);
+  }
+  const e = a.match(/^rgba?\s*\(([^)]+)\)$/i);
   if (e) {
-    const t = e[1].split(",").map((o) => o.trim());
+    const t = e[1].split(",").map((n) => n.trim());
     return {
       r: Number.parseFloat(t[0]) || 0,
       g: Number.parseFloat(t[1]) || 0,
@@ -88,11 +112,11 @@ function J(l) {
   }
   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")}`;
+function wt(a, e) {
+  const t = at(a), n = at(e), o = n.a, s = Math.round(n.r * o + t.r * (1 - o)), h = Math.round(n.g * o + t.g * (1 - o)), r = Math.round(n.b * o + t.b * (1 - o));
+  return `#${s.toString(16).padStart(2, "0")}${h.toString(16).padStart(2, "0")}${r.toString(16).padStart(2, "0")}`;
 }
-class ft {
+class It {
   kind = "pie";
   #n = [];
   /**
@@ -108,39 +132,54 @@ class ft {
    * 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;
+  #u = -1;
   #e;
   /** Index of the hovered slice (-1 = none). Set via {@link setHoverIndex}. */
-  #i = -1;
+  #a = -1;
   /** Animated offset per slice (0..1), smoothly interpolated toward target. */
   #s = [];
-  #u = 0;
+  #f = 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;
+  #o = 1;
+  /**
+   * Initial-load reveal clock — armed on the first empty → non-empty seed;
+   * slices unfurl clockwise from 12 o'clock, then {@link #labelReveal}
+   * chains in. Armed with `entryMs / 2` because the wave's full window is
+   * `2 ×` its per-element duration and the pie treats `entryMs` as the
+   * total sweep time.
+   */
+  #r = new ut();
   /**
    * 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;
+  /**
+   * Horizontal reserve the last `render` actually applied — 0 when outside
+   * labels were auto-hidden below `MIN_LABELED_PIE_RADIUS`. `hitTest` reads
+   * this instead of the measurement cache so hover geometry always matches
+   * the painted frame.
+   */
+  #g = 0;
   /** Subscribers notified on setData (pie has no TimeSeriesStore to piggy-back on). */
-  #r = [];
+  #h = [];
   constructor(e) {
-    this.#e = this.#m(ot, e ?? {});
+    this.#e = this.#p(mt, 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;
+  #p(e, t) {
+    const n = { ...e, ...t };
+    return t.sliceLabels !== void 0 && (n.sliceLabels = pt(e.sliceLabels, t.sliceLabels)), typeof t.other == "object" && typeof e.other == "object" && (n.other = { ...e.other, ...t.other }), n;
   }
   /**
    * Build the display array from the raw data. When grouping applies, the
@@ -149,18 +188,18 @@ class ft {
    * layout-sanitized value so negative / non-finite entries can never outrank
    * a real slice.
    */
-  #p() {
-    this.#c = -1;
-    const e = nt(this.#e.other);
+  #b() {
+    this.#u = -1;
+    const e = gt(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 t = Math.max(1, e.maxSlices - 1), n = this.#n.map((r, u) => ({ index: u, value: this.#i(r.value) })).sort((r, u) => u.value - r.value), o = /* @__PURE__ */ new Set();
+    for (const r of n.slice(0, t))
+      o.add(r.index);
     const s = [];
-    let d = 0;
+    let h = 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;
+      o.has(r) ? s.push(this.#n[r]) : h += this.#i(this.#n[r].value);
+    return s.push({ label: e.label, value: h, color: e.color }), this.#u = s.length - 1, s;
   }
   /**
    * Paint color for one display slice: explicit slice color → theme-driven
@@ -169,28 +208,28 @@ class ft {
    * `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];
+  #c(e) {
+    const { index: t, palette: n, theme: o } = e, s = this.#t[t];
+    return s?.color ? s.color : t === this.#u ? o.pie?.otherColor ?? o.axis.textColor : n[t % n.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)
+    const t = this.#n.length > 0, n = e ?? [];
+    this.#n = n, this.#t = this.#b(), this.#s = new Array(this.#t.length).fill(0), !t && this.#t.length > 0 && this.#r.arm(this.#M() / 2), this.#o = this.#e.animate || this.#r.active ? 0 : 1, this.#l = null;
+    for (const o of this.#h)
       o();
   }
   onDataChanged(e) {
-    return this.#r.push(e), () => {
-      const t = this.#r.indexOf(e);
-      t >= 0 && this.#r.splice(t, 1);
+    return this.#h.push(e), () => {
+      const t = this.#h.indexOf(e);
+      t >= 0 && this.#h.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;
+    this.#e = this.#p(this.#e, e ?? {}), this.#e.sliceLabels?.mode === "outside" && t !== "outside" && (this.#o = this.#e.animate ? 0 : 1), this.#t = this.#b(), 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";
@@ -210,67 +249,85 @@ class ft {
     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) {
+  hitTest(e, t, n, o, 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,
+    const h = this.#d();
+    if (h <= 0) return -1;
+    const r = this.#g, { cx: u, cy: m, maxR: R } = st({
+      bitmapWidth: n,
+      bitmapHeight: o,
       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;
+    }), g = R, y = g * this.#e.innerRadiusRatio, p = e - u, T = t - m, b = Math.sqrt(p * p + T * T);
+    if (b > g || b < y) return -1;
+    let C = Math.atan2(T, p) + Math.PI / 2;
+    C < 0 && (C += H);
+    let P = 0;
+    for (let f = 0; f < this.#t.length; f++) {
+      const v = this.#i(this.#t[f].value) / h * H;
+      if (C >= P && C < P + v) return f;
+      P += v;
     }
     return -1;
   }
   setHoverIndex(e) {
-    return this.#i === e ? !1 : (this.#i = e, !0);
+    return this.#a === e ? !1 : (this.#a = e, !0);
   }
   getHoverIndex() {
-    return this.#i;
+    return this.#a;
   }
   getHoverInfo(e) {
-    if (this.#i < 0) return null;
-    const t = this.#t[this.#i];
+    if (this.#a < 0) return null;
+    const t = this.#t[this.#a];
     if (!t) return null;
-    const o = this.#f(), i = this.#e.colors ?? e.seriesColors;
+    const n = this.#d(), o = 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 })
+      percent: n > 0 ? this.#i(t.value) / n * 100 : 0,
+      color: this.#c({ index: this.#a, palette: o, 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 })
+    const t = this.#d(), n = this.#e.colors ?? e.seriesColors;
+    return this.#t.map((o, s) => ({
+      label: o.label,
+      value: o.value,
+      percent: t > 0 ? this.#i(o.value) / t * 100 : 0,
+      color: this.#c({ index: s, palette: n, theme: e })
     }));
   }
+  /** Resolved slice-sweep duration — `entryMs` with the `false` sentinel
+   *  normalized to `0` (pie stores raw public options, unlike the
+   *  time-series renderers which normalize at the merge boundary). */
+  #M() {
+    const e = this.#e.entryMs;
+    return e === !1 ? 0 : e ?? ct;
+  }
+  /**
+   * Settle every reveal clock when a render pass has nothing to paint
+   * (empty display or non-positive total). The clocks only advance inside
+   * the paint path, so leaving them armed here would hold
+   * {@link needsAnimation} true forever and busy-loop the frame scheduler
+   * over a blank chart.
+   */
+  #x() {
+    this.#r.finish(), this.#o = 1;
+  }
   /** Returns true if animation is still in progress. */
   get needsAnimation() {
+    if (this.#r.active || it(this.#e.sliceLabels).mode === "outside" && this.#o < 1) return !0;
     if (!this.#e.animate) return !1;
     for (let e = 0; e < this.#s.length; e++) {
-      const t = e === this.#i ? 1 : 0;
+      const t = e === this.#a ? 1 : 0;
       if (Math.abs(this.#s[e] - t) > 0.01) return !0;
     }
-    return this.#e.sliceLabels?.mode === "outside" && this.#a < 0.99;
+    return !1;
   }
   dispose() {
-    this.#r = [], this.#n = [], this.#t = [], this.#c = -1, this.#s = [], this.#u = 0;
+    this.#h = [], this.#n = [], this.#t = [], this.#u = -1, this.#s = [], this.#f = 0;
   }
   /**
    * @internal Test-only accessor for the animated slice offsets. The backing
@@ -289,21 +346,21 @@ class ft {
    * contribute nothing to the geometry. The original value is still surfaced
    * verbatim in reported SliceInfo / HoverInfo.
    */
-  #o(e) {
+  #i(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() {
+  #d() {
     let e = 0;
     for (const t of this.#t)
-      e += this.#o(t.value);
+      e += this.#i(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}`;
+  #m(e, t, n) {
+    const o = t > 0 ? this.#i(e.value) / t * 100 : 0, s = `${o.toFixed(o >= 10 ? 0 : 1)}%`;
+    return n === "percent" ? s : n === "label" ? e.label : `${e.label}  ${s}`;
   }
   /**
    * Bitmap-pixel horizontal reserve needed for outside labels. Measured using
@@ -314,17 +371,72 @@ class ft {
    * 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) {
+  #y(e, t, n, o) {
     const s = e.font;
-    if (this.#l && this.#l.fontScale === i && this.#l.font === s)
+    if (this.#l && this.#l.fontScale === o && 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);
+    let h = 0;
+    for (const m of this.#t) {
+      const R = this.#m(m, n, t.content), g = e.measureText(R).width;
+      g > h && (h = g);
     }
-    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;
+    const r = Math.max(t.distance, t.elbowLen), u = (h + (r + Math.max(0, t.railWidth) + t.legPad + 4) * o) / rt;
+    return this.#l = { fontScale: o, font: s, reserve: u }, u;
+  }
+  /**
+   * Trace one slice's outline with its four corners rounded (two on the
+   * outer rim, plus two on the inner rim when `innerR > 0`) instead of the
+   * plain `arc` + `lineTo` sharp-corner path. `cornerRadius` must already be
+   * clamped by the caller ({@link maxCornerRadius}) — this only draws.
+   *
+   * Each fillet is a small circle tangent to the ring and to the slice's
+   * straight edge; the main arcs are inset to the fillets' tangent angles
+   * instead of the slice's raw start/end angles. A closure keeps the sweep
+   * direction for each fillet's tiny arc correct regardless of which corner
+   * it's rounding, by always turning the shorter way between its two tangent
+   * points rather than reasoning about clockwise/anticlockwise per corner.
+   */
+  #v(e, t) {
+    const { sliceCx: n, sliceCy: o, outerR: s, innerR: h, startAngle: r, endAngle: u, cornerRadius: m } = t, R = (f, v) => [
+      n + f * Math.cos(v),
+      o + f * Math.sin(v)
+    ], g = (f, v, A, S) => {
+      const c = n + f, l = o + v, M = Math.atan2(A[1] - l, A[0] - c);
+      let i = Math.atan2(S[1] - l, S[0] - c) - M;
+      for (; i > Math.PI; ) i -= H;
+      for (; i <= -Math.PI; ) i += H;
+      e.arc(c, l, m, M, M + i, i < 0);
+    }, y = Z({
+      ringR: s,
+      theta: r,
+      radius: m,
+      outward: !0,
+      angleSign: 1
+    }), p = Z({
+      ringR: s,
+      theta: u,
+      radius: m,
+      outward: !0,
+      angleSign: -1
+    }), T = R(y.lineR, r), b = R(s, y.archAngle), C = R(s, p.archAngle), P = R(p.lineR, u);
+    if (h > 0) {
+      const f = Z({
+        ringR: h,
+        theta: r,
+        radius: m,
+        outward: !1,
+        angleSign: 1
+      }), v = Z({
+        ringR: h,
+        theta: u,
+        radius: m,
+        outward: !1,
+        angleSign: -1
+      }), A = R(f.lineR, r), S = R(v.lineR, u), c = R(h, v.archAngle), l = R(h, f.archAngle);
+      e.moveTo(...A), e.lineTo(...T), g(y.fx, y.fy, T, b), e.arc(n, o, s, y.archAngle, p.archAngle), g(p.fx, p.fy, C, P), e.lineTo(...S), g(v.fx, v.fy, S, c), e.arc(n, o, h, v.archAngle, f.archAngle, !0), g(f.fx, f.fy, l, A);
+      return;
+    }
+    e.moveTo(n, o), e.lineTo(...T), g(y.fx, y.fy, T, b), e.arc(n, o, s, y.archAngle, p.archAngle), g(p.fx, p.fy, C, P), e.lineTo(n, o);
   }
   /**
    * Draw one outside label: anchor dot → radial elbow (per-slice, at slice
@@ -333,20 +445,24 @@ class ft {
    * 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;
+  #S(e) {
+    const { context: t, entry: n, textColor: o, labels: s, hpr: h, progress: r, bitmapWidth: u } = 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);
+    const { anchorX: m, anchorY: R, elbowX: g, elbowY: y, side: p, text: T, color: b, labelX: C, labelY: P } = n, f = C + p * s.legPad * h, v = U(r / 0.15, 0, 1), A = U((r - 0.15) / 0.45, 0, 1), S = U((r - 0.6) / 0.4, 0, 1);
+    if (t.save(), t.globalAlpha = v, t.fillStyle = b, t.beginPath(), t.arc(m, R, 2.5 * h, 0, H), t.fill(), t.restore(), A > 0) {
+      t.save(), t.globalAlpha = A, t.strokeStyle = b, t.lineWidth = 1 * h, t.lineCap = "round", t.beginPath(), t.moveTo(m, R);
+      const c = m + (g - m) * A, l = R + (y - R) * A;
+      if (t.lineTo(c, l), S > 0) {
+        const M = g + (C - g) * S, i = y + (P - y) * S;
+        t.lineTo(M, i);
       }
       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());
+    if (S > 0) {
+      const c = 2 * h, l = p >= 0 ? u - c - f : f - c, M = St(t, T, l);
+      if (M.length === 0) return;
+      t.save(), t.globalAlpha = S, t.fillStyle = o, t.textAlign = p >= 0 ? "left" : "right", t.textBaseline = "middle", t.fillText(M, f, P), t.restore();
+    }
   }
   /**
    * Lay out one outside label per eligible slice. Returns entries in original
@@ -363,183 +479,204 @@ class ft {
    * 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 })
+  #R(e) {
+    const { cx: t, cy: n, outerR: o, total: s, palette: h, theme: r, labels: u, hpr: m, bitmapHeight: R } = e, g = new Array(this.#t.length).fill(null), y = u.elbowLen * m, p = Math.max(u.distance, u.elbowLen) * m, T = Math.max(0, u.railWidth) * m, b = [];
+    let C = -Math.PI / 2;
+    const P = u.minSliceAngle * et;
+    for (let S = 0; S < this.#t.length; S++) {
+      const c = this.#t[S], l = this.#i(c.value) / s * H;
+      if (l >= P) {
+        const M = C + l / 2, i = this.#s[S] * (8 * m), x = Math.cos(M), d = Math.sin(M), I = x >= 0 ? 1 : -1, Y = t + x * (o + i), k = n + d * (o + i), B = t + x * (o + i + y), V = n + d * (o + i + y), X = t + x * (o + i + p) + I * T, tt = n + d * (o + i + p), D = {
+          anchorX: Y,
+          anchorY: k,
+          elbowX: B,
+          elbowY: V,
+          side: I,
+          labelX: X,
+          labelY: tt,
+          text: this.#m(c, s, u.content),
+          color: this.#c({ index: S, palette: h, theme: r })
         };
-        x[v] = Y, $.push({ entry: Y });
+        g[S] = D, b.push({ entry: D });
       }
-      L += a;
+      C += l;
     }
-    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();
+    const f = Math.max(1, u.fontSize * u.labelGap) * m, v = u.fontSize * m, A = R - u.fontSize * m;
+    for (const S of [1, -1]) {
+      const c = [];
+      for (const i of b)
+        i.entry.side === S && c.push(i.entry);
+      if (c.length === 0) continue;
+      c.sort((i, x) => i.labelY - x.labelY);
+      const l = [];
+      for (let i = 0; i < c.length; i++)
+        for (l.push({ count: 1, sumIdeal: c[i].labelY, startIdx: i }); l.length >= 2; ) {
+          const x = l[l.length - 2], d = l[l.length - 1], I = x.sumIdeal / x.count, Y = d.sumIdeal / d.count, k = I + (x.count - 1) * f / 2;
+          if (Y - (d.count - 1) * f / 2 >= k + f) break;
+          x.count += d.count, x.sumIdeal += d.sumIdeal, l.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 (l.length > 0) {
+        const i = l[0], x = i.sumIdeal / i.count - (i.count - 1) * f / 2;
+        if (x < v)
+          for (i.sumIdeal += (v - x) * i.count; l.length >= 2; ) {
+            const d = l[0], I = l[1], Y = d.sumIdeal / d.count, k = I.sumIdeal / I.count, B = Y + (d.count - 1) * f / 2;
+            if (k - (I.count - 1) * f / 2 >= B + f) break;
+            d.count += I.count, d.sumIdeal += I.sumIdeal, l.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();
+      if (l.length > 0) {
+        const i = l[l.length - 1], x = i.sumIdeal / i.count + (i.count - 1) * f / 2;
+        if (x > A)
+          for (i.sumIdeal -= (x - A) * i.count; l.length >= 2; ) {
+            const d = l[l.length - 2], I = l[l.length - 1], Y = d.sumIdeal / d.count, k = I.sumIdeal / I.count, B = Y + (d.count - 1) * f / 2;
+            if (k - (I.count - 1) * f / 2 >= B + f) break;
+            d.count += I.count, d.sumIdeal += I.sumIdeal, l.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);
+      const M = (v + A) / 2;
+      for (const i of l) {
+        const x = (i.count - 1) * f, d = i.sumIdeal / i.count;
+        x > A - v && d - x / 2 < v && (i.sumIdeal = M * i.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 i of l) {
+        const x = i.sumIdeal / i.count;
+        for (let d = 0; d < i.count; d++)
+          c[i.startIdx + d].labelY = x + (d - (i.count - 1) / 2) * f;
       }
     }
-    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;
+    for (const S of b) {
+      const c = S.entry, l = c.labelY - c.anchorY;
+      let M;
+      if (Math.abs(l) <= y) {
+        const d = c.side * Math.sqrt(Math.max(0, y * y - l * l));
+        M = c.anchorX + d;
       } 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;
+        M = (c.anchorX + c.labelX) / 2;
+      const i = Math.min(c.anchorX, c.labelX), x = Math.max(c.anchorX, c.labelX);
+      c.elbowX = Math.max(i, Math.min(x, M)), c.elbowY = c.labelY;
     }
-    return x;
+    return g;
   }
   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;
+    if (this.#t.length === 0) {
+      this.#x();
+      return;
+    }
+    const { scope: t, theme: n, padding: o } = e, { context: s, bitmapSize: h, horizontalPixelRatio: r, verticalPixelRatio: u } = t, m = performance.now(), R = this.#f ? Math.min(0.05, (m - this.#f) / 1e3) : 0;
+    this.#f = m;
+    const g = this.#d();
+    if (g <= 0) {
+      this.#x();
+      return;
+    }
+    this.#r.tick(m);
+    const y = this.#r.active, p = -Math.PI / 2 + this.#r.sweep() * H, T = 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);
+      for (let w = 0; w < this.#t.length; w++) {
+        const O = w === this.#a ? 1 : 0;
+        this.#s[w] = nt(this.#s[w], O, T, R);
+      }
+    const b = it(this.#e.sliceLabels);
+    s.font = `${b.fontSize * r}px ${n.typography.fontFamily}`, b.mode === "outside" && !y && this.#o < 1 && (this.#o = nt(this.#o, 1, 6, R), this.#o >= 0.995 && (this.#o = 1));
+    const C = this.#e.colors ?? n.seriesColors;
+    let P = b.mode === "outside" ? this.#y(s, b, g, r) : 0;
+    const f = {
+      bitmapWidth: h.width,
+      bitmapHeight: h.height,
+      padTop: o.top * u,
+      padBottom: o.bottom * u
+    };
+    let { cx: v, cy: A, maxR: S } = st({ ...f, labelReserve: P }), c = b.mode === "outside";
+    c && S < yt * r && (c = !1, P = 0, { cx: v, cy: A, maxR: S } = st({ ...f, labelReserve: P })), this.#g = P;
+    const l = S, M = l * this.#e.innerRadiusRatio, i = this.#e.padAngle * et, x = (this.#e.cornerRadius ?? 3) * r, d = 8 * r, I = this.#e.shadow ?? !1, Y = bt(I), k = this.#e.innerShadow ?? !1, B = xt(k), V = this.#e.gradient !== !1;
+    let X = -Math.PI / 2;
+    for (let w = 0; w < this.#t.length; w++) {
+      const O = this.#t[w], $ = this.#i(O.value) / g * H, W = X + i / 2;
+      let L = X + $ - i / 2;
+      const _ = X + $ / 2, F = this.#c({ index: w, palette: C, theme: n });
+      if (y) {
+        if (W >= p) {
+          X += $;
+          continue;
+        }
+        L = Math.min(L, p);
       }
-    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;
+      if (L <= W) {
+        X += $;
         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));
+      const K = this.#s[w] * d, q = Math.cos(_) * K, J = Math.sin(_) * K, N = v + q, E = A + J, j = x > 0.5 ? Math.min(x, vt({ outerR: l, innerR: M, halfSpan: (L - W) / 2 })) : 0;
+      if (s.beginPath(), j > 0.5 ? this.#v(s, { sliceCx: N, sliceCy: E, outerR: l, innerR: M, startAngle: W, endAngle: L, cornerRadius: j }) : (s.arc(N, E, l, W, L), M > 0 ? s.arc(N, E, M, L, W, !0) : s.lineTo(N, E)), s.closePath(), V || k) {
+        const z = s.createRadialGradient(N, E, M || 0, N, E, l);
+        if (z.addColorStop(0, V ? Rt(F, 0.15) : F), k) {
+          const G = Math.max(0, Math.min(0.999, 1 - B.depth));
+          z.addColorStop(G, F), z.addColorStop(1, wt(F, B.color));
         } else
-          T.addColorStop(1, F);
-        s.fillStyle = T;
+          z.addColorStop(1, F);
+        s.fillStyle = z;
       } 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;
+      const Q = this.#s[w];
+      if (I || Q > 0.01) {
+        const z = I ? 1 : 0, G = Q;
+        s.shadowColor = I ? Y.color : "rgba(0,0,0,0.25)", s.shadowBlur = (Y.blur * z + 12 * G) * r, s.shadowOffsetX = Y.offsetX * z * r + q * 0.3 * G, s.shadowOffsetY = Y.offsetY * z * u + J * 0.3 * G;
       }
-      s.fill(), s.shadowColor = "transparent", s.shadowBlur = 0, s.shadowOffsetX = 0, s.shadowOffsetY = 0, m += y;
+      s.fill(), s.shadowColor = "transparent", s.shadowBlur = 0, s.shadowOffsetX = 0, s.shadowOffsetY = 0, X += $;
     }
-    if (M.mode === "none") return;
-    m = -Math.PI / 2;
-    const O = o.tooltip.textColor;
-    if (M.mode === "outside") {
-      const p = this.#x({
-        cx: L,
+    if (b.mode === "none" || b.mode === "outside" && !c) return;
+    X = -Math.PI / 2;
+    const tt = n.tooltip.textColor;
+    if (b.mode === "outside") {
+      const w = this.#R({
+        cx: v,
         cy: A,
-        outerR: I,
-        total: x,
-        palette: X,
-        theme: o,
-        labels: M,
+        outerR: l,
+        total: g,
+        palette: C,
+        theme: n,
+        labels: b,
         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({
+        bitmapHeight: h.height
+      }), O = w.length > 1 ? Math.min(0.06, 0.9 / (w.length - 1)) : 0;
+      for (let $ = 0; $ < w.length; $++) {
+        const W = w[$];
+        if (W === null) continue;
+        const L = $ * O, _ = U((this.#o - L) / (1 - L), 0, 1);
+        this.#S({
           context: s,
-          entry: Y,
-          textColor: O,
-          labels: M,
+          entry: W,
+          textColor: tt,
+          labels: b,
           hpr: r,
-          progress: D
+          progress: _,
+          bitmapWidth: h.width
         });
       }
       return;
     }
-    const P = S > 0 ? (I + S) / 2 : I * 0.65;
+    const D = M > 0 ? (l + M) / 2 : l * 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);
+    const ht = b.minSliceAngle * et;
+    for (let w = 0; w < this.#t.length; w++) {
+      const O = this.#t[w], $ = this.#i(O.value) / g * H;
+      if ($ >= ht) {
+        const W = X + $ / 2, L = this.#s[w] * d, _ = this.#c({ index: w, palette: C, theme: n }), F = this.#m(O, g, b.content), K = s.measureText(F).width, q = b.fontSize * 1.2 * r, J = $ < Math.PI ? 2 * D * Math.sin($ / 2) : 2 * D, N = K > J - 4 * r, E = M > 0 && D - M < q, j = y ? U((p - (X + $)) / 0.35, 0, 1) : 1;
+        if (!N && !E && j > 0) {
+          const Q = v + Math.cos(W) * (D + L), z = A + Math.sin(W) * (D + L), G = j < 1;
+          G && (s.save(), s.globalAlpha *= j), s.fillStyle = ft(_) ? "#000000" : "#ffffff", s.fillText(F, Q, z), G && s.restore();
         }
       }
-      m += y;
+      X += $;
     }
   }
 }
-const pt = {
+const Pt = {
   type: "pie",
-  create: (l, e) => new ft({ ...e })
+  create: (a, e) => new It({ ...e })
 };
 export {
-  ft as PieRenderer,
-  pt as PieSeriesDef
+  It as PieRenderer,
+  Pt as PieSeriesDef
 };