ooxml-core 0.21.2 → 0.22.1

package/dist/chart/index.cjs

@@ -380,17 +380,259 @@ function aggregateByCategory(values, rawCategories) {
   });
 }
 
+// chart/treemap-squarify.ts
+function worstAspectRatio(areas, side) {
+  const sum = areas.reduce((total, area) => total + area, 0);
+  const max = Math.max(...areas);
+  const min = Math.min(...areas);
+  const sideSq = side * side;
+  const sumSq = sum * sum;
+  return Math.max(sideSq * max / sumSq, sumSq / (sideSq * min));
+}
+function squarify(nodes, box) {
+  const sorted = [...nodes].sort((a, b) => b.weight - a.weight);
+  const total = sorted.reduce((sum, node) => sum + node.weight, 0);
+  const scale = total > 0 ? box.w * box.h / total : box.w * box.h / sorted.length;
+  const items = sorted.map((node) => ({ node, area: (total > 0 ? node.weight : 1) * scale }));
+  const result = [];
+  let rect = { ...box };
+  let remaining = items;
+  for (let first = remaining[0]; first !== void 0; first = remaining[0]) {
+    const side = Math.min(rect.w, rect.h);
+    let row = [first];
+    let rowAreas = [first.area];
+    let worst = worstAspectRatio(rowAreas, side);
+    let cursor = 1;
+    for (let next = remaining[cursor]; next !== void 0; next = remaining[cursor]) {
+      const candidateAreas = [...rowAreas, next.area];
+      const candidateWorst = worstAspectRatio(candidateAreas, side);
+      if (candidateWorst > worst) {
+        break;
+      }
+      row = [...row, next];
+      rowAreas = candidateAreas;
+      worst = candidateWorst;
+      cursor++;
+    }
+    const rowTotalArea = rowAreas.reduce((sum, area) => sum + area, 0);
+    const thickness = side > 0 ? rowTotalArea / side : 0;
+    const layoutVertically = rect.w >= rect.h;
+    let offset = layoutVertically ? rect.y : rect.x;
+    for (const item of row) {
+      const length = thickness > 0 ? item.area / thickness : 0;
+      if (layoutVertically) {
+        result.push([item.node, { x: rect.x, y: offset, w: thickness, h: length }]);
+      } else {
+        result.push([item.node, { x: offset, y: rect.y, w: length, h: thickness }]);
+      }
+      offset += length;
+    }
+    rect = layoutVertically ? { ...rect, x: rect.x + thickness, w: rect.w - thickness } : { ...rect, y: rect.y + thickness, h: rect.h - thickness };
+    remaining = remaining.slice(row.length);
+  }
+  return result;
+}
+
+// chart/trendline-equation.ts
+var SIGNIFICANT_DIGITS = 4;
+function formatTrendlineCoefficient(value) {
+  if (!Number.isFinite(value) || value === 0) {
+    return "0";
+  }
+  const rounded = Number(value.toPrecision(SIGNIFICANT_DIGITS));
+  return rounded === 0 ? "0" : String(rounded);
+}
+function signedTerm(value) {
+  return { sign: value < 0 ? "-" : "+", abs: formatTrendlineCoefficient(Math.abs(value)) };
+}
+function formatLinearEquation(slope, intercept) {
+  const { sign, abs } = signedTerm(intercept);
+  return `y = ${formatTrendlineCoefficient(slope)}x ${sign} ${abs}`;
+}
+function formatExponentialEquation(a, b) {
+  return `y = ${formatTrendlineCoefficient(a)} e^(${formatTrendlineCoefficient(b)}x)`;
+}
+function formatLogarithmicEquation(slope, intercept) {
+  const { sign, abs } = signedTerm(intercept);
+  return `y = ${formatTrendlineCoefficient(slope)}ln(x) ${sign} ${abs}`;
+}
+function formatPowerEquation(a, b) {
+  return `y = ${formatTrendlineCoefficient(a)}x^${formatTrendlineCoefficient(b)}`;
+}
+function formatPolynomialEquation(coeffsAscending) {
+  const order = coeffsAscending.length - 1;
+  let out = "y = ";
+  for (let power = order; power >= 0; power--) {
+    const coeff = coeffsAscending[power] ?? 0;
+    const { sign, abs } = signedTerm(coeff);
+    const variable = power === 0 ? "" : power === 1 ? "x" : `x^${power}`;
+    out += power === order ? `${sign === "-" ? "-" : ""}${abs}${variable}` : ` ${sign} ${abs}${variable}`;
+  }
+  return out;
+}
+
+// chart/radar-geometry.ts
+function radarAngle(index, catCount) {
+  const n = Math.max(catCount, 1);
+  return Math.PI * 2 * index / n - Math.PI / 2;
+}
+function computeRadarPoints(values, maxVal, radius, cx, cy, catCount) {
+  const denom = maxVal > 0 ? maxVal : 1;
+  return values.slice(0, Math.max(catCount, 1)).map((val, i) => {
+    const angle = radarAngle(i, catCount), r = Math.abs(val) / denom * radius;
+    return { x: cx + r * Math.cos(angle), y: cy + r * Math.sin(angle) };
+  });
+}
+function radarRingPoints(cx, cy, rr, catCount) {
+  const n = Math.max(catCount, 1);
+  return Array.from({ length: n }, (_, i) => {
+    const angle = radarAngle(i, n);
+    return `${(cx + rr * Math.cos(angle)).toFixed(2)},${(cy + rr * Math.sin(angle)).toFixed(2)}`;
+  }).join(" ");
+}
+
+// chart/pie-best-fit.ts
+var PX_PER_PT = 4 / 3;
+var BEST_FIT_RIM_INSET = 4 * PX_PER_PT;
+var BEST_FIT_EDGE_TOLERANCE = 1.5 * PX_PER_PT;
+var BEST_FIT_OUTSIDE_GAP = 2 * PX_PER_PT;
+function farCorner(x, y, w, h) {
+  return Math.hypot(Math.abs(x) + w / 2, Math.abs(y) + h / 2);
+}
+function insideDistance(ux, uy, w, h, limit) {
+  if (farCorner(0, 0, w, h) > limit) {
+    return void 0;
+  }
+  let lo = 0;
+  let hi = limit;
+  for (let i = 0; i < 40; i++) {
+    const mid = (lo + hi) / 2;
+    if (farCorner(mid * ux, mid * uy, w, h) > limit) {
+      hi = mid;
+    } else {
+      lo = mid;
+    }
+  }
+  return lo;
+}
+function edgeOverhang(x, y, w, h, slice) {
+  let worst = Number.NEGATIVE_INFINITY;
+  const corners = [
+    [-w / 2, -h / 2],
+    [w / 2, -h / 2],
+    [-w / 2, h / 2],
+    [w / 2, h / 2]
+  ];
+  for (const [dx, dy] of corners) {
+    const px = x + dx;
+    const py = y + dy;
+    const fromStart = Math.cos(slice.startAngle) * py - Math.sin(slice.startAngle) * px;
+    const fromEnd = Math.sin(slice.endAngle) * px - Math.cos(slice.endAngle) * py;
+    worst = Math.max(worst, -fromStart, -fromEnd);
+  }
+  return worst;
+}
+function placeBestFitLabel(slice, w, h) {
+  const mid = (slice.startAngle + slice.endAngle) / 2;
+  const ux = Math.cos(mid);
+  const uy = Math.sin(mid);
+  const distance = insideDistance(ux, uy, w, h, slice.outerR - BEST_FIT_RIM_INSET);
+  if (distance !== void 0) {
+    const x = distance * ux;
+    const y = distance * uy;
+    const reflex = slice.endAngle - slice.startAngle >= Math.PI;
+    if (reflex || edgeOverhang(x, y, w, h, slice) <= BEST_FIT_EDGE_TOLERANCE) {
+      return { x: slice.cx + x, y: slice.cy + y, inside: true };
+    }
+  }
+  const extent = Math.abs(ux) * w / 2 + Math.abs(uy) * h / 2;
+  const outside = slice.outerR + BEST_FIT_OUTSIDE_GAP + extent;
+  return { x: slice.cx + outside * ux, y: slice.cy + outside * uy, inside: false };
+}
+
+// chart/pie-label-collision.ts
+var LABEL_COLLISION_GAP = 2;
+function boxDistanceToCentre(box, y, disc) {
+  const nearestX = Math.max(box.x - box.w / 2, Math.min(disc.cx, box.x + box.w / 2));
+  const nearestY = Math.max(y - box.h / 2, Math.min(disc.cy, y + box.h / 2));
+  return Math.hypot(nearestX - disc.cx, nearestY - disc.cy);
+}
+function clearOfDisc(box, y, disc) {
+  if (boxDistanceToCentre(box, y, disc) >= disc.r) {
+    return 0;
+  }
+  const sign = box.x >= disc.cx ? 1 : -1;
+  let dx = 0;
+  while (dx < disc.r * 2 && boxDistanceToCentre({ ...box, x: box.x + sign * dx }, y, disc) < disc.r) {
+    dx += 1;
+  }
+  return sign * dx;
+}
+function overlapsX(a, b) {
+  return Math.abs(a.x - b.x) < (a.w + b.w) / 2;
+}
+function sweepSide(boxes, minY, maxY) {
+  const sorted = [...boxes].sort((a, b) => a.y - b.y || a.id - b.id);
+  const ys = sorted.map((box) => box.y);
+  for (let i = 1; i < sorted.length; i++) {
+    const prev = sorted[i - 1];
+    const box = sorted[i];
+    if (overlapsX(prev, box)) {
+      ys[i] = Math.max(ys[i], ys[i - 1] + (prev.h + box.h) / 2 + LABEL_COLLISION_GAP);
+    }
+  }
+  for (let i = sorted.length - 1; i >= 0; i--) {
+    const box = sorted[i];
+    const limit = i === sorted.length - 1 ? maxY - box.h / 2 : ys[i + 1] - (box.h + sorted[i + 1].h) / 2 - LABEL_COLLISION_GAP;
+    if (ys[i] > limit) {
+      ys[i] = Math.max(limit, minY + box.h / 2);
+    }
+  }
+  return new Map(sorted.map((box, i) => [box.id, ys[i]]));
+}
+function nudgeOutsideLabels(boxes, disc, minY, maxY) {
+  const resolved = /* @__PURE__ */ new Map();
+  for (const side of [
+    boxes.filter((box) => box.x >= disc.cx),
+    boxes.filter((box) => box.x < disc.cx)
+  ]) {
+    for (const [id, y] of sweepSide(side, minY, maxY)) {
+      resolved.set(id, y);
+    }
+  }
+  return boxes.map((box) => {
+    const y = resolved.get(box.id) ?? box.y;
+    return { id: box.id, dx: y === box.y ? 0 : clearOfDisc(box, y, disc), dy: y - box.y };
+  });
+}
+
+exports.BEST_FIT_EDGE_TOLERANCE = BEST_FIT_EDGE_TOLERANCE;
+exports.BEST_FIT_OUTSIDE_GAP = BEST_FIT_OUTSIDE_GAP;
+exports.BEST_FIT_RIM_INSET = BEST_FIT_RIM_INSET;
+exports.LABEL_COLLISION_GAP = LABEL_COLLISION_GAP;
 exports.aggregateByCategory = aggregateByCategory;
 exports.axisTargetIntervals = axisTargetIntervals;
 exports.computeBoxStats = computeBoxStats;
 exports.computeHistogramBins = computeHistogramBins;
 exports.computeLinearRegression = computeLinearRegression;
 exports.computeRSquared = computeRSquared;
+exports.computeRadarPoints = computeRadarPoints;
 exports.computeStackedSeriesPlots = computeStackedSeriesPlots;
 exports.fitPolynomial = fitPolynomial;
+exports.formatExponentialEquation = formatExponentialEquation;
+exports.formatLinearEquation = formatLinearEquation;
+exports.formatLogarithmicEquation = formatLogarithmicEquation;
+exports.formatPolynomialEquation = formatPolynomialEquation;
+exports.formatPowerEquation = formatPowerEquation;
+exports.formatTrendlineCoefficient = formatTrendlineCoefficient;
 exports.groupRowsByCategory = groupRowsByCategory;
 exports.niceAxisStep = niceAxisStep;
 exports.niceValueAxisBounds = niceValueAxisBounds;
+exports.nudgeOutsideLabels = nudgeOutsideLabels;
+exports.placeBestFitLabel = placeBestFitLabel;
+exports.radarAngle = radarAngle;
+exports.radarRingPoints = radarRingPoints;
 exports.resolveBlankDisplay = resolveBlankDisplay;
 exports.scottBinCount = scottBinCount;
+exports.squarify = squarify;
 exports.visibleRuns = visibleRuns;

package/dist/chart/index.d.ts

@@ -5,4 +5,9 @@ export * from './blank-display.js';
 export * from './stacked-series.js';
 export * from './axis-nice.js';
 export * from './histogram-binning.js';
+export * from './treemap-squarify.js';
+export * from './trendline-equation.js';
+export * from './radar-geometry.js';
+export * from './pie-best-fit.js';
+export * from './pie-label-collision.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/chart/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../chart/index.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../chart/index.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC"}

package/dist/chart/index.mjs

@@ -378,4 +378,230 @@ function aggregateByCategory(values, rawCategories) {
   });
 }
 
-export { aggregateByCategory, axisTargetIntervals, computeBoxStats, computeHistogramBins, computeLinearRegression, computeRSquared, computeStackedSeriesPlots, fitPolynomial, groupRowsByCategory, niceAxisStep, niceValueAxisBounds, resolveBlankDisplay, scottBinCount, visibleRuns };
+// chart/treemap-squarify.ts
+function worstAspectRatio(areas, side) {
+  const sum = areas.reduce((total, area) => total + area, 0);
+  const max = Math.max(...areas);
+  const min = Math.min(...areas);
+  const sideSq = side * side;
+  const sumSq = sum * sum;
+  return Math.max(sideSq * max / sumSq, sumSq / (sideSq * min));
+}
+function squarify(nodes, box) {
+  const sorted = [...nodes].sort((a, b) => b.weight - a.weight);
+  const total = sorted.reduce((sum, node) => sum + node.weight, 0);
+  const scale = total > 0 ? box.w * box.h / total : box.w * box.h / sorted.length;
+  const items = sorted.map((node) => ({ node, area: (total > 0 ? node.weight : 1) * scale }));
+  const result = [];
+  let rect = { ...box };
+  let remaining = items;
+  for (let first = remaining[0]; first !== void 0; first = remaining[0]) {
+    const side = Math.min(rect.w, rect.h);
+    let row = [first];
+    let rowAreas = [first.area];
+    let worst = worstAspectRatio(rowAreas, side);
+    let cursor = 1;
+    for (let next = remaining[cursor]; next !== void 0; next = remaining[cursor]) {
+      const candidateAreas = [...rowAreas, next.area];
+      const candidateWorst = worstAspectRatio(candidateAreas, side);
+      if (candidateWorst > worst) {
+        break;
+      }
+      row = [...row, next];
+      rowAreas = candidateAreas;
+      worst = candidateWorst;
+      cursor++;
+    }
+    const rowTotalArea = rowAreas.reduce((sum, area) => sum + area, 0);
+    const thickness = side > 0 ? rowTotalArea / side : 0;
+    const layoutVertically = rect.w >= rect.h;
+    let offset = layoutVertically ? rect.y : rect.x;
+    for (const item of row) {
+      const length = thickness > 0 ? item.area / thickness : 0;
+      if (layoutVertically) {
+        result.push([item.node, { x: rect.x, y: offset, w: thickness, h: length }]);
+      } else {
+        result.push([item.node, { x: offset, y: rect.y, w: length, h: thickness }]);
+      }
+      offset += length;
+    }
+    rect = layoutVertically ? { ...rect, x: rect.x + thickness, w: rect.w - thickness } : { ...rect, y: rect.y + thickness, h: rect.h - thickness };
+    remaining = remaining.slice(row.length);
+  }
+  return result;
+}
+
+// chart/trendline-equation.ts
+var SIGNIFICANT_DIGITS = 4;
+function formatTrendlineCoefficient(value) {
+  if (!Number.isFinite(value) || value === 0) {
+    return "0";
+  }
+  const rounded = Number(value.toPrecision(SIGNIFICANT_DIGITS));
+  return rounded === 0 ? "0" : String(rounded);
+}
+function signedTerm(value) {
+  return { sign: value < 0 ? "-" : "+", abs: formatTrendlineCoefficient(Math.abs(value)) };
+}
+function formatLinearEquation(slope, intercept) {
+  const { sign, abs } = signedTerm(intercept);
+  return `y = ${formatTrendlineCoefficient(slope)}x ${sign} ${abs}`;
+}
+function formatExponentialEquation(a, b) {
+  return `y = ${formatTrendlineCoefficient(a)} e^(${formatTrendlineCoefficient(b)}x)`;
+}
+function formatLogarithmicEquation(slope, intercept) {
+  const { sign, abs } = signedTerm(intercept);
+  return `y = ${formatTrendlineCoefficient(slope)}ln(x) ${sign} ${abs}`;
+}
+function formatPowerEquation(a, b) {
+  return `y = ${formatTrendlineCoefficient(a)}x^${formatTrendlineCoefficient(b)}`;
+}
+function formatPolynomialEquation(coeffsAscending) {
+  const order = coeffsAscending.length - 1;
+  let out = "y = ";
+  for (let power = order; power >= 0; power--) {
+    const coeff = coeffsAscending[power] ?? 0;
+    const { sign, abs } = signedTerm(coeff);
+    const variable = power === 0 ? "" : power === 1 ? "x" : `x^${power}`;
+    out += power === order ? `${sign === "-" ? "-" : ""}${abs}${variable}` : ` ${sign} ${abs}${variable}`;
+  }
+  return out;
+}
+
+// chart/radar-geometry.ts
+function radarAngle(index, catCount) {
+  const n = Math.max(catCount, 1);
+  return Math.PI * 2 * index / n - Math.PI / 2;
+}
+function computeRadarPoints(values, maxVal, radius, cx, cy, catCount) {
+  const denom = maxVal > 0 ? maxVal : 1;
+  return values.slice(0, Math.max(catCount, 1)).map((val, i) => {
+    const angle = radarAngle(i, catCount), r = Math.abs(val) / denom * radius;
+    return { x: cx + r * Math.cos(angle), y: cy + r * Math.sin(angle) };
+  });
+}
+function radarRingPoints(cx, cy, rr, catCount) {
+  const n = Math.max(catCount, 1);
+  return Array.from({ length: n }, (_, i) => {
+    const angle = radarAngle(i, n);
+    return `${(cx + rr * Math.cos(angle)).toFixed(2)},${(cy + rr * Math.sin(angle)).toFixed(2)}`;
+  }).join(" ");
+}
+
+// chart/pie-best-fit.ts
+var PX_PER_PT = 4 / 3;
+var BEST_FIT_RIM_INSET = 4 * PX_PER_PT;
+var BEST_FIT_EDGE_TOLERANCE = 1.5 * PX_PER_PT;
+var BEST_FIT_OUTSIDE_GAP = 2 * PX_PER_PT;
+function farCorner(x, y, w, h) {
+  return Math.hypot(Math.abs(x) + w / 2, Math.abs(y) + h / 2);
+}
+function insideDistance(ux, uy, w, h, limit) {
+  if (farCorner(0, 0, w, h) > limit) {
+    return void 0;
+  }
+  let lo = 0;
+  let hi = limit;
+  for (let i = 0; i < 40; i++) {
+    const mid = (lo + hi) / 2;
+    if (farCorner(mid * ux, mid * uy, w, h) > limit) {
+      hi = mid;
+    } else {
+      lo = mid;
+    }
+  }
+  return lo;
+}
+function edgeOverhang(x, y, w, h, slice) {
+  let worst = Number.NEGATIVE_INFINITY;
+  const corners = [
+    [-w / 2, -h / 2],
+    [w / 2, -h / 2],
+    [-w / 2, h / 2],
+    [w / 2, h / 2]
+  ];
+  for (const [dx, dy] of corners) {
+    const px = x + dx;
+    const py = y + dy;
+    const fromStart = Math.cos(slice.startAngle) * py - Math.sin(slice.startAngle) * px;
+    const fromEnd = Math.sin(slice.endAngle) * px - Math.cos(slice.endAngle) * py;
+    worst = Math.max(worst, -fromStart, -fromEnd);
+  }
+  return worst;
+}
+function placeBestFitLabel(slice, w, h) {
+  const mid = (slice.startAngle + slice.endAngle) / 2;
+  const ux = Math.cos(mid);
+  const uy = Math.sin(mid);
+  const distance = insideDistance(ux, uy, w, h, slice.outerR - BEST_FIT_RIM_INSET);
+  if (distance !== void 0) {
+    const x = distance * ux;
+    const y = distance * uy;
+    const reflex = slice.endAngle - slice.startAngle >= Math.PI;
+    if (reflex || edgeOverhang(x, y, w, h, slice) <= BEST_FIT_EDGE_TOLERANCE) {
+      return { x: slice.cx + x, y: slice.cy + y, inside: true };
+    }
+  }
+  const extent = Math.abs(ux) * w / 2 + Math.abs(uy) * h / 2;
+  const outside = slice.outerR + BEST_FIT_OUTSIDE_GAP + extent;
+  return { x: slice.cx + outside * ux, y: slice.cy + outside * uy, inside: false };
+}
+
+// chart/pie-label-collision.ts
+var LABEL_COLLISION_GAP = 2;
+function boxDistanceToCentre(box, y, disc) {
+  const nearestX = Math.max(box.x - box.w / 2, Math.min(disc.cx, box.x + box.w / 2));
+  const nearestY = Math.max(y - box.h / 2, Math.min(disc.cy, y + box.h / 2));
+  return Math.hypot(nearestX - disc.cx, nearestY - disc.cy);
+}
+function clearOfDisc(box, y, disc) {
+  if (boxDistanceToCentre(box, y, disc) >= disc.r) {
+    return 0;
+  }
+  const sign = box.x >= disc.cx ? 1 : -1;
+  let dx = 0;
+  while (dx < disc.r * 2 && boxDistanceToCentre({ ...box, x: box.x + sign * dx }, y, disc) < disc.r) {
+    dx += 1;
+  }
+  return sign * dx;
+}
+function overlapsX(a, b) {
+  return Math.abs(a.x - b.x) < (a.w + b.w) / 2;
+}
+function sweepSide(boxes, minY, maxY) {
+  const sorted = [...boxes].sort((a, b) => a.y - b.y || a.id - b.id);
+  const ys = sorted.map((box) => box.y);
+  for (let i = 1; i < sorted.length; i++) {
+    const prev = sorted[i - 1];
+    const box = sorted[i];
+    if (overlapsX(prev, box)) {
+      ys[i] = Math.max(ys[i], ys[i - 1] + (prev.h + box.h) / 2 + LABEL_COLLISION_GAP);
+    }
+  }
+  for (let i = sorted.length - 1; i >= 0; i--) {
+    const box = sorted[i];
+    const limit = i === sorted.length - 1 ? maxY - box.h / 2 : ys[i + 1] - (box.h + sorted[i + 1].h) / 2 - LABEL_COLLISION_GAP;
+    if (ys[i] > limit) {
+      ys[i] = Math.max(limit, minY + box.h / 2);
+    }
+  }
+  return new Map(sorted.map((box, i) => [box.id, ys[i]]));
+}
+function nudgeOutsideLabels(boxes, disc, minY, maxY) {
+  const resolved = /* @__PURE__ */ new Map();
+  for (const side of [
+    boxes.filter((box) => box.x >= disc.cx),
+    boxes.filter((box) => box.x < disc.cx)
+  ]) {
+    for (const [id, y] of sweepSide(side, minY, maxY)) {
+      resolved.set(id, y);
+    }
+  }
+  return boxes.map((box) => {
+    const y = resolved.get(box.id) ?? box.y;
+    return { id: box.id, dx: y === box.y ? 0 : clearOfDisc(box, y, disc), dy: y - box.y };
+  });
+}
+
+export { BEST_FIT_EDGE_TOLERANCE, BEST_FIT_OUTSIDE_GAP, BEST_FIT_RIM_INSET, LABEL_COLLISION_GAP, aggregateByCategory, axisTargetIntervals, computeBoxStats, computeHistogramBins, computeLinearRegression, computeRSquared, computeRadarPoints, computeStackedSeriesPlots, fitPolynomial, formatExponentialEquation, formatLinearEquation, formatLogarithmicEquation, formatPolynomialEquation, formatPowerEquation, formatTrendlineCoefficient, groupRowsByCategory, niceAxisStep, niceValueAxisBounds, nudgeOutsideLabels, placeBestFitLabel, radarAngle, radarRingPoints, resolveBlankDisplay, scottBinCount, squarify, visibleRuns };

package/dist/chart/pie-best-fit.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Where PowerPoint puts a pie data label at `c:dLblPos val="bestFit"`.
+ *
+ * COM ground truth (`chart-pie-best-fit.pptx`: eight pies of different slice
+ * sizes, boxed 12pt labels, measured from `Slide.Export` pixels at two pie
+ * sizes, R = 89.6pt and 190.3pt):
+ *
+ *  - A label that fits inside its slice sits INSIDE it, on the slice's
+ *    mid-angle, pushed out until the box corner farthest from the centre is
+ *    4pt inside the rim. The 4pt is the same for both pie sizes, so it is a
+ *    fixed inset, not a fraction of the radius. (The renderer used to put
+ *    every such label at 0.7 of the radius, well short of PowerPoint's.)
+ *  - "Fits" means that box, so placed, stays inside the slice's two edges:
+ *    PowerPoint tolerates about 1.5pt of overhang (a 10% slice with a
+ *    two-line label is on the boundary: one of three stays inside).
+ *  - A label that does not fit goes OUTSIDE, on the mid-angle, with the box
+ *    side facing the pie 2pt beyond the rim. PowerPoint then nudges outside
+ *    labels apart when they collide and draws leader lines to the nudged
+ *    ones; that pass is `chart-pie-label-collision` (an approximation).
+ *
+ * All lengths are in the chart's px space (1pt = 4/3px).
+ *
+ * @module chart/pie-best-fit
+ */
+/** COM: the farthest box corner of an inside label sits this far inside the rim. */
+export declare const BEST_FIT_RIM_INSET: number;
+/** COM: how far a box may overhang a slice edge and still count as inside. */
+export declare const BEST_FIT_EDGE_TOLERANCE: number;
+/** COM: the gap between the rim and an outside label's box. */
+export declare const BEST_FIT_OUTSIDE_GAP: number;
+/** A slice as the placement needs it: centre, radius and its two edge angles. */
+export interface BestFitSlice {
+    cx: number;
+    cy: number;
+    outerR: number;
+    /** Radians, SVG convention (0 = 3 o'clock, clockwise positive). */
+    startAngle: number;
+    endAngle: number;
+}
+/** Where the label box's centre goes, and whether that is inside the slice. */
+export interface BestFitPlacement {
+    x: number;
+    y: number;
+    inside: boolean;
+}
+/**
+ * Place a `w x h` label box for a slice at `bestFit` (see the module doc).
+ * A slice of half the pie or more always has room, so its label stays inside.
+ */
+export declare function placeBestFitLabel(slice: BestFitSlice, w: number, h: number): BestFitPlacement;
+//# sourceMappingURL=pie-best-fit.d.ts.map

package/dist/chart/pie-best-fit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pie-best-fit.d.ts","sourceRoot":"","sources":["../../chart/pie-best-fit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,oFAAoF;AACpF,eAAO,MAAM,kBAAkB,QAAgB,CAAC;AAChD,8EAA8E;AAC9E,eAAO,MAAM,uBAAuB,QAAkB,CAAC;AACvD,+DAA+D;AAC/D,eAAO,MAAM,oBAAoB,QAAgB,CAAC;AAElD,iFAAiF;AACjF,MAAM,WAAW,YAAY;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,mEAAmE;IACnE,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,+EAA+E;AAC/E,MAAM,WAAW,gBAAgB;IAChC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,OAAO,CAAC;CAChB;AAsDD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAiB7F"}

package/dist/chart/pie-label-collision.d.ts

@@ -0,0 +1,48 @@
+/**
+ * chart-pie-label-collision.ts: nudge colliding OUTSIDE pie labels apart.
+ *
+ * At `c:dLblPos val="bestFit"` PowerPoint puts a label that does not fit in its
+ * slice outside the rim; when two such labels overlap it moves them apart
+ * (vertically, within their own side of the pie) and draws a leader line to
+ * each one it moved. This module is the pure geometry half: it takes the
+ * outside label boxes and returns how far each one moves. The caller decides
+ * what to draw (a moved label gets a leader line; see `chart-pie-labels`).
+ *
+ * The algorithm is a per-side sweep: labels on the right (or left) of the pie
+ * are sorted top to bottom, each is pushed below the previous one when they
+ * overlap, and if the stack then runs past the bottom bound it is shifted back
+ * up. Constants are not COM-measured; the gap is one line of breathing room.
+ *
+ * @module chart/pie-label-collision
+ */
+/** Minimum vertical gap (px) kept between two nudged labels. */
+export declare const LABEL_COLLISION_GAP = 2;
+/** One outside label box: its centre and size, keyed by an opaque id. */
+export interface OutsideLabelBox {
+    id: number;
+    /** Box centre, in the same space as `pieCx`. */
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** How far one label moves (`dx`/`dy` are 0 when it stays put). */
+export interface LabelNudge {
+    id: number;
+    dx: number;
+    dy: number;
+}
+/** The pie disc a nudged label must never be pushed into. */
+export interface PieDisc {
+    cx: number;
+    cy: number;
+    r: number;
+}
+/**
+ * Compute the vertical nudges that separate overlapping outside labels.
+ * `disc` splits the labels into a left and a right column and keeps every
+ * nudged label outside the pie; `minY`/`maxY` bound the drawing area. Labels
+ * that do not collide get `dx: 0, dy: 0`.
+ */
+export declare function nudgeOutsideLabels(boxes: ReadonlyArray<OutsideLabelBox>, disc: PieDisc, minY: number, maxY: number): LabelNudge[];
+//# sourceMappingURL=pie-label-collision.d.ts.map

package/dist/chart/pie-label-collision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pie-label-collision.d.ts","sourceRoot":"","sources":["../../chart/pie-label-collision.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,gEAAgE;AAChE,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC,yEAAyE;AACzE,MAAM,WAAW,eAAe;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,gDAAgD;IAChD,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED,mEAAmE;AACnE,MAAM,WAAW,UAAU;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACX;AAED,6DAA6D;AAC7D,MAAM,WAAW,OAAO;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;CACV;AA+DD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CACjC,KAAK,EAAE,aAAa,CAAC,eAAe,CAAC,EACrC,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACV,UAAU,EAAE,CAcd"}

package/dist/chart/radar-geometry.d.ts

@@ -0,0 +1,19 @@
+/**
+ * chart-radar-geometry.ts: radar (spider) chart polar-coordinate geometry,
+ * split out of `chart-view-model-points.ts` to keep that file within the
+ * repo's ~300-LOC limit. Re-exported from there (and from `chart-view-model.ts`)
+ * so the public import surface is unchanged.
+ *
+ * @module chart/radar-geometry
+ */
+/** Angle (radians) of the i-th radar spoke; 0 points up (-90°), clockwise. */
+export declare function radarAngle(index: number, catCount: number): number;
+export interface RadarPoint {
+    x: number;
+    y: number;
+}
+/** Project a series' values onto radar (polar) coordinates around (cx, cy). */
+export declare function computeRadarPoints(values: ReadonlyArray<number>, maxVal: number, radius: number, cx: number, cy: number, catCount: number): RadarPoint[];
+/** Points string for a radar gridline ring at radius `rr`. */
+export declare function radarRingPoints(cx: number, cy: number, rr: number, catCount: number): string;
+//# sourceMappingURL=radar-geometry.d.ts.map

package/dist/chart/radar-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radar-geometry.d.ts","sourceRoot":"","sources":["../../chart/radar-geometry.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,8EAA8E;AAC9E,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGlE;AAED,MAAM,WAAW,UAAU;IAC1B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,CACjC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,EAC7B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,MAAM,GACd,UAAU,EAAE,CAOd;AAED,8DAA8D;AAC9D,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAM5F"}

package/dist/chart/treemap-squarify.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Squarified treemap layout algorithm, generic over any weighted node.
+ * Split out of `chart-treemap-hierarchy.ts` (which supplies the node/box
+ * shapes and drives the recursive render) to keep each file under the
+ * repo's ~300-LOC budget.
+ *
+ * @module chart/treemap-squarify
+ */
+export interface TreemapBox {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+interface WeightedNode {
+    weight: number;
+}
+/**
+ * Squarified treemap layout (Bruls, Huizing & van Wijk): repeatedly lays out
+ * the widest possible "row" of items along the box's shorter side, adding
+ * items to the row only while doing so keeps improving (or not worsening)
+ * that row's worst aspect ratio, so cells stay close to square instead of
+ * degenerating into thin slivers the way a plain alternating slice-and-dice
+ * split does. COM-verified against charts-com.pptx slide 28 (chartEx3.xml):
+ * PowerPoint's own treemap mixes row and column splits within the SAME
+ * parent region (e.g. a tall cell beside a further row/column split), which
+ * a single alternating dimension split can never reproduce.
+ */
+export declare function squarify<TNode extends WeightedNode>(nodes: readonly TNode[], box: TreemapBox): Array<[TNode, TreemapBox]>;
+export {};
+//# sourceMappingURL=treemap-squarify.d.ts.map

package/dist/chart/treemap-squarify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"treemap-squarify.d.ts","sourceRoot":"","sources":["../../chart/treemap-squarify.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,UAAU;IAC1B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED,UAAU,YAAY;IACrB,MAAM,EAAE,MAAM,CAAC;CACf;AAYD;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,KAAK,SAAS,YAAY,EAClD,KAAK,EAAE,SAAS,KAAK,EAAE,EACvB,GAAG,EAAE,UAAU,GACb,KAAK,CAAC,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC,CAkD5B"}