@automattic/charts 4.2.0 → 4.4.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import { getStringWidth as getStringWidth$1 } from "./visx/text/index.js";
 import { formatNumber, formatNumberCompact } from "@automattic/number-formatters";
-import { AnimatedAreaSeries, AnimatedAreaStack, AreaSeries, Axis, BarGroup, BarSeries, DataContext, Grid, TooltipContext, XYChart, buildChartTheme, useEventEmitter } from "@visx/xychart";
+import { AnimatedAreaSeries, AnimatedAreaStack, AreaSeries, Axis, BarGroup, BarSeries, DataContext, GlyphSeries, Grid, TooltipContext, XYChart, buildChartTheme, useEventEmitter } from "@visx/xychart";
 import { __, _x, sprintf } from "@wordpress/i18n";
 import clsx from "clsx";
 import * as React from "react";
@@ -12,7 +12,7 @@ import { Text, getStringWidth } from "@visx/text";
 import deepmerge from "deepmerge";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 import { Tooltip, defaultStyles, useTooltip } from "@visx/tooltip";
-import { createScale, getTicks, scaleBand, scaleOrdinal, scaleTime } from "@visx/scale";
+import { createScale, getTicks, scaleBand, scaleCanBeZeroed, scaleOrdinal, scaleTime } from "@visx/scale";
 import { Group } from "@visx/group";
 import { LegendItem, LegendLabel, LegendOrdinal, LegendShape } from "@visx/legend";
 import { IconButton, Stack, Text as Text$1 } from "@wordpress/ui";
@@ -21,6 +21,7 @@ import { LinearGradient } from "@visx/gradient";
 import { curveCatmullRom, curveLinear, curveMonotoneX } from "@visx/curve";
 import { useParentSize } from "@visx/responsive";
 import { Annotation, CircleSubject, Connector, HtmlLabel, Label, LineSubject } from "@visx/annotation";
+import { bisector } from "@visx/vendor/d3-array";
 import { PatternCircles, PatternHexagons, PatternLines, PatternWaves } from "@visx/pattern";
 import { Chart } from "react-google-charts";
 import DOMPurify from "dompurify";
@@ -1074,7 +1075,7 @@ const GlobalChartsProvider = ({ children, theme, locale, timeZone }) => {
 		return getChartColor(index, colorCache);
 	}, [colorCache, groupToColorMap]);
 	const getElementStyles = useCallback(({ data, index, overrideColor, legendShape }) => {
-		const isSeriesData = data && typeof data === "object" && "data" in data && "options" in data;
+		const isSeriesData = data && typeof data === "object" && "data" in data;
 		const isPointPercentageData = data && typeof data === "object" && "value" in data && typeof data.value === "number" && !("data" in data);
 		return {
 			color: resolveColor({
@@ -1455,8 +1456,9 @@ const useChartMargin = (height, options, data, theme, horizontal = false) => {
 		const allDataPoints = data.flatMap((series) => series.data);
 		if (horizontal) return allDataPoints.map((d) => d.label || d.date?.getTime());
 		if (options.axis?.y?.tickValues?.length) return options.axis.y.tickValues;
-		const minY = Math.min(...allDataPoints.map((d) => d.value));
-		const maxY = Math.max(...allDataPoints.map((d) => d.value));
+		const values = allDataPoints.map((d) => d.value).filter((value) => typeof value === "number" && Number.isFinite(value));
+		const minY = values.length ? Math.min(...values) : 0;
+		const maxY = values.length ? Math.max(...values) : 1;
 		const yScale = createScale({
 			...options.yScale,
 			domain: options.yScale?.domain ?? [minY, maxY],
@@ -1791,23 +1793,6 @@ function valueOrIdentityString(_) {
 	return String(valueOrIdentity(_));
 }
 //#endregion
-//#region src/components/legend/utils/label-transform-factory.ts
-/**
-* Returns a function which takes a Datum and index as input, and returns a formatted label object.
-* @param {object}                            root0             - The object to return the value of.
-* @param {AnyD3Scale}                        root0.scale       - The scale to use.
-* @param {LabelFormatter<ScaleInput<Scale>>} root0.labelFormat - The label format to use.
-* @return {ItemTransformer<ScaleInput<Scale>, ReturnType<Scale>>} The label transform factory.
-*/
-function labelTransformFactory({ scale, labelFormat }) {
-	return (d, i) => ({
-		datum: d,
-		index: i,
-		text: `${labelFormat(d, i)}`,
-		value: scale(d)
-	});
-}
-//#endregion
 //#region src/components/legend/private/base-legend.module.scss
 var base_legend_module_default = {
 	"legend": "a8ccharts-04TogW-legend",
@@ -1849,7 +1834,7 @@ const getLegendItemAriaLabel = (text, value, visible, interactive) => {
 	if (visible) return;
 	return sprintf(_x("%s: hidden", "hidden non-interactive legend item", "jetpack-charts"), accessibleText);
 };
-const BaseLegend = forwardRef(({ items, className, orientation = "horizontal", alignment = "center", shape = "rect", fill = valueOrIdentityString, size = valueOrIdentityString, labelFormat = valueOrIdentity, labelTransform = labelTransformFactory, itemStyles, itemClassName, labelStyles, labelClassName, shapeStyles, render, interactive = false, chartId }, ref) => {
+const BaseLegend = forwardRef(({ items, className, orientation = "horizontal", alignment = "center", shape = "rect", fill = valueOrIdentityString, size = valueOrIdentityString, labelFormat = valueOrIdentity, labelTransform, itemStyles, itemClassName, labelStyles, labelClassName, shapeStyles, render, interactive = false, chartId }, ref) => {
 	const { margin: itemMargin = "0", flexDirection: itemDirection = "row" } = itemStyles ?? {};
 	const { justifyContent: labelJustifyContent = "flex-start", flex: labelFlex = "0 0 auto", margin: labelMargin = "0 4px", maxWidth, textOverflow = "wrap" } = labelStyles ?? {};
 	const { width: shapeWidth = 16, height: shapeHeight = 16, margin: shapeMargin = "2px 4px 2px 0" } = shapeStyles ?? {};
@@ -1857,11 +1842,17 @@ const BaseLegend = forwardRef(({ items, className, orientation = "horizontal", a
 	const context = useContext(GlobalChartsContext);
 	const chartInstanceContext = useContext(ChartInstanceContext);
 	const standaloneScopeClass = useStandaloneScopeClass();
+	const domain = items.map((item) => item.label);
 	const legendScale = scaleOrdinal({
-		domain: items.map((item) => item.label),
+		domain,
 		range: items.map((item) => item.color)
 	});
-	const domain = legendScale.domain();
+	const defaultLabelTransform = useCallback(({ labelFormat: format }) => (datum, index) => ({
+		datum,
+		index,
+		text: String(format(datum, index)),
+		value: items[index].color
+	}), [items]);
 	const getShapeStyle = useCallback(({ index }) => items[index]?.shapeStyle, [items]);
 	const handleLegendClick = useCallback((seriesLabels) => {
 		if (interactive && chartId && context) {
@@ -1882,24 +1873,26 @@ const BaseLegend = forwardRef(({ items, className, orientation = "horizontal", a
 		chartInstanceContext,
 		context
 	]);
-	const createClickHandler = useCallback((seriesLabels) => {
-		if (!interactive) return;
+	const createClickHandler = useCallback((seriesLabels, itemInteractive) => {
+		if (!itemInteractive) return;
 		return () => handleLegendClick(seriesLabels);
-	}, [interactive, handleLegendClick]);
-	const createKeyDownHandler = useCallback((seriesLabels) => {
-		if (!interactive) return;
+	}, [handleLegendClick]);
+	const createKeyDownHandler = useCallback((seriesLabels, itemInteractive) => {
+		if (!itemInteractive) return;
 		return (event) => {
 			if (event.key === "Enter" || event.key === " ") {
 				event.preventDefault();
 				handleLegendClick(seriesLabels);
 			}
 		};
-	}, [interactive, handleLegendClick]);
+	}, [handleLegendClick]);
 	const flexAlignment = ALIGNMENT_TO_FLEX[alignment] ?? "center";
+	const staticItemRole = interactive ? void 0 : "listitem";
 	return render ? render(items) : /* @__PURE__ */ jsx(LegendOrdinal, {
 		scale: legendScale,
+		domain,
 		labelFormat,
-		labelTransform,
+		labelTransform: labelTransform ?? defaultLabelTransform,
 		children: (labels) => /* @__PURE__ */ jsx(Stack, {
 			ref,
 			direction: orientation === "vertical" ? "column" : "row",
@@ -1913,19 +1906,20 @@ const BaseLegend = forwardRef(({ items, className, orientation = "horizontal", a
 			children: labels.map((label, i) => {
 				const matchedItem = items[i];
 				const seriesLabels = matchedItem?.seriesLabels?.length ? matchedItem.seriesLabels : [label.text];
-				const visible = isSeriesVisible(seriesLabels[0]);
-				const handleClick = createClickHandler(seriesLabels);
-				const handleKeyDown = createKeyDownHandler(seriesLabels);
+				const visible = matchedItem?.interactive === false || isSeriesVisible(seriesLabels[0]);
+				const itemInteractive = interactive && matchedItem?.interactive !== false;
+				const handleClick = createClickHandler(seriesLabels, itemInteractive);
+				const handleKeyDown = createKeyDownHandler(seriesLabels, itemInteractive);
 				return /* @__PURE__ */ jsxs(LegendItem, {
-					className: clsx("visx-legend-item", base_legend_module_default["legend-item"], interactive && base_legend_module_default["legend-item--interactive"], !visible && base_legend_module_default["legend-item--inactive"], itemClassName),
+					className: clsx("visx-legend-item", base_legend_module_default["legend-item"], itemInteractive && base_legend_module_default["legend-item--interactive"], !visible && base_legend_module_default["legend-item--inactive"], itemClassName),
 					margin: itemMargin,
 					flexDirection: orientation === "vertical" && alignment === "end" ? "row-reverse" : itemDirection,
 					onClick: handleClick,
 					onKeyDown: handleKeyDown,
-					role: interactive ? "button" : "listitem",
-					tabIndex: interactive ? 0 : void 0,
-					"aria-pressed": interactive ? visible : void 0,
-					"aria-label": getLegendItemAriaLabel(label.text, matchedItem?.value, visible, interactive),
+					role: itemInteractive ? "button" : staticItemRole,
+					tabIndex: itemInteractive ? 0 : void 0,
+					"aria-pressed": itemInteractive ? visible : void 0,
+					"aria-label": getLegendItemAriaLabel(label.text, matchedItem?.value, visible, itemInteractive),
 					children: [items[i]?.renderGlyph ? /* @__PURE__ */ jsx("svg", {
 						width: items[i]?.glyphSize * 2,
 						height: items[i]?.glyphSize * 2,
@@ -2127,6 +2121,32 @@ function processSeriesData(seriesData, getElementStyles, showValues, withGlyph,
 	});
 }
 /**
+* Builds the static item that names the comparison overlay, styled like its first series.
+* Skipped when a comparison series already has an item of its own, so nothing is listed twice.
+* @param seriesData       - The series data to search for a comparison series
+* @param items            - The legend items already built from the series
+* @param label            - The item label
+* @param getElementStyles - Function to get element styles
+* @param legendShape      - The shape type for legend items (string literal or React component)
+* @return The legend item, or null when it would add nothing
+*/
+function buildComparisonLegendItem(seriesData, items, label, getElementStyles, legendShape) {
+	const itemLabels = new Set(items.map((item) => item.label));
+	const index = seriesData.findIndex((series) => series.options?.type === "comparison" && !itemLabels.has(series.label));
+	if (index === -1) return null;
+	const { color, shapeStyles } = getElementStyles({
+		data: seriesData[index],
+		index,
+		legendShape
+	});
+	return {
+		label,
+		color,
+		shapeStyle: shapeStyles,
+		interactive: false
+	};
+}
+/**
 * Processes point data into legend items
 * @param pointData          - The point data to process
 * @param getElementStyles   - Function to get element styles
@@ -2162,11 +2182,16 @@ function processPointData(pointData, getElementStyles, showValues, legendValueDi
 * @return Array of legend items ready for display
 */
 function useChartLegendItems(data, options = {}, legendShape) {
-	const { showValues = false, legendValueDisplay = "percentage", withGlyph = false, glyphSize = 8, collapseGroups = false, renderGlyph } = options;
+	const { showValues = false, legendValueDisplay = "percentage", withGlyph = false, glyphSize = 8, collapseGroups = false, comparisonItem = false, renderGlyph } = options;
 	const { getElementStyles } = useGlobalChartsContext();
 	return useMemo(() => {
 		if (!data || !Array.isArray(data) || data.length === 0) return [];
-		if ("data" in data[0]) return processSeriesData(data, getElementStyles, showValues, withGlyph, glyphSize, collapseGroups, renderGlyph, legendShape);
+		if ("data" in data[0]) {
+			const seriesData = data;
+			const items = processSeriesData(seriesData, getElementStyles, showValues, withGlyph, glyphSize, collapseGroups, renderGlyph, legendShape);
+			const comparison = comparisonItem ? buildComparisonLegendItem(seriesData, items, typeof comparisonItem === "string" ? comparisonItem : __("Comparison period", "jetpack-charts"), getElementStyles, legendShape) : null;
+			return comparison ? [...items, comparison] : items;
+		}
 		return processPointData(data, getElementStyles, showValues, legendValueDisplay, withGlyph, glyphSize, renderGlyph, legendShape);
 	}, [
 		data,
@@ -2176,6 +2201,7 @@ function useChartLegendItems(data, options = {}, legendShape) {
 		withGlyph,
 		glyphSize,
 		collapseGroups,
+		comparisonItem,
 		renderGlyph,
 		legendShape
 	]);
@@ -2639,7 +2665,7 @@ const AccessibleTooltip = ({ renderTooltip, selectedIndex, tooltipRef, keyboardF
 				tooltipContext?.showTooltip({
 					datum: tooltipItem.datum,
 					key: tooltipItem.seriesLabel,
-					index: tooltipItem.seriesIndex
+					index: tooltipItem.dataPointIndex
 				});
 			}
 		}
@@ -2962,6 +2988,31 @@ const DefaultGlyph = (props) => {
 	});
 };
 //#endregion
+//#region src/charts/private/readings.ts
+/**
+* Whether a value is a reading a scale can place.
+*
+* @param value - The point's value.
+* @return True for a finite number.
+*/
+const isReading = (value) => typeof value === "number" && Number.isFinite(value);
+/**
+* Whether a data point's value cannot be drawn.
+*
+* @param value                - The point's value.
+* @param options              - Validation options.
+* @param options.allowMissing - Whether `null` is a bucket with no reading rather than a fault.
+* @return True when the value is invalid.
+*/
+const isInvalidReading = (value, { allowMissing }) => value === null ? !allowMissing : value === void 0 || isNaN(value);
+/**
+* Formats a reading for a tooltip.
+*
+* @param value - The reading, or null when the bucket has none.
+* @return The formatted value.
+*/
+const formatReading = (value) => value == null ? __("No data", "jetpack-charts") : formatNumber(value);
+//#endregion
 //#region src/charts/private/center/center.module.scss
 var center_module_default = { "center": "a8ccharts-w3qxlG-center" };
 //#endregion
@@ -3334,6 +3385,54 @@ const buildTimeAxisOptions = ({ dataSorted, width, axisOptions, scaleDomain, zoo
 	};
 };
 //#endregion
+//#region src/charts/private/whole-number-ticks.tsx
+/**
+* Whether every reading in the series is a whole number.
+*
+* @param series - The series visx renders.
+* @return True when at least one reading exists and none has a fraction.
+*/
+const hasOnlyWholeNumbers = (series) => {
+	let sawReading = false;
+	for (const { data } of series) for (const point of data) {
+		const value = point?.value;
+		if (!isReading(value)) continue;
+		if (!Number.isInteger(value)) return false;
+		sawReading = true;
+	}
+	return sawReading;
+};
+/**
+* The scale's ticks with the fractional ones dropped.
+*
+* d3 steps by 1, 2 or 5 times a power of ten, so every whole number inside the domain is one of its ticks.
+*
+* @param scale - The value scale visx built.
+* @param count - Ticks to ask the scale for; undefined uses the scale's own default, as visx does.
+* @return Whole-number ticks, or undefined when visx's own ticks need no change.
+*/
+const getWholeNumberTickValues = (scale, count) => {
+	const ticks = scale?.ticks?.(count);
+	if (!ticks?.every((tick) => typeof tick === "number")) return;
+	const whole = ticks.filter((tick) => Number.isInteger(tick));
+	return whole.length > 1 && whole.length < ticks.length ? whole : void 0;
+};
+/**
+* Hands its children the whole-number ticks of the chart's value scale.
+*
+* @param props          - Component props.
+* @param props.axis     - Which scale carries the values.
+* @param props.numTicks - Ticks to ask the scale for.
+* @param props.enabled  - Whether the plotted values are all whole numbers and the caller pinned neither the ticks nor the value domain.
+* @param props.children - Renders the axis and grid with the tick values.
+* @return The rendered children.
+*/
+const WholeNumberTicks = ({ axis, numTicks, enabled, children }) => {
+	const { xScale, yScale } = useContext(DataContext);
+	const tickValues = enabled ? getWholeNumberTickValues(axis === "x" ? xScale : yScale, numTicks) : void 0;
+	return /* @__PURE__ */ jsx(Fragment$1, { children: children(tickValues) });
+};
+//#endregion
 //#region src/charts/private/with-responsive/with-responsive.module.scss
 var with_responsive_module_default = {
 	"container": "a8ccharts-sP1gHa-container",
@@ -4000,11 +4099,15 @@ const toNumber$1 = (val) => {
 const LineChartGlyph = ({ data, index, color, glyphStyle, renderGlyph, accessors, position }) => {
 	const { xScale, yScale } = useContext(DataContext) || {};
 	if (!xScale || !yScale) return null;
-	if (data.data.length === 0) return null;
-	const point = position === "start" ? data.data[0] : data.data[data.data.length - 1];
+	const hasFiniteY = (datum) => {
+		const scaledY = yScale(accessors.yAccessor(datum));
+		return typeof scaledY === "number" && Number.isFinite(scaledY);
+	};
+	const point = position === "start" ? data.data.find(hasFiniteY) : data.data.findLast(hasFiniteY);
+	if (!point) return null;
 	const x = xScale(accessors.xAccessor(point));
 	const y = yScale(accessors.yAccessor(point));
-	if (typeof x !== "number" || typeof y !== "number") return null;
+	if (typeof x !== "number" || typeof y !== "number" || !Number.isFinite(x) || !Number.isFinite(y)) return null;
 	const size = Math.max(0, toNumber$1(glyphStyle?.radius) ?? 4);
 	return renderGlyph({
 		key: `${position}-glyph-${data.label}`,
@@ -4019,6 +4122,106 @@ const LineChartGlyph = ({ data, index, color, glyphStyle, renderGlyph, accessors
 	});
 };
 //#endregion
+//#region src/charts/line-chart/private/nearest-pointer-events.tsx
+/**
+* Find the datum nearest a pointer along x, in one series sorted by x.
+*
+* @param data      - The series' registered data, in ascending x order.
+* @param xAccessor - Reads a datum's x value.
+* @param xScale    - The chart's x scale.
+* @param x         - Pointer x in SVG coordinates.
+* @return Index of the nearest datum and its distance, or index -1 when none has a position.
+*/
+function nearestByX(data, xAccessor, xScale, x) {
+	return (typeof xScale.invert === "function" ? [bisector(xAccessor).left(data, xScale.invert(x))].flatMap((index) => [index - 1, index]) : data.map((_datum, index) => index)).filter((index) => index >= 0 && index < data.length).reduce((best, index) => {
+		const distance = Math.abs(Number(xScale(xAccessor(data[index]))) - x);
+		return distance < best.distance ? {
+			index,
+			distance
+		} : best;
+	}, {
+		index: -1,
+		distance: Infinity
+	});
+}
+/**
+* Pick the candidate to report: the closest placed reading, else the closest bucket with no reading along x.
+*
+* @param candidates - One candidate per series.
+* @return The chosen candidate's params, or undefined when there are none.
+*/
+function pickNearest(candidates) {
+	const placed = candidates.map(({ params }) => params).filter((params) => Number.isFinite(params.distanceY));
+	const missing = candidates.filter(({ isMissing }) => isMissing).map(({ params }) => params);
+	const distance = (params) => placed.length ? Math.hypot(params.distanceX ?? 0, params.distanceY ?? 0) : params.distanceX ?? 0;
+	return (placed.length ? placed : missing).reduce((best, params) => !best || distance(params) < distance(best) ? params : best, void 0);
+}
+/**
+* Report pointer events at the nearest datum, including a bucket with no reading.
+*
+* visx's own nearest search measures y distance too, which is NaN for a null value, so a pointer
+* over a bucket where no series has a reading fires no event at all.
+*
+* @param props               - Handlers to call.
+* @param props.onPointerDown - Receives the nearest datum on pointer down.
+* @param props.onPointerMove - Receives the nearest datum on pointer move.
+* @param props.onPointerUp   - Receives the nearest datum on pointer up.
+* @return No visual content.
+*/
+function NearestPointerEvents({ onPointerDown, onPointerMove, onPointerUp }) {
+	const { xScale, yScale, dataRegistry } = useContext(DataContext);
+	const findNearest = useCallback((params) => {
+		const point = params?.svgPoint;
+		if (!point || !xScale || !yScale || !dataRegistry) return;
+		const candidates = [];
+		for (const key of dataRegistry.keys()) {
+			const entry = dataRegistry.get(key);
+			if (!entry) continue;
+			const { index, distance } = nearestByX(entry.data, entry.xAccessor, xScale, point.x);
+			if (index < 0) continue;
+			const datum = entry.data[index];
+			const value = entry.yAccessor(datum);
+			candidates.push({
+				params: {
+					event: params.event,
+					svgPoint: point,
+					key,
+					datum,
+					index,
+					distanceX: distance,
+					distanceY: Math.abs(Number(yScale(value)) - point.y)
+				},
+				isMissing: value == null
+			});
+		}
+		return pickNearest(candidates);
+	}, [
+		xScale,
+		yScale,
+		dataRegistry
+	]);
+	const handlers = useMemo(() => {
+		const report = (handler) => handler && ((params) => {
+			const nearest = findNearest(params);
+			if (nearest) handler(nearest);
+		});
+		return {
+			pointerdown: report(onPointerDown),
+			pointermove: report(onPointerMove),
+			pointerup: report(onPointerUp)
+		};
+	}, [
+		findNearest,
+		onPointerDown,
+		onPointerMove,
+		onPointerUp
+	]);
+	useEventEmitter("pointerdown", handlers.pointerdown);
+	useEventEmitter("pointermove", handlers.pointermove);
+	useEventEmitter("pointerup", handlers.pointerup);
+	return null;
+}
+//#endregion
 //#region src/charts/line-chart/line-chart.tsx
 const defaultRenderGlyph = (props) => {
 	return /* @__PURE__ */ createElement(DefaultGlyph, {
@@ -4062,8 +4265,13 @@ const renderDefaultTooltip = (params, contentStyle) => {
 	if (!nearestDatum) return null;
 	const tooltipPoints = Object.entries(tooltipData?.datumByKey || {}).map(([key, { datum }]) => ({
 		key,
-		value: datum.value
-	})).sort((a, b) => b.value - a.value);
+		value: datum.value ?? null
+	})).sort((a, b) => {
+		if (a.value === null && b.value === null) return 0;
+		if (a.value === null) return 1;
+		if (b.value === null) return -1;
+		return b.value - a.value;
+	});
 	return /* @__PURE__ */ jsxs("div", {
 		className: line_chart_module_default["line-chart__tooltip"],
 		style: contentStyle,
@@ -4083,16 +4291,23 @@ const renderDefaultTooltip = (params, contentStyle) => {
 				children: [point.key, ":"]
 			}), /* @__PURE__ */ jsx("span", {
 				className: line_chart_module_default["line-chart__tooltip-value"],
-				children: formatNumber(point.value)
+				children: formatReading(point.value)
 			})]
 		}, point.key))]
 	});
 };
 const validateData$4 = (data) => {
-	if (!data?.length) return "No data available";
-	if (data.some((series) => series.data.some((point) => isNaN(point.value) || point.value === null || point.value === void 0 || "date" in point && point.date && isNaN(point.date.getTime())))) return "Invalid data";
+	if (!data?.length) return __("No data available", "jetpack-charts");
+	if (data.some((series) => series.data.some((point) => isInvalidReading(point.value, { allowMissing: true }) || "date" in point && point.date && isNaN(point.date.getTime())))) return __("Invalid data", "jetpack-charts");
 	return null;
 };
+const getFallbackYDomain = (readingExtent, isLogScale) => {
+	const emptyDomain = isLogScale ? [1, 10] : [0, 1];
+	if (!readingExtent) return emptyDomain;
+	const [min, max] = readingExtent;
+	if (min !== max || isLogScale) return;
+	return min === 0 ? emptyDomain : [Math.min(0, min), Math.max(0, max)];
+};
 const LineChartScalesRef = ({ chartRef, width, height, margin }) => {
 	const context = useContext(DataContext);
 	useImperativeHandle(chartRef, () => ({
@@ -4119,6 +4334,7 @@ const LineChartScalesRef = ({ chartRef, width, height, margin }) => {
 const LineChartInternal = forwardRef(({ data, chartId: providedChartId, width, height, className, margin, withTooltips = true, withTooltipCrosshairs, showLegend = false, legend = {}, renderGlyph = defaultRenderGlyph, glyphStyle = {}, withLegendGlyph = false, withGradientFill = false, smoothing = true, curveType, renderTooltip = renderDefaultTooltip, tooltipPlacement, tooltipStyle, withStartGlyphs = false, withEndGlyphs = false, animation, options = {}, onPointerDown = void 0, onPointerUp = void 0, onPointerMove = void 0, onPointerOut = void 0, onDatumActivate = void 0, zoomable = false, rescaleYOnVisibilityChange = true, defaultHiddenSeries, children, gridVisibility, gap = "md" }, ref) => {
 	const legendInteractive = legend.interactive ?? false;
 	const legendCollapseGroups = legend.collapseGroups ?? false;
+	const legendComparisonItem = legend.comparisonItem ?? false;
 	const legendShape = legend.shape ?? "line";
 	const legendPosition = legend.position ?? "bottom";
 	const formatting = useChartFormatting();
@@ -4165,19 +4381,32 @@ const LineChartInternal = forwardRef(({ data, chartId: providedChartId, width, h
 	const allSeriesHidden = useMemo(() => {
 		return seriesWithVisibility.every(({ isVisible }) => !isVisible);
 	}, [seriesWithVisibility]);
-	const stableYDomain = useMemo(() => {
-		if (rescaleYOnVisibilityChange) return;
+	const yDomain = useMemo(() => {
+		const includeZero = options?.yScale?.zero === true && scaleCanBeZeroed({ type: options.yScale.type ?? "linear" });
+		if (rescaleYOnVisibilityChange && !includeZero) return;
 		let min = Infinity;
 		let max = -Infinity;
-		for (const series of dataSorted) for (const point of series.data ?? []) {
-			const value = point?.value;
-			if (typeof value === "number" && Number.isFinite(value)) {
-				min = Math.min(min, value);
-				max = Math.max(max, value);
+		for (const series of dataSorted) {
+			if (rescaleYOnVisibilityChange && !isSeriesVisible(series.label)) continue;
+			for (const point of series.data ?? []) {
+				const value = point?.value;
+				if (isReading(value)) {
+					min = Math.min(min, value);
+					max = Math.max(max, value);
+				}
 			}
 		}
+		if (includeZero) {
+			if (min === Infinity) return;
+			return max === 0 && min === 0 ? [0, 1] : [Math.min(0, min), Math.max(0, max)];
+		}
 		return min < max ? [min, max] : void 0;
-	}, [rescaleYOnVisibilityChange, dataSorted]);
+	}, [
+		rescaleYOnVisibilityChange,
+		dataSorted,
+		isSeriesVisible,
+		options?.yScale
+	]);
 	const activateSelectedPoint = useCallback((index) => {
 		const series = dataSorted[0];
 		const datum = series?.data[index];
@@ -4197,7 +4426,24 @@ const LineChartInternal = forwardRef(({ data, chartId: providedChartId, width, h
 		onActivate: activateSelectedPoint,
 		preventTooltipScroll: tooltipPlacement === "below-axis"
 	});
+	const visibleReadingExtent = useMemo(() => {
+		let min = Infinity;
+		let max = -Infinity;
+		for (const series of dataSorted) {
+			if (!isSeriesVisible(series.label)) continue;
+			for (const point of series.data) {
+				const value = point?.value;
+				if (isReading(value)) {
+					min = Math.min(min, value);
+					max = Math.max(max, value);
+				}
+			}
+		}
+		return min <= max ? [min, max] : void 0;
+	}, [dataSorted, isSeriesVisible]);
+	const hasWholeNumberValues = useMemo(() => hasOnlyWholeNumbers(dataSorted.filter((series) => isSeriesVisible(series.label))), [dataSorted, isSeriesVisible]);
 	const chartOptions = useMemo(() => {
+		const fallbackYDomain = getFallbackYDomain(visibleReadingExtent, options?.yScale?.type === "log");
 		return {
 			axis: {
 				x: buildTimeAxisOptions({
@@ -4226,7 +4472,8 @@ const LineChartInternal = forwardRef(({ data, chartId: providedChartId, width, h
 				type: "linear",
 				nice: true,
 				zero: false,
-				...stableYDomain ? { domain: stableYDomain } : {},
+				...fallbackYDomain ? { domain: fallbackYDomain } : {},
+				...yDomain ? { domain: yDomain } : {},
 				...options?.yScale
 			}
 		};
@@ -4235,7 +4482,8 @@ const LineChartInternal = forwardRef(({ data, chartId: providedChartId, width, h
 		dataSorted,
 		width,
 		zoom.domain,
-		stableYDomain,
+		yDomain,
+		visibleReadingExtent,
 		formatting,
 		isSeriesVisible
 	]);
@@ -4270,11 +4518,13 @@ const LineChartInternal = forwardRef(({ data, chartId: providedChartId, width, h
 		withGlyph: withLegendGlyph,
 		glyphSize: Math.max(0, toNumber(glyphStyle?.radius) ?? 4),
 		collapseGroups: legendCollapseGroups,
+		comparisonItem: legendComparisonItem,
 		renderGlyph
 	}), [
 		withLegendGlyph,
 		glyphStyle?.radius,
 		legendCollapseGroups,
+		legendComparisonItem,
 		renderGlyph
 	]), legendShape);
 	const chartMetadata = useMemo(() => ({
@@ -4386,18 +4636,26 @@ const LineChartInternal = forwardRef(({ data, chartId: providedChartId, width, h
 							},
 							xScale: chartOptions.xScale,
 							yScale: chartOptions.yScale,
-							onPointerDown: zoom.handlers.onPointerDown,
-							onPointerUp: zoom.handlers.onPointerUp,
-							onPointerMove: zoom.handlers.onPointerMove,
 							onPointerOut,
-							pointerEventsDataKey: "nearest",
 							children: [
-								!allSeriesHidden && gridVisibility !== "none" && /* @__PURE__ */ jsx(Grid, {
-									columns: false,
-									numTicks: 4
+								/* @__PURE__ */ jsx(NearestPointerEvents, { ...zoom.handlers }),
+								/* @__PURE__ */ jsx(WholeNumberTicks, {
+									axis: "y",
+									numTicks: chartOptions.axis.y.numTicks,
+									enabled: hasWholeNumberValues && !chartOptions.axis.y.tickValues && !options?.yScale?.domain,
+									children: (tickValues) => /* @__PURE__ */ jsxs(Fragment$1, { children: [
+										!allSeriesHidden && gridVisibility !== "none" && /* @__PURE__ */ jsx(Grid, {
+											columns: false,
+											numTicks: chartOptions.axis.y.numTicks,
+											tickValues: tickValues ?? chartOptions.axis.y.tickValues
+										}),
+										!allSeriesHidden && chartOptions.axis.x.display && /* @__PURE__ */ jsx(Axis, { ...chartOptions.axis.x }),
+										!allSeriesHidden && chartOptions.axis.y.display && /* @__PURE__ */ jsx(Axis, {
+											...chartOptions.axis.y,
+											...tickValues ? { tickValues } : {}
+										})
+									] })
 								}),
-								!allSeriesHidden && chartOptions.axis.x.display && /* @__PURE__ */ jsx(Axis, { ...chartOptions.axis.x }),
-								!allSeriesHidden && chartOptions.axis.y.display && /* @__PURE__ */ jsx(Axis, { ...chartOptions.axis.y }),
 								allSeriesHidden ? /* @__PURE__ */ jsx(SvgEmptyState, {
 									x: width / 2,
 									y: chartHeight / 2,
@@ -4538,7 +4796,7 @@ var area_chart_module_default = {
 const validateData$3 = (data) => {
 	if (!data?.length) return __("No data available", "jetpack-charts");
 	if (data.some((series) => !series.data?.length)) return __("No data available", "jetpack-charts");
-	if (data.some((series) => series.data.some((point) => isNaN(point.value) || point.value === null || point.value === void 0 || "date" in point && point.date && isNaN(point.date.getTime())))) return __("Invalid data", "jetpack-charts");
+	if (data.some((series) => series.data.some((point) => isInvalidReading(point.value, { allowMissing: false }) || "date" in point && point.date && isNaN(point.date.getTime())))) return __("Invalid data", "jetpack-charts");
 	return null;
 };
 //#endregion
@@ -4654,6 +4912,12 @@ const AreaChartInternal = forwardRef(({ data, chartId: providedChartId, width, h
 		}));
 	}, [dataSorted, hiddenSeries]);
 	const allSeriesHidden = useMemo(() => seriesWithVisibility.every(({ isVisible }) => !isVisible), [seriesWithVisibility]);
+	const hasWholeNumberValues = useMemo(() => (!stacked || stackOffset === "none") && hasOnlyWholeNumbers(dataSorted.filter((series) => isSeriesVisible(series.label))), [
+		dataSorted,
+		isSeriesVisible,
+		stacked,
+		stackOffset
+	]);
 	const { tooltipRef, onChartFocus, onChartBlur, onChartKeyDown } = useKeyboardNavigation({
 		selectedIndex,
 		setSelectedIndex,
@@ -4746,8 +5010,9 @@ const AreaChartInternal = forwardRef(({ data, chartId: providedChartId, width, h
 	const legendItems = useChartLegendItems(dataSorted, useMemo(() => ({
 		withGlyph: false,
 		glyphSize: 0,
-		collapseGroups: legend.collapseGroups ?? false
-	}), [legend.collapseGroups]), legendShape);
+		collapseGroups: legend.collapseGroups ?? false,
+		comparisonItem: legend.comparisonItem ?? false
+	}), [legend.collapseGroups, legend.comparisonItem]), legendShape);
 	const chartMetadata = useMemo(() => ({
 		stacked,
 		stackOffset,
@@ -4897,12 +5162,23 @@ const AreaChartInternal = forwardRef(({ data, chartId: providedChartId, width, h
 							onPointerOut,
 							pointerEventsDataKey: "nearest",
 							children: [
-								!allSeriesHidden && gridVisibility !== "none" && /* @__PURE__ */ jsx(Grid, {
-									columns: false,
-									numTicks: 4
+								/* @__PURE__ */ jsx(WholeNumberTicks, {
+									axis: "y",
+									numTicks: chartOptions.axis.y.numTicks,
+									enabled: hasWholeNumberValues && !chartOptions.axis.y.tickValues && !options?.yScale?.domain,
+									children: (tickValues) => /* @__PURE__ */ jsxs(Fragment$1, { children: [
+										!allSeriesHidden && gridVisibility !== "none" && /* @__PURE__ */ jsx(Grid, {
+											columns: false,
+											numTicks: chartOptions.axis.y.numTicks,
+											tickValues: tickValues ?? chartOptions.axis.y.tickValues
+										}),
+										!allSeriesHidden && chartOptions.axis.x.display && /* @__PURE__ */ jsx(Axis, { ...chartOptions.axis.x }),
+										!allSeriesHidden && chartOptions.axis.y.display && /* @__PURE__ */ jsx(Axis, {
+											...chartOptions.axis.y,
+											...tickValues ? { tickValues } : {}
+										})
+									] })
 								}),
-								!allSeriesHidden && chartOptions.axis.x.display && /* @__PURE__ */ jsx(Axis, { ...chartOptions.axis.x }),
-								!allSeriesHidden && chartOptions.axis.y.display && /* @__PURE__ */ jsx(Axis, { ...chartOptions.axis.y }),
 								allSeriesHidden ? /* @__PURE__ */ jsx(SvgEmptyState, {
 									x: width / 2,
 									y: chartHeight / 2,
@@ -5091,6 +5367,65 @@ const createTruncatedTickComponent = (axis) => (props) => {
 const TruncatedXTickComponent = createTruncatedTickComponent("x");
 const TruncatedYTickComponent = createTruncatedTickComponent("y");
 //#endregion
+//#region src/charts/bar-chart/private/value-domain.ts
+/** Domain for a value axis that has nothing to scale, so its ticks still read 0 to 1. */
+const EMPTY_DOMAIN = [0, 1];
+/**
+* The value a bar is drawn at, preferring `visualValue` so a zero still shows a sliver.
+*
+* A missing reading is NaN, not null: `ComparisonBars` coerces the value with `Number()`,
+* which turns null into 0 and would draw a comparison shadow at the baseline.
+*
+* @param point - A data point handed to visx.
+* @return The bar value, or NaN when the bucket has no reading.
+*/
+const getBarValue = (point) => {
+	const enhanced = point;
+	return (enhanced?.visualValue !== void 0 ? enhanced.visualValue : point?.value) ?? NaN;
+};
+/**
+* Whether visx renders a bar for a point.
+*
+* @param point - A data point handed to visx.
+* @return True when the point has a finite bar value.
+*/
+const isBarRendered = (point) => Number.isFinite(getBarValue(point));
+/**
+* How many bars visx renders for a list of points.
+*
+* @param points - Data points handed to visx.
+* @return The number of points that get a bar.
+*/
+const countRenderedBars = (points) => points.filter(isBarRendered).length;
+/**
+* An explicit domain for the value scale, or null to let visx fit one to the data.
+*
+* Zero goes into the domain here rather than through the scale's `zero` flag: visx applies
+* `nice` before `zero`, which would leave the axis topping out at a raw maximum.
+*
+* @param data             - Every series handed to the chart.
+* @param includeZero      - Whether the domain must span zero.
+* @param isSeriesRendered - Whether visx mounts a series, i.e. the legend shows it.
+* @return Value domain, or null when visx should fit its own.
+*/
+const getValueScaleDomain = (data, includeZero, isSeriesRendered) => {
+	let min = Infinity;
+	let max = -Infinity;
+	for (const series of data) {
+		if (!isSeriesRendered(series)) continue;
+		for (const point of series.data) {
+			const value = getBarValue(point);
+			if (!Number.isFinite(value)) continue;
+			min = Math.min(min, value);
+			max = Math.max(max, value);
+		}
+	}
+	if (min === Infinity) return [...EMPTY_DOMAIN];
+	if (min === max) return min === 0 ? [...EMPTY_DOMAIN] : [Math.min(0, min), Math.max(0, max)];
+	if (includeZero) return [Math.min(0, min), Math.max(0, max)];
+	return null;
+};
+//#endregion
 //#region src/charts/bar-chart/private/use-bar-chart-options.ts
 /** Outer padding of the category band scale (space at the chart edges). */
 const BASE_BAND_PADDING = .2;
@@ -5215,10 +5550,6 @@ function useBarChartOptions(data, horizontal, options = {}, isSeriesRendered = A
 		const tooltipDatumFormatter = hasLabels ? labelFormatter : byBucket(getTooltipFormatter(data, tickResolution, formatting));
 		const valueFormatter = formatNumberCompact;
 		const bandDomain = timeTickFormatter ? getBandDomain(data, isSeriesRendered) : null;
-		const valueAccessor = (d) => {
-			const enhancedPoint = d;
-			return enhancedPoint?.visualValue !== void 0 ? enhancedPoint.visualValue : d?.value;
-		};
 		return {
 			timeAxis: bandDomain && timeTickFormatter && {
 				domain: bandDomain,
@@ -5229,7 +5560,7 @@ function useBarChartOptions(data, horizontal, options = {}, isSeriesRendered = A
 				yTickFormat: valueFormatter,
 				tooltipLabelFormatter: tooltipDatumFormatter,
 				xAccessor: bucketAccessor,
-				yAccessor: valueAccessor,
+				yAccessor: getBarValue,
 				gridVisibility: "x",
 				xScale: bandScale,
 				yScale: linearScale
@@ -5238,7 +5569,7 @@ function useBarChartOptions(data, horizontal, options = {}, isSeriesRendered = A
 				xTickFormat: valueFormatter,
 				yTickFormat: labelFormatter,
 				tooltipLabelFormatter: tooltipDatumFormatter,
-				xAccessor: valueAccessor,
+				xAccessor: getBarValue,
 				yAccessor: bucketAccessor,
 				gridVisibility: "y",
 				xScale: linearScale,
@@ -5253,20 +5584,10 @@ function useBarChartOptions(data, horizontal, options = {}, isSeriesRendered = A
 	]);
 	return useMemo(() => {
 		const { xTickFormat: defaultXTickFormat, yTickFormat: defaultYTickFormat, tooltipLabelFormatter: defaultTooltipLabelFormatter, xAccessor, yAccessor, gridVisibility, xScale: baseXScale, yScale: baseYScale } = defaultOptions[horizontal ? "horizontal" : "vertical"];
-		let valueScaleDomainOverride = {};
-		if (data.some((s) => s.options?.type === "comparison")) {
-			if (!(!horizontal ? stableOptions.yScale?.domain : stableOptions.xScale?.domain)) {
-				const allValues = [];
-				data.forEach((series) => {
-					series.data.forEach((d) => {
-						const enhanced = d;
-						const v = enhanced.visualValue !== void 0 ? enhanced.visualValue : d.value;
-						if (typeof v === "number" && Number.isFinite(v)) allValues.push(v);
-					});
-				});
-				if (allValues.length > 0) valueScaleDomainOverride = { domain: [Math.min(0, ...allValues), Math.max(0, ...allValues)] };
-			}
-		}
+		const valueScaleOptions = horizontal ? stableOptions.xScale : stableOptions.yScale;
+		const includeZero = data.some((s) => s.options?.type === "comparison") || valueScaleOptions?.zero !== false;
+		const domain = valueScaleOptions?.domain ? null : getValueScaleDomain(data, includeZero, isSeriesRendered);
+		const valueScaleDomainOverride = domain ? { domain } : {};
 		const xScale = {
 			...baseXScale,
 			...stableOptions.xScale || {},
@@ -5317,7 +5638,8 @@ function useBarChartOptions(data, horizontal, options = {}, isSeriesRendered = A
 		axisConfig,
 		stableOptions,
 		horizontal,
-		data
+		data,
+		isSeriesRendered
 	]);
 }
 //#endregion
@@ -5337,9 +5659,8 @@ const createGroupScale = (keys, bandwidth, padding) => scaleBand({
 //#endregion
 //#region src/charts/bar-chart/private/comparison-bars-geometry.ts
 /**
-* Output position of a value scale's baseline: zero if in-domain, else the
-* nearest range edge. Mirrors visx's getScaleBaseline so comparison shadows
-* sit on the same baseline as primary bars.
+* Mirrors visx's getScaleBaseline so comparison shadows and primary bars
+* share the same baseline, including out-of-domain zero values.
 *
 * @param {ValueScale} scale - The continuous value scale.
 * @return {number} The baseline output position in pixels.
@@ -5350,7 +5671,7 @@ function getValueScaleBaseline(scale) {
 	const maybeZero = scale(0);
 	const [minOutput, maxOutput] = isDescending ? [b, a] : [a, b];
 	if (isDescending) return Number.isFinite(maybeZero) ? Math.min(Math.max(minOutput, maybeZero), maxOutput) : maxOutput;
-	return Number.isFinite(maybeZero) ? Math.min(Math.max(maybeZero, minOutput), maxOutput) : minOutput;
+	return Number.isFinite(maybeZero) ? Math.max(maybeZero, minOutput) : minOutput;
 }
 /**
 * Compute the rect for a comparison "shadow" bar, centered on the paired
@@ -5386,6 +5707,51 @@ function computeComparisonRect(params) {
 		height: valueLength
 	};
 }
+//#endregion
+//#region src/charts/bar-chart/private/classified-bar-series.tsx
+const ClassifiedBarSeries = ({ barClassName, primaryKeys, groupPadding, ...props }) => {
+	const { xScale, yScale, horizontal } = useContext(DataContext);
+	const bandScale = horizontal ? yScale : xScale;
+	const valueScale = horizontal ? xScale : yScale;
+	const groupScale = useMemo(() => createGroupScale(primaryKeys, bandScale?.bandwidth?.() ?? 0, groupPadding), [
+		primaryKeys,
+		bandScale,
+		groupPadding
+	]);
+	const renderGlyph = useCallback(({ datum, x, y, color, onBlur, onFocus, onPointerMove, onPointerOut, onPointerUp }) => {
+		if (!bandScale?.bandwidth || !valueScale) return null;
+		const baseline = getValueScaleBaseline(valueScale);
+		const position = Number(bandScale((horizontal ? props.yAccessor : props.xAccessor)(datum))) + (groupScale(props.dataKey) ?? 0);
+		const value = horizontal ? x : y;
+		return /* @__PURE__ */ jsx("rect", {
+			className: clsx("visx-bar", barClassName(datum)),
+			tabIndex: onFocus || onBlur ? 0 : void 0,
+			onBlur,
+			onFocus,
+			onPointerMove,
+			onPointerOut,
+			onPointerUp,
+			x: horizontal ? baseline + Math.min(0, value - baseline) : position,
+			y: horizontal ? position : baseline + Math.min(0, value - baseline),
+			width: horizontal ? Math.abs(value - baseline) : groupScale.bandwidth(),
+			height: horizontal ? groupScale.bandwidth() : Math.abs(value - baseline),
+			fill: color
+		});
+	}, [
+		bandScale,
+		valueScale,
+		horizontal,
+		groupScale,
+		props.dataKey,
+		props.xAccessor,
+		props.yAccessor,
+		barClassName
+	]);
+	return /* @__PURE__ */ jsx(GlyphSeries, {
+		...props,
+		renderGlyph
+	});
+};
 /**
 * Upper clamp on the computed group padding, so bars can never collapse to zero width
 * even at very large `widthFactor` values.
@@ -5482,6 +5848,8 @@ function BandHighlight({ visible, horizontal, onChange }) {
 		if (position === void 0 || !Number.isFinite(position)) return null;
 		return {
 			datum: nearest.datum,
+			key: nearest.key,
+			index: nearest.index,
 			x: horizontal ? margin?.left ?? 0 : position,
 			y: horizontal ? position : margin?.top ?? 0,
 			width: horizontal ? innerWidth : scale.bandwidth(),
@@ -5618,8 +5986,8 @@ function BandTooltip({ keys, groupPadding, withTooltips, onPointerDown, onPointe
 //#endregion
 //#region src/charts/bar-chart/bar-chart.tsx
 const validateData$2 = (data) => {
-	if (!data?.length) return "No data available";
-	if (data.some((series) => series.data.some((point) => isNaN(point.value) || point.value === null || point.value === void 0 || !point.label && (!("date" in point && point.date) || isNaN(point.date.getTime()))))) return "Invalid data";
+	if (!data?.length) return __("No data available", "jetpack-charts");
+	if (data.some((series) => series.data.some((point) => isInvalidReading(point.value, { allowMissing: true }) || !point.label && (!("date" in point && point.date) || isNaN(point.date.getTime()))))) return __("Invalid data", "jetpack-charts");
 	return null;
 };
 const getPatternId = (chartId, index) => `bar-pattern-${chartId}-${index}`;
@@ -5627,9 +5995,11 @@ const renderTooltipRow = (label, value) => /* @__PURE__ */ jsx("div", {
 	className: bar_chart_module_default["bar-chart__tooltip-row"],
 	children: sprintf(__("%1$s: %2$s", "jetpack-charts"), label, value)
 });
-const BarChartInternal = ({ data, chartId: providedChartId, width, height, className, margin, withTooltips = false, showLegend = false, legend = {}, gridVisibility: gridVisibilityProp, renderTooltip, tooltipPlacement, tooltipAnchorTop, options = {}, orientation = "vertical", withPatterns = false, showZeroValues = false, withBandHighlight = false, onBandHighlightChange, defaultHiddenSeries, animation, children, gap = "md", onPointerDown, onPointerUp, onDatumActivate }) => {
+const BarChartInternal = ({ data, chartId: providedChartId, width, height, className, margin, withTooltips = false, showLegend = false, legend = {}, gridVisibility: gridVisibilityProp, renderTooltip, tooltipPlacement, tooltipAnchorTop, tooltipStyle, barClassName, options = {}, orientation = "vertical", withPatterns = false, showZeroValues = false, withBandHighlight = false, onBandHighlightChange, defaultHiddenSeries, animation, children, gap = "md", onPointerDown, onPointerUp, onDatumActivate }) => {
+	if (!withTooltips && (withBandHighlight || onBandHighlightChange)) warnOnce("bar-chart-band-highlight-without-tooltips", "BarChart: withBandHighlight and onBandHighlightChange require withTooltips.");
 	const legendInteractive = legend.interactive ?? false;
 	const legendCollapseGroups = legend.collapseGroups ?? false;
+	const legendComparisonItem = legend.comparisonItem ?? false;
 	const horizontal = orientation === "horizontal";
 	const chartId = useChartId(providedChartId);
 	const hiddenSeries = useDefaultHiddenSeries(chartId, defaultHiddenSeries);
@@ -5640,10 +6010,21 @@ const BarChartInternal = ({ data, chartId: providedChartId, width, height, class
 		enabled: showZeroValues,
 		valueAxisLength: horizontal ? width : height
 	});
-	const legendItems = useChartLegendItems(dataSorted, useMemo(() => ({ collapseGroups: legendCollapseGroups }), [legendCollapseGroups]));
+	const legendItems = useChartLegendItems(dataSorted, useMemo(() => ({
+		collapseGroups: legendCollapseGroups,
+		comparisonItem: legendComparisonItem
+	}), [legendCollapseGroups, legendComparisonItem]));
 	const { getElementStyles } = useGlobalChartsContext();
 	const isSeriesRendered = useCallback((series) => isSeriesVisible(series.label), [isSeriesVisible]);
+	const hasWholeNumberValues = useMemo(() => hasOnlyWholeNumbers(dataSorted.filter(isSeriesRendered)), [dataSorted, isSeriesRendered]);
 	const chartOptions = useBarChartOptions(dataWithVisibleZeros, horizontal, options, isSeriesRendered);
+	const valueAxis = horizontal ? chartOptions.axis.x : chartOptions.axis.y;
+	const callerValueDomain = horizontal ? options.xScale?.domain : options.yScale?.domain;
+	const wholeNumberTicksProps = {
+		axis: horizontal ? "x" : "y",
+		numTicks: valueAxis.numTicks,
+		enabled: hasWholeNumberValues && !valueAxis.tickValues && !callerValueDomain
+	};
 	const defaultMargin = useChartMargin(height, chartOptions, dataSorted, theme, horizontal);
 	const chartRef = useRef(null);
 	const { legendChildren, nonLegendChildren } = useChartChildren(children, "BarChart");
@@ -5776,15 +6157,15 @@ const BarChartInternal = ({ data, chartId: providedChartId, width, height, class
 			const p = point;
 			return nearestDatum.label != null ? p.label === nearestDatum.label : !!nearestDatum.date && !!p.date && p.date.getTime() === nearestDatum.date.getTime();
 		});
-		if (comparisonEntry && comparisonDatum && comparisonDatum.value != null) return /* @__PURE__ */ jsxs("div", {
+		if (comparisonEntry && comparisonDatum) return /* @__PURE__ */ jsxs("div", {
 			className: bar_chart_module_default["bar-chart__tooltip"],
 			children: [
 				/* @__PURE__ */ jsx("div", {
 					className: bar_chart_module_default["bar-chart__tooltip-header"],
 					children: categoryLabel
 				}),
-				renderTooltipRow(primaryKey, formatNumber(nearestDatum.value)),
-				renderTooltipRow(comparisonEntry.series.label, formatNumber(comparisonDatum.value))
+				renderTooltipRow(primaryKey, formatReading(nearestDatum.value)),
+				renderTooltipRow(comparisonEntry.series.label, formatReading(comparisonDatum.value))
 			]
 		});
 		return /* @__PURE__ */ jsxs("div", {
@@ -5792,7 +6173,7 @@ const BarChartInternal = ({ data, chartId: providedChartId, width, height, class
 			children: [/* @__PURE__ */ jsx("div", {
 				className: bar_chart_module_default["bar-chart__tooltip-header"],
 				children: primaryKey
-			}), renderTooltipRow(categoryLabel, formatNumber(nearestDatum.value))]
+			}), renderTooltipRow(categoryLabel, formatReading(nearestDatum.value))]
 		});
 	}, [chartOptions.tooltip, comparisonEntries]);
 	const renderPattern = useCallback((index, color) => {
@@ -5843,15 +6224,15 @@ const BarChartInternal = ({ data, chartId: providedChartId, width, height, class
 	const createKeyboardHighlightStyle = useCallback(() => {
 		if (selectedIndex === void 0) return "";
 		const primaryCount = primaryEntries.length;
-		const maxDataPoints = Math.max(...primaryEntries.map((e) => e.series.data.length));
+		if (!primaryCount) return "";
 		const dataPointIndex = Math.floor(selectedIndex / primaryCount);
 		const seriesIndex = selectedIndex % primaryCount;
-		if (dataPointIndex >= maxDataPoints || seriesIndex >= primaryCount) return "";
 		const seriesData = primaryEntries[seriesIndex]?.series;
-		if (!seriesData || dataPointIndex >= seriesData.data.length) return "";
-		const actualBarIndex = seriesIndex * maxDataPoints + dataPointIndex;
+		const datum = seriesData?.data[dataPointIndex];
+		if (!seriesData || !datum || !isBarRendered(datum)) return "";
+		const domBarIndex = primaryEntries.slice(0, seriesIndex).reduce((count, { series }) => count + countRenderedBars(series.data), 0) + countRenderedBars(seriesData.data.slice(0, dataPointIndex));
 		return `
-			.bar-chart[data-chart-id="bar-chart-${chartId}"] .visx-bar-group .visx-bar:nth-child(${actualBarIndex + 1}) {
+			.bar-chart[data-chart-id="bar-chart-${chartId}"] .visx-bar-group .visx-bar:nth-child(${domBarIndex + 1}) {
 				stroke: #005fcc;
 				stroke-width: 2px;
 			}
@@ -5945,17 +6326,20 @@ const BarChartInternal = ({ data, chartId: providedChartId, width, height, class
 									horizontal,
 									onChange: onBandHighlightChange
 								}),
-								!allSeriesHidden && /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Grid, {
-									columns: gridVisibility.includes("y"),
-									rows: false,
-									numTicks: 4,
-									tickValues: chartOptions.axis.x.tickValues
-								}), /* @__PURE__ */ jsx(Grid, {
-									columns: false,
-									rows: gridVisibility.includes("x"),
-									numTicks: 4,
-									tickValues: chartOptions.axis.y.tickValues
-								})] }),
+								!allSeriesHidden && /* @__PURE__ */ jsx(WholeNumberTicks, {
+									...wholeNumberTicksProps,
+									children: (valueTicks) => /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Grid, {
+										columns: gridVisibility.includes("y"),
+										rows: false,
+										numTicks: chartOptions.axis.x.numTicks,
+										tickValues: (horizontal ? valueTicks : void 0) ?? chartOptions.axis.x.tickValues
+									}), /* @__PURE__ */ jsx(Grid, {
+										columns: false,
+										rows: gridVisibility.includes("x"),
+										numTicks: chartOptions.axis.y.numTicks,
+										tickValues: (horizontal ? void 0 : valueTicks) ?? chartOptions.axis.y.tickValues
+									})] })
+								}),
 								withPatterns && /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("defs", { children: dataSorted.map((seriesData, index) => renderPattern(index, getElementStyles({
 									data: seriesData,
 									index
@@ -5981,7 +6365,19 @@ const BarChartInternal = ({ data, chartId: providedChartId, width, height, class
 									getElementStyles,
 									resolveFill: resolveComparisonFill
 								}),
-								/* @__PURE__ */ jsx(BarGroup, {
+								barClassName ? /* @__PURE__ */ jsx("g", {
+									className: "visx-bar-group",
+									children: primaryEntries.map(({ series: seriesData, index }) => /* @__PURE__ */ jsx(ClassifiedBarSeries, {
+										dataKey: seriesData.label,
+										data: seriesData.data,
+										xAccessor: chartOptions.accessors.xAccessor,
+										yAccessor: chartOptions.accessors.yAccessor,
+										colorAccessor: getBarBackground(index),
+										barClassName,
+										primaryKeys,
+										groupPadding
+									}, seriesData.label))
+								}) : /* @__PURE__ */ jsx(BarGroup, {
 									padding: groupPadding,
 									children: primaryEntries.map(({ series: seriesData, index }) => /* @__PURE__ */ jsx(BarSeries, {
 										dataKey: seriesData?.label,
@@ -5998,10 +6394,20 @@ const BarChartInternal = ({ data, chartId: providedChartId, width, height, class
 									onPointerDown,
 									onPointerUp
 								}),
-								!allSeriesHidden && /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Axis, { ...chartOptions.axis.x }), /* @__PURE__ */ jsx(Axis, { ...chartOptions.axis.y })] }),
+								!allSeriesHidden && /* @__PURE__ */ jsx(WholeNumberTicks, {
+									...wholeNumberTicksProps,
+									children: (valueTicks) => /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Axis, {
+										...chartOptions.axis.x,
+										...horizontal && valueTicks ? { tickValues: valueTicks } : {}
+									}), /* @__PURE__ */ jsx(Axis, {
+										...chartOptions.axis.y,
+										...!horizontal && valueTicks ? { tickValues: valueTicks } : {}
+									})] })
+								}),
 								withTooltips && /* @__PURE__ */ jsx(AccessibleTooltip, {
 									tooltipPlacement,
 									tooltipAnchorTop,
+									style: tooltipStyle,
 									detectBounds: true,
 									snapTooltipToDatumX: true,
 									snapTooltipToDatumY: true,