@stll/folio-core 0.25.0 → 0.25.1

package/dist/layout-engine/index.js

@@ -560,20 +560,39 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 		const splittableRow = rows[currentRowIndex];
 		if (canSplitRow(currentRowIndex)) {
 			let consumed = 0;
+			const renderedBreakHints = tableRowHasTrackedChanges(block, currentRowIndex) ? [] : breakInfo.renderedBreakHints[currentRowIndex] ?? [];
+			let renderedBreakHintIndex = 0;
+			const discardPassedRenderedBreakHints = () => {
+				while ((renderedBreakHints[renderedBreakHintIndex]?.offset ?? Infinity) <= consumed) renderedBreakHintIndex += 1;
+			};
+			const advanceAfterNaturalFlowBreak = (previousPageNumber) => {
+				discardPassedRenderedBreakHints();
+				if (paginator.getCurrentState().page.number > previousPageNumber && renderedBreakHintIndex < renderedBreakHints.length) renderedBreakHintIndex += 1;
+			};
 			while (consumed < splittableRow.height) {
 				const sliceState = paginator.getCurrentState();
 				const repeatHeaderRows = shouldRepeatHeaderRows(currentRowIndex, consumed, sliceState);
 				const headerOverhead = repeatHeaderRows ? headerRowsHeight : 0;
 				const sliceAvail = paginator.getAvailableHeight() - headerOverhead - (consumed === 0 ? sliceState.trailingSpacing : 0);
 				let slice = snapRowBreak(breakInfo, currentRowIndex, consumed, sliceAvail);
+				let forceRenderedPageBreak = false;
 				if (slice <= 0) {
 					if (!(sliceState.cursorY === sliceState.topMargin && sliceState.page.fragments.length === 0)) {
+						const previousPageNumber = sliceState.page.number;
 						paginator.forceColumnBreak();
+						advanceAfterNaturalFlowBreak(previousPageNumber);
 						continue;
 					}
 					const from = consumed;
 					slice = (breakInfo.breakOffsets[currentRowIndex]?.find((o) => o > from) ?? splittableRow.height) - consumed;
 				}
+				discardPassedRenderedBreakHints();
+				const renderedBreakHint = renderedBreakHints[renderedBreakHintIndex];
+				if (renderedBreakHint && renderedBreakHint.offset <= consumed + slice && sliceAvail - (renderedBreakHint.offset - consumed) <= renderedBreakHint.lineAdvance * RENDERED_BREAK_REFLOW_TOLERANCE_LINES) {
+					slice = renderedBreakHint.offset - consumed;
+					renderedBreakHintIndex += 1;
+					forceRenderedPageBreak = true;
+				}
 				const sliceBottom = consumed + slice;
 				const continuationSkip = sliceBottom < splittableRow.height ? getRowContinuationSkip(breakInfo, currentRowIndex, sliceBottom) : 0;
 				const nextConsumed = Math.min(splittableRow.height, sliceBottom + continuationSkip);
@@ -601,7 +620,12 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 				sliceFragment.y = sliceResult.y;
 				sliceFragment.x = computeTableX(sliceResult.state.columnIndex);
 				consumed = nextConsumed;
-				if (consumed < splittableRow.height) paginator.forceColumnBreak();
+				if (consumed < splittableRow.height) if (forceRenderedPageBreak) paginator.forcePageBreak();
+				else {
+					const previousPageNumber = paginator.getCurrentState().page.number;
+					paginator.forceColumnBreak();
+					advanceAfterNaturalFlowBreak(previousPageNumber);
+				}
 			}
 			currentRowIndex += 1;
 			continue;

package/dist/layout-engine/tableRowBreak.d.ts

@@ -1,5 +1,9 @@
 import { TableBlock, TableMeasure } from "./types.js";
 //#region src/layout-engine/tableRowBreak.d.ts
+type RenderedRowBreakHint = {
+  offset: number;
+  lineAdvance: number;
+};
 /** Precomputed break geometry for a table. */
 type TableRowBreakInfo = {
   /** Cumulative y of the top of each row; `rowTops[rows.length]` is the table height. */
@@ -10,6 +14,8 @@ type TableRowBreakInfo = {
    * final boundary.
    */
   breakOffsets: number[][];
+  /** Safe cached page boundaries within each row, relative to the row top. */
+  renderedBreakHints: RenderedRowBreakHint[][];
   /** Suppressible leading paragraph whitespace after each matching break offset. */
   continuationSkips: number[][];
 };

package/dist/layout-engine/tableRowBreak.js

@@ -1,3 +1,4 @@
+import { measuredLineAdvance } from "./lineFlow.js";
 import { measureParagraph } from "./measure/measureParagraph.js";
 import { buildTableCellFloatingZones, getTableCellContentWidth, getTableCellFloatingImages } from "./measure/tableCellFloating.js";
 import { createTableCellFlowState, placeTableCellBlock } from "./measure/tableCellFlow.js";
@@ -32,6 +33,10 @@ function shiftCellGeometry(geometry, offset) {
 	if (offset <= 0) return geometry;
 	return {
 		bottoms: geometry.bottoms.map((bottom) => bottom + offset),
+		renderedBreakHints: geometry.renderedBreakHints.map((hint) => ({
+			offset: hint.offset + offset,
+			lineAdvance: hint.lineAdvance
+		})),
 		unsafeRanges: geometry.unsafeRanges.map((range) => ({
 			top: range.top + offset,
 			bottom: range.bottom + offset
@@ -45,6 +50,7 @@ function shiftCellGeometry(geometry, offset) {
 /** Cumulative break geometry within a single cell's content. */
 function cellBreakGeometry(cell, measure) {
 	const bottoms = [];
+	const renderedBreakHints = [];
 	const unsafeRanges = [];
 	const suppressibleLeadingRanges = [];
 	const cellBlocks = cell?.blocks;
@@ -71,6 +77,10 @@ function cellBreakGeometry(cell, measure) {
 			for (const line of blockMeasure.lines) {
 				y += line.floatSkipBefore ?? 0;
 				const top = y;
+				if (line.renderedPageBreakBefore === true) renderedBreakHints.push({
+					offset: top,
+					lineAdvance: measuredLineAdvance(line)
+				});
 				y += line.lineHeight;
 				unsafeRanges.push({
 					top,
@@ -97,10 +107,23 @@ function cellBreakGeometry(cell, measure) {
 	}
 	return {
 		bottoms,
+		renderedBreakHints,
 		unsafeRanges,
 		suppressibleLeadingRanges
 	};
 }
+const mergeRenderedBreakHints = (hints) => {
+	const merged = [];
+	for (const hint of hints.sort((a, b) => a.offset - b.offset)) {
+		const previous = merged.at(-1);
+		if (previous && Math.abs(previous.offset - hint.offset) <= BREAK_OFFSET_EPSILON) {
+			previous.lineAdvance = Math.max(previous.lineAdvance, hint.lineAdvance);
+			continue;
+		}
+		merged.push({ ...hint });
+	}
+	return merged;
+};
 const continuationSkipForCell = (geometry, offset) => {
 	if (!geometry.unsafeRanges.some(({ bottom }) => bottom > offset + BREAK_OFFSET_EPSILON)) return;
 	const leadingRange = geometry.suppressibleLeadingRanges.find(({ top, bottom }) => top <= offset + BREAK_OFFSET_EPSILON && bottom > offset + BREAK_OFFSET_EPSILON);
@@ -128,6 +151,7 @@ function buildTableRowBreakInfo(block, measure) {
 	}
 	rowTops.push(acc);
 	const breakOffsets = [];
+	const renderedBreakHints = [];
 	const continuationSkips = [];
 	for (let r = 0; r < rowCount; r++) {
 		const rowHeight = measure.rows[r]?.height ?? 0;
@@ -146,11 +170,13 @@ function buildTableRowBreakInfo(block, measure) {
 		}
 		const sortedOffsets = [...offsets].filter((offset) => offset === rowHeight || cellGeometries.every((geometry) => geometry.unsafeRanges.every((range) => !isInsideRange(offset, range)))).sort((a, b) => a - b);
 		breakOffsets.push(sortedOffsets);
+		renderedBreakHints.push(mergeRenderedBreakHints(cellGeometries.flatMap((geometry) => geometry.renderedBreakHints).filter(({ offset }) => offset > BREAK_OFFSET_EPSILON && offset < rowHeight - BREAK_OFFSET_EPSILON && cellGeometries.every((geometry) => geometry.unsafeRanges.every((range) => !isInsideRange(offset, range))))));
 		continuationSkips.push(sortedOffsets.map((offset) => continuationSkipAfter(cellGeometries, offset)));
 	}
 	return {
 		rowTops,
 		breakOffsets,
+		renderedBreakHints,
 		continuationSkips
 	};
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stll/folio-core",
-  "version": "0.25.0",
+  "version": "0.25.1",
   "description": "Headless, framework-neutral core of folio: the OOXML (.docx) parser, document model, ProseMirror integration, and page-layout engine. No React.",
   "keywords": [
     "document-model",