@galaxy-io/dls 1.6.1 → 2.0.1

package/dist/charts/lineChartGeometry.d.ts

@@ -1,92 +1,142 @@
-import { buildValueScale } from "./chartScales";
-import { LineChartCurve } from "./types";
-import type { LineChartLineDatum } from "./types";
-/** Signed value domain across every line, ignoring gaps. */
-export declare function getLineValueDomain<TMetric extends string>(lines: LineChartLineDatum<TMetric>[]): [number, number];
-/** One line, resolved to SVG paths. */
+/**
+ * @internal Line chart geometry (LineChart, AreaChart; `resolveCurve` and the path builders are
+ * reused by Sparkline). Turns lines and points into SVG paths plus one hit column per category, so
+ * the component body maps over finished data. Pure: no React; colors arrive through a resolver.
+ */
+import { type CurveFactory } from "d3-shape";
+import type { ChartSeriesColor } from "./chartPalette.js";
+import { ChartCurve } from "./types.js";
+/** @internal The data a line needs (LineChart's `LineChartLineDatum`, structurally). */
+export interface LineGeometryInput<TMetric extends string> {
+    /** Series key. */
+    metric: TMetric;
+    /** Readings by category. */
+    points: {
+        x: string;
+        y: number | null;
+    }[];
+    /** Dashed stroke. */
+    isDashed?: boolean | undefined;
+}
+/** @internal A point in pixel space (`undefined` y = gap). */
+export interface PlotPoint {
+    /** x in plot coordinates. */
+    x: number;
+    /** y in plot coordinates, or `null` for a gap. */
+    y: number | null;
+}
+/** @internal `ChartCurve` → the d3 curve factory. */
+export declare function resolveCurve(curve: ChartCurve): CurveFactory;
+/** @internal A line path through `points`, broken at gaps (`y === null`). Empty when nothing plots. */
+export declare function buildLinePath(points: PlotPoint[], curve: ChartCurve): string;
+/** @internal An area path from `y0` (a baseline, or each point's lower edge) to each point, broken at gaps. */
+export declare function buildAreaPath(points: PlotPoint[], y0: number | ((index: number) => number), curve: ChartCurve): string;
+/**
+ * @internal The category axis: an explicit list, else the union of every line's `x` in
+ * first-seen order (worth passing `categories` whenever lines are sparse).
+ */
+export declare function getLineCategories(lines: LineGeometryInput<string>[], explicit?: string[]): string[];
+/** @internal Signed extent across every reading, ignoring gaps, always including 0. */
+export declare function getLineValueDomain(lines: LineGeometryInput<string>[]): [number, number];
+/**
+ * @internal Each line's readings densified onto the category axis: a missing category or a `null`
+ * reading is `null`, never zero.
+ */
+export declare function densifyLineValues(lines: LineGeometryInput<string>[], categories: string[]): (number | null)[][];
+/**
+ * @internal Stack offsets (AreaChart `isStacked`): for every line and category, the running total
+ * of the lines before it, in array order (`d3-shape` `stack()`). A gap contributes 0, so the stack
+ * stays a total; only the gapped line's own top edge breaks.
+ */
+export declare function getStackOffsets(values: (number | null)[][]): number[][];
+/** @internal Extent of the stacked totals (every band's lower and upper edge), always including 0. */
+export declare function getStackedLineValueDomain(lines: LineGeometryInput<string>[], explicitCategories?: string[]): [number, number];
+/** @internal `true` when no line has a single reading. */
+export declare function hasNoReadings(lines: LineGeometryInput<string>[]): boolean;
+/** @internal One line, resolved to paths. */
 export interface LineChartPath<TMetric extends string> {
-    /** React key. Equal to the metric, which is unique by construction. */
+    /** React key (the metric). */
     id: string;
+    /** Series key. */
     metric: TMetric;
-    /** `d` for the stroke. Empty when the line has no plottable points. */
+    /** Stroke `d`; empty when nothing plots. */
     path: string;
-    /** `d` for the area fill. Present only when the line opted into an area. */
+    /** Area `d` (fill `AREA` only). */
     areaPath?: string;
-    /** Pre-serialised `stroke-dasharray`. Absent for a solid line. */
-    dashArray?: string;
-    strokeWidth: number;
-    color: string;
+    /** Dashed stroke. */
+    isDashed: boolean;
+    /** Series color. */
+    color: ChartSeriesColor;
 }
-/** One point, resolved to pixels. */
+/** @internal One reading, resolved to pixels. */
 export interface LineChartPoint<TMetric extends string> {
-    /** React key. `${metric}:${categoryIndex}`. */
+    /** React key: `${metric}:${categoryIndex}`. */
     id: string;
+    /** Series key. */
     metric: TMetric;
+    /** The reading. */
     value: number;
+    /** x in plot coordinates. */
     x: number;
+    /** y in plot coordinates. */
     y: number;
-    color: string;
+    /** Series color. */
+    color: ChartSeriesColor;
 }
-/**
- * One category column: the hit target and everything the tooltip needs.
- *
- * Line charts hit-test by column rather than by proximity to a stroke, so the
- * whole vertical band is a target and the tooltip reports every line at once.
- */
+/** @internal One category column: the hit band and everything the tooltip needs. */
 export interface LineChartColumn<TMetric extends string> {
+    /** Position on the axis. */
     categoryIndex: number;
+    /** Raw label. */
     label: string;
     /** x of the category tick. */
     x: number;
-    /** Full-height hit target, tiling with its neighbours. */
+    /** Left edge of the hit band (bands tile the plot). */
     bandX: number;
+    /** Width of the hit band. */
     bandWidth: number;
-    /** Points present in this column, one per line that has a value here. */
+    /** Readings at this category, one per line that has one. */
     points: LineChartPoint<TMetric>[];
-    /** Topmost point in the column — where the tooltip anchors. */
+    /** Lines with no reading at this category. */
+    gaps: TMetric[];
+    /** Topmost point: where the tooltip anchors. */
     anchorY: number;
 }
+/** @internal The finished geometry. */
 export interface LineChartGeometry<TMetric extends string> {
+    /** One per line. */
     paths: LineChartPath<TMetric>[];
+    /** One per category. */
     columns: LineChartColumn<TMetric>[];
-    /**
-     * Points with no defined neighbour on either side.
-     *
-     * A lone reading has nothing to connect to, so it produces a zero-length path
-     * segment and renders as nothing at all — a silent hole in sparse data. These
-     * are drawn as explicit dots so the value is visible without hovering.
-     */
+    /** Readings with no neighbour on either side: drawn as dots so they do not vanish. */
     isolatedPoints: LineChartPoint<TMetric>[];
+    /** Category labels in axis order. */
     categories: string[];
-    valueScale: ReturnType<typeof buildValueScale>;
-    /**
-     * Distance between category ticks.
-     *
-     * Exposed because axis labels must be centred on their tick, which is not the
-     * same as being centred on the hit band: the first and last bands are clipped
-     * to the plot edge, and centring a label inside a half-width band pushes it
-     * off its tick.
-     */
+    /** Value → y. */
+    valueScale: (value: number) => number;
+    /** Distance between category ticks. */
     step: number;
 }
-interface BuildLineChartGeometryArgs<TMetric extends string> {
-    lines: LineChartLineDatum<TMetric>[];
-    categories?: string[];
+/** @internal Inputs of `buildLineChartGeometry`. */
+export interface BuildLineChartGeometryArgs<TMetric extends string> {
+    /** The lines. */
+    lines: LineGeometryInput<TMetric>[];
+    /** Explicit category order. */
+    categories?: string[] | undefined;
+    /** Plot width. */
     plotWidth: number;
+    /** Plot height. */
     plotHeight: number;
-    curve: LineChartCurve;
-    /**
-     * The final value domain, already overridden, zeroed and niced.
-     *
-     * Resolved by the caller rather than here, because the left gutter is sized
-     * from the tick labels and therefore needs the domain before the plot — and
-     * hence this builder — exists.
-     */
+    /** Segment shape. */
+    curve: ChartCurve;
+    /** The resolved value domain. */
     domain: [number, number];
-    strokeWidth?: number;
-    resolveColor: (args: {
-        metric: TMetric;
-    }) => string;
+    /** Draw each line's area to the zero baseline (or, stacked, to the band below). */
+    hasArea: boolean;
+    /** Stack the lines in array order (AreaChart `isStacked`): each top edge is the running total. */
+    isStacked?: boolean | undefined;
+    /** Series color by metric. */
+    resolveColor: (metric: TMetric) => ChartSeriesColor;
 }
-export declare function buildLineChartGeometry<TMetric extends string>({ lines, categories: explicitCategories, plotWidth, plotHeight, curve, domain, strokeWidth: defaultStrokeWidth, resolveColor, }: BuildLineChartGeometryArgs<TMetric>): LineChartGeometry<TMetric>;
-export {};
+/** @internal Builds a line chart's paths, columns and isolated points. */
+export declare function buildLineChartGeometry<TMetric extends string>({ lines, categories: explicitCategories, plotWidth, plotHeight, curve, domain, hasArea, isStacked, resolveColor, }: BuildLineChartGeometryArgs<TMetric>): LineChartGeometry<TMetric>;

package/dist/charts/lineChartGeometry.js

@@ -1,19 +1,28 @@
-import { LineChartCurve } from "./types.js";
-import { DEFAULT_LINE_STROKE_WIDTH } from "./constants.js";
+import { ChartCurve } from "./types.js";
 import { buildCategoryPointScale, buildValueScale, sanitizeValue } from "./chartScales.js";
 import { match } from "ts-pattern";
-import { area, curveLinear, curveMonotoneX, curveStepAfter, line } from "d3-shape";
+import { area, curveLinear, curveMonotoneX, curveStepAfter, line, stack } from "d3-shape";
 //#region src/charts/lineChartGeometry.ts
+/**
+* @internal Line chart geometry (LineChart, AreaChart; `resolveCurve` and the path builders are
+* reused by Sparkline). Turns lines and points into SVG paths plus one hit column per category, so
+* the component body maps over finished data. Pure: no React; colors arrive through a resolver.
+*/
+/** @internal `ChartCurve` → the d3 curve factory. */
 function resolveCurve(curve) {
-	return match(curve).with(LineChartCurve.LINEAR, () => curveLinear).with(LineChartCurve.SMOOTH, () => curveMonotoneX).with(LineChartCurve.STEP, () => curveStepAfter).exhaustive();
+	return match(curve).with(ChartCurve.LINEAR, () => curveLinear).with(ChartCurve.SMOOTH, () => curveMonotoneX).with(ChartCurve.STEP, () => curveStepAfter).exhaustive();
+}
+/** @internal A line path through `points`, broken at gaps (`y === null`). Empty when nothing plots. */
+function buildLinePath(points, curve) {
+	return line().defined((point) => point.y !== null).x((point) => point.x).y((point) => point.y ?? 0).curve(resolveCurve(curve))(points) ?? "";
+}
+/** @internal An area path from `y0` (a baseline, or each point's lower edge) to each point, broken at gaps. */
+function buildAreaPath(points, y0, curve) {
+	return area().defined((point) => point.y !== null).x((point) => point.x).y0((_, index) => typeof y0 === "number" ? y0 : y0(index)).y1((point) => point.y ?? 0).curve(resolveCurve(curve))(points) ?? "";
 }
 /**
-* The union of every line's categories, in first-seen order.
-*
-* Lines are allowed to be sparse, so the axis cannot come from any single one
-* of them. An explicit `categories` list wins, and is worth supplying whenever
-* the data is gappy — inferring order from a union of incomplete series is
-* guesswork, and guessing wrong reorders time.
+* @internal The category axis: an explicit list, else the union of every line's `x` in
+* first-seen order (worth passing `categories` whenever lines are sparse).
 */
 function getLineCategories(lines, explicit) {
 	if (explicit) return explicit;
@@ -25,110 +34,143 @@ function getLineCategories(lines, explicit) {
 	}
 	return seen;
 }
-/** Signed value domain across every line, ignoring gaps. */
+/** @internal Signed extent across every reading, ignoring gaps, always including 0. */
 function getLineValueDomain(lines) {
 	let min = 0;
 	let max = 0;
-	let hasValue = false;
 	for (const lineDatum of lines) for (const point of lineDatum.points) {
 		if (point.y === null || point.y === void 0) continue;
 		const value = sanitizeValue(point.y);
-		if (!hasValue) {
-			min = value;
-			max = value;
-			hasValue = true;
-			continue;
-		}
-		if (value < min) min = value;
-		if (value > max) max = value;
+		min = Math.min(min, value);
+		max = Math.max(max, value);
 	}
-	return [Math.min(0, min), Math.max(0, max)];
+	return [min, max];
+}
+/**
+* @internal Each line's readings densified onto the category axis: a missing category or a `null`
+* reading is `null`, never zero.
+*/
+function densifyLineValues(lines, categories) {
+	const indexOf = new Map(categories.map((label, index) => [label, index]));
+	return lines.map((lineDatum) => {
+		const values = categories.map(() => null);
+		for (const point of lineDatum.points) {
+			const index = indexOf.get(point.x);
+			if (index === void 0) continue;
+			values[index] = point.y === null || point.y === void 0 ? null : sanitizeValue(point.y);
+		}
+		return values;
+	});
+}
+/**
+* @internal Stack offsets (AreaChart `isStacked`): for every line and category, the running total
+* of the lines before it, in array order (`d3-shape` `stack()`). A gap contributes 0, so the stack
+* stays a total; only the gapped line's own top edge breaks.
+*/
+function getStackOffsets(values) {
+	const categoryCount = values[0]?.length ?? 0;
+	const keys = values.map((_, index) => index);
+	const rows = Array.from({ length: categoryCount }, (_, category) => category);
+	const series = stack().keys(keys).value((category, key) => values[key]?.[category] ?? 0)(rows);
+	return values.map((_, index) => rows.map((category) => series[index]?.[category]?.[0] ?? 0));
+}
+/** @internal Extent of the stacked totals (every band's lower and upper edge), always including 0. */
+function getStackedLineValueDomain(lines, explicitCategories) {
+	const values = densifyLineValues(lines, getLineCategories(lines, explicitCategories));
+	const offsets = getStackOffsets(values);
+	let min = 0;
+	let max = 0;
+	values.forEach((row, lineIndex) => {
+		row.forEach((value, category) => {
+			const base = offsets[lineIndex]?.[category] ?? 0;
+			const top = base + (value ?? 0);
+			min = Math.min(min, base, top);
+			max = Math.max(max, base, top);
+		});
+	});
+	return [min, max];
 }
-function buildLineChartGeometry({ lines, categories: explicitCategories, plotWidth, plotHeight, curve, domain, strokeWidth: defaultStrokeWidth = DEFAULT_LINE_STROKE_WIDTH, resolveColor }) {
+/** @internal `true` when no line has a single reading. */
+function hasNoReadings(lines) {
+	return lines.every((lineDatum) => lineDatum.points.every((point) => point.y === null));
+}
+/** @internal Builds a line chart's paths, columns and isolated points. */
+function buildLineChartGeometry({ lines, categories: explicitCategories, plotWidth, plotHeight, curve, domain, hasArea, isStacked = false, resolveColor }) {
 	const categories = getLineCategories(lines, explicitCategories);
-	const valueScale = buildValueScale(domain, [plotHeight, 0]);
-	const categoryScale = buildCategoryPointScale(categories, [0, plotWidth]);
-	const baselineY = valueScale(0);
-	const paths = [];
-	const columns = [];
-	const isolatedPoints = [];
-	if (categories.length === 0 || plotWidth <= 0 || plotHeight <= 0) return {
-		paths,
-		columns,
-		isolatedPoints,
+	const scale = buildValueScale(domain, [plotHeight, 0]);
+	const valueScale = (value) => scale(value);
+	const geometry = {
+		paths: [],
+		columns: [],
+		isolatedPoints: [],
 		categories,
 		valueScale,
 		step: 0
 	};
-	const curveFactory = resolveCurve(curve);
-	const categoryIndex = new Map(categories.map((label, index) => [label, index]));
-	const xAt = (index) => categoryScale(categories[index]) ?? 0;
+	if (categories.length === 0 || plotWidth <= 0 || plotHeight <= 0) return geometry;
+	const categoryScale = buildCategoryPointScale(categories, [0, plotWidth]);
+	const xAt = (index) => categoryScale(categories[index] ?? "") ?? 0;
+	const baselineY = valueScale(0);
 	const pointsByCategory = categories.map(() => []);
-	lines.forEach((lineDatum) => {
-		const color = resolveColor({ metric: lineDatum.metric });
-		const stroke = lineDatum.strokeWidth ?? defaultStrokeWidth;
-		const plotted = categories.map((_, index) => ({
-			categoryIndex: index,
-			value: null
+	const gapsByCategory = categories.map(() => []);
+	const valuesByLine = densifyLineValues(lines, categories);
+	const offsets = isStacked ? getStackOffsets(valuesByLine) : null;
+	lines.forEach((lineDatum, lineIndex) => {
+		const color = resolveColor(lineDatum.metric);
+		const values = valuesByLine[lineIndex] ?? [];
+		const lineOffsets = offsets?.[lineIndex];
+		const offsetAt = (index) => lineOffsets?.[index] ?? 0;
+		const plotted = values.map((value, index) => ({
+			x: xAt(index),
+			y: value === null ? null : valueScale(offsetAt(index) + value)
 		}));
-		for (const point of lineDatum.points) {
-			const index = categoryIndex.get(point.x);
-			if (index === void 0) continue;
-			plotted[index].value = point.y === null || point.y === void 0 ? null : sanitizeValue(point.y);
-		}
-		const isDefined = (p) => p.value !== null;
-		const strokePath = line().defined(isDefined).x((p) => xAt(p.categoryIndex)).y((p) => valueScale(p.value)).curve(curveFactory)(plotted) ?? "";
-		const areaPath = lineDatum.showArea ? area().defined(isDefined).x((p) => xAt(p.categoryIndex)).y0(baselineY).y1((p) => valueScale(p.value)).curve(curveFactory)(plotted) ?? void 0 : void 0;
-		paths.push({
+		const areaBase = lineOffsets ? (index) => valueScale(offsetAt(index)) : baselineY;
+		geometry.paths.push({
 			id: lineDatum.metric,
 			metric: lineDatum.metric,
-			path: strokePath,
-			areaPath,
-			dashArray: lineDatum.dashSize ? `${lineDatum.dashSize} ${lineDatum.dashSize}` : void 0,
-			strokeWidth: stroke,
+			path: buildLinePath(plotted, curve),
+			...hasArea && { areaPath: buildAreaPath(plotted, areaBase, curve) },
+			isDashed: lineDatum.isDashed ?? false,
 			color
 		});
-		plotted.forEach((p, index) => {
-			if (p.value === null) return;
+		values.forEach((value, index) => {
+			if (value === null) {
+				gapsByCategory[index]?.push(lineDatum.metric);
+				return;
+			}
 			const point = {
-				id: `${lineDatum.metric}:${p.categoryIndex}`,
+				id: `${lineDatum.metric}:${index}`,
 				metric: lineDatum.metric,
-				value: p.value,
-				x: xAt(p.categoryIndex),
-				y: valueScale(p.value),
+				value,
+				x: xAt(index),
+				y: valueScale(offsetAt(index) + value),
 				color
 			};
-			pointsByCategory[p.categoryIndex].push(point);
-			const hasPrev = index > 0 && plotted[index - 1].value !== null;
-			const hasNext = index < plotted.length - 1 && plotted[index + 1].value !== null;
-			if (!hasPrev && !hasNext) isolatedPoints.push(point);
+			pointsByCategory[index]?.push(point);
+			const hasPrev = index > 0 && values[index - 1] !== null;
+			const hasNext = index < values.length - 1 && values[index + 1] !== null;
+			if (!hasPrev && !hasNext) geometry.isolatedPoints.push(point);
 		});
 	});
 	const step = categories.length > 1 ? categoryScale.step() : plotWidth;
+	geometry.step = step;
 	categories.forEach((label, index) => {
 		const x = xAt(index);
-		const points = pointsByCategory[index];
+		const points = pointsByCategory[index] ?? [];
 		const rawBandX = x - step / 2;
 		const bandX = Math.max(0, rawBandX);
-		const bandWidth = Math.min(plotWidth, rawBandX + step) - bandX;
-		columns.push({
+		geometry.columns.push({
 			categoryIndex: index,
 			label,
 			x,
 			bandX,
-			bandWidth,
+			bandWidth: Math.min(plotWidth, rawBandX + step) - bandX,
 			points,
-			anchorY: points.length > 0 ? Math.min(...points.map((p) => p.y)) : baselineY
+			gaps: gapsByCategory[index] ?? [],
+			anchorY: points.length > 0 ? Math.min(...points.map((point) => point.y)) : baselineY
 		});
 	});
-	return {
-		paths,
-		columns,
-		isolatedPoints,
-		categories,
-		valueScale,
-		step
-	};
+	return geometry;
 }
 //#endregion
-export { buildLineChartGeometry, getLineValueDomain };
+export { buildAreaPath, buildLineChartGeometry, buildLinePath, densifyLineValues, getLineCategories, getLineValueDomain, getStackOffsets, getStackedLineValueDomain, hasNoReadings, resolveCurve };

package/dist/charts/pieChartGeometry.d.ts

@@ -1,60 +1,86 @@
-import type { ChartPalette, PieChartSliceDatum } from "./types";
+import type { ChartSeriesColor } from "./chartPalette.js";
+/** @internal Key of the folded "Other" slice in events, selection and the legend. */
+export declare const AGGREGATED_SLICE_KEY = "__other__";
+/** @internal Default share below which a slice folds into "Other" (1.x). */
+export declare const PIE_MIN_SLICE_SHARE = 0.02;
+/** @internal Donut hole as a fraction of the outer radius (1.x). */
+export declare const PIE_DONUT_INNER_RATIO = 0.62;
+/** @internal Slice corner radius: `radius.sm`. */
+export declare const PIE_CORNER_RADIUS: number;
 /**
- * Pie and donut geometry.
- *
- * Produces a flat array of finished arcs — path, anchor, colour and share all
- * resolved — so the component body is a `.map()`.
- *
- * Pure: no React, no theme access. Colours arrive through a resolver callback.
+ * @internal Share of the narrowest slice its two inner pad insets may consume (1.x). A solid pie
+ * keeps a tiny hole so every gap stays radial instead of collapsing at the center.
  */
-/** One rendered arc. */
-export interface PieChartArc {
-    /** React key. The slice key, or `AGGREGATED_SLICE_KEY` for the folded bucket. */
+export declare const PIE_MAX_INSET_SHARE = 0.7;
+/** @internal Ceiling on that auto inner radius, as a share of the outer radius (1.x). */
+export declare const PIE_MAX_AUTO_INNER_RATIO = 0.06;
+/** @internal One slice after clamping and folding: everything that comes from the data alone. */
+export interface PieChartSlice {
+    /** The slice key, or `AGGREGATED_SLICE_KEY` for the folded slice. */
     id: string;
+    /** Slice label. */
     label: string;
-    /** Summed value for the aggregated bucket, the slice's own otherwise. */
+    /** The slice's value (the folded slice: the sum). */
     value: number;
     /** Share of the total, 0–1. */
     share: number;
-    /** `d` for the arc. */
+    /** Resolved color. */
+    color: ChartSeriesColor;
+}
+/** @internal One rendered arc: a slice plus the parts that depend on the measured plot. */
+export interface PieChartArc extends PieChartSlice {
+    /** Arc `d`, around the origin. */
     path: string;
-    /** Anchor for the tooltip, just outside the arc's outer edge. */
+    /** Tooltip anchor just outside the arc's bisector, plot coordinates. */
     anchorX: number;
+    /** Tooltip anchor y. */
     anchorY: number;
-    color: string;
 }
+/** @internal The finished geometry. */
 export interface PieChartGeometry {
+    /** Arcs clockwise from 12 o'clock, index-aligned with the slices; empty until measured. */
     arcs: PieChartArc[];
-    /** Centre of the pie, in plot coordinates. */
+    /** Center x, plot coordinates. */
     centerX: number;
+    /** Center y. */
     centerY: number;
+    /** The hole's radius (0-ish for a solid pie). */
     innerRadius: number;
+    /** The outer radius. */
+    outerRadius: number;
+}
+/** @internal Inputs of `resolvePieChartSlices`. */
+export interface ResolvePieChartSlicesArgs<TSlice extends string> {
+    /** Slices in array order. */
+    slices: {
+        key: TSlice;
+        value: number;
+    }[];
+    /** Fold slices under this share; 0 draws every slice. */
+    minSliceShare: number;
+    /** Label of the folded slice. */
+    aggregatedLabel: string;
+    /** Color of a slice; `null` is the folded slice. */
+    resolveColor: (sliceKey: TSlice | null) => ChartSeriesColor;
+    /** Label of a slice. */
+    getSliceLabel: (sliceKey: TSlice) => string;
 }
-interface BuildPieChartGeometryArgs<TSlice extends string> {
-    slices: PieChartSliceDatum<TSlice>[];
+/**
+ * @internal The size-free half: clamps negatives to 0, folds the tail under `minSliceShare` into
+ * one slice (last), drops zero slices, and resolves labels, shares and colors. Runs from data
+ * alone, so the server render already knows the slice count and the legend.
+ */
+export declare function resolvePieChartSlices<TSlice extends string>({ slices, minSliceShare, aggregatedLabel, resolveColor, getSliceLabel, }: ResolvePieChartSlicesArgs<TSlice>): PieChartSlice[];
+/** @internal Inputs of `buildPieChartGeometry`. */
+export interface BuildPieChartGeometryArgs {
+    /** The resolved slices (`resolvePieChartSlices`). */
+    slices: PieChartSlice[];
+    /** Plot width. */
     plotWidth: number;
+    /** Plot height. */
     plotHeight: number;
-    /** Hole size as a fraction of the outer radius. `0` is a solid pie. */
-    innerRadiusRatio?: number;
-    padAngle?: number;
-    cornerRadius?: number;
-    /**
-     * Slices below this share of the total are folded into one bucket.
-     *
-     * `0` disables folding. A donut with forty slivers communicates nothing, and
-     * the slivers are individually unhoverable, so a modest default is kinder
-     * than faithfully rendering every one.
-     */
-    minSliceShare?: number;
-    /** Label for the folded bucket. */
-    aggregatedLabel?: string;
-    resolveColor: (args: {
-        sliceKey: TSlice | null;
-        explicit?: ChartPalette;
-    }) => string;
-    /** Palette override declared by the caller for a given slice. */
-    getSliceColor?: (sliceKey: TSlice) => ChartPalette | undefined;
-    getSliceLabel: (sliceKey: TSlice) => string;
+    /** Solid pie instead of a donut. */
+    isSolid: boolean;
 }
-export declare function buildPieChartGeometry<TSlice extends string>({ slices, plotWidth, plotHeight, innerRadiusRatio, padAngle, cornerRadius, minSliceShare, aggregatedLabel, resolveColor, getSliceColor, getSliceLabel, }: BuildPieChartGeometryArgs<TSlice>): PieChartGeometry;
-export {};
+/** @internal The size-bound half: radii, center, arc paths and tooltip anchors. */
+export declare function buildPieChartGeometry({ slices, plotWidth, plotHeight, isSolid, }: BuildPieChartGeometryArgs): PieChartGeometry;