documents.js 1.57.1 → 1.59.0

package/dist/layout/shared.cjs

@@ -0,0 +1,104 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let ooxml_js = require("ooxml.js");
+let pdf_codec = require("pdf-codec");
+let document_schema_js = require("document-schema.js");
+//#region src/layout/shared.ts
+const NOMINAL_TEXT_SIZE_PT = 18;
+const FALLBACK_ROW_HEIGHT_PT = 20;
+function runFont(run) {
+	return {
+		family: run.fontFamily ?? document_schema_js.DEFAULT_LAYOUT_FONT.family,
+		weight: run.bold === true ? "bold" : "normal",
+		style: run.italic === true ? "italic" : "normal"
+	};
+}
+function toStyledRuns(runs, fontScale = 1) {
+	return runs.map((run) => ({
+		text: run.text,
+		font: runFont(run),
+		sizePt: (run.sizePt ?? 18) * fontScale,
+		color: run.color ?? document_schema_js.COLOR_BLACK,
+		underline: run.underline,
+		hyperlink: run.hyperlink,
+		sourcePath: run.sourcePath
+	}));
+}
+function effectiveStyledRuns(runs, fontScale = 1) {
+	const styled = toStyledRuns(runs, fontScale);
+	return styled.length > 0 ? styled : [{
+		text: "",
+		font: document_schema_js.DEFAULT_LAYOUT_FONT,
+		sizePt: 18 * fontScale,
+		color: document_schema_js.COLOR_BLACK
+	}];
+}
+function lineNaturalHeightPt(line, measurer, fallback) {
+	if (line.fragments.length === 0) return measurer.lineHeightAtSize(fallback.font, fallback.sizePt);
+	let max = 0;
+	for (const fragment of line.fragments) max = Math.max(max, measurer.lineHeightAtSize(fragment.font, fragment.sizePt));
+	return max;
+}
+function alignmentOffsetPt(alignment, contentWidthPt, lineWidthPt) {
+	if (alignment === "center") return Math.max(0, (contentWidthPt - lineWidthPt) / 2);
+	if (alignment === "right") return Math.max(0, contentWidthPt - lineWidthPt);
+	return 0;
+}
+function decodeImageDimensions(format, bytes) {
+	if (format === "jpeg") {
+		const info = (0, pdf_codec.readJpegInfo)(bytes);
+		return {
+			widthPx: info.width,
+			heightPx: info.height
+		};
+	}
+	const raw = (0, pdf_codec.decodePng)(bytes);
+	return {
+		widthPx: raw.width,
+		heightPx: raw.height
+	};
+}
+function registerImage(block, images) {
+	const bytes = (0, ooxml_js.base64ToBytes)(block.base64);
+	const imageId = `img${(0, pdf_codec.crc32)(bytes).toString(16)}`;
+	if (!(imageId in images)) {
+		const { widthPx, heightPx } = decodeImageDimensions(block.format, bytes);
+		images[imageId] = {
+			format: block.format,
+			base64: block.base64,
+			widthPx,
+			heightPx
+		};
+	}
+	return imageId;
+}
+function sumColumnWidthsPt(columnWidthsPt, startIndex, span) {
+	let sum = 0;
+	for (let i = startIndex; i < startIndex + span && i < columnWidthsPt.length; i++) sum += columnWidthsPt[i] ?? 0;
+	return sum;
+}
+function estimateRowHeightPt(row, measurer, columnWidthsPt, scale) {
+	let max = FALLBACK_ROW_HEIGHT_PT;
+	let colIndex = 0;
+	for (const cell of row.cells) {
+		const span = cell.colSpan ?? 1;
+		const cellWidthPt = sumColumnWidthsPt(columnWidthsPt, colIndex, span) * scale;
+		for (const block of cell.blocks) {
+			if (block.kind !== "paragraph") continue;
+			const runs = effectiveStyledRuns(block.runs);
+			const lines = (0, pdf_codec.wrapRunsToWidth)(runs, measurer, cellWidthPt);
+			for (const line of lines) max = Math.max(max, lineNaturalHeightPt(line, measurer, runs[0]));
+		}
+		colIndex += span;
+	}
+	return max;
+}
+//#endregion
+exports.NOMINAL_TEXT_SIZE_PT = NOMINAL_TEXT_SIZE_PT;
+exports.alignmentOffsetPt = alignmentOffsetPt;
+exports.effectiveStyledRuns = effectiveStyledRuns;
+exports.estimateRowHeightPt = estimateRowHeightPt;
+exports.lineNaturalHeightPt = lineNaturalHeightPt;
+exports.registerImage = registerImage;
+exports.runFont = runFont;
+exports.sumColumnWidthsPt = sumColumnWidthsPt;
+exports.toStyledRuns = toStyledRuns;

package/dist/layout/shared.d.cts

@@ -0,0 +1,15 @@
+import { i as LayoutFont, t as Alignment } from "../style-DkamR3aY.cjs";
+import { ContentImageBlock, ContentRun, ContentTableRow, LayoutImageAsset } from "document-schema.js";
+import { StyledRun, TextMeasurer, WrappedLine } from "pdf-codec";
+//#region src/layout/shared.d.ts
+declare const NOMINAL_TEXT_SIZE_PT = 18;
+declare function runFont(run: ContentRun): LayoutFont;
+declare function toStyledRuns(runs: readonly ContentRun[], fontScale?: number): StyledRun[];
+declare function effectiveStyledRuns(runs: readonly ContentRun[], fontScale?: number): StyledRun[];
+declare function lineNaturalHeightPt(line: WrappedLine, measurer: TextMeasurer, fallback: StyledRun): number;
+declare function alignmentOffsetPt(alignment: Alignment | undefined, contentWidthPt: number, lineWidthPt: number): number;
+declare function registerImage(block: ContentImageBlock, images: Record<string, LayoutImageAsset>): string;
+declare function sumColumnWidthsPt(columnWidthsPt: readonly number[], startIndex: number, span: number): number;
+declare function estimateRowHeightPt(row: ContentTableRow, measurer: TextMeasurer, columnWidthsPt: readonly number[], scale: number): number;
+//#endregion
+export { NOMINAL_TEXT_SIZE_PT, alignmentOffsetPt, effectiveStyledRuns, estimateRowHeightPt, lineNaturalHeightPt, registerImage, runFont, sumColumnWidthsPt, toStyledRuns };

package/dist/layout/shared.d.ts

@@ -0,0 +1,15 @@
+import { i as LayoutFont, t as Alignment } from "../style-DkamR3aY.js";
+import { ContentImageBlock, ContentRun, ContentTableRow, LayoutImageAsset } from "document-schema.js";
+import { StyledRun, TextMeasurer, WrappedLine } from "pdf-codec";
+//#region src/layout/shared.d.ts
+declare const NOMINAL_TEXT_SIZE_PT = 18;
+declare function runFont(run: ContentRun): LayoutFont;
+declare function toStyledRuns(runs: readonly ContentRun[], fontScale?: number): StyledRun[];
+declare function effectiveStyledRuns(runs: readonly ContentRun[], fontScale?: number): StyledRun[];
+declare function lineNaturalHeightPt(line: WrappedLine, measurer: TextMeasurer, fallback: StyledRun): number;
+declare function alignmentOffsetPt(alignment: Alignment | undefined, contentWidthPt: number, lineWidthPt: number): number;
+declare function registerImage(block: ContentImageBlock, images: Record<string, LayoutImageAsset>): string;
+declare function sumColumnWidthsPt(columnWidthsPt: readonly number[], startIndex: number, span: number): number;
+declare function estimateRowHeightPt(row: ContentTableRow, measurer: TextMeasurer, columnWidthsPt: readonly number[], scale: number): number;
+//#endregion
+export { NOMINAL_TEXT_SIZE_PT, alignmentOffsetPt, effectiveStyledRuns, estimateRowHeightPt, lineNaturalHeightPt, registerImage, runFont, sumColumnWidthsPt, toStyledRuns };

package/dist/layout/shared.js

@@ -0,0 +1,96 @@
+import { COLOR_BLACK } from "../model/color.js";
+import { DEFAULT_LAYOUT_FONT } from "../model/style.js";
+import { base64ToBytes } from "ooxml.js";
+import { crc32, decodePng, readJpegInfo, wrapRunsToWidth } from "pdf-codec";
+//#region src/layout/shared.ts
+const NOMINAL_TEXT_SIZE_PT = 18;
+const FALLBACK_ROW_HEIGHT_PT = 20;
+function runFont(run) {
+	return {
+		family: run.fontFamily ?? DEFAULT_LAYOUT_FONT.family,
+		weight: run.bold === true ? "bold" : "normal",
+		style: run.italic === true ? "italic" : "normal"
+	};
+}
+function toStyledRuns(runs, fontScale = 1) {
+	return runs.map((run) => ({
+		text: run.text,
+		font: runFont(run),
+		sizePt: (run.sizePt ?? 18) * fontScale,
+		color: run.color ?? COLOR_BLACK,
+		underline: run.underline,
+		hyperlink: run.hyperlink,
+		sourcePath: run.sourcePath
+	}));
+}
+function effectiveStyledRuns(runs, fontScale = 1) {
+	const styled = toStyledRuns(runs, fontScale);
+	return styled.length > 0 ? styled : [{
+		text: "",
+		font: DEFAULT_LAYOUT_FONT,
+		sizePt: 18 * fontScale,
+		color: COLOR_BLACK
+	}];
+}
+function lineNaturalHeightPt(line, measurer, fallback) {
+	if (line.fragments.length === 0) return measurer.lineHeightAtSize(fallback.font, fallback.sizePt);
+	let max = 0;
+	for (const fragment of line.fragments) max = Math.max(max, measurer.lineHeightAtSize(fragment.font, fragment.sizePt));
+	return max;
+}
+function alignmentOffsetPt(alignment, contentWidthPt, lineWidthPt) {
+	if (alignment === "center") return Math.max(0, (contentWidthPt - lineWidthPt) / 2);
+	if (alignment === "right") return Math.max(0, contentWidthPt - lineWidthPt);
+	return 0;
+}
+function decodeImageDimensions(format, bytes) {
+	if (format === "jpeg") {
+		const info = readJpegInfo(bytes);
+		return {
+			widthPx: info.width,
+			heightPx: info.height
+		};
+	}
+	const raw = decodePng(bytes);
+	return {
+		widthPx: raw.width,
+		heightPx: raw.height
+	};
+}
+function registerImage(block, images) {
+	const bytes = base64ToBytes(block.base64);
+	const imageId = `img${crc32(bytes).toString(16)}`;
+	if (!(imageId in images)) {
+		const { widthPx, heightPx } = decodeImageDimensions(block.format, bytes);
+		images[imageId] = {
+			format: block.format,
+			base64: block.base64,
+			widthPx,
+			heightPx
+		};
+	}
+	return imageId;
+}
+function sumColumnWidthsPt(columnWidthsPt, startIndex, span) {
+	let sum = 0;
+	for (let i = startIndex; i < startIndex + span && i < columnWidthsPt.length; i++) sum += columnWidthsPt[i] ?? 0;
+	return sum;
+}
+function estimateRowHeightPt(row, measurer, columnWidthsPt, scale) {
+	let max = FALLBACK_ROW_HEIGHT_PT;
+	let colIndex = 0;
+	for (const cell of row.cells) {
+		const span = cell.colSpan ?? 1;
+		const cellWidthPt = sumColumnWidthsPt(columnWidthsPt, colIndex, span) * scale;
+		for (const block of cell.blocks) {
+			if (block.kind !== "paragraph") continue;
+			const runs = effectiveStyledRuns(block.runs);
+			const lines = wrapRunsToWidth(runs, measurer, cellWidthPt);
+			for (const line of lines) max = Math.max(max, lineNaturalHeightPt(line, measurer, runs[0]));
+		}
+		colIndex += span;
+	}
+	return max;
+}
+//#endregion
+export { NOMINAL_TEXT_SIZE_PT, alignmentOffsetPt, effectiveStyledRuns, estimateRowHeightPt, lineNaturalHeightPt, registerImage, runFont, sumColumnWidthsPt, toStyledRuns };

package/dist/layout/sheets.cjs

@@ -0,0 +1,413 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_layout_shared = require("./shared.cjs");
+const require_ports_abort = require("../ports/abort.cjs");
+let document_schema_js = require("document-schema.js");
+let pdf_codec = require("pdf-codec");
+//#region src/layout/sheets.ts
+const DEFAULT_COLUMN_WIDTH_PT = 64;
+const DEFAULT_ROW_HEIGHT_PT = 15;
+const NOMINAL_CELL_TEXT_SIZE_PT = 10;
+const HEADER_LABEL_SIZE_PT = 8;
+const CELL_TEXT_PADDING_PT = 2;
+const HEADER_LABEL_PADDING_PT = 2;
+const MINIMUM_SCALE = .01;
+const NUMERIC_OVERFLOW_TEXT = "###";
+const GRIDLINE_COLOR = (0, document_schema_js.rgbHexToColor)("#D0D0D0");
+const GRIDLINE_WIDTH_PT = .5;
+const HEADER_LABEL_COLOR = (0, document_schema_js.rgbHexToColor)("#606060");
+function columnLetters(index) {
+	let n = index + 1;
+	let letters = "";
+	while (n > 0) {
+		const remainder = (n - 1) % 26;
+		letters = String.fromCharCode(65 + remainder) + letters;
+		n = Math.floor((n - 1) / 26);
+	}
+	return letters;
+}
+function resolvePrintRange(sheet) {
+	if (sheet.printSettings.printRange !== void 0) return sheet.printSettings.printRange;
+	if (sheet.cells.length === 0) return;
+	let startRow = Number.POSITIVE_INFINITY;
+	let startColumn = Number.POSITIVE_INFINITY;
+	let endRow = Number.NEGATIVE_INFINITY;
+	let endColumn = Number.NEGATIVE_INFINITY;
+	for (const cell of sheet.cells) {
+		startRow = Math.min(startRow, cell.row);
+		startColumn = Math.min(startColumn, cell.column);
+		endRow = Math.max(endRow, cell.row + (cell.rowSpan ?? 1) - 1);
+		endColumn = Math.max(endColumn, cell.column + (cell.colSpan ?? 1) - 1);
+	}
+	return {
+		startRow,
+		startColumn,
+		endRow,
+		endColumn
+	};
+}
+function resolveAxis(entries, start, end, defaultSizePt) {
+	const sorted = [...entries].sort((a, b) => a.index - b.index);
+	const resolved = [];
+	let pointer = 0;
+	let currentSizePt = defaultSizePt;
+	let currentHidden = false;
+	for (let index = start; index <= end; index++) {
+		while (pointer < sorted.length && sorted[pointer].index <= index) {
+			currentSizePt = sorted[pointer].sizePt;
+			currentHidden = sorted[pointer].hidden ?? false;
+			pointer++;
+		}
+		resolved.push({
+			index,
+			sizePt: currentHidden ? 0 : currentSizePt,
+			hidden: currentHidden
+		});
+	}
+	return resolved;
+}
+function computeHeaderGutter(printSettings, range, measurer) {
+	if (!printSettings.headers) return {
+		widthPt: 0,
+		heightPt: 0
+	};
+	const widestRowLabel = String(range.endRow + 1);
+	return {
+		widthPt: measurer.widthOfTextAtSize(widestRowLabel, document_schema_js.DEFAULT_LAYOUT_FONT, HEADER_LABEL_SIZE_PT) + 4,
+		heightPt: measurer.lineHeightAtSize(document_schema_js.DEFAULT_LAYOUT_FONT, HEADER_LABEL_SIZE_PT)
+	};
+}
+function resolveScale(printSettings, availableWidthPt, availableHeightPt, totalContentWidthPt, totalContentHeightPt) {
+	if (printSettings.scale !== void 0) return Math.max(printSettings.scale / 100, MINIMUM_SCALE);
+	if (printSettings.fitToPages !== void 0) {
+		const budgetWidthPt = availableWidthPt * printSettings.fitToPages.width;
+		const budgetHeightPt = availableHeightPt * printSettings.fitToPages.height;
+		const widthRatio = totalContentWidthPt > 0 ? budgetWidthPt / totalContentWidthPt : 1;
+		const heightRatio = totalContentHeightPt > 0 ? budgetHeightPt / totalContentHeightPt : 1;
+		return Math.max(Math.min(widthRatio, heightRatio, 1), MINIMUM_SCALE);
+	}
+	return 1;
+}
+function partitionIndices(indices, sizeOf, availablePt, manualBreaks) {
+	const bands = [];
+	let current = [];
+	let currentSizePt = 0;
+	for (const index of indices) {
+		if (manualBreaks.has(index) && current.length > 0) {
+			bands.push(current);
+			current = [];
+			currentSizePt = 0;
+		}
+		const sizePt = sizeOf(index);
+		if (current.length > 0 && currentSizePt + sizePt > availablePt) {
+			bands.push(current);
+			current = [];
+			currentSizePt = 0;
+		}
+		current.push(index);
+		currentSizePt += sizePt;
+	}
+	if (current.length > 0) bands.push(current);
+	return bands;
+}
+function cellStyledRuns(cell) {
+	if (cell.runs !== void 0 && cell.runs.length > 0) {
+		const runsWithNominalSize = cell.runs.map((run) => run.sizePt === void 0 ? {
+			...run,
+			sizePt: NOMINAL_CELL_TEXT_SIZE_PT
+		} : run);
+		return require_layout_shared.toStyledRuns(runsWithNominalSize);
+	}
+	return [{
+		text: cell.displayText,
+		font: document_schema_js.DEFAULT_LAYOUT_FONT,
+		sizePt: NOMINAL_CELL_TEXT_SIZE_PT,
+		color: document_schema_js.COLOR_BLACK
+	}];
+}
+function isNumericLikeValue(kind) {
+	return kind === "number" || kind === "percentage" || kind === "currency" || kind === "date" || kind === "time";
+}
+function defaultAlignmentForValue(kind) {
+	if (isNumericLikeValue(kind)) return "right";
+	if (kind === "boolean" || kind === "error") return "center";
+	return "left";
+}
+function isCellVisuallyEmpty(cell) {
+	return cell === void 0 || cell.value.kind === "empty" && cell.displayText.length === 0;
+}
+function truncateFragmentsToWidth(fragments, measurer, maxWidthPt) {
+	const result = [];
+	for (const fragment of fragments) {
+		if (fragment.xOffsetPt >= maxWidthPt) break;
+		const remainingWidthPt = maxWidthPt - fragment.xOffsetPt;
+		if (measurer.widthOfTextAtSize(fragment.text, fragment.font, fragment.sizePt) <= remainingWidthPt) {
+			result.push(fragment);
+			continue;
+		}
+		const chars = Array.from(fragment.text);
+		let width = 0;
+		let fitCount = 0;
+		for (const char of chars) {
+			const charWidthPt = measurer.widthOfTextAtSize(char, fragment.font, fragment.sizePt);
+			if (width + charWidthPt > remainingWidthPt) break;
+			width += charWidthPt;
+			fitCount++;
+		}
+		if (fitCount > 0) result.push({
+			...fragment,
+			text: chars.slice(0, fitCount).join("")
+		});
+		break;
+	}
+	return result;
+}
+function buildPositionedAxis(repeatIndices, repeatSizePtOf, bandIndices, bandSizePtOf) {
+	const indices = [...repeatIndices, ...bandIndices];
+	const sizesPt = [...repeatIndices.map(repeatSizePtOf), ...bandIndices.map(bandSizePtOf)];
+	const offsetsPt = [0];
+	let running = 0;
+	for (const size of sizesPt) {
+		running += size;
+		offsetsPt.push(running);
+	}
+	return {
+		indices,
+		sizesPt,
+		offsetsPt,
+		positionByIndex: new Map(indices.map((index, position) => [index, position]))
+	};
+}
+function axisSpanSizePt(axis, startIndex, span) {
+	const startPosition = axis.positionByIndex.get(startIndex);
+	if (startPosition === void 0) return 0;
+	return require_layout_shared.sumColumnWidthsPt(axis.sizesPt, startPosition, span);
+}
+function renderCellText(cell, rowCells, columnAxis, rowAxis, gridLeftXPt, gridTopYDownPt, pageHeightPt, measurer, out) {
+	const columnPosition = columnAxis.positionByIndex.get(cell.column);
+	const rowPosition = rowAxis.positionByIndex.get(cell.row);
+	if (columnPosition === void 0 || rowPosition === void 0) return;
+	const ownWidthPt = axisSpanSizePt(columnAxis, cell.column, cell.colSpan ?? 1);
+	const heightPt = axisSpanSizePt(rowAxis, cell.row, cell.rowSpan ?? 1);
+	const xLeftPt = gridLeftXPt + columnAxis.offsetsPt[columnPosition];
+	const yTopDownPt = gridTopYDownPt + rowAxis.offsetsPt[rowPosition];
+	const alignment = defaultAlignmentForValue(cell.value.kind);
+	const numericLike = isNumericLikeValue(cell.value.kind);
+	const styledRuns = cellStyledRuns(cell);
+	const naturalLine = (0, pdf_codec.wrapRunsToWidth)(styledRuns, measurer, Number.POSITIVE_INFINITY)[0];
+	let availableWidthPt = Math.max(0, ownWidthPt - 4);
+	let fragments = naturalLine.fragments;
+	let lineWidthPt = naturalLine.widthPt;
+	if (lineWidthPt > availableWidthPt) if (numericLike) {
+		const overflowRuns = [{
+			text: NUMERIC_OVERFLOW_TEXT,
+			font: styledRuns[0].font,
+			sizePt: styledRuns[0].sizePt,
+			color: styledRuns[0].color
+		}];
+		const overflowLine = (0, pdf_codec.wrapRunsToWidth)(overflowRuns, measurer, Number.POSITIVE_INFINITY)[0];
+		fragments = overflowLine.fragments;
+		lineWidthPt = overflowLine.widthPt;
+	} else if (cell.value.kind === "string") {
+		let spillColumn = cell.column + (cell.colSpan ?? 1);
+		while (lineWidthPt > availableWidthPt) {
+			const neighborPosition = columnAxis.positionByIndex.get(spillColumn);
+			if (neighborPosition === void 0 || !isCellVisuallyEmpty(rowCells?.get(spillColumn))) break;
+			availableWidthPt += columnAxis.sizesPt[neighborPosition];
+			spillColumn++;
+		}
+		if (lineWidthPt > availableWidthPt) fragments = truncateFragmentsToWidth(fragments, measurer, availableWidthPt);
+	} else fragments = truncateFragmentsToWidth(fragments, measurer, availableWidthPt);
+	const alignOffsetPt = require_layout_shared.alignmentOffsetPt(alignment, availableWidthPt, lineWidthPt);
+	const textStartXPt = xLeftPt + CELL_TEXT_PADDING_PT + alignOffsetPt;
+	const lineHeightPt = require_layout_shared.lineNaturalHeightPt(naturalLine, measurer, styledRuns[0]);
+	const baselineYDownPt = yTopDownPt + Math.max(CELL_TEXT_PADDING_PT, heightPt - CELL_TEXT_PADDING_PT - lineHeightPt) + naturalLine.ascentPt;
+	for (const fragment of fragments) {
+		const textItem = {
+			kind: "text",
+			text: fragment.text,
+			xPt: textStartXPt + fragment.xOffsetPt,
+			yPt: pageHeightPt - baselineYDownPt,
+			font: fragment.font,
+			sizePt: fragment.sizePt,
+			color: fragment.color,
+			underline: fragment.underline,
+			sourcePath: fragment.sourcePath
+		};
+		out.push(textItem);
+	}
+}
+function renderHeaderLabels(gutter, columnAxis, rowAxis, gridLeftXPt, gridTopYDownPt, pageHeightPt, measurer, out) {
+	const lineHeightPt = measurer.lineHeightAtSize(document_schema_js.DEFAULT_LAYOUT_FONT, HEADER_LABEL_SIZE_PT);
+	const ascentPt = measurer.ascenderAtSize(document_schema_js.DEFAULT_LAYOUT_FONT, HEADER_LABEL_SIZE_PT);
+	columnAxis.indices.forEach((columnIndex, position) => {
+		const label = columnLetters(columnIndex);
+		const widthPt = columnAxis.sizesPt[position];
+		const labelWidthPt = measurer.widthOfTextAtSize(label, document_schema_js.DEFAULT_LAYOUT_FONT, HEADER_LABEL_SIZE_PT);
+		const xPt = gridLeftXPt + columnAxis.offsetsPt[position] + require_layout_shared.alignmentOffsetPt("center", widthPt, labelWidthPt);
+		const baselineYDownPt = gridTopYDownPt - gutter.heightPt + (gutter.heightPt - lineHeightPt) / 2 + ascentPt;
+		out.push({
+			kind: "text",
+			text: label,
+			xPt,
+			yPt: pageHeightPt - baselineYDownPt,
+			font: document_schema_js.DEFAULT_LAYOUT_FONT,
+			sizePt: HEADER_LABEL_SIZE_PT,
+			color: HEADER_LABEL_COLOR
+		});
+	});
+	rowAxis.indices.forEach((rowIndex, position) => {
+		const label = String(rowIndex + 1);
+		const heightPt = rowAxis.sizesPt[position];
+		const labelWidthPt = measurer.widthOfTextAtSize(label, document_schema_js.DEFAULT_LAYOUT_FONT, HEADER_LABEL_SIZE_PT);
+		const xPt = gridLeftXPt - gutter.widthPt + Math.max(HEADER_LABEL_PADDING_PT, gutter.widthPt - HEADER_LABEL_PADDING_PT - labelWidthPt);
+		const baselineYDownPt = gridTopYDownPt + rowAxis.offsetsPt[position] + Math.max(0, (heightPt - lineHeightPt) / 2) + ascentPt;
+		out.push({
+			kind: "text",
+			text: label,
+			xPt,
+			yPt: pageHeightPt - baselineYDownPt,
+			font: document_schema_js.DEFAULT_LAYOUT_FONT,
+			sizePt: HEADER_LABEL_SIZE_PT,
+			color: HEADER_LABEL_COLOR
+		});
+	});
+}
+function renderGridlines(gridLeftXPt, gridTopYDownPt, gridWidthPt, gridHeightPt, columnOffsetsPt, rowOffsetsPt, pageHeightPt, out) {
+	for (const offsetPt of columnOffsetsPt) {
+		const xPt = gridLeftXPt + offsetPt;
+		const line = {
+			kind: "line",
+			x1Pt: xPt,
+			y1Pt: pageHeightPt - gridTopYDownPt,
+			x2Pt: xPt,
+			y2Pt: pageHeightPt - (gridTopYDownPt + gridHeightPt),
+			color: GRIDLINE_COLOR,
+			widthPt: GRIDLINE_WIDTH_PT
+		};
+		out.push(line);
+	}
+	for (const offsetPt of rowOffsetsPt) {
+		const yDownPt = gridTopYDownPt + offsetPt;
+		const line = {
+			kind: "line",
+			x1Pt: gridLeftXPt,
+			y1Pt: pageHeightPt - yDownPt,
+			x2Pt: gridLeftXPt + gridWidthPt,
+			y2Pt: pageHeightPt - yDownPt,
+			color: GRIDLINE_COLOR,
+			widthPt: GRIDLINE_WIDTH_PT
+		};
+		out.push(line);
+	}
+}
+function bandableIndices(start, end, repeat) {
+	const indices = [];
+	for (let i = start; i <= end; i++) {
+		if (repeat !== void 0 && i >= repeat.start && i <= repeat.end) continue;
+		indices.push(i);
+	}
+	return indices;
+}
+function rangeIndices(start, end) {
+	const indices = [];
+	for (let i = start; i <= end; i++) indices.push(i);
+	return indices;
+}
+function convertSheetToPages(sheet, measurer, signal, out) {
+	require_ports_abort.throwIfAborted(signal);
+	const range = resolvePrintRange(sheet);
+	if (range === void 0) return;
+	const { printSettings } = sheet;
+	const { pageSize, margins } = printSettings;
+	const pageContentWidthPt = Math.max(0, pageSize.widthPt - margins.leftPt - margins.rightPt);
+	const pageContentHeightPt = Math.max(0, pageSize.heightPt - margins.topPt - margins.bottomPt);
+	const columnEntries = resolveAxis(sheet.columns.map((c) => ({
+		index: c.index,
+		sizePt: c.widthPt,
+		hidden: c.hidden
+	})), range.startColumn, range.endColumn, DEFAULT_COLUMN_WIDTH_PT);
+	const rowEntries = resolveAxis(sheet.rows.map((r) => ({
+		index: r.index,
+		sizePt: r.heightPt,
+		hidden: r.hidden
+	})), range.startRow, range.endRow, DEFAULT_ROW_HEIGHT_PT);
+	const columnSizeByIndex = new Map(columnEntries.map((e) => [e.index, e.sizePt]));
+	const rowSizeByIndex = new Map(rowEntries.map((e) => [e.index, e.sizePt]));
+	const hiddenColumnIndices = new Set(columnEntries.filter((e) => e.hidden).map((e) => e.index));
+	const hiddenRowIndices = new Set(rowEntries.filter((e) => e.hidden).map((e) => e.index));
+	const gutter = computeHeaderGutter(printSettings, range, measurer);
+	const repeatColumns = printSettings.repeatColumns;
+	const repeatRows = printSettings.repeatRows;
+	const repeatColumnIndices = repeatColumns === void 0 ? [] : rangeIndices(repeatColumns.start, repeatColumns.end);
+	const repeatRowIndices = repeatRows === void 0 ? [] : rangeIndices(repeatRows.start, repeatRows.end);
+	const repeatColumnsWidthPt = repeatColumnIndices.reduce((sum, i) => sum + (columnSizeByIndex.get(i) ?? 0), 0);
+	const repeatRowsHeightPt = repeatRowIndices.reduce((sum, i) => sum + (rowSizeByIndex.get(i) ?? 0), 0);
+	const bandableColumnIndices = bandableIndices(range.startColumn, range.endColumn, repeatColumns);
+	const bandableRowIndices = bandableIndices(range.startRow, range.endRow, repeatRows);
+	const availableWidthPt = Math.max(0, pageContentWidthPt - gutter.widthPt - repeatColumnsWidthPt);
+	const availableHeightPt = Math.max(0, pageContentHeightPt - gutter.heightPt - repeatRowsHeightPt);
+	const scale = resolveScale(printSettings, availableWidthPt, availableHeightPt, bandableColumnIndices.reduce((sum, i) => sum + (columnSizeByIndex.get(i) ?? 0), 0), bandableRowIndices.reduce((sum, i) => sum + (rowSizeByIndex.get(i) ?? 0), 0));
+	const descaledAvailableWidthPt = availableWidthPt / scale;
+	const descaledAvailableHeightPt = availableHeightPt / scale;
+	const manualBreakColumns = new Set(printSettings.manualBreaks?.columns ?? []);
+	const manualBreakRows = new Set(printSettings.manualBreaks?.rows ?? []);
+	require_ports_abort.throwIfAborted(signal);
+	const columnBands = partitionIndices(bandableColumnIndices, (i) => columnSizeByIndex.get(i) ?? 0, descaledAvailableWidthPt, manualBreakColumns);
+	const rowBands = partitionIndices(bandableRowIndices, (i) => rowSizeByIndex.get(i) ?? 0, descaledAvailableHeightPt, manualBreakRows);
+	const cellsByRow = /* @__PURE__ */ new Map();
+	for (const cell of sheet.cells) {
+		let row = cellsByRow.get(cell.row);
+		if (row === void 0) {
+			row = /* @__PURE__ */ new Map();
+			cellsByRow.set(cell.row, row);
+		}
+		row.set(cell.column, cell);
+	}
+	const scaledSizeOf = (sizeByIndex) => (index) => (sizeByIndex.get(index) ?? 0) * scale;
+	const unscaledSizeOf = (sizeByIndex) => (index) => sizeByIndex.get(index) ?? 0;
+	const bandPairs = printSettings.pageOrder === "overThenDown" ? rowBands.flatMap((rowBand) => columnBands.map((columnBand) => ({
+		columnBand,
+		rowBand
+	}))) : columnBands.flatMap((columnBand) => rowBands.map((rowBand) => ({
+		columnBand,
+		rowBand
+	})));
+	for (const { columnBand, rowBand } of bandPairs) {
+		require_ports_abort.throwIfAborted(signal);
+		const columnAxis = buildPositionedAxis(repeatColumnIndices, unscaledSizeOf(columnSizeByIndex), columnBand, scaledSizeOf(columnSizeByIndex));
+		const rowAxis = buildPositionedAxis(repeatRowIndices, unscaledSizeOf(rowSizeByIndex), rowBand, scaledSizeOf(rowSizeByIndex));
+		const gridLeftXPt = margins.leftPt + gutter.widthPt;
+		const gridTopYDownPt = margins.topPt + gutter.heightPt;
+		const gridWidthPt = columnAxis.offsetsPt[columnAxis.offsetsPt.length - 1];
+		const gridHeightPt = rowAxis.offsetsPt[rowAxis.offsetsPt.length - 1];
+		const items = [];
+		if (printSettings.gridlines) renderGridlines(gridLeftXPt, gridTopYDownPt, gridWidthPt, gridHeightPt, columnAxis.offsetsPt, rowAxis.offsetsPt, pageSize.heightPt, items);
+		if (printSettings.headers) renderHeaderLabels(gutter, columnAxis, rowAxis, gridLeftXPt, gridTopYDownPt, pageSize.heightPt, measurer, items);
+		for (const rowIndex of rowAxis.indices) {
+			const rowCells = cellsByRow.get(rowIndex);
+			if (rowCells === void 0) continue;
+			for (const [columnIndex, cell] of rowCells) {
+				require_ports_abort.throwIfAborted(signal);
+				if (!columnAxis.positionByIndex.has(columnIndex) || hiddenColumnIndices.has(columnIndex) || hiddenRowIndices.has(cell.row)) continue;
+				renderCellText(cell, rowCells, columnAxis, rowAxis, gridLeftXPt, gridTopYDownPt, pageSize.heightPt, measurer, items);
+			}
+		}
+		out.push({
+			widthPt: pageSize.widthPt,
+			heightPt: pageSize.heightPt,
+			items
+		});
+	}
+}
+function convertSpreadsheetToLayout(doc, options) {
+	const pages = [];
+	for (const sheet of doc.sheets) convertSheetToPages(sheet, options.measurer, options.signal, pages);
+	return {
+		formatVersion: document_schema_js.LAYOUT_FORMAT_VERSION,
+		metadata: doc.metadata,
+		pages,
+		images: {}
+	};
+}
+//#endregion
+exports.convertSpreadsheetToLayout = convertSpreadsheetToLayout;

package/dist/layout/sheets.d.cts

@@ -0,0 +1,14 @@
+import { ContentDocument } from "../model/content.cjs";
+import { LayoutDocument } from "document-schema.js";
+import { TextMeasurer } from "pdf-codec";
+//#region src/layout/sheets.d.ts
+interface SheetsLayoutOptions {
+  readonly measurer: TextMeasurer;
+  readonly signal?: AbortSignal;
+}
+type SpreadsheetContentDocument = Extract<ContentDocument, {
+  kind: 'spreadsheet';
+}>;
+declare function convertSpreadsheetToLayout(doc: SpreadsheetContentDocument, options: SheetsLayoutOptions): LayoutDocument;
+//#endregion
+export { SheetsLayoutOptions, convertSpreadsheetToLayout };

package/dist/layout/sheets.d.ts

@@ -0,0 +1,14 @@
+import { ContentDocument } from "../model/content.js";
+import { LayoutDocument } from "document-schema.js";
+import { TextMeasurer } from "pdf-codec";
+//#region src/layout/sheets.d.ts
+interface SheetsLayoutOptions {
+  readonly measurer: TextMeasurer;
+  readonly signal?: AbortSignal;
+}
+type SpreadsheetContentDocument = Extract<ContentDocument, {
+  kind: 'spreadsheet';
+}>;
+declare function convertSpreadsheetToLayout(doc: SpreadsheetContentDocument, options: SheetsLayoutOptions): LayoutDocument;
+//#endregion
+export { SheetsLayoutOptions, convertSpreadsheetToLayout };