@office-kit/xlsx 0.16.0 → 0.18.0

package/dist/streaming.mjs

@@ -1,61 +1,35 @@
 import { i as OpenXmlIoError, o as OpenXmlSchemaError } from "./exceptions-D-CFwxgm.mjs";
-import { s as coordinateToTuple } from "./coordinate-Bt5Gni2I.mjs";
+import { _ as rowNumberFromAttr, c as derivedRowNumber, s as coordinateToTuple } from "./coordinate-CxC88uBk.mjs";
 import { t as ERROR_CODES } from "./inference-BMvv9cUY.mjs";
-import { i as unescapeCellString, n as escapeXmlAttr } from "./escape-rnWSPpWY.mjs";
-import { _ as ARC_WORKBOOK_RELS, a as findChildren, c as ARC_CONTENT_TYPES, f as ARC_ROOT_RELS, ft as SHEET_MAIN_NS, g as ARC_WORKBOOK, i as findChild, lt as REL_NS, m as ARC_STYLE, p as ARC_SHARED_STRINGS, pt as STYLES_TYPE, ut as SHARED_STRINGS_TYPE, wt as XLSX_TYPE, yt as WORKSHEET_TYPE } from "./tree-BX-sRRVp.mjs";
-import { t as stylesheetToBytes, v as serializeCell } from "./stylesheet-writer-oXSuGnJy.mjs";
-import { t as parseXml } from "./parser-By6RWZVW.mjs";
-import { Q as findById, a as makeManifest, n as addOverride, nt as relsFromBytes, o as manifestFromBytes, rt as relsToBytes, s as manifestToBytes, t as addDefault, tt as makeRelationships } from "./manifest-pLmx7KYh.mjs";
-import { ct as buildXfPatch, ht as makeStylesheet, it as addCellXf, lt as defaultCellXf } from "./cell-style-CNsET6WU.mjs";
-import { A as serializeRichString, D as makeSharedStrings, S as validateSheetTitle, k as parseSharedStringsXml } from "./workbook-DOTFzCpz.mjs";
-import { i as parseStylesheetXml, n as parseDate1904, r as resolveRelTarget } from "./load-B1sK-LjT.mjs";
-import { t as openZip } from "./reader-DHMxLBQV.mjs";
+import { a as unescapeCellString, n as escapeXmlAttr } from "./escape-rA5UpibT.mjs";
+import { Tt as XLSX_TYPE, _ as ARC_WORKBOOK_RELS, bt as WORKSHEET_TYPE, c as ARC_CONTENT_TYPES, f as ARC_ROOT_RELS, ft as SHEET_MAIN_NS, g as ARC_WORKBOOK, jt as localNameOf, lt as REL_NS, m as ARC_STYLE, mt as STYLES_TYPE, p as ARC_SHARED_STRINGS, ut as SHARED_STRINGS_TYPE } from "./tree-CspNjuYl.mjs";
+import { t as stylesheetToBytes, v as serializeCell, x as parseCellNumber } from "./stylesheet-writer-BEn-0P0x.mjs";
+import { n as parseXml } from "./parser-B1tB9YaE.mjs";
+import { r as parseXsdBoolean } from "./serialize-BtxgssFK.mjs";
+import { $ as findByType, Q as findById, a as makeManifest, n as addOverride, nt as relsFromBytes, o as manifestFromBytes, rt as relsToBytes, s as manifestToBytes, t as addDefault, tt as makeRelationships } from "./manifest-9p0ccqmR.mjs";
+import { A as parseSharedStringsXml, C as validateSheetTitle, F as assertNotStrictRoot, O as makeSharedStrings, P as assertNotStrictRelTypes, j as serializeRichString } from "./workbook-tG9oYtzU.mjs";
+import { ct as buildXfPatch, ht as makeStylesheet, it as addCellXf, lt as defaultCellXf } from "./cell-style-CbB4nXTY.mjs";
+import { c as readOptionalWorkbookPart, i as WORKBOOK_TAG, l as resolveRelTarget, n as SHARED_STRINGS_PART, o as parseDate1904, r as STYLES_PART, s as parseSheetEntries, t as OFFICE_DOC_REL_TYPE, u as parseStylesheetXml } from "./load-BpnCPv1S.mjs";
+import { t as openZip } from "./reader-pC7bxYAs.mjs";
 import { t as utf8ByteLength } from "./utf8-OAkCDG5g.mjs";
 import { t as createZipWriter } from "./writer-C38RBZCy.mjs";
-import { t as iterParse } from "./iterparse-DZE0zy2M.mjs";
+import { t as iterParse } from "./iterparse-CZoRXvZW.mjs";
 //#region src/streaming/read-only.ts
-const SHEET_TAG = `{${SHEET_MAIN_NS}}sheet`;
-const SHEETS_TAG = `{${SHEET_MAIN_NS}}sheets`;
-const parseSheetList = (root, workbookPath, archive) => {
-	const sheetsEl = findChild(root, SHEETS_TAG);
-	if (!sheetsEl) return [];
-	const wbRelsPath = relsPathFor(workbookPath);
-	const wbRels = archive.has(wbRelsPath) ? relsFromBytes(archive.read(wbRelsPath)) : { rels: [] };
-	const out = [];
-	for (const sheet of findChildren(sheetsEl, SHEET_TAG)) {
-		const name = sheet.attrs["name"];
-		const rId = sheet.attrs[`{${REL_NS}}id`];
-		if (!name || !rId) continue;
-		const rel = findById(wbRels, rId);
-		if (!rel) continue;
-		const partPath = resolveRelTarget(workbookPath, rel.target);
-		out.push({
-			name,
-			rId,
-			partPath
-		});
-	}
-	return out;
-};
 const relsPathFor = (partPath) => {
 	const i = partPath.lastIndexOf("/");
 	if (i < 0) return `_rels/${partPath}.rels`;
 	return `${partPath.slice(0, i)}/_rels/${partPath.slice(i + 1)}.rels`;
 };
-const localName = (qname) => {
-	const i = qname.lastIndexOf("}");
-	return i < 0 ? qname : qname.slice(i + 1);
-};
-const decodeCellValue = (t, vText, inlineText, sst) => {
+const decodeCellValue = (t, vText, inlineText, sst, sheet, col, row) => {
 	switch (t) {
-		case "n": return vText !== void 0 && vText !== "" ? Number.parseFloat(vText) : null;
+		case "n": return parseCellNumber(vText, sheet, col, row);
 		case "s": {
 			if (vText === void 0) return null;
 			const idx = Number.parseInt(vText, 10);
 			if (!Number.isInteger(idx) || idx < 0 || idx >= sst.length) return null;
 			return sst[idx] ?? null;
 		}
-		case "b": return vText === "1";
+		case "b": return parseXsdBoolean(vText) ?? null;
 		case "e":
 			if (!vText || !ERROR_CODES.has(vText)) return null;
 			return {
@@ -71,15 +45,37 @@ const decodeCellValue = (t, vText, inlineText, sst) => {
 * SAX-iterate `<sheetData>/<row>/<c>` events out of the worksheet bytes (or a
 * stream that yields them), yielding one `ReadOnlyCell[]` per row that matches
 * `opts`.
+*
+* `readSheetData` in `../worksheet/reader.ts` walks the same element shapes for
+* `loadWorkbook`. The two stay separate because this one is an async generator
+* over a stream with a row band and an early exit, and that per-event cost is
+* what the other one exists to avoid. Where a row or cell with no `@r` lands
+* has to come out the same in both, and is asserted to: see "agrees with
+* loadWorkbook on where every cell lands" in
+* `tests/worksheet/row-without-r-attribute.test.ts`.
 */
-async function* iterSheetRows(sheetInput, sst, opts) {
+async function* iterSheetRows(title, sheetInput, sst, opts) {
 	const minRow = opts.minRow ?? 1;
 	const maxRow = opts.maxRow ?? Number.POSITIVE_INFINITY;
 	const minCol = opts.minCol ?? 1;
 	const maxCol = opts.maxCol ?? Number.POSITIVE_INFINITY;
 	let inSheetData = false;
 	let currentRow = -1;
+	let nextRow = 1;
 	let currentCells = [];
+	let nextCol = 1;
+	let pendingCells = [];
+	const settleRow = (row) => {
+		currentRow = row;
+		nextRow = Math.max(nextRow, row + 1);
+		if (row >= minRow && row <= maxRow) for (const cell of pendingCells) currentCells.push({
+			row,
+			col: cell.col,
+			value: decodeCellValue(cell.type, cell.text, cell.inline, sst, title, cell.col, row),
+			styleId: cell.styleId
+		});
+		pendingCells = [];
+	};
 	let cellOpen = false;
 	let cellRow = 0;
 	let cellCol = 0;
@@ -91,38 +87,50 @@ async function* iterSheetRows(sheetInput, sst, opts) {
 	let inIsT = false;
 	let isText = "";
 	let isRunText = "";
+	let checkedRoot = false;
 	for await (const ev of iterParse(sheetInput)) {
 		const e = ev;
 		if (e.kind === "start") {
-			const local = localName(e.name);
+			if (!checkedRoot) {
+				assertNotStrictRoot(e.name);
+				checkedRoot = true;
+			}
+			const local = localNameOf(e.name);
 			if (!inSheetData) {
 				if (local === "sheetData") inSheetData = true;
 				continue;
 			}
 			switch (local) {
 				case "row": {
-					e.attrs;
 					const rRaw = e.attrs["r"];
-					currentRow = rRaw ? Number.parseInt(rRaw, 10) : currentRow + 1;
+					if (rRaw === void 0) currentRow = 0;
+					else {
+						currentRow = rowNumberFromAttr(rRaw, "loadWorkbookStream");
+						nextRow = Math.max(nextRow, currentRow + 1);
+					}
 					currentCells = [];
+					pendingCells = [];
+					nextCol = 1;
 					break;
 				}
 				case "c": {
 					if (currentRow < 0) break;
-					if (currentRow < minRow || currentRow > maxRow) break;
+					const ref = e.attrs["r"];
+					if (currentRow === 0 && ref) settleRow(coordinateToTuple(ref).row);
+					if (currentRow !== 0 && (currentRow < minRow || currentRow > maxRow)) break;
 					cellOpen = true;
 					cellType = e.attrs["t"] ?? "n";
 					const sRaw = e.attrs["s"];
 					cellStyleId = sRaw ? Number.parseInt(sRaw, 10) || 0 : 0;
-					const ref = e.attrs["r"];
 					if (ref) {
 						const tup = coordinateToTuple(ref);
 						cellRow = tup.row;
 						cellCol = tup.col;
 					} else {
 						cellRow = currentRow;
-						cellCol = (currentCells[currentCells.length - 1]?.col ?? 0) + 1;
+						cellCol = nextCol;
 					}
+					nextCol = cellCol + 1;
 					vText = "";
 					isText = "";
 					break;
@@ -148,13 +156,14 @@ async function* iterSheetRows(sheetInput, sst, opts) {
 			else if (inIsT) isRunText += e.text;
 			continue;
 		}
-		const local = localName(e.name);
+		const local = localNameOf(e.name);
 		if (!inSheetData) continue;
 		switch (local) {
 			case "sheetData":
 				inSheetData = false;
 				return;
 			case "row":
+				if (currentRow === 0) settleRow(derivedRowNumber(nextRow, "loadWorkbookStream"));
 				if (currentRow >= minRow && currentRow <= maxRow && currentCells.length > 0) yield currentCells;
 				if (currentRow > maxRow) {
 					inSheetData = false;
@@ -164,8 +173,15 @@ async function* iterSheetRows(sheetInput, sst, opts) {
 				currentCells = [];
 				break;
 			case "c":
-				if (cellOpen && cellCol >= minCol && cellCol <= maxCol && cellRow >= minRow && cellRow <= maxRow) {
-					const value = decodeCellValue(cellType, vText, isText, sst);
+				if (cellOpen && cellRow === 0 && cellCol >= minCol && cellCol <= maxCol) pendingCells.push({
+					col: cellCol,
+					type: cellType,
+					text: vText,
+					inline: isText,
+					styleId: cellStyleId
+				});
+				else if (cellOpen && cellCol >= minCol && cellCol <= maxCol && cellRow >= minRow && cellRow <= maxRow) {
+					const value = decodeCellValue(cellType, vText, isText, sst, title, cellCol, cellRow);
 					currentCells.push({
 						row: cellRow,
 						col: cellCol,
@@ -194,7 +210,9 @@ async function* iterSheetRows(sheetInput, sst, opts) {
 const isXmlSpace = (b) => b === 32 || b === 9 || b === 10 || b === 13;
 /**
 * Read the `r="N"` row number out of a `<row …>` attribute region, scanning
-* bytes directly. Returns -1 when the attribute is absent or malformed.
+* bytes directly. Returns -1 when the attribute is absent, or holds anything
+* `parseRowNumberAttr` rejects: the two accept the same shapes, so the index
+* can never seek by a number the SAX walk reads differently.
 *
 * Decoding the region to a string and running a regex instead costs one
 * TextDecoder, one string and one match array per row, which on a million-row
@@ -204,9 +222,11 @@ const readRowAttr = (bytes, from, to) => {
 	for (let p = from; p + 3 < to; p++) {
 		if (!isXmlSpace(bytes[p])) continue;
 		if (bytes[p + 1] !== 114 || bytes[p + 2] !== 61 || bytes[p + 3] !== 34) continue;
+		let q = p + 4;
+		while (q < to && isXmlSpace(bytes[q])) q++;
+		if (bytes[q] === 43) q++;
 		let value = 0;
 		let digits = 0;
-		let q = p + 4;
 		while (q < to) {
 			const d = bytes[q];
 			if (d === void 0 || d < 48 || d > 57) break;
@@ -214,7 +234,8 @@ const readRowAttr = (bytes, from, to) => {
 			digits++;
 			q++;
 		}
-		if (digits > 0 && q < to && bytes[q] === 34) return value;
+		while (q < to && isXmlSpace(bytes[q])) q++;
+		if (digits > 0 && value >= 1 && value <= 1048576 && q < to && bytes[q] === 34) return value;
 	}
 	return -1;
 };
@@ -277,9 +298,14 @@ const findSheetDataTagEnd = (bytes) => {
 * `sheetDataEnd` is the byte offset of `</sheetData>` so callers can clip the
 * region that gets handed to saxes. `sheetDataTagEnd` includes the original
 * namespace-bearing ancestor tags, reused by {@link replayFromRow}.
+*
+* `hasUnnumberedRow` reports a `<row>` this scan cannot number, which makes the
+* whole sheet unseekable: a row without `@r` takes the row its first cell
+* names, and reading cell refs is the SAX walk's job.
 */
 const buildRowOffsetIndex = (bytes) => {
 	const out = [];
+	let hasUnnumberedRow = false;
 	let sheetDataEnd = -1;
 	let i = 0;
 	while (i < bytes.length) {
@@ -309,13 +335,15 @@ const buildRowOffsetIndex = (bytes) => {
 			row,
 			offset: start
 		});
+		else hasUnnumberedRow = true;
 		i = j + 1;
 	}
 	if (sheetDataEnd < 0) sheetDataEnd = bytes.length;
 	return {
 		index: out,
 		sheetDataEnd,
-		sheetDataTagEnd: findSheetDataTagEnd(bytes)
+		sheetDataTagEnd: findSheetDataTagEnd(bytes),
+		hasUnnumberedRow
 	};
 };
 /**
@@ -365,7 +393,9 @@ const replayFromRow = (bytes, sheetDataTagEnd, fromOffset, sheetDataEnd) => {
 * `iterRows({ minRow > 1 })` needs random access instead, so the first band
 * query inflates the part and indexes its row offsets, and holds both for the
 * life of the worksheet handle or until the workbook closes. Subsequent band
-* queries jump straight to the first matching row without inflating or scanning again.
+* queries jump straight to the first matching row without inflating or scanning
+* again. A sheet whose rows omit `@r` cannot be indexed by row number, so its
+* band queries keep streaming and hold nothing.
 */
 const makeStreamingReadOnlyWorksheet = (title, archive, partPath, sst, indexes) => {
 	const cacheKey = {};
@@ -373,9 +403,13 @@ const makeStreamingReadOnlyWorksheet = (title, archive, partPath, sst, indexes)
 		let cached = indexes.byWorksheet.get(cacheKey);
 		if (!cached) {
 			const bytes = archive.read(partPath);
-			cached = {
+			const { hasUnnumberedRow, index, sheetDataEnd, sheetDataTagEnd } = buildRowOffsetIndex(bytes);
+			cached = hasUnnumberedRow ? { seekable: false } : {
+				seekable: true,
 				bytes,
-				...buildRowOffsetIndex(bytes)
+				index,
+				sheetDataEnd,
+				sheetDataTagEnd
 			};
 			indexes.byWorksheet.set(cacheKey, cached);
 		}
@@ -383,14 +417,16 @@ const makeStreamingReadOnlyWorksheet = (title, archive, partPath, sst, indexes)
 	};
 	const iterRows = (opts = {}) => {
 		const minRow = opts.minRow ?? 1;
-		if (minRow <= 1) return iterSheetRows(archive.readStream(partPath), sst, opts);
-		const { bytes, index, sheetDataEnd, sheetDataTagEnd } = ensureIndexed();
-		if (index.length === 0 || sheetDataTagEnd < 0) return iterSheetRows(bytes, sst, opts);
+		if (minRow <= 1) return iterSheetRows(title, archive.readStream(partPath), sst, opts);
+		const seek = ensureIndexed();
+		if (!seek.seekable) return iterSheetRows(title, archive.readStream(partPath), sst, opts);
+		const { bytes, index, sheetDataEnd, sheetDataTagEnd } = seek;
+		if (index.length === 0 || sheetDataTagEnd < 0) return iterSheetRows(title, bytes, sst, opts);
 		const pos = firstRowAtOrAfter(index, minRow);
 		if (pos < 0) return (async function* () {})();
 		const target = index[pos];
-		if (!target) return iterSheetRows(bytes, sst, opts);
-		return iterSheetRows(replayFromRow(bytes, sheetDataTagEnd, target.offset, sheetDataEnd), sst, opts);
+		if (!target) return iterSheetRows(title, bytes, sst, opts);
+		return iterSheetRows(title, replayFromRow(bytes, sheetDataTagEnd, target.offset, sheetDataEnd), sst, opts);
 	};
 	const iterValues = async function* (opts = {}) {
 		for await (const row of iterRows(opts)) yield row.map((c) => c.value);
@@ -406,16 +442,16 @@ const makeStreamingReadOnlyWorksheet = (title, archive, partPath, sst, indexes)
 * sheet list / styles / shared strings. Per the project-wide "no classes" rule
 * (CLAUDE.md), the workbook is a plain object closing over the archive handle.
 */
-const makeStreamingReadOnlyWorkbook = (sheetNames, styles, date1904, archive, entries, sst) => {
+const makeStreamingReadOnlyWorkbook = (sheetNames, styles, date1904, archive, partPathByName, sst) => {
 	const indexes = { byWorksheet: /* @__PURE__ */ new WeakMap() };
 	return {
 		sheetNames,
 		styles,
 		date1904,
 		openWorksheet(name) {
-			const entry = entries.get(name);
-			if (!entry) throw new OpenXmlSchemaError(`loadWorkbookStream: no worksheet named "${name}"`);
-			return makeStreamingReadOnlyWorksheet(name, archive, entry.partPath, sst, indexes);
+			const partPath = partPathByName.get(name);
+			if (partPath === void 0) throw new OpenXmlSchemaError(`loadWorkbookStream: no worksheet named "${name}"`);
+			return makeStreamingReadOnlyWorksheet(name, archive, partPath, sst, indexes);
 		},
 		async close() {
 			archive.close();
@@ -429,19 +465,35 @@ async function loadWorkbookStream(source, opts = {}) {
 	if (!archive.has("[Content_Types].xml")) throw new OpenXmlSchemaError(`loadWorkbookStream: missing "${ARC_CONTENT_TYPES}"`);
 	manifestFromBytes(archive.read(ARC_CONTENT_TYPES));
 	if (!archive.has(ARC_ROOT_RELS)) throw new OpenXmlSchemaError(`loadWorkbookStream: missing "${ARC_ROOT_RELS}"`);
-	const officeDocRel = relsFromBytes(archive.read(ARC_ROOT_RELS)).rels.find((r) => r.type === `${REL_NS}/officeDocument`);
-	if (!officeDocRel) throw new OpenXmlSchemaError(`loadWorkbookStream: no officeDocument relationship in root rels`);
+	const rootRels = relsFromBytes(archive.read(ARC_ROOT_RELS));
+	const officeDocRel = findByType(rootRels, OFFICE_DOC_REL_TYPE);
+	if (!officeDocRel) {
+		assertNotStrictRelTypes(rootRels.rels.map((r) => r.type));
+		throw new OpenXmlSchemaError(`loadWorkbookStream: no officeDocument relationship in root rels`);
+	}
 	const workbookPath = resolveRelTarget("", officeDocRel.target);
 	if (!archive.has(workbookPath)) throw new OpenXmlSchemaError(`loadWorkbookStream: workbook part "${workbookPath}" missing`);
 	const workbookRoot = parseXml(archive.read(workbookPath));
-	const sheetEntries = parseSheetList(workbookRoot, workbookPath, archive);
-	const entryMap = /* @__PURE__ */ new Map();
-	for (const e of sheetEntries) entryMap.set(e.name, e);
-	let sst = makeSharedStrings();
-	if (archive.has(ARC_SHARED_STRINGS)) sst = parseSharedStringsXml(archive.read(ARC_SHARED_STRINGS));
-	let styles = makeStylesheet();
-	if (archive.has(ARC_STYLE)) styles = parseStylesheetXml(archive.read(ARC_STYLE));
-	return makeStreamingReadOnlyWorkbook(sheetEntries.map((e) => e.name), styles, parseDate1904(workbookRoot), archive, entryMap, sst.entries.map((e) => typeof e === "string" ? e : e.runs.map((r) => r.text).join("")));
+	if (workbookRoot.name !== WORKBOOK_TAG) {
+		assertNotStrictRoot(workbookRoot.name);
+		throw new OpenXmlSchemaError(`loadWorkbookStream: ${workbookPath} root is "${workbookRoot.name}", expected workbook`);
+	}
+	const declaredSheets = parseSheetEntries(workbookRoot);
+	const wbRelsPath = relsPathFor(workbookPath);
+	if (declaredSheets.length > 0 && !archive.has(wbRelsPath)) throw new OpenXmlSchemaError(`loadWorkbookStream: workbook has sheets but rels part "${wbRelsPath}" is missing`);
+	const wbRels = archive.has(wbRelsPath) ? relsFromBytes(archive.read(wbRelsPath)) : makeRelationships();
+	const partPathByName = /* @__PURE__ */ new Map();
+	for (const declared of declaredSheets) {
+		if (partPathByName.has(declared.name)) throw new OpenXmlSchemaError(`loadWorkbookStream: duplicate sheet name "${declared.name}"`);
+		const rel = findById(wbRels, declared.rId);
+		if (!rel) throw new OpenXmlSchemaError(`loadWorkbookStream: sheet "${declared.name}" rId "${declared.rId}" has no matching rels entry`);
+		partPathByName.set(declared.name, resolveRelTarget(workbookPath, rel.target));
+	}
+	const sstBytes = readOptionalWorkbookPart(archive, workbookPath, wbRels, SHARED_STRINGS_PART);
+	const sst = sstBytes === void 0 ? makeSharedStrings() : parseSharedStringsXml(sstBytes);
+	const stylesBytes = readOptionalWorkbookPart(archive, workbookPath, wbRels, STYLES_PART);
+	const styles = stylesBytes === void 0 ? makeStylesheet() : parseStylesheetXml(stylesBytes);
+	return makeStreamingReadOnlyWorkbook(declaredSheets.map((e) => e.name), styles, parseDate1904(workbookRoot), archive, partPathByName, sst.entries.map((e) => typeof e === "string" ? e : e.runs.map((r) => r.text).join("")));
 }
 //#endregion
 //#region src/streaming/string-table.ts