@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-QS76E3TD.mjs

@@ -0,0 +1,111 @@
+import { isGradientColor } from './chunk-O2X6FF45.mjs';
+import { parseColorToRGB, parseHexColor, parseColorToRGBA } from './chunk-SSLTFJ3U.mjs';
+
+// src/utils/color/luminance.ts
+function calculateLuminanceFromRGB(r, g, b) {
+  return 0.2126 * (r / 255) + 0.7152 * (g / 255) + 0.0722 * (b / 255);
+}
+function perceivedLuminanceFromRGB(r, g, b) {
+  return (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+}
+function getColorLuminance(color) {
+  const rgb = parseColorToRGB(color);
+  if (!rgb) return 0.5;
+  return calculateLuminanceFromRGB(rgb.r, rgb.g, rgb.b);
+}
+function getGradientLuminance(stops) {
+  if (!stops || stops.length === 0) return 0.5;
+  let totalWeight = 0;
+  let weightedLuminance = 0;
+  for (const stop of stops) {
+    const weight = 1 - Math.abs(stop.offset - 0.5) * 0.5;
+    weightedLuminance += getColorLuminance(stop.color) * weight;
+    totalWeight += weight;
+  }
+  return totalWeight > 0 ? weightedLuminance / totalWeight : 0.5;
+}
+function getContrastingTextColor(bgColor, threshold = 0.5) {
+  let luminance;
+  if (isGradientColor(bgColor)) {
+    luminance = getGradientLuminance(bgColor.stops);
+  } else {
+    luminance = getColorLuminance(bgColor);
+  }
+  return luminance < threshold ? "#ffffff" : "#1f2937";
+}
+function getContrastColor(bgColor) {
+  let r = 0, g = 0, b = 0;
+  if (bgColor.startsWith("#")) {
+    [r, g, b] = parseHexColor(bgColor);
+  } else if (bgColor.startsWith("rgb")) {
+    const match = bgColor.match(/(\d+)/g);
+    if (match && match.length >= 3) {
+      r = parseInt(match[0]);
+      g = parseInt(match[1]);
+      b = parseInt(match[2]);
+    }
+  }
+  return perceivedLuminanceFromRGB(r, g, b) > 0.55 ? "#374151" : "#FFFFFF";
+}
+
+// src/utils/color/scale.ts
+function interpolateColor(colorScale, colorRange, value, fallback = "#808080") {
+  if (colorScale.length === 0 || colorRange.length === 0) return fallback;
+  if (colorScale.length !== colorRange.length) return fallback;
+  const clamped = Math.max(colorScale[0], Math.min(colorScale[colorScale.length - 1], value));
+  for (let i = 0; i < colorScale.length - 1; i++) {
+    const lo = colorScale[i];
+    const hi = colorScale[i + 1];
+    if (clamped >= lo && clamped <= hi) {
+      const t = hi === lo ? 0 : (clamped - lo) / (hi - lo);
+      const [r1, g1, b1] = parseHexColor(colorRange[i]);
+      const [r2, g2, b2] = parseHexColor(colorRange[i + 1]);
+      const r = Math.round(r1 + (r2 - r1) * t);
+      const g = Math.round(g1 + (g2 - g1) * t);
+      const b = Math.round(b1 + (b2 - b1) * t);
+      return `rgb(${r},${g},${b})`;
+    }
+  }
+  return colorRange[colorRange.length - 1];
+}
+var DEFAULT_HEAT_COLORS = ["#fde68a", "#ee1c1c"];
+function buildAutoColorScale(min, max, stops) {
+  if (stops <= 0) return [];
+  if (stops === 1 || min === max) return [min];
+  const scale = [];
+  for (let i = 0; i < stops; i++) {
+    scale.push(min + (max - min) * (i / (stops - 1)));
+  }
+  return scale;
+}
+function resolveColorScaleRange(opts, min, max) {
+  const { colorScale, colorRange, color, defaultColors = DEFAULT_HEAT_COLORS } = opts;
+  if (colorScale && colorRange && colorScale.length > 0 && colorRange.length > 0) {
+    return { colorScale, colorRange };
+  }
+  if (colorRange && colorRange.length > 0) {
+    return { colorScale: buildAutoColorScale(min, max, colorRange.length), colorRange };
+  }
+  if (color) {
+    return null;
+  }
+  return { colorScale: buildAutoColorScale(min, max, defaultColors.length), colorRange: defaultColors };
+}
+function lerpColor(from, to, t) {
+  if (isGradientColor(from) || isGradientColor(to)) {
+    return t >= 0.5 ? to : from;
+  }
+  const fromRGBA = parseColorToRGBA(from);
+  const toRGBA = parseColorToRGBA(to);
+  if (!fromRGBA) return from;
+  if (!toRGBA) return to;
+  const effectiveFrom = from.trim().toLowerCase() === "transparent" && toRGBA ? { r: toRGBA.r, g: toRGBA.g, b: toRGBA.b, a: 0 } : fromRGBA;
+  const effectiveTo = to.trim().toLowerCase() === "transparent" && fromRGBA ? { r: fromRGBA.r, g: fromRGBA.g, b: fromRGBA.b, a: 0 } : toRGBA;
+  const r = Math.round(effectiveFrom.r + (effectiveTo.r - effectiveFrom.r) * t);
+  const g = Math.round(effectiveFrom.g + (effectiveTo.g - effectiveFrom.g) * t);
+  const b = Math.round(effectiveFrom.b + (effectiveTo.b - effectiveFrom.b) * t);
+  const a = effectiveFrom.a + (effectiveTo.a - effectiveFrom.a) * t;
+  return `rgba(${r}, ${g}, ${b}, ${a})`;
+}
+
+export { DEFAULT_HEAT_COLORS, buildAutoColorScale, calculateLuminanceFromRGB, getColorLuminance, getContrastColor, getContrastingTextColor, getGradientLuminance, interpolateColor, lerpColor, perceivedLuminanceFromRGB, resolveColorScaleRange };

package/dist/chunk-QWQ6HY4I.mjs

@@ -0,0 +1,209 @@
+import { measureTextWidth } from './chunk-XTVE4P3L.mjs';
+
+// src/cartesian/crosshair.ts
+function computeCrosshairLayout(input) {
+  const { plotArea, ctx, lineColor, dashArray, lineStrokeWidth, showX, showY, cursorX, cursorY, snapX, snapY, categoryText, cursorValueText, barValueText, barColor, badgeBg, badgeTextColor, allSeriesHits } = input;
+  const isSharedMode = allSeriesHits != null && allSeriesHits.length > 0;
+  const dash = dashArray.join(" ");
+  const clampedX = Math.max(plotArea.x, Math.min(cursorX, plotArea.x + plotArea.width));
+  const clampedY = Math.max(plotArea.y, Math.min(cursorY, plotArea.y + plotArea.height));
+  const badgeFontSize = 11;
+  const badgePadH = 6;
+  const badgePadV = 3;
+  const badgeHeight = badgeFontSize + badgePadV * 2;
+  const badgeRadius = 4;
+  const badgeGap = 4;
+  const catBadgeOffset = 11;
+  const catTextWidth = measureTextWidth(categoryText, badgeFontSize);
+  const cursorValTextWidth = measureTextWidth(cursorValueText, badgeFontSize);
+  const barValTextWidth = measureTextWidth(barValueText, badgeFontSize);
+  const catBadgeWidth = catTextWidth + badgePadH * 2;
+  const cursorValBadgeWidth = cursorValTextWidth + badgePadH * 2;
+  const barValBadgeWidth = barValTextWidth + badgePadH * 2;
+  const { orientation, categoryAxisPosition, valueAxisPosition } = ctx;
+  let catBadge = null;
+  let valBadge = null;
+  let barLabel = null;
+  let seriesLabels = [];
+  if (orientation === "vertical") {
+    const catBadgeX = snapX - catBadgeWidth / 2;
+    if (categoryAxisPosition === "bottom") {
+      const catBadgeY = plotArea.y + plotArea.height + catBadgeOffset;
+      catBadge = { x: catBadgeX, y: catBadgeY, w: catBadgeWidth, h: badgeHeight, text: categoryText, textX: snapX, textY: catBadgeY + badgeHeight / 2 };
+    } else {
+      const catBadgeY = plotArea.y - catBadgeOffset - badgeHeight;
+      catBadge = { x: catBadgeX, y: catBadgeY, w: catBadgeWidth, h: badgeHeight, text: categoryText, textX: snapX, textY: catBadgeY + badgeHeight / 2 };
+    }
+    if (isSharedMode) {
+      seriesLabels = computeSeriesLabels(allSeriesHits, "vertical", valueAxisPosition, plotArea, badgePadH, badgeHeight, badgeGap, badgeFontSize);
+    } else {
+      const valBadgeY = clampedY - badgeHeight / 2;
+      if (valueAxisPosition === "left") {
+        const valBadgeX = plotArea.x - badgeGap - cursorValBadgeWidth;
+        valBadge = { x: valBadgeX, y: valBadgeY, w: cursorValBadgeWidth, h: badgeHeight, text: cursorValueText, textX: valBadgeX + cursorValBadgeWidth / 2, textY: clampedY };
+      } else {
+        const valBadgeX = plotArea.x + plotArea.width + badgeGap;
+        valBadge = { x: valBadgeX, y: valBadgeY, w: cursorValBadgeWidth, h: badgeHeight, text: cursorValueText, textX: valBadgeX + cursorValBadgeWidth / 2, textY: clampedY };
+      }
+      barLabel = {
+        x: snapX - barValBadgeWidth / 2,
+        y: snapY - badgeHeight - badgeGap,
+        w: barValBadgeWidth,
+        h: badgeHeight,
+        text: barValueText,
+        textX: snapX,
+        textY: snapY - badgeHeight / 2 - badgeGap,
+        color: barColor
+      };
+    }
+  } else {
+    if (categoryAxisPosition === "left") {
+      const catBadgeX = plotArea.x - badgeGap - catBadgeWidth;
+      catBadge = { x: catBadgeX, y: snapY - badgeHeight / 2, w: catBadgeWidth, h: badgeHeight, text: categoryText, textX: catBadgeX + catBadgeWidth / 2, textY: snapY };
+    } else {
+      const catBadgeX = plotArea.x + plotArea.width + badgeGap;
+      catBadge = { x: catBadgeX, y: snapY - badgeHeight / 2, w: catBadgeWidth, h: badgeHeight, text: categoryText, textX: catBadgeX + catBadgeWidth / 2, textY: snapY };
+    }
+    if (isSharedMode) {
+      seriesLabels = computeSeriesLabels(allSeriesHits, "horizontal", valueAxisPosition, plotArea, badgePadH, badgeHeight, badgeGap, badgeFontSize);
+    } else {
+      const valBadgeX = clampedX - cursorValBadgeWidth / 2;
+      if (valueAxisPosition === "bottom") {
+        const valBadgeYPos = plotArea.y + plotArea.height + badgeGap;
+        valBadge = { x: valBadgeX, y: valBadgeYPos, w: cursorValBadgeWidth, h: badgeHeight, text: cursorValueText, textX: clampedX, textY: valBadgeYPos + badgeHeight / 2 };
+      } else {
+        const valBadgeYPos = plotArea.y - badgeGap - badgeHeight;
+        valBadge = { x: valBadgeX, y: valBadgeYPos, w: cursorValBadgeWidth, h: badgeHeight, text: cursorValueText, textX: clampedX, textY: valBadgeYPos + badgeHeight / 2 };
+      }
+      barLabel = {
+        x: snapX + badgeGap,
+        y: snapY - badgeHeight / 2,
+        w: barValBadgeWidth,
+        h: badgeHeight,
+        text: barValueText,
+        textX: snapX + badgeGap + barValBadgeWidth / 2,
+        textY: snapY,
+        color: barColor
+      };
+    }
+  }
+  return {
+    plotArea,
+    lineColor,
+    dash,
+    sw: lineStrokeWidth,
+    cursorX: clampedX,
+    cursorY: clampedY,
+    showX,
+    showY,
+    catBadge,
+    valBadge,
+    barLabel,
+    seriesLabels,
+    badgeBg,
+    badgeTextColor,
+    badgeRadius,
+    badgeFontSize
+  };
+}
+function computeSeriesLabels(hits, orientation, valueAxisPosition, plotArea, padH, badgeHeight, gap, fontSize) {
+  if (hits.length === 0) return [];
+  const raw = hits.map((hit) => {
+    const textWidth = measureTextWidth(hit.formattedValue, fontSize);
+    const badgeWidth = textWidth + padH * 2;
+    return { hit, badgeWidth, snapPixel: hit.snapPixel };
+  });
+  raw.sort((a, b) => a.snapPixel - b.snapPixel);
+  const posMin = orientation === "vertical" ? plotArea.y + badgeHeight / 2 : plotArea.x + badgeHeight / 2;
+  const posMax = orientation === "vertical" ? plotArea.y + plotArea.height - badgeHeight / 2 : plotArea.x + plotArea.width - badgeHeight / 2;
+  const spacing = badgeHeight + 2;
+  const positions = raw.map((r) => Math.max(posMin, Math.min(r.snapPixel, posMax)));
+  for (let i = 1; i < positions.length; i++) {
+    const prevBottom = positions[i - 1] + spacing;
+    if (positions[i] < prevBottom) positions[i] = prevBottom;
+  }
+  if (positions[positions.length - 1] > posMax) {
+    positions[positions.length - 1] = posMax;
+    for (let i = positions.length - 2; i >= 0; i--) {
+      const nextTop = positions[i + 1] - spacing;
+      if (positions[i] > nextTop) positions[i] = nextTop;
+    }
+  }
+  const labels = [];
+  for (let i = 0; i < raw.length; i++) {
+    const { hit, badgeWidth } = raw[i];
+    const pos = positions[i];
+    let label;
+    if (orientation === "vertical") {
+      if (valueAxisPosition === "left") {
+        const bx = plotArea.x - gap - badgeWidth;
+        label = {
+          x: bx,
+          y: pos - badgeHeight / 2,
+          w: badgeWidth,
+          h: badgeHeight,
+          text: hit.formattedValue,
+          textX: bx + badgeWidth / 2,
+          textY: pos,
+          color: hit.color
+        };
+      } else {
+        const bx = plotArea.x + plotArea.width + gap;
+        label = {
+          x: bx,
+          y: pos - badgeHeight / 2,
+          w: badgeWidth,
+          h: badgeHeight,
+          text: hit.formattedValue,
+          textX: bx + badgeWidth / 2,
+          textY: pos,
+          color: hit.color
+        };
+      }
+    } else {
+      if (valueAxisPosition === "bottom") {
+        const by = plotArea.y + plotArea.height + gap;
+        label = {
+          x: pos - badgeWidth / 2,
+          y: by,
+          w: badgeWidth,
+          h: badgeHeight,
+          text: hit.formattedValue,
+          textX: pos,
+          textY: by + badgeHeight / 2,
+          color: hit.color
+        };
+      } else {
+        const by = plotArea.y - gap - badgeHeight;
+        label = {
+          x: pos - badgeWidth / 2,
+          y: by,
+          w: badgeWidth,
+          h: badgeHeight,
+          text: hit.formattedValue,
+          textX: pos,
+          textY: by + badgeHeight / 2,
+          color: hit.color
+        };
+      }
+    }
+    labels.push(label);
+  }
+  return labels;
+}
+function normalizeCrosshairConfig(crosshair) {
+  if (!crosshair) return null;
+  if (crosshair === true) {
+    return { enabled: true, showX: true, showY: true, width: 1, dashArray: [4, 4] };
+  }
+  return {
+    enabled: true,
+    showX: crosshair.x !== false,
+    showY: crosshair.y !== false,
+    color: crosshair.color,
+    width: crosshair.width ?? 1,
+    dashArray: crosshair.dashArray ?? [4, 4]
+  };
+}
+
+export { computeCrosshairLayout, normalizeCrosshairConfig };

package/dist/chunk-R6Y3R7EW.mjs

@@ -0,0 +1,135 @@
+import { measureTextWidth } from './chunk-XTVE4P3L.mjs';
+
+// src/utils/text/label.utils.ts
+function resolveCollisionAvoidance(options) {
+  const { labels, positions, isHorizontal, fontSize, fontWeight, fontFamily, autoRotate, autoRotateAngle, manualRotation, tickCount, labelMinSpacing, autoSkip = true } = options;
+  if (labels.length <= 1) {
+    return { rotation: manualRotation, skipStep: 1 };
+  }
+  if (!autoSkip) {
+    let effectiveRotation2 = manualRotation;
+    if (manualRotation === 0 && autoRotate && isHorizontal) {
+      if (hasCollisions(labels, positions, fontSize, fontWeight, fontFamily, 0, labelMinSpacing, isHorizontal)) {
+        effectiveRotation2 = autoRotateAngle;
+      }
+    }
+    return { rotation: effectiveRotation2, skipStep: 1 };
+  }
+  let effectiveRotation = manualRotation;
+  if (manualRotation === 0 && autoRotate && isHorizontal) {
+    if (hasCollisions(labels, positions, fontSize, fontWeight, fontFamily, 0, labelMinSpacing, isHorizontal)) {
+      effectiveRotation = autoRotateAngle;
+    }
+  }
+  let skipStep = 1;
+  if (tickCount !== void 0 && tickCount > 0) {
+    if (labels.length > tickCount) {
+      skipStep = Math.ceil(labels.length / tickCount);
+    }
+    const footprints = computeLabelFootprints(labels, fontSize, fontWeight, fontFamily, effectiveRotation, isHorizontal);
+    if (hasCollisionsAtStep(labels, positions, footprints, labelMinSpacing, skipStep)) {
+      skipStep = findMinSkipStep(labels, positions, fontSize, fontWeight, fontFamily, effectiveRotation, labelMinSpacing, skipStep, isHorizontal);
+    }
+  } else {
+    skipStep = findMinSkipStep(labels, positions, fontSize, fontWeight, fontFamily, effectiveRotation, labelMinSpacing, 1, isHorizontal);
+  }
+  return { rotation: effectiveRotation, skipStep };
+}
+function computeLabelFootprints(labels, fontSize, fontWeight, fontFamily, rotation, isHorizontal) {
+  if (!isHorizontal) {
+    const lineHeight = fontSize * 1.2;
+    return labels.map(() => lineHeight);
+  }
+  const footprints = new Array(labels.length);
+  for (let i = 0; i < labels.length; i++) {
+    footprints[i] = labels[i] ? calculateLabelFootprint(measureTextWidth(labels[i], fontSize, fontWeight, fontFamily), fontSize, rotation) : 0;
+  }
+  return footprints;
+}
+function hasCollisions(labels, positions, fontSize, fontWeight, fontFamily, rotation, minSpacing, isHorizontal = true) {
+  const footprintCache = new Array(labels.length);
+  const lineHeight = fontSize * 1.2;
+  const footprintAt = (i) => {
+    let fp = footprintCache[i];
+    if (fp === void 0) {
+      fp = !isHorizontal ? lineHeight : labels[i] ? calculateLabelFootprint(measureTextWidth(labels[i], fontSize, fontWeight, fontFamily), fontSize, rotation) : 0;
+      footprintCache[i] = fp;
+    }
+    return fp;
+  };
+  return hasCollisionsAtStepLazy(labels, positions, footprintAt, minSpacing, 1);
+}
+function hasCollisionsAtStepLazy(labels, positions, footprintAt, minSpacing, step) {
+  const visibleIndices = [];
+  for (let i = 0; i < labels.length; i++) {
+    if (i % step === 0 && labels[i]) visibleIndices.push(i);
+  }
+  if (visibleIndices.length <= 1) return false;
+  for (let k = 0; k < visibleIndices.length - 1; k++) {
+    const i = visibleIndices[k];
+    const j = visibleIndices[k + 1];
+    const gap = Math.abs(positions[j] - positions[i]);
+    const minRequired = (footprintAt(i) + footprintAt(j)) / 2 + minSpacing;
+    if (gap < minRequired) return true;
+  }
+  return false;
+}
+function hasCollisionsAtStep(labels, positions, footprints, minSpacing, step) {
+  const visibleIndices = [];
+  for (let i = 0; i < labels.length; i++) {
+    if (i % step === 0 && labels[i]) {
+      visibleIndices.push(i);
+    }
+  }
+  if (visibleIndices.length <= 1) return false;
+  for (let k = 0; k < visibleIndices.length - 1; k++) {
+    const i = visibleIndices[k];
+    const j = visibleIndices[k + 1];
+    const gap = Math.abs(positions[j] - positions[i]);
+    const minRequired = (footprints[i] + footprints[j]) / 2 + minSpacing;
+    if (gap < minRequired) {
+      return true;
+    }
+  }
+  return false;
+}
+function findMinSkipStep(labels, positions, fontSize, fontWeight, fontFamily, rotation, minSpacing, startStep, isHorizontal = true) {
+  const maxStep = Math.max(1, Math.ceil(labels.length / 2));
+  const footprints = computeLabelFootprints(labels, fontSize, fontWeight, fontFamily, rotation, isHorizontal);
+  for (let step = startStep; step <= maxStep; step++) {
+    if (!hasCollisionsAtStep(labels, positions, footprints, minSpacing, step)) {
+      return step;
+    }
+  }
+  return maxStep;
+}
+function calculateLabelFootprint(labelWidth, fontSize, rotation) {
+  if (rotation === 0) return labelWidth;
+  const radians = Math.abs(rotation * Math.PI / 180);
+  const textHeight = fontSize * 1.2;
+  return labelWidth * Math.cos(radians) + textHeight * Math.sin(radians);
+}
+function adjustLabelForRotation(rotation, textAnchor, baseline) {
+  if (rotation === 0) return { textAnchor, baseline };
+  const absRotation = Math.abs(rotation);
+  const isAboveBar = baseline === "auto";
+  const isBelowBar = baseline === "hanging";
+  if (isAboveBar) {
+    return {
+      textAnchor: rotation < 0 ? "start" : "end",
+      baseline: absRotation > 60 ? "central" : "auto"
+    };
+  }
+  if (isBelowBar) {
+    return {
+      textAnchor: rotation < 0 ? "end" : "start",
+      baseline: absRotation > 60 ? "central" : "hanging"
+    };
+  }
+  return {
+    textAnchor: rotation < 0 ? "end" : "start",
+    baseline: "central"
+  };
+}
+
+export { adjustLabelForRotation, calculateLabelFootprint, hasCollisions, resolveCollisionAvoidance };

package/dist/chunk-RBLZRT5K.mjs

@@ -0,0 +1,190 @@
+import { renderPieCanvas } from './chunk-VWF57TS3.mjs';
+import { renderPieSvg } from './chunk-IXOWSEHO.mjs';
+import { computeSlices, isFullCircle, findSliceAtPoint } from './chunk-LVMDQ4OJ.mjs';
+import { calculateRadiusAndCenter } from './chunk-NPDZLYIF.mjs';
+import { isIndexVisible } from './chunk-5JCI2DEB.mjs';
+import { FIELD_DEFAULTS, batchResolveRequired, batchResolveAccessor, resolveAccessor, makeItemContext } from './chunk-O2X6FF45.mjs';
+import { toRad } from './chunk-RQ3CKQOX.mjs';
+
+// src/series/pie/geometry.ts
+var DEFAULT_START_ANGLE = -90;
+var DEFAULT_SWEEP_ANGLE = 360;
+var DEFAULT_INNER_RADIUS = 0;
+function calculatePieLayout(props, chartArea) {
+  const { data, valueField, color: colorProp, startAngle = DEFAULT_START_ANGLE, sweepAngle = DEFAULT_SWEEP_ANGLE, visibility } = props;
+  const valueAccessor = valueField ?? FIELD_DEFAULTS.valueField;
+  const keyField = props.keyField;
+  const rawInnerRadius = props.innerRadius ?? DEFAULT_INNER_RADIUS;
+  const normalizedInnerRadius = rawInnerRadius > 1 ? rawInnerRadius / 100 : rawInnerRadius;
+  const innerRadiusRatio = Math.max(0, Math.min(1, normalizedInnerRadius));
+  const values = valueAccessor ? batchResolveRequired(valueAccessor, data, "valueField") : data.map((_, i) => i + 1);
+  const seriesExtras = { seriesIndex: props.order ?? 0, seriesId: props.id ?? "" };
+  const categoryAccessor = props.categoryField ?? props.labelField ?? FIELD_DEFAULTS.categoryField;
+  const categoryFor = (i) => categoryAccessor ? resolveAccessor(categoryAccessor, makeItemContext(data[i], i, { value: values[i], ...seriesExtras })) ?? void 0 : void 0;
+  const dataKeys = keyField ? batchResolveAccessor(keyField, data) : [];
+  const allIndices = values.map((_, i) => i);
+  const sortProp = props.sort;
+  const sortedAllIndices = allIndices.slice();
+  if (sortProp) {
+    const labelAccessor = props.categoryField ?? props.labelField ?? FIELD_DEFAULTS.categoryField;
+    sortedAllIndices.sort((a, b) => {
+      if (sortProp === "value-asc") return values[a] - values[b];
+      if (sortProp === "value-desc") return values[b] - values[a];
+      const labelA = labelAccessor ? String(resolveAccessor(labelAccessor, makeItemContext(data[a], a)) ?? "") : "";
+      const labelB = labelAccessor ? String(resolveAccessor(labelAccessor, makeItemContext(data[b], b)) ?? "") : "";
+      return sortProp === "label-asc" ? labelA.localeCompare(labelB) : labelB.localeCompare(labelA);
+    });
+  }
+  const visibleValues = [];
+  const visibleIndices = [];
+  for (const idx of sortedAllIndices) {
+    if (isIndexVisible(visibility, idx)) {
+      visibleValues.push(values[idx]);
+      visibleIndices.push(idx);
+    }
+  }
+  const computedSlices = computeSlices(visibleValues, visibleIndices, startAngle, sweepAngle);
+  const computedByIndex = new Map(computedSlices.map((s) => [s.originalIndex, s]));
+  const slices = sortedAllIndices.map((dataIndex) => {
+    const visible = isIndexVisible(visibility, dataIndex);
+    const cs = computedByIndex.get(dataIndex);
+    if (cs) {
+      return { ...cs, visible, dataIndex, dataKey: dataKeys[dataIndex] };
+    }
+    return {
+      value: values[dataIndex],
+      percentage: 0,
+      rotation: startAngle,
+      endAngle: startAngle,
+      valueAngle: startAngle,
+      originalIndex: dataIndex,
+      visible,
+      dataIndex,
+      dataKey: dataKeys[dataIndex]
+    };
+  });
+  const visibleSlices = slices.filter((s) => s.visible);
+  const { center, radius: naturalRadius } = calculateRadiusAndCenter(chartArea, void 0, { rotation: startAngle, sweepAngle });
+  const rawOuterRatio = props.outerRadius ?? 1;
+  const normalizedOuterRatio = rawOuterRatio > 1 ? rawOuterRatio / 100 : rawOuterRatio;
+  const outerRadiusRatio = normalizedOuterRatio <= 0 ? 1 : Math.min(normalizedOuterRatio, 1);
+  const offsetProp = props.offset;
+  let maxSliceOffset = 0;
+  if (offsetProp != null) {
+    for (let i = 0; i < data.length; i++) {
+      const val = resolveAccessor(offsetProp, makeItemContext(data[i], i, { value: values[i], category: categoryFor(i), ...seriesExtras }), { arrayMode: "clip", fallback: 0 }) ?? 0;
+      if (val > maxSliceOffset) maxSliceOffset = val;
+    }
+  }
+  const hoverEffects = props.effects;
+  const hoverOffset = hoverEffects?.hoverOffset ?? 0;
+  const hoverScale = hoverEffects?.hoverScale && hoverEffects.hoverScale > 1 ? hoverEffects.hoverScale : 1;
+  const reservedOffset = Math.max(maxSliceOffset, hoverOffset);
+  const radius = Math.max(0, naturalRadius - reservedOffset) / hoverScale * outerRadiusRatio;
+  const innerRadius = radius * innerRadiusRatio;
+  const borderColorProp = props.borderColor;
+  const colors = [];
+  const borderColors = [];
+  for (let i = 0; i < data.length; i++) {
+    let color;
+    let borderColor;
+    if (colorProp != null) {
+      const resolved = resolveAccessor(colorProp, makeItemContext(data[i], i, { value: values[i], category: categoryFor(i), ...seriesExtras }));
+      if (resolved) color = resolved;
+    }
+    colors.push(color);
+    if (borderColorProp) {
+      const resolvedBorderColor = batchResolveAccessor(borderColorProp, [data[i]])[0];
+      if (resolvedBorderColor) {
+        borderColor = resolvedBorderColor;
+      }
+    }
+    borderColors.push(borderColor ?? "transparent");
+  }
+  const sliceCenters = slices.map((slice) => {
+    const midRadius = (radius + innerRadius) / 2;
+    const angleRad = toRad(slice.valueAngle);
+    return {
+      dataIndex: slice.dataIndex,
+      x: center.x + Math.cos(angleRad) * midRadius,
+      y: center.y + Math.sin(angleRad) * midRadius,
+      angle: slice.valueAngle
+    };
+  });
+  return {
+    slices,
+    visibleSlices,
+    center,
+    outerRadius: radius,
+    innerRadius,
+    colors,
+    borderColors,
+    isFullCircle: isFullCircle(sweepAngle),
+    startAngle,
+    sweepAngle,
+    sliceCenters
+  };
+}
+function hitTestPie(x, y, _props, layout) {
+  const { visibleSlices, center, outerRadius, innerRadius } = layout;
+  const relX = x - center.x;
+  const relY = y - center.y;
+  const sliceIndex = findSliceAtPoint(relX, relY, visibleSlices, outerRadius, innerRadius);
+  if (sliceIndex === -1) return null;
+  return visibleSlices[sliceIndex].dataIndex;
+}
+function calculateMultiRingLayout(ringCount, options = {}) {
+  const { ringGap = 0, minInnerRadius = 0, equalWidth = true } = options;
+  if (ringCount <= 0) return [];
+  if (ringCount === 1) {
+    return [{ ringIndex: 0, innerRadiusRatio: minInnerRadius, outerRadiusRatio: 1 }];
+  }
+  const layouts = [];
+  const totalGapSpace = ringGap * (ringCount - 1);
+  const availableSpace = 1 - minInnerRadius - totalGapSpace;
+  if (equalWidth) {
+    const ringWidth = availableSpace / ringCount;
+    for (let i = 0; i < ringCount; i++) {
+      const outerRadius = 1 - i * (ringWidth + ringGap);
+      const innerRadius = outerRadius - ringWidth;
+      layouts.push({
+        ringIndex: i,
+        innerRadiusRatio: Math.max(minInnerRadius, innerRadius),
+        outerRadiusRatio: outerRadius
+      });
+    }
+  } else {
+    let currentOuter = 1;
+    for (let i = 0; i < ringCount; i++) {
+      const proportion = (ringCount - i) / (ringCount * (ringCount + 1) / 2);
+      const ringWidth = availableSpace * proportion;
+      const innerRadius = currentOuter - ringWidth;
+      layouts.push({
+        ringIndex: i,
+        innerRadiusRatio: Math.max(minInnerRadius, innerRadius),
+        outerRadiusRatio: currentOuter
+      });
+      currentOuter = innerRadius - ringGap;
+    }
+  }
+  return layouts;
+}
+function applyRingLayoutToProps(props, ringLayout) {
+  return {
+    ...props,
+    // Override inner radius with calculated ring inner radius
+    innerRadius: ringLayout.innerRadiusRatio / ringLayout.outerRadiusRatio,
+    // Store ring metadata for potential use in rendering
+    _ringLayout: ringLayout
+  };
+}
+
+// src/series/pie/index.ts
+var pieRenderer = {
+  calculateLayout: calculatePieLayout,
+  renderSvg: renderPieSvg,
+  renderCanvas: renderPieCanvas,
+  hitTest: hitTestPie
+};
+
+export { applyRingLayoutToProps, calculateMultiRingLayout, calculatePieLayout, hitTestPie, pieRenderer };