reamkit 1.32.0 → 1.32.1

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

@@ -25,6 +25,27 @@ var TYPE_OF_TAG = {
 	"c:scatterChart": "scatter"
 };
 /**
+* The most points a chart keeps, all its series together: as many as a sheet
+* has rows, the longest range a series can name. A chart part states its own
+* point counts — a cache's `c:ptCount`, each point's `idx`, the range of a
+* `c:f` — and taken at their word, a count of two billion in a part a few
+* hundred bytes long asked for a dense array that ran the process out of
+* memory, and one past 2³² − 1 threw.
+*/
+var MOST_CHART_POINTS = 1048576;
+/**
+* How many points each of a chart's `seriesCount` series keeps: an even share
+* of {@link MOST_CHART_POINTS}, so that the bound holds for the chart and not
+* series by series — two thousand series, each declaring a sheet's worth of
+* points, are two billion. A series' points past its share are not read.
+*
+* @param seriesCount How many series the chart has.
+* @returns The points each keeps, at least one.
+*/
+function pointsPerSeries(seriesCount) {
+	return Math.max(1, Math.floor(MOST_CHART_POINTS / Math.max(1, seriesCount)));
+}
+/**
 * Parse a DrawingML chart part (chart1.xml) into a {@link Chart}, reading the
 * CACHED data (`c:numCache` / `c:strCache`) rather than the embedded spreadsheet
 * — the cache holds the last-computed categories and values, exactly what Word
@@ -48,6 +69,7 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 	const type = group ? TYPE_OF_TAG[poTag(group)] ?? "unknown" : "unknown";
 	const groupAxIds = (g) => poChildren(g).filter((c) => poIs(c, "c:axId")).map((c) => poAttr(c, "val") ?? "");
 	const primaryAxIds = new Set(group ? groupAxIds(group) : []);
+	const most = pointsPerSeries(groups.reduce((n, g) => n + poChildren(g).filter((c) => poIs(c, "c:ser")).length, 0));
 	const serNodes = [];
 	const series = [];
 	let secondaryValAxId;
@@ -58,7 +80,7 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 		for (const s of poChildren(g).filter((c) => poIs(c, "c:ser"))) {
 			serNodes.push(s);
 			series.push({
-				...parseSeries(s, resolveColor),
+				...parseSeries(s, resolveColor, most),
 				...groupType === type ? {} : { type: groupType },
 				...secondary ? { secondaryAxis: true } : {}
 			});
@@ -75,8 +97,8 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 	for (const s of serNodes) {
 		const cat = poChildren(s).find((c) => poIs(c, "c:cat"));
 		if (cat) {
-			const levels = multiLevelCategories(cat);
-			categories = levels ? levels.categories : denseStrings(cat);
+			const levels = multiLevelCategories(cat, most);
+			categories = levels ? levels.categories : denseStrings(cat, most);
 			categoryGroups = levels?.groups;
 			categoriesRef ??= refFormula(cat);
 			break;
@@ -165,11 +187,11 @@ function parseChart(chartXml, resolveColor, resolveImage) {
 		...numberFormat ? { numberFormat } : {}
 	};
 }
-function parseSeries(ser, resolveColor) {
+function parseSeries(ser, resolveColor, most) {
 	const valNode = poChildren(ser).find((c) => poIs(c, "c:val")) ?? poChildren(ser).find((c) => poIs(c, "c:yVal"));
-	const values = valNode ? denseNumbers(valNode) : [];
+	const values = valNode ? denseNumbers(valNode, most) : [];
 	const xValNode = poChildren(ser).find((c) => poIs(c, "c:xVal"));
-	const xValues = xValNode ? denseNumbers(xValNode) : void 0;
+	const xValues = xValNode ? denseNumbers(xValNode, most) : void 0;
 	const name = seriesName(ser);
 	const colorHex = fillColorOf(poChildren(ser).find((c) => poIs(c, "c:spPr")), resolveColor);
 	const pointColors = dataPointColors(ser, resolveColor);
@@ -375,7 +397,7 @@ function cachedTitleText(title) {
 	const tx = poChildren(title).find((c) => poIs(c, "c:tx"));
 	const ref = tx ? poChildren(tx).find((c) => poIs(c, "c:strRef")) : void 0;
 	if (!ref) return void 0;
-	const cached = denseStrings(ref).filter((t) => t.length > 0);
+	const cached = denseStrings(ref, MOST_CHART_POINTS).filter((t) => t.length > 0);
 	return cached.length > 0 ? cached.join(" ") : void 0;
 }
 function axisTitle(plotArea, axTag) {
@@ -509,24 +531,36 @@ function ptCountOf(container) {
 	const pc = cache ? poChildren(cache).find((c) => poIs(c, "c:ptCount")) : void 0;
 	return pc ? poIntAttr(pc, "val") ?? 0 : 0;
 }
-function denseLength(container, pts) {
-	let max = ptCountOf(container);
-	for (const p of pts) max = Math.max(max, p.idx + 1);
-	return max;
+/** Whether `n` can index a point: a whole number from zero. */
+var isPointIndex = (n) => Number.isInteger(n) && n >= 0;
+/**
+* How many slots `count` points and those at `indexes` take — the count, or
+* past it the last of them, and never more than `most`. A count or an index
+* that is no whole number (2.5) asked for an array of no possible length and
+* threw; it counts for nothing.
+*/
+function denseLength(count, indexes, most) {
+	let length = isPointIndex(count) ? count : 0;
+	for (const idx of indexes) if (isPointIndex(idx)) length = Math.max(length, idx + 1);
+	return Math.min(length, most);
 }
-function denseNumbers(container) {
+/** A cache's values by point index, gaps 0, at most `most` of them. */
+function denseNumbers(container, most) {
 	const pts = readPts(container);
-	const arr = new Array(denseLength(container, pts)).fill(0);
+	const length = denseLength(ptCountOf(container), pts.map((p) => p.idx), most);
+	const arr = new Array(length).fill(0);
 	for (const p of pts) {
 		const n = Number(p.v);
-		if (Number.isFinite(n)) arr[p.idx] = n;
+		if (Number.isFinite(n) && isPointIndex(p.idx) && p.idx < length) arr[p.idx] = n;
 	}
 	return arr;
 }
-function denseStrings(container) {
+/** A cache's texts by point index, gaps empty, at most `most` of them. */
+function denseStrings(container, most) {
 	const pts = readPts(container);
-	const arr = new Array(denseLength(container, pts)).fill("");
-	for (const p of pts) arr[p.idx] = p.v;
+	const length = denseLength(ptCountOf(container), pts.map((p) => p.idx), most);
+	const arr = new Array(length).fill("");
+	for (const p of pts) if (isPointIndex(p.idx) && p.idx < length) arr[p.idx] = p.v;
 	return arr;
 }
 /**
@@ -537,11 +571,12 @@ function denseStrings(container) {
 * 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.
+* @param cat  The `c:cat` element.
+* @param most The most categories it keeps (see {@link pointsPerSeries}).
 * @returns The innermost labels and the outer levels' groups, or undefined
 *   for a category axis of one level.
 */
-function multiLevelCategories(cat) {
+function multiLevelCategories(cat, most) {
 	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;
@@ -553,11 +588,13 @@ function multiLevelCategories(cat) {
 		};
 	}));
 	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;
+	const length = denseLength(count, inner.map((p) => p.start), most);
+	const categories = new Array(length).fill("");
+	const kept = (p) => isPointIndex(p.start) && p.start < length;
+	for (const p of inner) if (kept(p)) categories[p.start] = p.label;
 	return {
 		categories,
-		groups: outer.map((level) => [...level].sort((a, b) => a.start - b.start))
+		groups: outer.map((level) => level.filter(kept).sort((a, b) => a.start - b.start))
 	};
 }
 function isLegendPos(v) {
@@ -636,4 +673,4 @@ var SCATTER_STYLES = new Set([
 ]);
 var REL_CHART_COLOR_STYLE = "http://schemas.microsoft.com/office/2011/relationships/chartColorStyle";
 //#endregion
-export { parseChart, withChartColorStyle };
+export { parseChart, pointsPerSeries, withChartColorStyle };

package/dist/esm/core/number-format.d.ts

@@ -50,25 +50,50 @@ export declare function excelSerialToDate(serial: number, date1904: boolean): Da
  */
 export declare function excelSerialFromUtcParts(year: number, month0: number, day: number, date1904: boolean): number;
 /**
- * A General number rounded to the decimals that fit `maxChars` characters.
+ * A General number in its column: the most precise of the ways General may
+ * write it ({@link generalRenderings}) that `fits`.
  *
- * General is not a fixed format: a spreadsheet shows as many decimal places as
- * the column has room for and ROUNDS to that, so 4.3900875881221957 in a
- * column eight characters wide reads 4.390088. We rendered every stored digit
- * and let the cell clip it, which turns the same value into 4.390087 — off by
- * one in the last place shown, with nothing to say a digit was cut.
+ * General is not a fixed format: a spreadsheet shows as many places as the
+ * column has room for and ROUNDS to that, so 4.3900875881221957 in a column
+ * eight characters wide reads 4.390088. We rendered every stored digit and let
+ * the cell clip it, which turns the same value into 4.390087 — off by one in
+ * the last place shown, with nothing to say a digit was cut. A number too wide
+ * for every way of writing it comes back in its finest, and the cell fills
+ * with `#` (CellProperties.hashOnOverflow); one under 1 always fits as `0` or
+ * `-0`, which is what Excel prints in a column too narrow for anything else.
  *
- * The integer part is never dropped: a number too wide even without decimals
- * keeps them all and the cell says so its own way (see hashOnOverflow).
- *
- * `fits` decides, and it must measure in the face this will be DRAWN in rather
- * than count characters against the column's width in the document's unit.
- * Counted that way we produced nine digits for a column that holds nine of
- * Excel's and eight of ours, and the layout clipped the ninth — the very
- * truncation this exists to prevent. Fewer digits than the reference shows is a
- * coarser number; a clipped one is a different number.
+ * `fits` decides whether a rendering has room. The print model asks it in the
+ * document's own terms — the column's width less the padding it carries, in
+ * the font's widest digits — because that is the room Excel gives up places
+ * against, whatever face the page is drawn in.
  *
  * @param rawValue The cell's stored value.
  * @param fits     Whether a rendering will fit the cell.
  */
 export declare function generalToWidth(rawValue: string, fits: (text: string) => boolean): string;
+/**
+ * Every way General may write `value` in `chars` characters, the most precise
+ * first. One rule, measured in Excel's own PDF on chart axes, which give it
+ * nine characters with the sign among them, and in cells, eleven with the
+ * sign apart (2026-10-01/02):
+ *
+ *  - the number as it is, its first 15 significant digits, where that fits:
+ *    0.000012345, 0.0000003, 12345678901;
+ *  - else rounded to fewer places or written in scientific notation, whichever
+ *    keeps the finer last digit — 0.123456789, not 1.23457E-01; 1.23457E-10,
+ *    not 0; 4E-04, not 0, in a column five characters wide — and of two as
+ *    fine, the plain one down to 0.0001 and the scientific one below it: 0.0001
+ *    for 0.000123456 but 1E-05 for 1.00049E-05;
+ *  - a whole part longer than the room only in scientific notation, and never
+ *    with the zeros a mantissa or a fraction ends in: 1E+10, 2.5E+12.
+ *
+ * The digits are the 15 of {@link decimalOf}, rounded half away from zero, so
+ * 1.2345E-05 is 1.235E-05, where `toExponential` rounded the binary double
+ * down to 1.234E-05.
+ *
+ * @param value      The number.
+ * @param chars      How many characters General has.
+ * @param signCounts Whether a minus sign takes one of them.
+ * @returns The renderings, sign included, finest first.
+ */
+export declare function generalRenderings(value: number, chars: number, signCounts?: boolean): Generator<string, void, undefined>;