@galaxy-io/dls 1.3.0 → 1.3.2

package/dist/charts/barChartGeometry.d.ts

@@ -1,29 +1,6 @@
 import { buildValueScale } from "./chartScales";
 import { BarChartNormalization, BarCorners } from "./types";
-import type { BarChartGroupBand, BarChartGroupDatum, BarChartRect, ChartPalette, ChartValueDomain } from "./types";
-/**
- * Bar chart geometry.
- *
- * Flattens the group → bar → component hierarchy into a flat array of
- * rectangles plus one hit band per group, so the component body is a `.map()`
- * with no nested loops or running accumulators.
- *
- * Pure: no React, no theme access. Colors arrive through a resolver callback so
- * this module never has to know how the palette maps to the theme.
- */
-interface BarSpacing {
-    /** Px between neighbouring groups. */
-    groupGap: number;
-    /** Px between bars inside a group. */
-    barGap: number;
-}
-/**
- * Pick gap sizes from how crowded the chart is.
- *
- * Sparse charts stay roomy regardless of width; once there are enough bars to
- * matter, the gaps tighten as the plot narrows.
- */
-export declare function getBarSpacing(plotWidth: number, totalBars: number): BarSpacing;
+import type { BarChartGroupDatum, ChartPalette } from "./types";
 /**
  * Rectangle with one pair of corners rounded.
  *
@@ -37,7 +14,60 @@ export declare function roundedRectPath(x: number, y: number, width: number, hei
  * Percent-normalized charts always span 0–1, so the axis is stable no matter
  * what the underlying totals are.
  */
-export declare function getBarValueDomain<TMetric extends string, TPivot extends string, TComponentKey extends string>(groups: BarChartGroupDatum<TMetric, TPivot, TComponentKey>[], normalization: BarChartNormalization): [number, number];
+export declare function getBarValueDomain<TMetric extends string, TComponentKey extends string>(groups: BarChartGroupDatum<TMetric, TComponentKey>[], normalization: BarChartNormalization): [number, number];
+/**
+ * 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;
+    metric: TMetric;
+    componentKey: TComponentKey;
+    /** The component's label, carried through for the tooltip. */
+    label: string;
+    /** The raw value, before any normalization. */
+    value: 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;
+}
 export interface BarChartGeometry<TMetric extends string, TComponentKey extends string = string> {
     /** Every rendered rectangle, in draw order. */
     rects: BarChartRect<TMetric, TComponentKey>[];
@@ -45,11 +75,9 @@ export interface BarChartGeometry<TMetric extends string, TComponentKey extends
     bands: BarChartGroupBand[];
     /** The resolved value scale, shared with the axis. */
     valueScale: ReturnType<typeof buildValueScale>;
-    /** Pixel y of value zero — where bars meet the baseline. */
-    baselineY: number;
 }
-interface BuildBarChartGeometryArgs<TMetric extends string, TPivot extends string, TComponentKey extends string> {
-    groups: BarChartGroupDatum<TMetric, TPivot, TComponentKey>[];
+interface BuildBarChartGeometryArgs<TMetric extends string, TComponentKey extends string> {
+    groups: BarChartGroupDatum<TMetric, TComponentKey>[];
     plotWidth: number;
     plotHeight: number;
     normalization: BarChartNormalization;
@@ -61,7 +89,14 @@ interface BuildBarChartGeometryArgs<TMetric extends string, TPivot extends strin
      * single-component bar by metric while the legend named components.
      */
     isStacked: boolean;
-    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];
     /**
      * Maps one segment to a concrete color.
      *
@@ -74,8 +109,6 @@ interface BuildBarChartGeometryArgs<TMetric extends string, TPivot extends strin
 }
 export interface ResolveBarColorArgs<TMetric extends string> {
     metric: TMetric;
-    /** Index of the bar within its group. */
-    barIndex: number;
     /** Index of the component within its bar. */
     componentIndex: number;
     /** True when the *chart* is stacked — see the option of the same name. */
@@ -83,5 +116,5 @@ export interface ResolveBarColorArgs<TMetric extends string> {
     /** The component's own palette override, if it declared one. */
     explicit?: ChartPalette;
 }
-export declare function buildBarChartGeometry<TMetric extends string, TPivot extends string = string, TComponentKey extends string = string>({ groups, plotWidth, plotHeight, normalization, isStacked, valueDomain, resolveColor, }: BuildBarChartGeometryArgs<TMetric, TPivot, TComponentKey>): BarChartGeometry<TMetric, TComponentKey>;
+export declare function buildBarChartGeometry<TMetric extends string, TComponentKey extends string = string>({ groups, plotWidth, plotHeight, normalization, isStacked, domain, resolveColor, }: BuildBarChartGeometryArgs<TMetric, TComponentKey>): BarChartGeometry<TMetric, TComponentKey>;
 export {};

package/dist/charts/barChartGeometry.js

@@ -1,6 +1,6 @@
 import { BarChartNormalization, BarCorners } from "./types.js";
 import { BAR_WIDTH_RATIO, MAX_GAP_SHARE } from "./constants.js";
-import { applyDomainOverride, buildValueScale, sanitizeValue } from "./chartScales.js";
+import { buildValueScale, sanitizeValue } from "./chartScales.js";
 //#region src/charts/barChartGeometry.ts
 /**
 * Pick gap sizes from how crowded the chart is.
@@ -111,16 +111,15 @@ function getBarValueDomain(groups, normalization) {
 	}
 	return [min, max];
 }
-function buildBarChartGeometry({ groups, plotWidth, plotHeight, normalization, isStacked, valueDomain, resolveColor }) {
-	const valueScale = buildValueScale(applyDomainOverride(getBarValueDomain(groups, normalization), valueDomain), [plotHeight, 0]);
+function buildBarChartGeometry({ groups, plotWidth, plotHeight, normalization, isStacked, domain, resolveColor }) {
+	const valueScale = buildValueScale(domain, [plotHeight, 0]);
 	const baselineY = valueScale(0);
 	const rects = [];
 	const bands = [];
 	if (groups.length === 0 || plotWidth <= 0 || plotHeight <= 0) return {
 		rects,
 		bands,
-		valueScale,
-		baselineY
+		valueScale
 	};
 	const { groupGap, barGap } = getBarSpacing(plotWidth, groups.reduce((sum, group) => sum + group.bars.length, 0));
 	const step = plotWidth / groups.length;
@@ -136,7 +135,6 @@ function buildBarChartGeometry({ groups, plotWidth, plotHeight, normalization, i
 		const radius = barWidth < 40 ? 2 : 4;
 		const barsStartX = groupX + (groupWidth - (barCount * barWidth + (barCount - 1) * effectiveBarGap)) / 2;
 		let groupTopY = baselineY;
-		let hasValue = false;
 		group.bars.forEach((bar, barIndex) => {
 			const barX = barsStartX + barIndex * (barWidth + effectiveBarGap);
 			const values = bar.components.map((component) => sanitizeValue(component.value));
@@ -158,7 +156,6 @@ function buildBarChartGeometry({ groups, plotWidth, plotHeight, normalization, i
 			bar.components.forEach((component, componentIndex) => {
 				const { value, from, to } = intervals[componentIndex];
 				if (value === 0) return;
-				hasValue = true;
 				const isNegative = value < 0;
 				const isCap = componentIndex === (isNegative ? lastNegative : lastPositive);
 				const fromY = Math.round(valueScale(from));
@@ -173,19 +170,16 @@ function buildBarChartGeometry({ groups, plotWidth, plotHeight, normalization, i
 				rects.push({
 					id: `${groupIndex}:${barIndex}:${component.key}`,
 					groupIndex,
-					barIndex,
 					metric: bar.metric,
 					componentKey: component.key,
 					label: component.label,
 					value,
-					valueRange: [from, to],
 					x: barX,
 					y,
 					width: barWidth,
 					height,
 					color: resolveColor({
 						metric: bar.metric,
-						barIndex,
 						componentIndex,
 						isStacked,
 						explicit: component.color
@@ -203,16 +197,14 @@ function buildBarChartGeometry({ groups, plotWidth, plotHeight, normalization, i
 			width: step,
 			height: plotHeight,
 			anchorX: bandX + step / 2,
-			anchorY: groupTopY,
-			isEmpty: !hasValue
+			anchorY: groupTopY
 		});
 	});
 	return {
 		rects,
 		bands,
-		valueScale,
-		baselineY
+		valueScale
 	};
 }
 //#endregion
-export { buildBarChartGeometry, getBarSpacing, getBarValueDomain, roundedRectPath };
+export { buildBarChartGeometry, getBarValueDomain, roundedRectPath };

package/dist/charts/barChartLegend.d.ts

@@ -0,0 +1,25 @@
+import type { BarChartGroupDatum, ChartLegendItem, ChartSeriesStyles } from "./types";
+import type { SeriesColorResolver } from "./useSeriesColorResolver";
+/**
+ * Legend entries for a bar chart.
+ *
+ * A pure walk over the data, kept out of the component because it is the one
+ * legend in the DLS that cannot be a `.map()` over the `series` record: a bar's
+ * *components* are a second dimension with no record of their own, so a stacked
+ * chart's legend has to be recovered from the data itself.
+ */
+interface GetBarLegendItemsArgs<TMetric extends string, TComponentKey extends string> {
+    /**
+     * Whether the chart as a whole is stacked.
+     *
+     * Decides which dimension the legend names, and must match the flag the
+     * geometry coloured with — a legend naming metrics beside bars coloured by
+     * component describes a chart that is not on screen.
+     */
+    isStacked: boolean;
+    series: ChartSeriesStyles<TMetric>;
+    groups: BarChartGroupDatum<TMetric, TComponentKey>[];
+    colors: SeriesColorResolver<TMetric>;
+}
+export declare function getBarLegendItems<TMetric extends string, TComponentKey extends string>({ isStacked, series, groups, colors, }: GetBarLegendItemsArgs<TMetric, TComponentKey>): ChartLegendItem[];
+export {};

package/dist/charts/barChartLegend.js

@@ -0,0 +1,23 @@
+//#region src/charts/barChartLegend.ts
+function getBarLegendItems({ isStacked, series, groups, colors }) {
+	if (!isStacked) return colors.keys.map((metric) => ({
+		key: metric,
+		label: series[metric].label,
+		color: colors.resolve(metric)
+	}));
+	const seen = /* @__PURE__ */ new Map();
+	for (const group of groups) for (const bar of group.bars) bar.components.forEach((component, componentIndex) => {
+		if (!seen.has(component.key)) seen.set(component.key, {
+			label: component.label,
+			index: componentIndex,
+			explicit: component.color
+		});
+	});
+	return [...seen.entries()].map(([key, { label, index, explicit }]) => ({
+		key,
+		label,
+		color: colors.resolveByIndex(index, explicit)
+	}));
+}
+//#endregion
+export { getBarLegendItems };

package/dist/charts/chartFormat.d.ts

@@ -1,5 +1,5 @@
 import { ChartValueUnit } from "./types";
-import type { ChartLabelFormatter, ChartValueFormatter } from "./types";
+import type { ChartLabelFormatter, ChartPlotTooltipModel, ChartValueFormatter } from "./types";
 /**
  * Format a value with a built-in unit.
  *
@@ -17,3 +17,11 @@ export declare function formatChartValue(value: number, unit: ChartValueUnit): s
 export declare function resolveValueFormatter(valueFormatter?: ChartValueFormatter, unit?: ChartValueUnit): ChartValueFormatter;
 /** Pick the effective label formatter, defaulting to identity. */
 export declare function resolveLabelFormatter(labelFormatter?: ChartLabelFormatter): ChartLabelFormatter;
+/**
+ * Flatten a tooltip model into one sentence, for a screen reader.
+ *
+ * Derived from the tooltip rather than written separately so the two cannot
+ * drift: whatever a sighted reader sees on hover is what a keyboard reader
+ * hears on focus, by construction.
+ */
+export declare function describeTooltipModel(model: ChartPlotTooltipModel): string;

package/dist/charts/chartFormat.js

@@ -55,5 +55,17 @@ function resolveValueFormatter(valueFormatter, unit) {
 function resolveLabelFormatter(labelFormatter) {
 	return labelFormatter ?? ((label) => label);
 }
+/**
+* Flatten a tooltip model into one sentence, for a screen reader.
+*
+* Derived from the tooltip rather than written separately so the two cannot
+* drift: whatever a sighted reader sees on hover is what a keyboard reader
+* hears on focus, by construction.
+*/
+function describeTooltipModel(model) {
+	if (model.rows.length === 0) return model.label;
+	const rows = model.rows.map((row) => `${row.label} ${row.formattedValue}`).join(", ");
+	return `${model.label}: ${rows}`;
+}
 //#endregion
-export { formatChartValue, resolveLabelFormatter, resolveValueFormatter };
+export { describeTooltipModel, formatChartValue, resolveLabelFormatter, resolveValueFormatter };

package/dist/charts/chartScales.d.ts

@@ -5,14 +5,14 @@ import type { ChartMargin, ChartValueDomain, ChartValueFormatter } from "./types
  * Pure arithmetic with no React and no theme access, so it can be unit-reasoned
  * about and stays safe for Linaria's build-time evaluation.
  */
-export declare const clamp: (value: number, min: number, max: number) => number;
+export declare function clamp(value: number, min: number, max: number): number;
 /**
  * Coerce a datum value into something safe to feed a scale.
  *
  * A single `NaN` or `Infinity` in consumer data otherwise propagates into every
  * path's `d` attribute and blanks the entire chart rather than one mark.
  */
-export declare const sanitizeValue: (value: number | undefined | null) => number;
+export declare function sanitizeValue(value: number | undefined | null): number;
 /**
  * Merge a partial margin over the defaults.
  *
@@ -20,10 +20,16 @@ export declare const sanitizeValue: (value: number | undefined | null) => number
  * an explicit `undefined` overwrites the default with `undefined` rather than
  * falling back to it, which is easy to trip over when the partial is assembled
  * from separate optional values.
+ *
+ * `defaults` exists because the cartesian default reserves axis gutters a
+ * radial chart has no use for. Taking it as a parameter keeps the merge
+ * per-field: a chart that substituted its own defaults with `margin ?? OWN`
+ * would silently fall back to the *cartesian* defaults the moment a caller
+ * passed a partial, handing an axis-less chart a 52px left gutter.
  */
-export declare const resolveMargin: (partial?: Partial<ChartMargin>) => ChartMargin;
+export declare function resolveMargin(partial?: Partial<ChartMargin>, defaults?: ChartMargin): ChartMargin;
 /** Inner plot dimensions, never negative. */
-export declare const getPlotDimensions: (width: number, height: number, margin: ChartMargin) => {
+export declare function getPlotDimensions(width: number, height: number, margin: ChartMargin): {
     plotWidth: number;
     plotHeight: number;
 };
@@ -40,14 +46,14 @@ export declare const getPlotDimensions: (width: number, height: number, margin:
  * title band is added on top of it rather than eating into it. Returns the input
  * untouched when there are no titles, so the common case allocates nothing.
  */
-export declare const addAxisTitleSpace: (partial: Partial<ChartMargin> | undefined, { hasValueTitle, hasCategoryTitle }: {
+export declare function addAxisTitleSpace(partial: Partial<ChartMargin> | undefined, { hasValueTitle, hasCategoryTitle }: {
     hasValueTitle: boolean;
     hasCategoryTitle: boolean;
-}) => Partial<ChartMargin> | undefined;
+}): Partial<ChartMargin> | undefined;
 /**
- * Build the value scale from a signed domain.
+ * Turn a raw data extent into the domain the axis and the marks both use.
  *
- * Two behaviours worth knowing, both fixing defects in the V1 charts:
+ * Applies the caller's override, then three behaviours worth knowing:
  *
  * - **Zero is always in the domain.** Bars need a baseline to grow from, and
  *   without this a negative value maps outside the range and renders as a
@@ -56,29 +62,59 @@ export declare const addAxisTitleSpace: (partial: Partial<ChartMargin> | undefin
  *   constant `0.5` when the domain has no extent, so empty or all-zero data
  *   would otherwise map every value to the middle of the plot and strand the
  *   baseline halfway up.
+ * - **`nice()` rounds the ends outward** to values a reader would choose.
+ *
+ * Split out of {@link buildValueScale} so the domain is computed exactly once
+ * per chart and then handed to both the tick list and the geometry. Building it
+ * twice — once at a throwaway range to get ticks, once at the real range to
+ * place marks — leaves two `nice()` calls that must agree forever.
+ *
+ * `nice()` deliberately takes **no argument**. The default count is 10, not the
+ * five ticks {@link DEFAULT_VALUE_TICK_COUNT} asks for, and nicing to the tick
+ * count instead would change the axis extent on every existing chart.
+ */
+export declare function resolveValueDomain(raw: [number, number], override?: Partial<ChartValueDomain>): [number, number];
+/**
+ * Linear scale over an already-resolved domain.
+ *
+ * Does no nicing and no zero-forcing — {@link resolveValueDomain} has done
+ * both. Takes the domain rather than raw data so the same numbers drive the
+ * axis, the ticks and every mark.
  */
-export declare const buildValueScale: ([min, max]: [number, number], range: [number, number]) => import("d3-scale").ScaleLinear<number, number, never>;
-/** Apply an explicit domain override on top of a computed domain. */
-export declare const applyDomainOverride: (computed: [number, number], override?: Partial<ChartValueDomain>) => [number, number];
-/** Band scale for categories, used by the bar chart. */
-export declare const buildCategoryBandScale: (labels: string[], range: [number, number], paddingInner: number, paddingOuter: number) => import("d3-scale").ScaleBand<string>;
+export declare function buildValueScale(domain: [number, number], range: [number, number]): import("d3-scale").ScaleLinear<number, number, never>;
 /** Point scale for categories, used by the line chart. */
-export declare const buildCategoryPointScale: (labels: string[], range: [number, number], padding?: number) => import("d3-scale").ScalePoint<string>;
+export declare function buildCategoryPointScale(labels: string[], range: [number, number], padding?: number): import("d3-scale").ScalePoint<string>;
 /**
- * Estimate the left margin needed to fit the widest formatted tick label.
+ * Left margin needed to fit the widest formatted tick label.
  *
  * Estimated from character count rather than measured from the DOM, mirroring
- * `estimateColumnWidth` in `table/utils.ts`, so it works during server
- * rendering. Clamped to at least the default margin, so it can only widen a
- * chart, never shrink one.
+ * `estimateColumnWidth` in `table/utils.ts`, so it works during server rendering
+ * and build-time evaluation. The estimate only has to be close: tick labels
+ * right-align against the plot and ellipsize, so an underestimate truncates one
+ * label rather than breaking the layout, and {@link MAX_AUTO_MARGIN_LEFT} caps
+ * what a pathological formatter can take from the plot.
+ *
+ * Rounded up to {@link AUTO_MARGIN_LEFT_STEP} rather than used raw — see that
+ * constant for why an exact fit is the wrong target.
+ *
+ * Safe to call before the chart has been measured: `nice()` and `ticks()` depend
+ * on the domain and the requested count, never on the scale's range, so the tick
+ * values here are the same ones the axis renders later.
  */
-export declare const estimateValueAxisMargin: (ticks: number[], formatter: ChartValueFormatter) => number;
+export declare function estimateValueAxisMargin(ticks: number[], formatter: ChartValueFormatter): number;
 /**
  * How many categories to skip between rendered axis labels.
  *
  * Returns 1 when every label fits, so a chart that is not crowded renders
  * exactly as it would with no skipping at all.
  */
-export declare const getCategoryLabelStride: (labels: string[], step: number) => number;
-/** Tick values for the value axis, honoring an explicit tick count. */
-export declare const getValueTicks: (scale: ReturnType<typeof buildValueScale>, override?: Partial<ChartValueDomain>) => number[];
+export declare function getCategoryLabelStride(labels: string[], step: number): number;
+/**
+ * Tick values for a resolved domain, honoring an explicit tick count.
+ *
+ * Needs no dimensions, which is what breaks the apparent circularity in the
+ * layout: the left margin must fit the tick labels, the margin decides the plot
+ * size, and the plot size builds the scale. Tick *values* fall out of the domain
+ * alone, so they can be known before anything is measured.
+ */
+export declare function getValueTicks(domain: [number, number], override?: Partial<ChartValueDomain>): number[];

package/dist/charts/chartScales.js

@@ -1,5 +1,5 @@
 import { CAPTION_CHAR_WIDTH_PX, DEFAULT_CHART_MARGIN } from "./constants.js";
-import { scaleBand, scaleLinear, scalePoint } from "d3-scale";
+import { scaleLinear, scalePoint } from "d3-scale";
 //#region src/charts/chartScales.ts
 /**
 * Scale construction and axis sizing for the chart components.
@@ -7,14 +7,18 @@ import { scaleBand, scaleLinear, scalePoint } from "d3-scale";
 * Pure arithmetic with no React and no theme access, so it can be unit-reasoned
 * about and stays safe for Linaria's build-time evaluation.
 */
-var clamp = (value, min, max) => Math.min(Math.max(value, min), max);
+function clamp(value, min, max) {
+	return Math.min(Math.max(value, min), max);
+}
 /**
 * Coerce a datum value into something safe to feed a scale.
 *
 * A single `NaN` or `Infinity` in consumer data otherwise propagates into every
 * path's `d` attribute and blanks the entire chart rather than one mark.
 */
-var sanitizeValue = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
+function sanitizeValue(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
 /**
 * Merge a partial margin over the defaults.
 *
@@ -22,18 +26,28 @@ var sanitizeValue = (value) => typeof value === "number" && Number.isFinite(valu
 * an explicit `undefined` overwrites the default with `undefined` rather than
 * falling back to it, which is easy to trip over when the partial is assembled
 * from separate optional values.
+*
+* `defaults` exists because the cartesian default reserves axis gutters a
+* radial chart has no use for. Taking it as a parameter keeps the merge
+* per-field: a chart that substituted its own defaults with `margin ?? OWN`
+* would silently fall back to the *cartesian* defaults the moment a caller
+* passed a partial, handing an axis-less chart a 52px left gutter.
 */
-var resolveMargin = (partial) => ({
-	top: partial?.top ?? DEFAULT_CHART_MARGIN.top,
-	right: partial?.right ?? DEFAULT_CHART_MARGIN.right,
-	bottom: partial?.bottom ?? DEFAULT_CHART_MARGIN.bottom,
-	left: partial?.left ?? DEFAULT_CHART_MARGIN.left
-});
+function resolveMargin(partial, defaults = DEFAULT_CHART_MARGIN) {
+	return {
+		top: partial?.top ?? defaults.top,
+		right: partial?.right ?? defaults.right,
+		bottom: partial?.bottom ?? defaults.bottom,
+		left: partial?.left ?? defaults.left
+	};
+}
 /** Inner plot dimensions, never negative. */
-var getPlotDimensions = (width, height, margin) => ({
-	plotWidth: Math.max(0, width - margin.left - margin.right),
-	plotHeight: Math.max(0, height - margin.top - margin.bottom)
-});
+function getPlotDimensions(width, height, margin) {
+	return {
+		plotWidth: Math.max(0, width - margin.left - margin.right),
+		plotHeight: Math.max(0, height - margin.top - margin.bottom)
+	};
+}
 /**
 * Widen a margin to leave room for axis titles.
 *
@@ -47,18 +61,18 @@ var getPlotDimensions = (width, height, margin) => ({
 * title band is added on top of it rather than eating into it. Returns the input
 * untouched when there are no titles, so the common case allocates nothing.
 */
-var addAxisTitleSpace = (partial, { hasValueTitle, hasCategoryTitle }) => {
+function addAxisTitleSpace(partial, { hasValueTitle, hasCategoryTitle }) {
 	if (!hasValueTitle && !hasCategoryTitle) return partial;
 	return {
 		...partial,
-		left: (partial?.left ?? DEFAULT_CHART_MARGIN.left) + (hasValueTitle ? 18 : 0),
+		left: (partial?.left ?? DEFAULT_CHART_MARGIN.left) + (hasValueTitle ? 26 : 0),
 		bottom: (partial?.bottom ?? DEFAULT_CHART_MARGIN.bottom) + (hasCategoryTitle ? 18 : 0)
 	};
-};
+}
 /**
-* Build the value scale from a signed domain.
+* Turn a raw data extent into the domain the axis and the marks both use.
 *
-* Two behaviours worth knowing, both fixing defects in the V1 charts:
+* Applies the caller's override, then three behaviours worth knowing:
 *
 * - **Zero is always in the domain.** Bars need a baseline to grow from, and
 *   without this a negative value maps outside the range and renders as a
@@ -67,45 +81,85 @@ var addAxisTitleSpace = (partial, { hasValueTitle, hasCategoryTitle }) => {
 *   constant `0.5` when the domain has no extent, so empty or all-zero data
 *   would otherwise map every value to the middle of the plot and strand the
 *   baseline halfway up.
+* - **`nice()` rounds the ends outward** to values a reader would choose.
+*
+* Split out of {@link buildValueScale} so the domain is computed exactly once
+* per chart and then handed to both the tick list and the geometry. Building it
+* twice — once at a throwaway range to get ticks, once at the real range to
+* place marks — leaves two `nice()` calls that must agree forever.
+*
+* `nice()` deliberately takes **no argument**. The default count is 10, not the
+* five ticks {@link DEFAULT_VALUE_TICK_COUNT} asks for, and nicing to the tick
+* count instead would change the axis extent on every existing chart.
 */
-var buildValueScale = ([min, max], range) => {
+function resolveValueDomain(raw, override) {
+	const min = override?.min ?? raw[0];
+	const max = override?.max ?? raw[1];
 	const lo = Math.min(0, min);
 	const hi = Math.max(0, max);
-	return scaleLinear().domain([lo, lo === hi ? hi + 1 : hi]).nice().range(range);
-};
-/** Apply an explicit domain override on top of a computed domain. */
-var applyDomainOverride = (computed, override) => [override?.min ?? computed[0], override?.max ?? computed[1]];
-/** Band scale for categories, used by the bar chart. */
-var buildCategoryBandScale = (labels, range, paddingInner, paddingOuter) => scaleBand().domain(labels).range(range).paddingInner(paddingInner).paddingOuter(paddingOuter);
+	const [niceLo, niceHi] = scaleLinear().domain([lo, lo === hi ? hi + 1 : hi]).nice().domain();
+	return [niceLo, niceHi];
+}
+/**
+* Linear scale over an already-resolved domain.
+*
+* Does no nicing and no zero-forcing — {@link resolveValueDomain} has done
+* both. Takes the domain rather than raw data so the same numbers drive the
+* axis, the ticks and every mark.
+*/
+function buildValueScale(domain, range) {
+	return scaleLinear().domain(domain).range(range);
+}
 /** Point scale for categories, used by the line chart. */
-var buildCategoryPointScale = (labels, range, padding = 0) => scalePoint().domain(labels).range(range).padding(padding);
+function buildCategoryPointScale(labels, range, padding = 0) {
+	return scalePoint().domain(labels).range(range).padding(padding);
+}
 /**
-* Estimate the left margin needed to fit the widest formatted tick label.
+* Left margin needed to fit the widest formatted tick label.
 *
 * Estimated from character count rather than measured from the DOM, mirroring
-* `estimateColumnWidth` in `table/utils.ts`, so it works during server
-* rendering. Clamped to at least the default margin, so it can only widen a
-* chart, never shrink one.
+* `estimateColumnWidth` in `table/utils.ts`, so it works during server rendering
+* and build-time evaluation. The estimate only has to be close: tick labels
+* right-align against the plot and ellipsize, so an underestimate truncates one
+* label rather than breaking the layout, and {@link MAX_AUTO_MARGIN_LEFT} caps
+* what a pathological formatter can take from the plot.
+*
+* Rounded up to {@link AUTO_MARGIN_LEFT_STEP} rather than used raw — see that
+* constant for why an exact fit is the wrong target.
+*
+* Safe to call before the chart has been measured: `nice()` and `ticks()` depend
+* on the domain and the requested count, never on the scale's range, so the tick
+* values here are the same ones the axis renders later.
 */
-var estimateValueAxisMargin = (ticks, formatter) => {
+function estimateValueAxisMargin(ticks, formatter) {
 	let widest = 0;
 	for (const tick of ticks) widest = Math.max(widest, formatter(tick).length * CAPTION_CHAR_WIDTH_PX);
-	return clamp(Math.ceil(widest) + 12, DEFAULT_CHART_MARGIN.left, 96);
-};
+	const needed = Math.ceil(widest) + 12;
+	return clamp(Math.ceil(needed / 8) * 8, 32, 96);
+}
 /**
 * How many categories to skip between rendered axis labels.
 *
 * Returns 1 when every label fits, so a chart that is not crowded renders
 * exactly as it would with no skipping at all.
 */
-var getCategoryLabelStride = (labels, step) => {
+function getCategoryLabelStride(labels, step) {
 	if (labels.length === 0 || step <= 0) return 1;
 	let widest = 0;
 	for (const label of labels) widest = Math.max(widest, label.length * CAPTION_CHAR_WIDTH_PX);
 	const required = widest + 8;
 	return required <= step ? 1 : Math.ceil(required / step);
-};
-/** Tick values for the value axis, honoring an explicit tick count. */
-var getValueTicks = (scale, override) => scale.ticks(override?.tickCount ?? 5);
+}
+/**
+* Tick values for a resolved domain, honoring an explicit tick count.
+*
+* Needs no dimensions, which is what breaks the apparent circularity in the
+* layout: the left margin must fit the tick labels, the margin decides the plot
+* size, and the plot size builds the scale. Tick *values* fall out of the domain
+* alone, so they can be known before anything is measured.
+*/
+function getValueTicks(domain, override) {
+	return scaleLinear().domain(domain).ticks(override?.tickCount ?? 5);
+}
 //#endregion
-export { addAxisTitleSpace, applyDomainOverride, buildCategoryBandScale, buildCategoryPointScale, buildValueScale, clamp, estimateValueAxisMargin, getCategoryLabelStride, getPlotDimensions, getValueTicks, resolveMargin, sanitizeValue };
+export { addAxisTitleSpace, buildCategoryPointScale, buildValueScale, clamp, estimateValueAxisMargin, getCategoryLabelStride, getPlotDimensions, getValueTicks, resolveMargin, resolveValueDomain, sanitizeValue };