reamkit 1.31.0 → 1.32.0

package/dist/esm/core/drawingml/chart-geometry.js

@@ -23,37 +23,63 @@ var SERIES_COLORS = [
 * @returns An RRGGBB hex string.
 */
 var seriesColor = (s, i, cycle) => s.colorHex ?? (cycle && cycle.length > 0 ? cycle[i % cycle.length] : SERIES_COLORS[i % SERIES_COLORS.length]);
-function niceNum(range, round) {
-	const exp = Math.floor(Math.log10(range));
-	const f = range / 10 ** exp;
-	let nf;
-	if (round) nf = f < 1.5 ? 1 : f < 3 ? 2 : f < 7 ? 5 : 10;
-	else nf = f <= 1 ? 1 : f <= 2 ? 2 : f <= 5 ? 5 : 10;
-	return nf * 10 ** exp;
-}
 /**
-* Compute a human-friendly axis {@link Scale} for the data range using
-* Heckbert's "nice numbers" algorithm: rounded endpoints and a 1/2/5·10ⁿ step
-* that yields about `maxTicks` ticks. A degenerate range (`dataMin === dataMax`)
-* is widened by 1 so the axis is non-empty.
+* The scale Excel gives a value axis it is left to choose, measured against
+* Excel's own PDF of eight column charts (2026-10-01):
+*
+*  - the ends: values all of one sign put the axis's near end at zero —
+*    unless their spread is under a sixth of the largest of them, when it
+*    stops half a spread short of the nearest (93…97 runs from 91) — and the
+*    far end, like both ends of a range across zero, takes 5% of the spread
+*    beyond the data before it is rounded out to the step;
+*  - the step: the smallest 1, 2 or 5 × 10ⁿ that leaves at most ten intervals
+*    (`maxIntervals`), whatever the chart's height — 3 750 runs 0…4 000 by 500
+*    on a 150pt chart as on a 400pt one. Only an axis too short to hold the
+*    labels asks for fewer, and the caller says so.
 *
-* @param dataMin  The smallest data value to cover.
-* @param dataMax  The largest data value to cover.
-* @param maxTicks Target upper bound on tick count (default 6).
+* Every case of the probe lands where Excel puts it: −1…1.2 on −1.5…1.5 by
+* 0.5, 0.3…4.7 on 0…5 by 0.5, 120…950 on 0…1 000 by 100, 0.012…0.047 on
+* 0…0.05 by 0.005. Heckbert's nice numbers with a budget of ticks by height
+* stepped the budget chart by 1 000 and started 93…97 at zero.
+*
+* @param dataMin      The smallest value to cover.
+* @param dataMax      The largest value to cover.
+* @param maxIntervals At most this many steps between the ends (default 10).
 * @returns The rounded min/max and tick step.
 */
-function niceScale(dataMin, dataMax, maxTicks = 6) {
-	const lo = Math.min(dataMin, dataMax);
+function niceScale(dataMin, dataMax, maxIntervals = 10) {
+	let lo = Math.min(dataMin, dataMax);
 	let hi = Math.max(dataMin, dataMax);
-	if (lo === hi) hi = lo + 1;
-	const step = niceNum((hi - lo) / Math.max(1, maxTicks - 1), true);
-	const headroom = hi > 0 ? hi * 1.05 : hi;
+	if (lo === hi) if (hi > 0) lo = 0;
+	else if (lo < 0) hi = 0;
+	else hi = 1;
+	const spread = hi - lo;
+	const end = {
+		lo: lo - spread * .05,
+		hi: hi + spread * .05
+	};
+	if (lo >= 0) end.lo = spread < hi / 6 ? lo - spread / 2 : 0;
+	else if (hi <= 0) end.hi = spread < -lo / 6 ? hi + spread / 2 : 0;
+	const step = stepFor(end.hi - end.lo, maxIntervals);
 	return {
-		min: Math.floor(lo / step) * step,
-		max: Math.ceil(headroom / step) * step,
+		min: Math.floor(end.lo / step + 1e-9) * step,
+		max: Math.ceil(end.hi / step - 1e-9) * step,
 		step
 	};
 }
+/** The smallest 1, 2 or 5 × 10ⁿ that cuts `span` into at most `maxIntervals` steps. */
+function stepFor(span, maxIntervals) {
+	const most = Math.max(1, maxIntervals);
+	let base = 10 ** Math.floor(Math.log10(span / most));
+	for (;;) {
+		for (const m of [
+			1,
+			2,
+			5
+		]) if (span / (m * base) <= most + 1e-9) return m * base;
+		base *= 10;
+	}
+}
 /**
 * Format an axis tick value, choosing decimal places from the tick `step` so
 * `0.25`-spaced ticks read `0.25` while integer steps drop the fraction.
@@ -65,7 +91,8 @@ function niceScale(dataMin, dataMax, maxTicks = 6) {
 function formatTick(v, step) {
 	if (Number.isInteger(step) && Number.isInteger(v)) return String(v);
 	const decimals = Math.max(0, -Math.floor(Math.log10(step)));
-	return v.toFixed(decimals).replace(/\.?0+$/, (m) => m.includes(".") ? "" : m);
+	const fixed = v.toFixed(decimals);
+	return fixed.includes(".") ? fixed.replace(/0+$/, "").replace(/\.$/, "") : fixed;
 }
 var ticks = (s) => {
 	const out = [];
@@ -85,23 +112,54 @@ var ticks = (s) => {
 *                the plot, not about the numbers.
 * @returns The axis min/max and tick step.
 */
-function axisScale(chart, dataMin, dataMax, hPt) {
-	const rounded = niceScale(chart.valAxisMin ?? dataMin, chart.valAxisMax ?? dataMax, tickBudget(hPt));
+function axisScale(chart, dataMin, dataMax, extentPt, horizontal = false) {
+	const rounded = niceScale(chart.valAxisMin ?? dataMin, chart.valAxisMax ?? dataMax, intervalsThatFit(extentPt, horizontal));
+	const step = chart.valAxisMajorUnit ?? rounded.step;
 	return {
-		min: chart.valAxisMin ?? rounded.min,
-		max: chart.valAxisMax ?? rounded.max,
-		step: rounded.step
+		min: chart.valAxisMin ?? (step === rounded.step ? rounded.min : Math.floor(rounded.min / step) * step),
+		max: chart.valAxisMax ?? (step === rounded.step ? rounded.max : Math.ceil(rounded.max / step) * step),
+		step
 	};
 }
-function pushChartTitle(labels, chart, wPt, hPt) {
-	if (!chart.title) return;
-	labels.push({
-		text: chart.title,
-		x: wPt / 2,
-		y: hPt - 4 - 13,
-		sizePt: 13,
-		colorHex: TITLE_COLOR,
-		align: "center"
+/**
+* The chart title's lines. A title longer than the chart is wide wraps at its
+* spaces, as Excel's and Calc's do, rather than running out past both sides
+* of the frame: dataValidationTableRange.xlsx's "Ranking of Washington
+* Counties on Days per Patient (ALOS) in 2015" crossed the cells beside its
+* chart. A line holds at most four fifths of the chart's width.
+*
+* @param chart   The chart.
+* @param wPt     The chart's width.
+* @param measure The text measurer.
+* @returns The lines, top first; none for a chart without a title.
+*/
+function titleLines(chart, wPt, measure) {
+	if (!chart.title) return [];
+	const room = wPt * .8;
+	const lines = [];
+	let line = "";
+	for (const word of chart.title.split(/\s+/).filter((w) => w.length > 0)) {
+		const longer = line ? `${line} ${word}` : word;
+		if (line && measure(longer, 13) > room) {
+			lines.push(line);
+			line = word;
+		} else line = longer;
+	}
+	if (line) lines.push(line);
+	return lines;
+}
+/** The band a title of `lines` takes at the top of the chart. */
+var titleHeight = (lines) => lines.length === 0 ? 0 : 13 * (1.6 + 1.2 * (lines.length - 1));
+function pushChartTitle(labels, lines, wPt, hPt) {
+	lines.forEach((text, i) => {
+		labels.push({
+			text,
+			x: wPt / 2,
+			y: hPt - 4 - 13 * (1 + 1.2 * i),
+			sizePt: 13,
+			colorHex: TITLE_COLOR,
+			align: "center"
+		});
 	});
 }
 function buildLegendBlock(chart, wPt, hPt, measure) {
@@ -113,7 +171,7 @@ function buildLegendBlock(chart, wPt, hPt, measure) {
 	const marker = chart.type === "line" || chart.type === "scatter" ? "line" : "box";
 	return layoutLegend(legendEntries, chart.hasLegend, chart.legendPos ?? "b", wPt, hPt, measure, marker);
 }
-function pushGridTicks(gridlines, labels, tickVals, fmt, axis, at, x0, y0, plotW, plotH, grid) {
+function pushGridTicks(gridlines, labels, tickVals, fmt, axis, at, x0, y0, plotW, plotH, grid, atEnd = false) {
 	for (const v of tickVals) if (axis === "x") {
 		const gx = at(v);
 		gridlines.push({
@@ -124,7 +182,7 @@ function pushGridTicks(gridlines, labels, tickVals, fmt, axis, at, x0, y0, plotW
 		labels.push({
 			text: fmt(v),
 			x: gx,
-			y: y0 - 9,
+			y: atEnd ? y0 + plotH + 9 * .4 : y0 - 9,
 			sizePt: 9,
 			colorHex: LABEL_COLOR,
 			align: "center"
@@ -138,11 +196,11 @@ function pushGridTicks(gridlines, labels, tickVals, fmt, axis, at, x0, y0, plotW
 		});
 		labels.push({
 			text: fmt(v),
-			x: x0 - 3,
+			x: atEnd ? x0 + plotW + 3 : x0 - 3,
 			y: gy - 9 / 3,
 			sizePt: 9,
 			colorHex: LABEL_COLOR,
-			align: "right"
+			align: atEnd ? "left" : "right"
 		});
 	}
 }
@@ -159,16 +217,24 @@ function axisStroke(style) {
 		widthPt: style?.widthPt ?? 1
 	};
 }
-function pushAxisLines(polylines, x0, y0, plotW, plotH, chart) {
+/**
+* The two axis lines: the upright one (in the left axis's style) and the one
+* lying along (in the bottom axis's). The category axis lies where it crosses
+* the value axis — `cross.y` up a column chart, `cross.x` along a bar chart —
+* and the other stands at the plot's edge.
+*/
+function pushAxisLines(polylines, x0, y0, plotW, plotH, chart, cross = {}) {
 	const val = axisStroke(chart.valAxisLine);
+	const x = x0 + (cross.x ?? 0);
+	const y = y0 + (cross.y ?? 0);
 	if (val) polylines.push({
-		points: [[x0, y0], [x0, y0 + plotH]],
+		points: [[x, y0], [x, y0 + plotH]],
 		strokeHex: val.hex,
 		widthPt: val.widthPt
 	});
 	const cat = axisStroke(chart.catAxisLine);
 	if (cat) polylines.push({
-		points: [[x0, y0], [x0 + plotW, y0]],
+		points: [[x0, y], [x0 + plotW, y]],
 		strokeHex: cat.hex,
 		widthPt: cat.widthPt
 	});
@@ -181,27 +247,43 @@ function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
 	const nCats = Math.max(chart.categories.length, ...chart.series.map((s) => s.values.length), 1);
 	const onSecondary = chart.series.filter((s) => s.secondaryAxis);
 	const allVals = (onSecondary.length > 0 ? chart.series.filter((s) => !s.secondaryAxis) : chart.series).flatMap((s) => s.values.slice(0, nCats));
-	const [dataMin, dataMax] = opts.dataRange ?? [Math.min(0, ...allVals), Math.max(0, ...allVals)];
-	const scale = axisScale(chart, dataMin, dataMax, hPt);
+	const [dataMin, dataMax] = opts.dataRange ?? (allVals.length > 0 ? [Math.min(...allVals), Math.max(...allVals)] : [0, 1]);
+	const scale = opts.exactRange ? {
+		min: dataMin,
+		max: dataMax,
+		step: niceScale(dataMin, dataMax, intervalsThatFit(horizontal ? wPt : hPt, horizontal)).step
+	} : axisScale(chart, dataMin, dataMax, horizontal ? wPt : hPt, horizontal);
 	const fmtVal = opts.formatValue ?? ((v) => formatTick(v, scale.step));
 	const tickVals = ticks(scale);
 	const vals2 = onSecondary.flatMap((s) => s.values.slice(0, nCats));
-	const scale2 = vals2.length > 0 ? niceScale(Math.min(0, ...vals2), Math.max(0, ...vals2), tickBudget(hPt)) : void 0;
+	const scale2 = vals2.length > 0 ? niceScale(Math.min(...vals2), Math.max(...vals2), intervalsThatFit(hPt, false)) : void 0;
 	const tickVals2 = scale2 ? ticks(scale2) : [];
-	let top = 4;
-	if (chart.title) top += 13 * 1.6;
+	const crosses = chart.catAxisCrosses;
+	const crossValue = Math.min(Math.max(crosses === "min" ? scale.min : crosses === "max" ? scale.max : crosses ?? 0, scale.min), scale.max);
+	const labelsAt = chart.catTickLabelPos === "none" ? "none" : chart.catTickLabelPos === "low" ? "start" : chart.catTickLabelPos === "high" ? "end" : crossValue <= scale.min ? "start" : crossValue >= scale.max ? "end" : "cross";
+	const catText = (c) => chart.categories[c] ?? String(c + 1);
+	const widestCat = Math.max(0, ...Array.from({ length: nCats }, (_, c) => measure(catText(c), 9)));
+	const catBand = 9 * 1.6;
+	const groupLevels = horizontal ? [] : chart.categoryGroups ?? [];
+	const valAtEnd = chart.catAxisReversed === true ? chart.valAxisCrosses !== "max" : chart.valAxisCrosses === "max";
+	const title = titleLines(chart, wPt, measure);
+	const top = 4 + titleHeight(title) + (!horizontal && labelsAt === "end" ? catBand : 0) + (horizontal && valAtEnd ? catBand : 0);
 	const legend = buildLegendBlock(chart, wPt, hPt, measure);
 	const tick2W = scale2 && !horizontal ? Math.max(0, ...tickVals2.map((v) => measure(formatTick(v, scale2.step), 9))) + 4 + (chart.secondaryValAxisTitle ? 9 * 1.5 : 0) : 0;
-	const plotRight = wPt - 4 - legend.rightWidth - tick2W;
+	const tickHalf = (v) => horizontal && v !== void 0 ? measure(fmtVal(v), 9) / 2 : 0;
+	const lastTickHalf = tickHalf(tickVals[tickVals.length - 1]);
+	const catLabelW = Math.min(wPt * .4, widestCat + 6);
 	const tickLabelW = Math.max(0, ...tickVals.map((v) => measure(fmtVal(v), 9))) + 4;
-	const catLabelH = 9 * 1.6;
-	const catTitleH = chart.catAxisTitle ? 9 * 1.5 : 0;
-	const x0 = 4 + (chart.valAxisTitle ? 9 * 1.5 : 0) + tickLabelW;
-	const y0 = 4 + legend.bottomHeight + catTitleH + catLabelH;
+	const plotRight = wPt - 4 - legend.rightWidth - tick2W - (horizontal && labelsAt === "end" ? catLabelW : lastTickHalf) - (!horizontal && valAtEnd ? tickLabelW : 0);
+	const axisTitleBand = 9 * 1.5;
+	const leftTitle = horizontal ? chart.catAxisTitle : chart.valAxisTitle;
+	const footTitle = horizontal ? chart.valAxisTitle : chart.catAxisTitle;
+	const x0 = 4 + (leftTitle ? axisTitleBand : 0) + (horizontal ? labelsAt === "start" ? catLabelW : tickHalf(tickVals[0]) : valAtEnd ? 0 : tickLabelW);
+	const y0 = 4 + legend.bottomHeight + (footTitle ? axisTitleBand : 0) + ((horizontal ? !valAtEnd : labelsAt === "start") ? catBand : 0) + (!horizontal && labelsAt === "start" ? groupLevels.length * catBand : 0);
 	const plotW = Math.max(1, plotRight - x0);
 	const plotH = Math.max(1, hPt - top - y0);
 	const valueOffset = (v) => (v - scale.min) / (scale.max - scale.min) * (horizontal ? plotW : plotH);
-	const zeroOffset = valueOffset(0);
+	const zeroOffset = valueOffset(crossValue);
 	const plotBackground = chart.plotFillHex ?? chart.plotLine?.colorHex ? {
 		x: x0,
 		y: y0,
@@ -214,9 +296,9 @@ function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
 			...chart.plotLine.dash ? { strokeDash: chart.plotLine.dash } : {}
 		} : {}
 	} : void 0;
-	pushChartTitle(labels, chart, wPt, hPt);
-	if (chart.valAxisTitle) labels.push({
-		text: chart.valAxisTitle,
+	pushChartTitle(labels, title, wPt, hPt);
+	if (leftTitle) labels.push({
+		text: leftTitle,
 		x: 12.1,
 		y: y0 + plotH / 2,
 		sizePt: 9,
@@ -224,16 +306,16 @@ function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
 		align: "center",
 		rotationDeg: 90
 	});
-	if (chart.catAxisTitle) labels.push({
-		text: chart.catAxisTitle,
+	if (footTitle) labels.push({
+		text: footTitle,
 		x: x0 + plotW / 2,
 		y: legend.bottomHeight + 2,
 		sizePt: 9,
 		colorHex: LABEL_COLOR,
 		align: "center"
 	});
-	if (horizontal) pushGridTicks(gridlines, labels, tickVals, fmtVal, "x", (v) => x0 + valueOffset(v), x0, y0, plotW, plotH, chart.gridLine);
-	else pushGridTicks(gridlines, labels, tickVals, fmtVal, "y", (v) => y0 + valueOffset(v), x0, y0, plotW, plotH, chart.gridLine);
+	if (horizontal) pushGridTicks(gridlines, labels, tickVals, fmtVal, "x", (v) => x0 + valueOffset(v), x0, y0, plotW, plotH, chart.gridLine, valAtEnd);
+	else pushGridTicks(gridlines, labels, tickVals, fmtVal, "y", (v) => y0 + valueOffset(v), x0, y0, plotW, plotH, chart.gridLine, valAtEnd);
 	const valueOffset2 = scale2 && !horizontal ? (v) => (v - scale2.min) / (scale2.max - scale2.min) * plotH : void 0;
 	if (scale2 && valueOffset2) {
 		for (const v of tickVals2) labels.push({
@@ -261,30 +343,60 @@ function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
 		});
 	}
 	const slot = (horizontal ? plotH : plotW) / nCats;
-	const need = horizontal ? 9 * 1.4 : Math.max(0, ...chart.categories.map((t) => measure(t, 9))) + 4;
+	const need = horizontal ? 9 * 1.4 : widestCat + 4;
 	const step = Math.max(1, Math.ceil(need / Math.max(slot, .01)));
-	for (let c = 0; c < nCats; c += step) {
-		const cat = chart.categories[c] ?? String(c + 1);
+	const across = labelsAt === "start" ? 0 : labelsAt === "end" ? horizontal ? plotW : plotH : zeroOffset;
+	const labelled = [];
+	if (labelsAt !== "none") if (chart.catAxisReversed === true) for (let c = nCats - 1; c >= 0; c -= step) labelled.push(c);
+	else for (let c = 0; c < nCats; c += step) labelled.push(c);
+	for (const c of labelled) {
+		const cat = catText(c);
 		if (!cat) continue;
 		const center = (horizontal ? y0 : x0) + c * slot + slot / 2;
 		if (horizontal) labels.push({
 			text: cat,
-			x: x0 - 3,
+			x: labelsAt === "end" ? x0 + across + 3 : x0 + across - 3,
 			y: center - 9 / 3,
 			sizePt: 9,
 			colorHex: LABEL_COLOR,
-			align: "right"
+			align: labelsAt === "end" ? "left" : "right"
 		});
 		else labels.push({
 			text: cat,
 			x: center,
-			y: y0 - 9,
+			y: labelsAt === "end" ? y0 + across + 9 * .4 : y0 + across - 9,
 			sizePt: 9,
 			colorHex: LABEL_COLOR,
 			align: "center"
 		});
 	}
-	pushAxisLines(polylines, x0, y0, plotW, plotH, chart);
+	if (labelsAt !== "none" && labelsAt !== "end") groupLevels.forEach((groups, level) => {
+		const rowY = y0 + across - 9 - (level + 1) * catBand;
+		groups.forEach((group, i) => {
+			const end = Math.min(nCats, groups[i + 1]?.start ?? nCats);
+			if (end <= group.start) return;
+			labels.push({
+				text: group.label,
+				x: x0 + (group.start + end) / 2 * slot,
+				y: rowY,
+				sizePt: 9,
+				colorHex: LABEL_COLOR,
+				align: "center"
+			});
+			if (i > 0) polylines.push({
+				points: [[x0 + group.start * slot, y0 + across], [x0 + group.start * slot, rowY - 9 * .4]],
+				strokeHex: GRID_COLOR,
+				widthPt: .75
+			});
+		});
+	});
+	pushAxisLines(polylines, x0, y0, plotW, plotH, chart, horizontal ? {
+		x: zeroOffset,
+		...valAtEnd ? { y: plotH } : {}
+	} : {
+		y: zeroOffset,
+		...valAtEnd ? { x: plotW } : {}
+	});
 	legend.emit(rects, labels);
 	return {
 		x0,
@@ -332,6 +444,7 @@ function groupingFrameOpts(chart, nCats) {
 	const g = chart.grouping ?? "clustered";
 	if (g === "percentStacked") return {
 		dataRange: [0, 1],
+		exactRange: true,
 		formatValue: pctLabel
 	};
 	const format = chartValueFormatter(chart);
@@ -655,12 +768,12 @@ function buildScatterScene(chart, wPt, hPt, measure) {
 		wedges: [],
 		labels
 	};
-	const xScale = niceScale(...autoRange(xs), tickBudget(wPt / 2));
-	const yScale = niceScale(...autoRange(ys), tickBudget(hPt));
+	const xScale = niceScale(Math.min(...xs), Math.max(...xs), intervalsThatFit(wPt, true));
+	const yScale = niceScale(Math.min(...ys), Math.max(...ys), intervalsThatFit(hPt, false));
 	const xTicks = ticks(xScale);
 	const yTicks = ticks(yScale);
-	let top = 4;
-	if (chart.title) top += 13 * 1.6;
+	const title = titleLines(chart, wPt, measure);
+	const top = 4 + titleHeight(title);
 	const legend = buildLegendBlock(chart, wPt, hPt, measure);
 	const x0 = 4 + (Math.max(0, ...yTicks.map((v) => measure(formatTick(v, yScale.step), 9))) + 4);
 	const y0 = 4 + legend.bottomHeight + 9 * 1.6;
@@ -668,7 +781,7 @@ function buildScatterScene(chart, wPt, hPt, measure) {
 	const plotH = Math.max(1, hPt - top - y0);
 	const xAt = (v) => x0 + (v - xScale.min) / (xScale.max - xScale.min) * plotW;
 	const yAt = (v) => y0 + (v - yScale.min) / (yScale.max - yScale.min) * plotH;
-	pushChartTitle(labels, chart, wPt, hPt);
+	pushChartTitle(labels, title, wPt, hPt);
 	pushGridTicks(gridlines, labels, yTicks, (v) => formatTick(v, yScale.step), "y", yAt, x0, y0, plotW, plotH, chart.gridLine);
 	pushGridTicks(gridlines, labels, xTicks, (v) => formatTick(v, xScale.step), "x", xAt, x0, y0, plotW, plotH, chart.gridLine);
 	pushAxisLines(polylines, x0, y0, plotW, plotH, chart);
@@ -702,27 +815,13 @@ function buildScatterScene(chart, wPt, hPt, measure) {
 	};
 }
 /**
-* The data range an automatic axis covers: its own extent, except that data
-* starting within 5/6 of the top reads as data that belongs against a zero
-* baseline — Excel's own rule for when an automatic minimum stays at 0.
+* How many intervals an axis `extentPt` long has room to label: ten, Excel's
+* own most, unless its labels would run into each other first — one label
+* line apiece stacked up a vertical axis, a few digits' width apiece along a
+* horizontal one. Excel crams nine labels up a 150pt column chart rather than
+* step it more coarsely, so the room is all that limits it.
 */
-function autoRange(vals) {
-	const lo = Math.min(...vals);
-	const hi = Math.max(...vals);
-	return [lo > 0 && lo < 5 / 6 * hi ? 0 : lo, hi];
-}
-/**
-* How many ticks an axis `extentPt` long carries (mirrors {@link axisScale}).
-*
-* A tall axis takes more of them — a fixed six drew 0/100/200/300 down a plot
-* where both references fit 0/50/…/300 — but the appetite is milder than it
-* looks: asked for one every 32pt, a 427pt chart wanted ten, and Excel labels
-* that chart's 0…5 data 0/1/…/6 where we drew half-steps (chart-texture-bg
-* .pptx). One per ~48pt and never more than eight satisfies both, now that
-* {@link niceScale} measures its step against the range the data spans rather
-* than against Heckbert's rounded-up one.
-*/
-var tickBudget = (extentPt) => Math.min(8, Math.max(4, Math.round(extentPt / 48)));
+var intervalsThatFit = (extentPt, horizontal) => Math.min(10, Math.max(2, Math.floor(extentPt * .75 / (9 * (horizontal ? 3.5 : 1.4)))));
 /** Side (points) of the square stamped for a series that names no symbol. */
 var DEFAULT_MARKER_PT = 4;
 /**
@@ -773,9 +872,7 @@ function pushMarker(rects, wedges, marker, x, y, color) {
 */
 function buildLineScene(chart, wPt, hPt, measure) {
 	const allVals = chart.series.flatMap((s) => s.values);
-	const lo = allVals.length > 0 ? Math.min(...allVals) : 0;
-	const hi = allVals.length > 0 ? Math.max(...allVals) : 1;
-	const range = lo > 0 && lo > 5 / 6 * hi ? [lo, hi] : [Math.min(0, lo), Math.max(0, hi)];
+	const range = [allVals.length > 0 ? Math.min(...allVals) : 0, allVals.length > 0 ? Math.max(...allVals) : 1];
 	const lineFormat = chartValueFormatter(chart);
 	const f = buildFrame(chart, wPt, hPt, measure, false, {
 		dataRange: range,
@@ -846,8 +943,8 @@ function buildPieScene(chart, wPt, hPt, measure) {
 		wedges,
 		labels
 	};
-	let top = 4;
-	if (chart.title) top += 13 * 1.6;
+	const title = titleLines(chart, wPt, measure);
+	const top = 4 + titleHeight(title);
 	const legend = layoutLegend(values.map((_, i) => ({
 		name: chart.categories[i] ?? String(i + 1),
 		colorHex: sliceColor(series, i, chart.seriesColorCycle)
@@ -895,14 +992,7 @@ function buildPieScene(chart, wPt, hPt, measure) {
 		sweepRad: -2 * Math.PI,
 		fillHex: "FFFFFF"
 	});
-	if (chart.title) labels.push({
-		text: chart.title,
-		x: wPt / 2,
-		y: hPt - 4 - 13,
-		sizePt: 13,
-		colorHex: TITLE_COLOR,
-		align: "center"
-	});
+	pushChartTitle(labels, title, wPt, hPt);
 	legend.emit(rects, labels);
 	return {
 		rects,
@@ -1014,7 +1104,7 @@ function withReversedCategories(chart) {
 	const flip = (i) => n - 1 - i;
 	return {
 		...chart,
-		categories: chart.categories.length > 0 ? Array.from({ length: n }, (_, i) => chart.categories[flip(i)] ?? "") : chart.categories,
+		categories: Array.from({ length: n }, (_, i) => chart.categories.length > 0 ? chart.categories[flip(i)] ?? "" : String(flip(i) + 1)),
 		series: chart.series.map((s) => ({
 			...s,
 			values: Array.from({ length: n }, (_, i) => s.values[flip(i)] ?? 0),

package/dist/esm/core/drawingml/chart-parser.js

@@ -71,10 +71,13 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 	const secondaryValAxisTitle = secondaryTitleNode ? collectAT(secondaryTitleNode) || "Axis Title" : void 0;
 	let categories = [];
 	let categoriesRef;
+	let categoryGroups;
 	for (const s of serNodes) {
 		const cat = poChildren(s).find((c) => poIs(c, "c:cat"));
 		if (cat) {
-			categories = denseStrings(cat);
+			const levels = multiLevelCategories(cat);
+			categories = levels ? levels.categories : denseStrings(cat);
+			categoryGroups = levels?.groups;
 			categoriesRef ??= refFormula(cat);
 			break;
 		}
@@ -99,7 +102,12 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 	const gridLine = lineStyleOf(leftAxNode ? poChildren(leftAxNode).find((c) => poIs(c, "c:majorGridlines")) : void 0, resolveColor);
 	const valAxisMin = axisScaling(plotArea, "c:min");
 	const valAxisMax = axisScaling(plotArea, "c:max");
+	const valAxisMajorUnit = majorUnitOf(plotArea);
 	const catAxisReversed = axisOrientation(catAxNode) === "maxMin";
+	const catAxisCrosses = axisCrossing(catAxNode);
+	const valAxisCrosses = axisCrossing(valAxNode);
+	const tickLblPos = catAxNode ? poVal(poChildren(catAxNode).find((c) => poIs(c, "c:tickLblPos"))) : void 0;
+	const catTickLabelPos = tickLblPos === "low" || tickLblPos === "high" || tickLblPos === "none" ? tickLblPos : void 0;
 	const chartSpace = tree.find((c) => poIs(c, "c:chartSpace"));
 	const spaceSpPr = poChildren(chartSpace).find((c) => poIs(c, "c:spPr"));
 	const frameLine = spaceSpPr ? poChildren(spaceSpPr).find((c) => poIs(c, "a:ln")) : void 0;
@@ -123,6 +131,7 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 		...Number.isFinite(gapPercent) && gapPercent >= 0 ? { gapPercent } : {},
 		categories,
 		...categoriesRef ? { categoriesRef } : {},
+		...categoryGroups && categoryGroups.length > 0 ? { categoryGroups } : {},
 		series,
 		hasLegend: legend !== void 0,
 		...isLegendPos(legendPos) ? { legendPos } : {},
@@ -132,6 +141,9 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 		...showValues ? { showValues: true } : {},
 		...catAxisTitle ? { catAxisTitle } : {},
 		...catAxisReversed ? { catAxisReversed } : {},
+		...catAxisCrosses !== void 0 ? { catAxisCrosses } : {},
+		...valAxisCrosses !== void 0 ? { valAxisCrosses } : {},
+		...catTickLabelPos ? { catTickLabelPos } : {},
 		...valAxisTitle ? { valAxisTitle } : {},
 		...secondaryValAxisTitle ? { secondaryValAxisTitle } : {},
 		...scatterStyle ? { scatterStyle } : {},
@@ -142,6 +154,7 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 		...gridLine ? { gridLine } : {},
 		...valAxisMin !== void 0 ? { valAxisMin } : {},
 		...valAxisMax !== void 0 ? { valAxisMax } : {},
+		...valAxisMajorUnit !== void 0 ? { valAxisMajorUnit } : {},
 		...frameFillHex ? { frameFillHex } : {},
 		...frameFillImage ? { frameFillImage } : {},
 		...frameLineHex ? { frameLineHex } : {},
@@ -298,9 +311,16 @@ function fillColorOf(spPr, resolveColor) {
 	const lnFill = ln ? poChildren(ln).find((c) => poIs(c, "a:solidFill")) : void 0;
 	return lnFill ? colorFromSolidFill(lnFill, resolveColor) : void 0;
 }
+/** The colour elements a chart's fill names a colour by (§20.1.2.3). */
+var CHART_COLOR_NODES = [
+	"a:srgbClr",
+	"a:schemeClr",
+	"a:sysClr",
+	"a:prstClr"
+];
 function colorFromSolidFill(solid, resolveColor) {
 	for (const c of poChildren(solid)) {
-		if (!poIs(c, "a:srgbClr") && !poIs(c, "a:schemeClr")) continue;
+		if (!CHART_COLOR_NODES.some((name) => poIs(c, name))) continue;
 		if (!poAttr(c, "val")) continue;
 		return resolveColorNode(c, resolveColor);
 	}
@@ -374,10 +394,30 @@ function axisTitle(plotArea, axTag) {
 * does not carry — those keep the plain numeric render.
 */
 /** §21.2.2.134 `c:scaling/c:orientation` — `minMax` (the default) or `maxMin`. */
+/**
+* §21.2.2.33/§21.2.2.34 — where an axis crosses the one it is drawn against:
+* `crossesAt` a value, or `crosses` at that axis's minimum or maximum.
+* undefined for `autoZero`, the default.
+*/
+function axisCrossing(ax) {
+	if (!ax) return void 0;
+	const at = poChildren(ax).find((c) => poIs(c, "c:crossesAt"));
+	const value = at ? Number(poAttr(at, "val")) : NaN;
+	if (Number.isFinite(value)) return value;
+	const crosses = poVal(poChildren(ax).find((c) => poIs(c, "c:crosses")));
+	return crosses === "min" || crosses === "max" ? crosses : void 0;
+}
 function axisOrientation(ax) {
 	const scaling = ax ? poChildren(ax).find((c) => poIs(c, "c:scaling")) : void 0;
 	return scaling ? poVal(poChildren(scaling).find((c) => poIs(c, "c:orientation"))) : void 0;
 }
+/** §21.2.2.98 `c:valAx/c:majorUnit` — a positive step, or undefined for "auto". */
+function majorUnitOf(plotArea) {
+	const ax = poChildren(plotArea).find((c) => poIs(c, "c:valAx"));
+	const node = ax ? poChildren(ax).find((c) => poIs(c, "c:majorUnit")) : void 0;
+	const v = node ? Number(poAttr(node, "val")) : NaN;
+	return Number.isFinite(v) && v > 0 ? v : void 0;
+}
 function axisScaling(plotArea, tag) {
 	const ax = poChildren(plotArea).find((c) => poIs(c, "c:valAx"));
 	const scaling = ax ? poChildren(ax).find((c) => poIs(c, "c:scaling")) : void 0;
@@ -489,6 +529,37 @@ function denseStrings(container) {
 	for (const p of pts) arr[p.idx] = p.v;
 	return arr;
 }
+/**
+* §21.2.2.115 `c:multiLvlStrCache` — categories labelled on several levels:
+* the first `c:lvl` labels each category, every later one groups them, a
+* group's label standing at the category it starts at. Read as one flat cache
+* it read as none, and an xlsx chart fell back to the cells its reference
+* names, both columns of them in turn: WithChartSheet.xlsx's six bars stood in
+* the first six of sixteen slots under a jumble of years and measure names.
+*
+* @param cat The `c:cat` element.
+* @returns The innermost labels and the outer levels' groups, or undefined
+*   for a category axis of one level.
+*/
+function multiLevelCategories(cat) {
+	const cache = poFindDescendant(cat, "c:multiLvlStrCache");
+	if (!cache) return void 0;
+	const count = poIntAttr(poChildren(cache).find((c) => poIs(c, "c:ptCount")) ?? cache, "val") ?? 0;
+	const [inner, ...outer] = poChildren(cache).filter((c) => poIs(c, "c:lvl")).map((lvl) => poChildren(lvl).filter((pt) => poIs(pt, "c:pt")).map((pt) => {
+		const v = poChildren(pt).find((c) => poIs(c, "c:v"));
+		return {
+			start: poIntAttr(pt, "idx") ?? 0,
+			label: v ? poText(v) : ""
+		};
+	}));
+	if (!inner) return void 0;
+	const categories = new Array(Math.max(count, ...inner.map((p) => p.start + 1))).fill("");
+	for (const p of inner) categories[p.start] = p.label;
+	return {
+		categories,
+		groups: outer.map((level) => [...level].sort((a, b) => a.start - b.start))
+	};
+}
 function isLegendPos(v) {
 	return v === "r" || v === "l" || v === "t" || v === "b";
 }

package/dist/esm/core/drawingml/colors.d.ts

@@ -40,6 +40,12 @@ export declare function applyColorMods(hex: string, mods: ReadonlyArray<ColorMod
  * scheme slots when a document carries no custom theme part.
  */
 export declare const DEFAULT_THEME_PALETTE: ReadonlyMap<string, string>;
+/**
+ * The Office 2023 theme's palette — what Excel colours a workbook that carries
+ * no theme part with. Its own PDF of theme slots 0…9 in such a workbook
+ * (2026-10-01) paints exactly these: accent1 is 156082, not 2013's 4472C4.
+ */
+export declare const OFFICE_2023_THEME_PALETTE: ReadonlyMap<string, string>;
 /**
  * Which theme slot each `schemeClr` name stands for. Only the text/background
  * aliases are ever remapped; anything absent resolves under its own name.