@stll/folio-core 0.0.1-placeholder.0 → 0.1.0

package/dist/layout-engine/measure/measureBlocks.js

@@ -0,0 +1,450 @@
+import { DEFAULT_TEXTBOX_MARGINS, floatingTextBoxReservesBand } from "../types.js";
+import { findClearLineY, measureParagraph } from "./measureParagraph.js";
+import { getCachedParagraphMeasure, setCachedParagraphMeasure } from "./cache.js";
+import { recordMeasureBlock, recordMeasureBlockError } from "../layoutInstrumentation.js";
+import { bandTopContentY, isPageFrameRelativeAnchor } from "../textBoxFlow.js";
+//#region src/layout-engine/measure/measureBlocks.ts
+/**
+* Pseudo-infinite measurement width (px) used for `w:noWrap` table cells so
+* the paragraph line breaker never inserts a soft break. Large enough to
+* exceed any realistic single Word line; small enough to stay well clear of
+* floating-point precision concerns when summed downstream.
+*/
+const NO_WRAP_MEASURE_WIDTH = 1e6;
+/**
+* Check if an image run is a *text-wrapping* floating image — it
+* occupies an exclusion zone the body text should flow around.
+*
+* `wrapType: "behind"` and `wrapType: "inFront"` are anchored
+* (out-of-flow) but Word's wrapNone semantics put them behind /
+* over the text without shrinking the body. They render as
+* `displayMode: "float"` in the prose model so the painter knows
+* they're out of normal flow, but `extractFloatingZones` must skip
+* them — including them here would make the line breaker wrap text
+* around a background letterhead or a foreground overlay (Codex
+* PR #258 review).
+*/
+function isFloatingImageRun(run) {
+	const wrapType = run.wrapType;
+	const displayMode = run.displayMode;
+	if (wrapType === "behind" || wrapType === "inFront") return false;
+	if (wrapType && [
+		"square",
+		"tight",
+		"through"
+	].includes(wrapType)) return true;
+	if (displayMode === "float") return true;
+	return false;
+}
+/**
+* EMU to pixels conversion
+*/
+function emuToPixels(emu) {
+	if (emu === void 0) return 0;
+	return Math.round(emu * 96 / 914400);
+}
+function resolveTableWidthPx(width, widthType, contentWidth) {
+	if (!width) return;
+	if (widthType === "pct") return contentWidth * width / 5e3;
+	if (widthType === "dxa" || !widthType || widthType === "auto") return Math.round(width / 20 * 1.333);
+}
+function isInlineFlowImageRun(run) {
+	if (run.displayMode === "float") return false;
+	if (run.wrapType === "square" || run.wrapType === "tight" || run.wrapType === "through" || run.wrapType === "behind" || run.wrapType === "inFront") return false;
+	if (run.displayMode === "block" || run.wrapType === "topAndBottom") return false;
+	return true;
+}
+function measureTableCellBlockVisualHeight(block, blockMeasure) {
+	if (block.kind !== "paragraph" || blockMeasure.kind !== "paragraph") {
+		if ("totalHeight" in blockMeasure) return blockMeasure.totalHeight;
+		if ("height" in blockMeasure) return blockMeasure.height;
+		return 0;
+	}
+	const paragraphBlock = block;
+	const paragraphMeasure = blockMeasure;
+	const nonEmptyRuns = paragraphBlock.runs.filter((run) => run.kind !== "text" || run.text.replace(/\u00a0/gu, " ").trim().length > 0);
+	if (paragraphMeasure.lines.length !== 1 || nonEmptyRuns.length === 0) return paragraphMeasure.totalHeight;
+	const inlineImageRuns = [];
+	for (const run of nonEmptyRuns) {
+		if (run.kind !== "image" || !isInlineFlowImageRun(run)) return paragraphMeasure.totalHeight;
+		inlineImageRuns.push(run);
+	}
+	let maxImageHeight = 0;
+	for (const run of inlineImageRuns) maxImageHeight = Math.max(maxImageHeight, run.height);
+	const spacingBefore = paragraphBlock.attrs?.spacing?.before ?? 0;
+	const spacingAfter = paragraphBlock.attrs?.spacing?.after ?? 0;
+	return spacingBefore + maxImageHeight + spacingAfter;
+}
+function getTableCellVerticalBorderHeight(cell) {
+	return (cell?.borders?.top?.width ?? 0) + (cell?.borders?.bottom?.width ?? 0);
+}
+function measureTableBlock(tableBlock, contentWidth, fieldValues) {
+	const DEFAULT_CELL_PADDING_X = 7;
+	const DEFAULT_CELL_PADDING_Y = 0;
+	let columnWidths = tableBlock.columnWidths ?? [];
+	const explicitWidthPx = resolveTableWidthPx(tableBlock.width, tableBlock.widthType, contentWidth);
+	if (columnWidths.length === 0 && tableBlock.rows.length > 0) {
+		const colCount = tableBlock.rows[0].cells.reduce((sum, cell) => sum + (cell.colSpan ?? 1), 0);
+		const equalWidth = (explicitWidthPx ?? contentWidth) / Math.max(1, colCount);
+		columnWidths = Array.from({ length: colCount }, () => equalWidth);
+	} else if (columnWidths.length > 0 && explicitWidthPx) {
+		const totalWidth = columnWidths.reduce((sum, w) => sum + w, 0);
+		if (totalWidth > 0 && Math.abs(totalWidth - explicitWidthPx) > 1) {
+			const scale = explicitWidthPx / totalWidth;
+			columnWidths = columnWidths.map((w) => w * scale);
+		}
+	}
+	const occupiedColumnsPerRow = /* @__PURE__ */ new Map();
+	for (let rowIdx = 0; rowIdx < tableBlock.rows.length; rowIdx++) {
+		const row = tableBlock.rows[rowIdx];
+		if (!row) continue;
+		let colIdx = 0;
+		const occupied = occupiedColumnsPerRow.get(rowIdx) ?? /* @__PURE__ */ new Set();
+		while (occupied.has(colIdx)) colIdx++;
+		for (const cell of row.cells) {
+			const colSpan = cell.colSpan ?? 1;
+			const rowSpan = cell.rowSpan ?? 1;
+			if (rowSpan > 1) for (let r = rowIdx + 1; r < rowIdx + rowSpan; r++) {
+				if (!occupiedColumnsPerRow.has(r)) occupiedColumnsPerRow.set(r, /* @__PURE__ */ new Set());
+				const occSet = occupiedColumnsPerRow.get(r);
+				for (let c = 0; c < colSpan; c++) occSet.add(colIdx + c);
+			}
+			colIdx += colSpan;
+			while (occupied.has(colIdx)) colIdx++;
+		}
+	}
+	const rows = tableBlock.rows.map((row, rowIdx) => {
+		let columnIndex = 0;
+		const occupied = occupiedColumnsPerRow.get(rowIdx) ?? /* @__PURE__ */ new Set();
+		while (occupied.has(columnIndex)) columnIndex++;
+		return {
+			cells: row.cells.map((cell) => {
+				const colSpan = cell.colSpan ?? 1;
+				let cellWidth = 0;
+				for (let c = 0; c < colSpan && columnIndex + c < columnWidths.length; c++) cellWidth += columnWidths[columnIndex + c] ?? 0;
+				if (cellWidth === 0) cellWidth = cell.width ?? 100;
+				columnIndex += colSpan;
+				while (occupied.has(columnIndex)) columnIndex++;
+				const padLeft = cell.padding?.left ?? DEFAULT_CELL_PADDING_X;
+				const padRight = cell.padding?.right ?? DEFAULT_CELL_PADDING_X;
+				const cellContentWidth = Math.max(1, cellWidth - padLeft - padRight);
+				const measureWidth = cell.noWrap ? NO_WRAP_MEASURE_WIDTH : cellContentWidth;
+				const cellMeasure = {
+					blocks: cell.blocks.map((b) => measureBlock(b, measureWidth, void 0, void 0, fieldValues)),
+					width: cellWidth,
+					height: 0
+				};
+				if (cell.colSpan !== void 0) cellMeasure.colSpan = cell.colSpan;
+				if (cell.rowSpan !== void 0) cellMeasure.rowSpan = cell.rowSpan;
+				return cellMeasure;
+			}),
+			height: 0
+		};
+	});
+	for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+		const row = rows[rowIdx];
+		const sourceRowCells = tableBlock.rows[rowIdx]?.cells;
+		let maxCellHeightWithBorders = 0;
+		for (let cellIdx = 0; cellIdx < row.cells.length; cellIdx++) {
+			const cell = row.cells[cellIdx];
+			const sourceCell = sourceRowCells?.[cellIdx];
+			cell.height = 0;
+			for (let blockIdx = 0; blockIdx < cell.blocks.length; blockIdx++) {
+				const sourceBlock = sourceCell?.blocks[blockIdx];
+				const blockMeasure = cell.blocks[blockIdx];
+				if (!sourceBlock || !blockMeasure) continue;
+				cell.height += measureTableCellBlockVisualHeight(sourceBlock, blockMeasure);
+			}
+			const padTop = sourceCell?.padding?.top ?? DEFAULT_CELL_PADDING_Y;
+			const padBottom = sourceCell?.padding?.bottom ?? DEFAULT_CELL_PADDING_Y;
+			cell.height += padTop + padBottom;
+			maxCellHeightWithBorders = Math.max(maxCellHeightWithBorders, cell.height + getTableCellVerticalBorderHeight(sourceCell));
+		}
+		const sourceRow = tableBlock.rows[rowIdx];
+		const explicitHeight = sourceRow?.height;
+		const heightRule = sourceRow?.heightRule;
+		if (explicitHeight && heightRule === "exact") row.height = explicitHeight;
+		else if (explicitHeight) row.height = Math.max(maxCellHeightWithBorders, explicitHeight);
+		else row.height = maxCellHeightWithBorders;
+	}
+	const totalHeight = rows.reduce((h, r) => h + r.height, 0);
+	const totalWidth = columnWidths.reduce((w, cw) => w + cw, 0) || explicitWidthPx || contentWidth;
+	return {
+		kind: "table",
+		rows,
+		columnWidths,
+		totalWidth,
+		totalHeight
+	};
+}
+function perBlockNumberValue(value, blockIndex, fallback) {
+	if (Array.isArray(value)) return value[blockIndex] ?? fallback;
+	return value;
+}
+function extractFloatingZones(blocks, contentWidth, marginTop = 0, pageGeometry) {
+	const zones = [];
+	const defaultMarginTop = Array.isArray(marginTop) ? marginTop[0] ?? 0 : marginTop;
+	const pageHeightInput = pageGeometry?.pageHeight ?? 0;
+	const marginBottomInput = pageGeometry?.marginBottom ?? 0;
+	const defaultPageHeight = Array.isArray(pageHeightInput) ? pageHeightInput[0] ?? 0 : pageHeightInput;
+	const defaultMarginBottom = Array.isArray(marginBottomInput) ? marginBottomInput[0] ?? 0 : marginBottomInput;
+	for (let blockIndex = 0; blockIndex < blocks.length; blockIndex++) {
+		const block = blocks[blockIndex];
+		if (block.kind !== "paragraph") continue;
+		const paragraphBlock = block;
+		for (const run of paragraphBlock.runs) {
+			if (run.kind !== "image") continue;
+			const imgRun = run;
+			if (!isFloatingImageRun(imgRun)) continue;
+			let topY = 0;
+			const position = imgRun.position;
+			const distTop = imgRun.distTop ?? 0;
+			const distBottom = imgRun.distBottom ?? 0;
+			const distLeft = imgRun.distLeft ?? 12;
+			const distRight = imgRun.distRight ?? 12;
+			if (position?.vertical) {
+				const v = position.vertical;
+				if (v.align === "top" && v.relativeTo === "margin") topY = 0;
+				else if (v.posOffset !== void 0) topY = emuToPixels(v.posOffset);
+			}
+			const bottomY = topY + imgRun.height;
+			let leftMargin = 0;
+			let rightMargin = 0;
+			if (position?.horizontal) {
+				const h = position.horizontal;
+				if (h.align === "left") leftMargin = imgRun.width + distRight;
+				else if (h.align === "right") rightMargin = imgRun.width + distLeft;
+				else if (h.posOffset !== void 0) {
+					const x = emuToPixels(h.posOffset);
+					if (x < contentWidth / 2) leftMargin = x + imgRun.width + distRight;
+					else rightMargin = contentWidth - x + distLeft;
+				}
+			} else if (imgRun.cssFloat === "left") leftMargin = imgRun.width + distRight;
+			else if (imgRun.cssFloat === "right") rightMargin = imgRun.width + distLeft;
+			if (leftMargin > 0 || rightMargin > 0) {
+				const isMarginRelative = position?.vertical?.relativeTo === "margin" || position?.vertical?.relativeTo === "page";
+				zones.push({
+					leftMargin,
+					rightMargin,
+					topY: topY - distTop,
+					bottomY: bottomY + distBottom,
+					anchorBlockIndex: blockIndex,
+					isMarginRelative
+				});
+			}
+		}
+	}
+	for (let blockIndex = 0; blockIndex < blocks.length; blockIndex++) {
+		const block = blocks[blockIndex];
+		if (block.kind !== "table") continue;
+		const tableBlock = block;
+		const floating = tableBlock.floating;
+		if (!floating) continue;
+		const tableMeasure = measureTableBlock(tableBlock, contentWidth);
+		const tableWidth = tableMeasure.totalWidth;
+		const tableHeight = tableMeasure.totalHeight;
+		const distLeft = floating.leftFromText ?? 12;
+		const distRight = floating.rightFromText ?? 12;
+		const distTop = floating.topFromText ?? 0;
+		const distBottom = floating.bottomFromText ?? 0;
+		let leftMargin = 0;
+		let rightMargin = 0;
+		let x = 0;
+		if (floating.tblpX !== void 0) x = floating.tblpX;
+		else if (floating.tblpXSpec) if (floating.tblpXSpec === "left" || floating.tblpXSpec === "inside") x = 0;
+		else if (floating.tblpXSpec === "right" || floating.tblpXSpec === "outside") x = contentWidth - tableWidth;
+		else x = (contentWidth - tableWidth) / 2;
+		else if (tableBlock.justification === "center") x = (contentWidth - tableWidth) / 2;
+		else if (tableBlock.justification === "right") x = contentWidth - tableWidth;
+		if (x < contentWidth / 2) leftMargin = x + tableWidth + distRight;
+		else rightMargin = contentWidth - x + distLeft;
+		const topY = floating.tblpY ?? 0;
+		const bottomY = topY + tableHeight;
+		zones.push({
+			leftMargin,
+			rightMargin,
+			topY: topY - distTop,
+			bottomY: bottomY + distBottom,
+			anchorBlockIndex: blockIndex
+		});
+	}
+	for (let blockIndex = 0; blockIndex < blocks.length; blockIndex++) {
+		const block = blocks[blockIndex];
+		if (block.kind !== "textBox") continue;
+		const tb = block;
+		if (!floatingTextBoxReservesBand(tb)) continue;
+		const v = tb.position?.vertical;
+		if (!isPageFrameRelativeAnchor(v?.relativeTo)) continue;
+		const height = measureTextBoxBlock(tb).height;
+		const distTop = tb.distTop ?? 0;
+		const distBottom = tb.distBottom ?? 0;
+		const blockMarginTop = perBlockNumberValue(marginTop, blockIndex, defaultMarginTop);
+		const rawTop = bandTopContentY(v, {
+			pageHeight: perBlockNumberValue(pageHeightInput, blockIndex, defaultPageHeight),
+			marginTop: blockMarginTop,
+			marginBottom: perBlockNumberValue(marginBottomInput, blockIndex, defaultMarginBottom),
+			boxHeight: height
+		});
+		const bottomY = rawTop + height + distBottom;
+		if (bottomY <= 0) continue;
+		zones.push({
+			leftMargin: 0,
+			rightMargin: 0,
+			topY: Math.max(0, rawTop - distTop),
+			bottomY,
+			anchorBlockIndex: blockIndex,
+			isMarginRelative: true,
+			fullWidthBlock: true
+		});
+	}
+	return zones;
+}
+/**
+* Measure a block based on its type.
+*/
+function measureBlock(block, contentWidth, floatingZones, cumulativeY, fieldValues) {
+	switch (block.kind) {
+		case "paragraph": {
+			const pBlock = block;
+			const hasFieldRuns = pBlock.runs.some((run) => run.kind === "field");
+			const cacheable = (!floatingZones || floatingZones.length === 0) && (!fieldValues || !hasFieldRuns);
+			if (cacheable) {
+				const cached = getCachedParagraphMeasure(pBlock, contentWidth);
+				if (cached) return cached;
+			}
+			const measureOpts = { paragraphYOffset: cumulativeY ?? 0 };
+			if (floatingZones) measureOpts.floatingZones = floatingZones;
+			if (fieldValues) measureOpts.fieldValues = fieldValues;
+			const result = measureParagraph(pBlock, contentWidth, measureOpts);
+			if (cacheable) setCachedParagraphMeasure(pBlock, contentWidth, result);
+			return result;
+		}
+		case "table": return measureTableBlock(block, contentWidth, fieldValues);
+		case "image": {
+			const imageBlock = block;
+			return {
+				kind: "image",
+				width: imageBlock.width,
+				height: imageBlock.height
+			};
+		}
+		case "textBox": return measureTextBoxBlock(block, fieldValues);
+		case "pageBreak": return { kind: "pageBreak" };
+		case "columnBreak": return { kind: "columnBreak" };
+		case "sectionBreak": return { kind: "sectionBreak" };
+		default: return {
+			kind: "paragraph",
+			lines: [],
+			totalHeight: 0
+		};
+	}
+}
+function measureTextBoxBlock(tb, fieldValues) {
+	const margins = tb.margins ?? DEFAULT_TEXTBOX_MARGINS;
+	const innerWidth = tb.width - margins.left - margins.right;
+	const innerMeasures = tb.content.map((p) => measureParagraph(p, innerWidth, fieldValues ? { fieldValues } : void 0));
+	const contentHeight = innerMeasures.reduce((sum, m) => sum + m.totalHeight, 0);
+	const totalHeight = tb.height ?? contentHeight + margins.top + margins.bottom;
+	return {
+		kind: "textBox",
+		width: tb.width,
+		height: totalHeight,
+		innerMeasures
+	};
+}
+/**
+* `true` for a section break that starts a new page (`nextPage`/`evenPage`/
+* `oddPage`, or an unspecified type, which the layout treats as `nextPage`).
+* A `continuous` break stays on the current page, so it does not open a fresh
+* page frame. Used by `measureBlocks` to reset the running Y for a page-pinned
+* band that lands right after the break. eigenpal #694.
+*/
+function isNextPageSectionBreak(block) {
+	return block.kind === "sectionBreak" && block.type !== "continuous";
+}
+/**
+* Measure all blocks with floating image support.
+*
+* Pre-scans all blocks to find floating images and creates exclusion zones.
+* Then measures each block, passing the zones so paragraphs can calculate
+* per-line widths based on vertical overlap with floating images.
+*/
+function measureBlocks(blocks, contentWidth, marginTop = 0, pageGeometry, fieldValues) {
+	const defaultWidth = Array.isArray(contentWidth) ? contentWidth[0] ?? 0 : contentWidth;
+	const floatingZonesWithAnchors = extractFloatingZones(blocks, defaultWidth, marginTop, pageGeometry);
+	const marginRelative = floatingZonesWithAnchors.filter((z) => z.isMarginRelative && !z.fullWidthBlock);
+	const ownAnchorZones = floatingZonesWithAnchors.filter((z) => !z.isMarginRelative || z.fullWidthBlock);
+	const marginByTopY = /* @__PURE__ */ new Map();
+	for (const z of marginRelative) {
+		const group = marginByTopY.get(z.topY) ?? [];
+		group.push(z);
+		marginByTopY.set(z.topY, group);
+	}
+	const adjustedZones = [...ownAnchorZones];
+	for (const group of marginByTopY.values()) {
+		const minAnchor = Math.min(...group.map((z) => z.anchorBlockIndex));
+		for (const z of group) adjustedZones.push({
+			...z,
+			anchorBlockIndex: minAnchor
+		});
+	}
+	const zonesByAnchor = /* @__PURE__ */ new Map();
+	for (const z of adjustedZones) {
+		const existing = zonesByAnchor.get(z.anchorBlockIndex) ?? [];
+		const { anchorBlockIndex: _anchorBlockIndex, isMarginRelative: _isMarginRelative, ...zone } = z;
+		existing.push(zone);
+		zonesByAnchor.set(z.anchorBlockIndex, existing);
+	}
+	const anchorIndices = new Set(zonesByAnchor.keys());
+	let cumulativeY = 0;
+	let pageRelativeY = 0;
+	let activeZones = [];
+	return blocks.map((block, blockIndex) => {
+		recordMeasureBlock(blockIndex, block);
+		if (block.kind === "pageBreak" || isNextPageSectionBreak(block)) {
+			activeZones = [];
+			cumulativeY = 0;
+			pageRelativeY = 0;
+		}
+		if (anchorIndices.has(blockIndex)) {
+			activeZones = zonesByAnchor.get(blockIndex) ?? [];
+			cumulativeY = activeZones.length > 0 && activeZones.every((z) => z.fullWidthBlock) ? pageRelativeY : 0;
+		}
+		const zones = activeZones.length > 0 ? activeZones : void 0;
+		try {
+			const blockWidth = Array.isArray(contentWidth) ? contentWidth[blockIndex] ?? defaultWidth : contentWidth;
+			const measure = measureBlock(block, blockWidth, zones, cumulativeY, fieldValues);
+			const bandZones = zones?.filter((zone) => zone.fullWidthBlock);
+			if (bandZones?.length && (measure.kind === "image" || measure.kind === "table" && !block.floating)) {
+				const blockHeight = measure.kind === "image" ? measure.height : measure.totalHeight;
+				const skip = findClearLineY(cumulativeY, blockHeight, bandZones, blockWidth, 24) - cumulativeY;
+				if (skip > 0) {
+					measure.bandSkipBefore = skip;
+					cumulativeY += skip;
+					pageRelativeY += skip;
+				}
+			}
+			if ("totalHeight" in measure && !(block.kind === "table" && block.floating)) {
+				cumulativeY += measure.totalHeight;
+				pageRelativeY += measure.totalHeight;
+			}
+			return measure;
+		} catch (error) {
+			recordMeasureBlockError(blockIndex, block, error);
+			const fallback = {
+				kind: "paragraph",
+				lines: [],
+				totalHeight: 20
+			};
+			cumulativeY += fallback.totalHeight;
+			pageRelativeY += fallback.totalHeight;
+			return fallback;
+		}
+	});
+}
+function measureSingleBlockWithoutFloatingZones(block, blockWidth, blockIndex) {
+	recordMeasureBlock(blockIndex, block);
+	return measureBlock(block, blockWidth);
+}
+//#endregion
+export { measureBlock, measureBlocks, measureSingleBlockWithoutFloatingZones, measureTableBlock, measureTableCellBlockVisualHeight, measureTextBoxBlock };

package/dist/layout-engine/measure/measureContainer.d.ts

@@ -0,0 +1,24 @@
+import { MeasureProvider } from "./measureProvider.js";
+
+//#region src/layout-engine/measure/measureContainer.d.ts
+/**
+ * Get or create a canvas 2D context for text measurement
+ */
+declare function getCanvasContext(): CanvasRenderingContext2D;
+/**
+ * Reset the canvas context (useful for testing)
+ */
+declare function resetCanvasContext(): void;
+/**
+ * Default provider backed by the canvas measurement functions above.
+ */
+declare const canvasMeasureProvider: MeasureProvider;
+/**
+ * Install the canvas backend as the active MeasureProvider. Called once at each
+ * composition root (the React editor's layout pipeline and the bun test
+ * preload) before any layout runs. Explicit call, not a module side effect, so
+ * importing this module never silently swaps the active provider.
+ */
+declare const installCanvasMeasureProvider: () => void;
+//#endregion
+export { canvasMeasureProvider, getCanvasContext, installCanvasMeasureProvider, resetCanvasContext };