@galaxy-io/dls 1.3.0 → 1.3.2

package/dist/charts/constants.d.ts

@@ -154,13 +154,10 @@ export declare const PIE_TOOLTIP_ANCHOR_INSET = 8;
  * them communicates more than rendering each faithfully.
  */
 export declare const PIE_MIN_SLICE_SHARE = 0.02;
+/** React key used for the bucket that absorbs slices below the fold threshold. */
+export declare const AGGREGATED_SLICE_KEY = "__other__";
 /** Margin around a pie, which needs no axis gutters. */
-export declare const PIE_CHART_MARGIN: {
-    top: number;
-    right: number;
-    bottom: number;
-    left: number;
-};
+export declare const PIE_CHART_MARGIN: ChartMargin;
 /**
  * Duration in ms for hover, dim and tooltip transitions.
  *
@@ -218,6 +215,25 @@ export declare const CHART_TOOLTIP_MAX_WIDTH = 320;
 export declare const CAPTION_CHAR_WIDTH_PX = 6.2;
 /** Ceiling for an auto-sized left margin, so a wide formatter can't eat the plot. */
 export declare const MAX_AUTO_MARGIN_LEFT = 96;
+/**
+ * Floor for an auto-sized left margin.
+ *
+ * Enough for a two- or three-character tick plus {@link VALUE_AXIS_TICK_GAP}, so
+ * an axis labelled `0`–`5` still has its numbers clear of the container edge
+ * rather than jammed against it.
+ */
+export declare const MIN_AUTO_MARGIN_LEFT = 32;
+/**
+ * Quantum for an auto-sized left margin, in px.
+ *
+ * Sizing the gutter to the widest tick means the plot origin moves whenever that
+ * label's width changes — live data crossing 999 → 1000 gains a digit and would
+ * shift every mark sideways. Rounding up to a step absorbs that: the margin only
+ * moves when a label crosses a real threshold, and two charts with similar ticks
+ * land on the *same* value, so stacked charts in a dashboard keep their plots
+ * aligned instead of each choosing its own origin.
+ */
+export declare const AUTO_MARGIN_LEFT_STEP = 8;
 /** Minimum px between category labels before AUTO mode starts skipping them. */
 export declare const MIN_CATEGORY_LABEL_GAP = 8;
 /**

package/dist/charts/constants.js

@@ -159,6 +159,8 @@ var PIE_TOOLTIP_ANCHOR_INSET = 8;
 * them communicates more than rendering each faithfully.
 */
 var PIE_MIN_SLICE_SHARE = .02;
+/** React key used for the bucket that absorbs slices below the fold threshold. */
+var AGGREGATED_SLICE_KEY = "__other__";
 /** Margin around a pie, which needs no axis gutters. */
 var PIE_CHART_MARGIN = {
 	top: 8,
@@ -223,6 +225,25 @@ var CHART_TOOLTIP_MAX_WIDTH = 320;
 var CAPTION_CHAR_WIDTH_PX = 6.2;
 /** Ceiling for an auto-sized left margin, so a wide formatter can't eat the plot. */
 var MAX_AUTO_MARGIN_LEFT = 96;
+/**
+* Floor for an auto-sized left margin.
+*
+* Enough for a two- or three-character tick plus {@link VALUE_AXIS_TICK_GAP}, so
+* an axis labelled `0`–`5` still has its numbers clear of the container edge
+* rather than jammed against it.
+*/
+var MIN_AUTO_MARGIN_LEFT = 32;
+/**
+* Quantum for an auto-sized left margin, in px.
+*
+* Sizing the gutter to the widest tick means the plot origin moves whenever that
+* label's width changes — live data crossing 999 → 1000 gains a digit and would
+* shift every mark sideways. Rounding up to a step absorbs that: the margin only
+* moves when a label crosses a real threshold, and two charts with similar ticks
+* land on the *same* value, so stacked charts in a dashboard keep their plots
+* aligned instead of each choosing its own origin.
+*/
+var AUTO_MARGIN_LEFT_STEP = 8;
 /** Minimum px between category labels before AUTO mode starts skipping them. */
 var MIN_CATEGORY_LABEL_GAP = 8;
 /**
@@ -243,4 +264,4 @@ var CHART_PALETTE_ORDER = [
 	ChartPalette.RED
 ];
 //#endregion
-export { AXIS_TITLE_BAND, AXIS_TITLE_GAP, BAR_GAP_COMFORTABLE, BAR_GAP_MEDIUM, BAR_GAP_TIGHT, BAR_RADIUS, BAR_RADIUS_NARROW, BAR_WIDTH_RATIO, CAPTION_CHAR_WIDTH_PX, CATEGORY_AXIS_LABEL_GAP, CATEGORY_AXIS_LABEL_HEIGHT, CHART_MARK_OPACITY_ACTIVE, CHART_MARK_OPACITY_FADED, CHART_MARK_OPACITY_MUTED, CHART_PALETTE_ORDER, CHART_RESTORE_DELAY_MS, CHART_TOOLTIP_MAX_WIDTH, CHART_TOOLTIP_MIN_WIDTH, CHART_TOOLTIP_OFFSET, CHART_TRANSITION_MS, DEFAULT_CHART_MARGIN, DEFAULT_LINE_STROKE_WIDTH, DEFAULT_VALUE_TICK_COUNT, GRID_LINE_BLEED, GROUP_GAP_COMFORTABLE, GROUP_GAP_MEDIUM, GROUP_GAP_TIGHT, LINE_AREA_OPACITY, LINE_POINT_RADIUS, MAX_AUTO_MARGIN_LEFT, MAX_BAR_WIDTH, MAX_GAP_SHARE, MIN_BARS_FOR_TIGHT_SPACING, MIN_BAR_LENGTH, MIN_CATEGORY_LABEL_GAP, NARROW_BAR_WIDTH, PIE_CHART_MARGIN, PIE_CORNER_RADIUS, PIE_DONUT_INNER_RATIO, PIE_MAX_AUTO_INNER_RATIO, PIE_MAX_INSET_SHARE, PIE_MIN_SLICE_SHARE, PIE_PAD_ANGLE, PIE_TOOLTIP_ANCHOR_INSET, STACK_SEGMENT_GAP, VALUE_AXIS_LABEL_HEIGHT, VALUE_AXIS_TICK_GAP, WIDTH_FOR_MEDIUM_SPACING, WIDTH_FOR_TIGHT_SPACING };
+export { AGGREGATED_SLICE_KEY, AUTO_MARGIN_LEFT_STEP, AXIS_TITLE_BAND, AXIS_TITLE_GAP, BAR_GAP_COMFORTABLE, BAR_GAP_MEDIUM, BAR_GAP_TIGHT, BAR_RADIUS, BAR_RADIUS_NARROW, BAR_WIDTH_RATIO, CAPTION_CHAR_WIDTH_PX, CATEGORY_AXIS_LABEL_GAP, CATEGORY_AXIS_LABEL_HEIGHT, CHART_MARK_OPACITY_ACTIVE, CHART_MARK_OPACITY_FADED, CHART_MARK_OPACITY_MUTED, CHART_PALETTE_ORDER, CHART_RESTORE_DELAY_MS, CHART_TOOLTIP_MAX_WIDTH, CHART_TOOLTIP_MIN_WIDTH, CHART_TOOLTIP_OFFSET, CHART_TRANSITION_MS, DEFAULT_CHART_MARGIN, DEFAULT_LINE_STROKE_WIDTH, DEFAULT_VALUE_TICK_COUNT, GRID_LINE_BLEED, GROUP_GAP_COMFORTABLE, GROUP_GAP_MEDIUM, GROUP_GAP_TIGHT, LINE_AREA_OPACITY, LINE_POINT_RADIUS, MAX_AUTO_MARGIN_LEFT, MAX_BAR_WIDTH, MAX_GAP_SHARE, MIN_AUTO_MARGIN_LEFT, MIN_BARS_FOR_TIGHT_SPACING, MIN_BAR_LENGTH, MIN_CATEGORY_LABEL_GAP, NARROW_BAR_WIDTH, PIE_CHART_MARGIN, PIE_CORNER_RADIUS, PIE_DONUT_INNER_RATIO, PIE_MAX_AUTO_INNER_RATIO, PIE_MAX_INSET_SHARE, PIE_MIN_SLICE_SHARE, PIE_PAD_ANGLE, PIE_TOOLTIP_ANCHOR_INSET, STACK_SEGMENT_GAP, VALUE_AXIS_LABEL_HEIGHT, VALUE_AXIS_TICK_GAP, WIDTH_FOR_MEDIUM_SPACING, WIDTH_FOR_TIGHT_SPACING };

package/dist/charts/lineChartGeometry.d.ts

@@ -1,17 +1,51 @@
-import { buildCategoryPointScale, buildValueScale } from "./chartScales";
+import { buildValueScale } from "./chartScales";
 import { LineChartCurve } from "./types";
-import type { ChartValueDomain, LineChartColumn, LineChartLineDatum, LineChartPath, LineChartPoint } 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. */
+export interface LineChartPath<TMetric extends string> {
+    /** React key. Equal to the metric, which is unique by construction. */
+    id: string;
+    metric: TMetric;
+    /** `d` for the stroke. Empty when the line has no plottable points. */
+    path: string;
+    /** `d` for the area fill. Present only when the line opted into an area. */
+    areaPath?: string;
+    /** Pre-serialised `stroke-dasharray`. Absent for a solid line. */
+    dashArray?: string;
+    strokeWidth: number;
+    color: string;
+}
+/** One point, resolved to pixels. */
+export interface LineChartPoint<TMetric extends string> {
+    /** React key. `${metric}:${categoryIndex}`. */
+    id: string;
+    metric: TMetric;
+    value: number;
+    x: number;
+    y: number;
+    color: string;
+}
 /**
- * The union of every line's categories, in first-seen order.
+ * One category column: the hit target and everything the tooltip needs.
  *
- * 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.
+ * 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.
  */
-export declare function getLineCategories<TMetric extends string>(lines: LineChartLineDatum<TMetric>[], explicit?: string[]): string[];
-/** Signed value domain across every line, ignoring gaps. */
-export declare function getLineValueDomain<TMetric extends string>(lines: LineChartLineDatum<TMetric>[]): [number, number];
+export interface LineChartColumn<TMetric extends string> {
+    categoryIndex: number;
+    label: string;
+    /** x of the category tick. */
+    x: number;
+    /** Full-height hit target, tiling with its neighbours. */
+    bandX: number;
+    bandWidth: number;
+    /** Points present in this column, one per line that has a value here. */
+    points: LineChartPoint<TMetric>[];
+    /** Topmost point in the column — where the tooltip anchors. */
+    anchorY: number;
+}
 export interface LineChartGeometry<TMetric extends string> {
     paths: LineChartPath<TMetric>[];
     columns: LineChartColumn<TMetric>[];
@@ -25,8 +59,6 @@ export interface LineChartGeometry<TMetric extends string> {
     isolatedPoints: LineChartPoint<TMetric>[];
     categories: string[];
     valueScale: ReturnType<typeof buildValueScale>;
-    categoryScale: ReturnType<typeof buildCategoryPointScale>;
-    baselineY: number;
     /**
      * Distance between category ticks.
      *
@@ -43,12 +75,18 @@ interface BuildLineChartGeometryArgs<TMetric extends string> {
     plotWidth: number;
     plotHeight: number;
     curve: LineChartCurve;
-    valueDomain?: Partial<ChartValueDomain>;
+    /**
+     * 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.
+     */
+    domain: [number, number];
     strokeWidth?: number;
     resolveColor: (args: {
         metric: TMetric;
-        lineIndex: number;
     }) => string;
 }
-export declare function buildLineChartGeometry<TMetric extends string>({ lines, categories: explicitCategories, plotWidth, plotHeight, curve, valueDomain, strokeWidth: defaultStrokeWidth, resolveColor, }: BuildLineChartGeometryArgs<TMetric>): LineChartGeometry<TMetric>;
+export declare function buildLineChartGeometry<TMetric extends string>({ lines, categories: explicitCategories, plotWidth, plotHeight, curve, domain, strokeWidth: defaultStrokeWidth, resolveColor, }: BuildLineChartGeometryArgs<TMetric>): LineChartGeometry<TMetric>;
 export {};

package/dist/charts/lineChartGeometry.js

@@ -1,6 +1,6 @@
 import { LineChartCurve } from "./types.js";
 import { DEFAULT_LINE_STROKE_WIDTH } from "./constants.js";
-import { applyDomainOverride, buildCategoryPointScale, buildValueScale, sanitizeValue } from "./chartScales.js";
+import { buildCategoryPointScale, buildValueScale, sanitizeValue } from "./chartScales.js";
 import { match } from "ts-pattern";
 import { area, curveLinear, curveMonotoneX, curveStepAfter, line } from "d3-shape";
 //#region src/charts/lineChartGeometry.ts
@@ -44,9 +44,9 @@ function getLineValueDomain(lines) {
 	}
 	return [Math.min(0, min), Math.max(0, max)];
 }
-function buildLineChartGeometry({ lines, categories: explicitCategories, plotWidth, plotHeight, curve, valueDomain, strokeWidth: defaultStrokeWidth = DEFAULT_LINE_STROKE_WIDTH, resolveColor }) {
+function buildLineChartGeometry({ lines, categories: explicitCategories, plotWidth, plotHeight, curve, domain, strokeWidth: defaultStrokeWidth = DEFAULT_LINE_STROKE_WIDTH, resolveColor }) {
 	const categories = getLineCategories(lines, explicitCategories);
-	const valueScale = buildValueScale(applyDomainOverride(getLineValueDomain(lines), valueDomain), [plotHeight, 0]);
+	const valueScale = buildValueScale(domain, [plotHeight, 0]);
 	const categoryScale = buildCategoryPointScale(categories, [0, plotWidth]);
 	const baselineY = valueScale(0);
 	const paths = [];
@@ -58,19 +58,14 @@ function buildLineChartGeometry({ lines, categories: explicitCategories, plotWid
 		isolatedPoints,
 		categories,
 		valueScale,
-		categoryScale,
-		baselineY,
 		step: 0
 	};
 	const curveFactory = resolveCurve(curve);
 	const categoryIndex = new Map(categories.map((label, index) => [label, index]));
 	const xAt = (index) => categoryScale(categories[index]) ?? 0;
 	const pointsByCategory = categories.map(() => []);
-	lines.forEach((lineDatum, lineIndex) => {
-		const color = resolveColor({
-			metric: lineDatum.metric,
-			lineIndex
-		});
+	lines.forEach((lineDatum) => {
+		const color = resolveColor({ metric: lineDatum.metric });
 		const stroke = lineDatum.strokeWidth ?? defaultStrokeWidth;
 		const plotted = categories.map((_, index) => ({
 			categoryIndex: index,
@@ -87,7 +82,6 @@ function buildLineChartGeometry({ lines, categories: explicitCategories, plotWid
 		paths.push({
 			id: lineDatum.metric,
 			metric: lineDatum.metric,
-			lineIndex,
 			path: strokePath,
 			areaPath,
 			dashArray: lineDatum.dashSize ? `${lineDatum.dashSize} ${lineDatum.dashSize}` : void 0,
@@ -99,7 +93,6 @@ function buildLineChartGeometry({ lines, categories: explicitCategories, plotWid
 			const point = {
 				id: `${lineDatum.metric}:${p.categoryIndex}`,
 				metric: lineDatum.metric,
-				categoryIndex: p.categoryIndex,
 				value: p.value,
 				x: xAt(p.categoryIndex),
 				y: valueScale(p.value),
@@ -134,10 +127,8 @@ function buildLineChartGeometry({ lines, categories: explicitCategories, plotWid
 		isolatedPoints,
 		categories,
 		valueScale,
-		categoryScale,
-		baselineY,
 		step
 	};
 }
 //#endregion
-export { buildLineChartGeometry, getLineCategories, getLineValueDomain };
+export { buildLineChartGeometry, getLineValueDomain };

package/dist/charts/pieChartGeometry.d.ts

@@ -1,4 +1,4 @@
-import type { ChartPalette, PieChartArc, PieChartSliceDatum } from "./types";
+import type { ChartPalette, PieChartSliceDatum } from "./types";
 /**
  * Pie and donut geometry.
  *
@@ -7,14 +7,27 @@ import type { ChartPalette, PieChartArc, PieChartSliceDatum } from "./types";
  *
  * Pure: no React, no theme access. Colours arrive through a resolver callback.
  */
-export interface PieChartGeometry<TSlice extends string> {
-    arcs: PieChartArc<TSlice>[];
-    /** Sum of every sanitised value. Zero means there is nothing to draw. */
-    total: number;
+/** One rendered arc. */
+export interface PieChartArc {
+    /** React key. The slice key, or `AGGREGATED_SLICE_KEY` for the folded bucket. */
+    id: string;
+    label: string;
+    /** Summed value for the aggregated bucket, the slice's own otherwise. */
+    value: number;
+    /** Share of the total, 0–1. */
+    share: number;
+    /** `d` for the arc. */
+    path: string;
+    /** Anchor for the tooltip, just outside the arc's outer edge. */
+    anchorX: number;
+    anchorY: number;
+    color: string;
+}
+export interface PieChartGeometry {
+    arcs: PieChartArc[];
     /** Centre of the pie, in plot coordinates. */
     centerX: number;
     centerY: number;
-    outerRadius: number;
     innerRadius: number;
 }
 interface BuildPieChartGeometryArgs<TSlice extends string> {
@@ -37,12 +50,11 @@ interface BuildPieChartGeometryArgs<TSlice extends string> {
     aggregatedLabel?: string;
     resolveColor: (args: {
         sliceKey: TSlice | null;
-        index: number;
         explicit?: ChartPalette;
     }) => string;
     /** Palette override declared by the caller for a given slice. */
     getSliceColor?: (sliceKey: TSlice) => ChartPalette | undefined;
     getSliceLabel: (sliceKey: TSlice) => string;
 }
-export declare function buildPieChartGeometry<TSlice extends string>({ slices, plotWidth, plotHeight, innerRadiusRatio, padAngle, cornerRadius, minSliceShare, aggregatedLabel, resolveColor, getSliceColor, getSliceLabel, }: BuildPieChartGeometryArgs<TSlice>): PieChartGeometry<TSlice>;
+export declare function buildPieChartGeometry<TSlice extends string>({ slices, plotWidth, plotHeight, innerRadiusRatio, padAngle, cornerRadius, minSliceShare, aggregatedLabel, resolveColor, getSliceColor, getSliceLabel, }: BuildPieChartGeometryArgs<TSlice>): PieChartGeometry;
 export {};

package/dist/charts/pieChartGeometry.js

@@ -1,5 +1,4 @@
-import { AGGREGATED_SLICE_KEY } from "./types.js";
-import { PIE_DONUT_INNER_RATIO, PIE_MAX_AUTO_INNER_RATIO, PIE_MAX_INSET_SHARE, PIE_PAD_ANGLE } from "./constants.js";
+import { AGGREGATED_SLICE_KEY, PIE_DONUT_INNER_RATIO, PIE_MAX_AUTO_INNER_RATIO, PIE_MAX_INSET_SHARE, PIE_PAD_ANGLE } from "./constants.js";
 import { sanitizeValue } from "./chartScales.js";
 import { arc, pie } from "d3-shape";
 //#region src/charts/pieChartGeometry.ts
@@ -16,10 +15,8 @@ function buildPieChartGeometry({ slices, plotWidth, plotHeight, innerRadiusRatio
 	const total = sanitized.reduce((sum, slice) => sum + slice.value, 0);
 	const empty = {
 		arcs: [],
-		total,
 		centerX,
 		centerY,
-		outerRadius,
 		innerRadius: requestedInnerRadius
 	};
 	if (total <= 0 || outerRadius <= 0) return empty;
@@ -51,13 +48,12 @@ function buildPieChartGeometry({ slices, plotWidth, plotHeight, innerRadiusRatio
 	const layout = pie().sort(null).value((slice) => slice.value).padAngle(padAngle);
 	const arcGenerator = arc().innerRadius(innerRadius).outerRadius(outerRadius).cornerRadius(cornerRadius);
 	return {
-		arcs: layout(kept).map((slot, index) => {
+		arcs: layout(kept).map((slot) => {
 			const slice = slot.data;
 			const midAngle = (slot.startAngle + slot.endAngle) / 2;
 			const anchorRadius = outerRadius + 8;
 			return {
 				id: slice.isAggregated ? AGGREGATED_SLICE_KEY : slice.sliceKey,
-				sliceKey: slice.sliceKey,
 				label: slice.label,
 				value: slice.value,
 				share: slice.value / total,
@@ -66,22 +62,16 @@ function buildPieChartGeometry({ slices, plotWidth, plotHeight, innerRadiusRatio
 					endAngle: slot.endAngle,
 					padAngle: slot.padAngle
 				}) ?? "",
-				startAngle: slot.startAngle,
-				endAngle: slot.endAngle,
 				anchorX: centerX + Math.sin(midAngle) * anchorRadius,
 				anchorY: centerY - Math.cos(midAngle) * anchorRadius,
 				color: resolveColor({
 					sliceKey: slice.sliceKey,
-					index,
 					explicit: slice.explicit
-				}),
-				isAggregated: slice.isAggregated
+				})
 			};
 		}),
-		total,
 		centerX,
 		centerY,
-		outerRadius,
 		innerRadius
 	};
 }

package/dist/charts/types.d.ts

@@ -108,6 +108,18 @@ export interface ChartValueDomain {
     /** Approximate tick count passed to d3's `scale.ticks()`. */
     tickCount: number;
 }
+/**
+ * Which chart is being rendered.
+ *
+ * Exists so the frame can phrase a default accessible name — a pie has slices
+ * where the cartesian charts have categories. Deliberately not a styling hook:
+ * nothing else branches on it.
+ */
+export declare enum ChartKind {
+    BAR = "BAR",
+    LINE = "LINE",
+    PIE = "PIE"
+}
 /** How the category axis copes when labels outgrow their slots. */
 export declare enum ChartCategoryLabelMode {
     /** Render every label that fits; otherwise show every nth. The default. */
@@ -175,83 +187,20 @@ export interface BarChartComponentDatum<TComponentKey extends string = string> {
 /**
  * One bar within a group: a stack of components for a single metric.
  */
-export interface BarChartBarDatum<TMetric extends string, TPivot extends string = string, TComponentKey extends string = string> {
+export interface BarChartBarDatum<TMetric extends string, TComponentKey extends string = string> {
     /** Which metric this bar represents, e.g. `"prospected"`. */
     metric: TMetric;
-    /** Optional dimension the bar is split by, e.g. `"persona"`. */
-    pivot?: TPivot;
     /** Segments of the bar, stacked in array order outward from the baseline. */
     components: BarChartComponentDatum<TComponentKey>[];
 }
 /**
  * One category on the x-axis, holding one bar per metric.
  */
-export interface BarChartGroupDatum<TMetric extends string, TPivot extends string = string, TComponentKey extends string = string> {
+export interface BarChartGroupDatum<TMetric extends string, TComponentKey extends string = string> {
     /** Label rendered beneath this group on the category axis. */
     label: string;
     /** Bars in this group, rendered left to right in array order. */
-    bars: BarChartBarDatum<TMetric, TPivot, TComponentKey>[];
-}
-/**
- * A single rendered rectangle.
- *
- * The geometry layer flattens the group/bar/component hierarchy into an array
- * of these, so rendering is a plain `.map()` with no nested loops or
- * accumulators in the component body.
- */
-export interface BarChartRect<TMetric extends string, TComponentKey extends string = string> {
-    /**
-     * React key: `${groupIndex}:${barIndex}:${componentKey}`.
-     *
-     * Deliberately index-based rather than label-based — group labels are free to
-     * repeat, and duplicated keys would silently drop rectangles.
-     */
-    id: string;
-    groupIndex: number;
-    barIndex: number;
-    metric: TMetric;
-    componentKey: TComponentKey;
-    /** The component's label, carried through for the tooltip. */
-    label: string;
-    /** The raw value, before any normalization. */
-    value: number;
-    /**
-     * The `[from, to]` interval this segment occupies in value space.
-     * Under {@link BarChartNormalization.PERCENT} this is normalized to 0–1.
-     */
-    valueRange: [number, number];
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    /** Resolved from the theme — never a raw hex from consumer data. */
-    color: string;
-    /** Interior stack segments get {@link BarCorners.NONE}. */
-    corners: BarCorners;
-    /** Corner radius in px, reduced for narrow bars so the curve can't dominate. */
-    radius: number;
-}
-/**
- * A category's invisible hit target and tooltip anchor.
- *
- * Hit testing happens per group rather than per rectangle: a two-pixel bar is
- * then exactly as hoverable as a two-hundred-pixel one, and moving the pointer
- * between segments inside one group fires nothing, so the tooltip stays put
- * instead of jumping between segment tops.
- */
-export interface BarChartGroupBand {
-    groupIndex: number;
-    label: string;
-    /** Tiles edge to edge with its neighbours, so there are no dead gutters. */
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    /** Group centre, at the top of its tallest bar. Stable while hovering. */
-    anchorX: number;
-    anchorY: number;
-    /** True when every component in the group is zero or absent. */
-    isEmpty: boolean;
+    bars: BarChartBarDatum<TMetric, TComponentKey>[];
 }
 /** How the segments between points are interpolated. */
 export declare enum LineChartCurve {
@@ -299,51 +248,6 @@ export interface LineChartLineDatum<TMetric extends string> {
     /** Fill the area between the line and the baseline. */
     showArea?: boolean;
 }
-/** One line, resolved to SVG paths. */
-export interface LineChartPath<TMetric extends string> {
-    /** React key. Equal to the metric, which is unique by construction. */
-    id: string;
-    metric: TMetric;
-    lineIndex: number;
-    /** `d` for the stroke. Empty when the line has no plottable points. */
-    path: string;
-    /** `d` for the area fill. Present only when the line opted into an area. */
-    areaPath?: string;
-    /** Pre-serialised `stroke-dasharray`. Absent for a solid line. */
-    dashArray?: string;
-    strokeWidth: number;
-    color: string;
-}
-/** One point, resolved to pixels. */
-export interface LineChartPoint<TMetric extends string> {
-    /** React key. `${metric}:${categoryIndex}`. */
-    id: string;
-    metric: TMetric;
-    categoryIndex: number;
-    value: number;
-    x: number;
-    y: number;
-    color: string;
-}
-/**
- * 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.
- */
-export interface LineChartColumn<TMetric extends string> {
-    categoryIndex: number;
-    label: string;
-    /** x of the category tick. */
-    x: number;
-    /** Full-height hit target, tiling with its neighbours. */
-    bandX: number;
-    bandWidth: number;
-    /** Points present in this column, one per line that has a value here. */
-    points: LineChartPoint<TMetric>[];
-    /** Topmost point in the column — where the tooltip anchors. */
-    anchorY: number;
-}
 /**
  * One slice of a pie or donut.
  *
@@ -361,44 +265,12 @@ export interface PieChartSliceDatum<TSlice extends string> {
      */
     value: number;
 }
-/** React key used for the bucket that absorbs slices below the fold threshold. */
-export declare const AGGREGATED_SLICE_KEY = "__other__";
-/** One rendered arc. */
-export interface PieChartArc<TSlice extends string> {
-    /** React key. The slice key, or {@link AGGREGATED_SLICE_KEY}. */
-    id: string;
-    /**
-     * The originating slice, or `null` for the aggregated bucket.
-     *
-     * Nullable rather than widened to `string` so callers must acknowledge the
-     * synthetic arc instead of accidentally treating it as a real slice key.
-     */
-    sliceKey: TSlice | null;
-    label: string;
-    /** Summed value for the aggregated bucket, the slice's own otherwise. */
-    value: number;
-    /** Share of the total, 0–1. */
-    share: number;
-    /** `d` for the arc. */
-    path: string;
-    /** Radians, clockwise from 12 o'clock. */
-    startAngle: number;
-    endAngle: number;
-    /** Anchor for the tooltip, just outside the arc's outer edge. */
-    anchorX: number;
-    anchorY: number;
-    color: string;
-    /** True for the bucket produced by folding small slices together. */
-    isAggregated: boolean;
-}
 /** One label/value row in the tooltip. */
 export interface ChartTooltipRow {
     /** React key, unique within the tooltip. */
     key: string;
     /** Row label — a component label, line label or slice label. */
     label: string;
-    /** Optional grouping label, used when bars are split by a pivot. */
-    group?: string;
     value: number;
     /** Already run through the resolved formatter. */
     formattedValue: string;
@@ -434,6 +306,33 @@ export interface ChartPlotTooltipModel {
 }
 /** Render prop for replacing the tooltip body. Positioning stays with the chart. */
 export type ChartTooltipRenderer = (model: ChartTooltipModel) => ReactNode;
+/** Which shape a category's hit target is drawn as. */
+export declare enum ChartTargetShape {
+    /** Cartesian charts: a full-height band over the category. */
+    RECT = "RECT",
+    /** Radial charts: the arc's own outline, redrawn transparent. */
+    PATH = "PATH"
+}
+/**
+ * One category's interactive target, in plot coordinates.
+ *
+ * Array position *is* the category index — already true of every geometry
+ * builder's output — so there is no index field that could fall out of step.
+ * `key` is carried separately because a pie's arcs reorder, where bar and line
+ * indices do not.
+ */
+export type ChartCategoryTarget = {
+    key: string;
+    shape: ChartTargetShape.RECT;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | {
+    key: string;
+    shape: ChartTargetShape.PATH;
+    d: string;
+};
 /** One legend entry. */
 export interface ChartLegendItem {
     key: string;
@@ -500,7 +399,7 @@ export interface ChartFluidBothAxes {
  */
 export type ChartSize = ChartFixedSize | ChartFluidFixedHeight | ChartFluidRatioHeight | ChartFixedWidthFluidHeight | ChartFluidBothAxes;
 /**
- * Props common to every  chart.
+ * Props common to every chart.
  *
  * Data props are declared per chart, since their shapes and generics differ.
  */
@@ -511,7 +410,14 @@ export interface BaseChartProps {
     valueUnit?: ChartValueUnit;
     /** Full control over value rendering. Wins over `valueUnit`. */
     valueFormatter?: ChartValueFormatter;
-    /** Format category labels. Applied to the axis *and* the tooltip heading. */
+    /**
+     * Format category labels, wherever a category is named.
+     *
+     * That is the axis and the tooltip heading on the cartesian charts, and
+     * additionally the legend on a pie — whose legend lists *slices*, which are
+     * its categories. Bar and line legends name series, which come from the
+     * `series` record and are not categories, so this does not reach them.
+     */
     labelFormatter?: ChartLabelFormatter;
     /** Replace the tooltip body. Collision handling stays with the chart. */
     tooltipRenderer?: ChartTooltipRenderer;

package/dist/charts/types.js

@@ -67,6 +67,19 @@ var ChartValueUnit = /* @__PURE__ */ function(ChartValueUnit) {
 	ChartValueUnit["COMPACT"] = "COMPACT";
 	return ChartValueUnit;
 }({});
+/**
+* Which chart is being rendered.
+*
+* Exists so the frame can phrase a default accessible name — a pie has slices
+* where the cartesian charts have categories. Deliberately not a styling hook:
+* nothing else branches on it.
+*/
+var ChartKind = /* @__PURE__ */ function(ChartKind) {
+	ChartKind["BAR"] = "BAR";
+	ChartKind["LINE"] = "LINE";
+	ChartKind["PIE"] = "PIE";
+	return ChartKind;
+}({});
 /** How the category axis copes when labels outgrow their slots. */
 var ChartCategoryLabelMode = /* @__PURE__ */ function(ChartCategoryLabelMode) {
 	/** Render every label that fits; otherwise show every nth. The default. */
@@ -130,7 +143,13 @@ var LineChartCurve = /* @__PURE__ */ function(LineChartCurve) {
 	LineChartCurve["STEP"] = "STEP";
 	return LineChartCurve;
 }({});
-/** React key used for the bucket that absorbs slices below the fold threshold. */
-var AGGREGATED_SLICE_KEY = "__other__";
+/** Which shape a category's hit target is drawn as. */
+var ChartTargetShape = /* @__PURE__ */ function(ChartTargetShape) {
+	/** Cartesian charts: a full-height band over the category. */
+	ChartTargetShape["RECT"] = "RECT";
+	/** Radial charts: the arc's own outline, redrawn transparent. */
+	ChartTargetShape["PATH"] = "PATH";
+	return ChartTargetShape;
+}({});
 //#endregion
-export { AGGREGATED_SLICE_KEY, BarChartNormalization, BarCorners, ChartCategoryLabelMode, ChartMarkState, ChartPalette, ChartValueUnit, LineChartCurve };
+export { BarChartNormalization, BarCorners, ChartCategoryLabelMode, ChartKind, ChartMarkState, ChartPalette, ChartTargetShape, ChartValueUnit, LineChartCurve };