Bookmarks are a mark, not a point: both formats store a range, and only a range lets a REF recompute its text. A cross-reference caches its display like a Word field and resolves live on each pagination settle — the bookmark's text, or the page it renders on — keeping the cached value when the target is gone. Ctrl+click jumps to it, internal #name links too. ODF splices its sentinels into the run text so cells and custom paragraphs need no separate emitter; DOCX needs no post-pass at all.
1348 lines
63 KiB
TypeScript
1348 lines
63 KiB
TypeScript
import { Extension } from '@tiptap/core';
|
|
import { Plugin, PluginKey } from '@tiptap/pm/state';
|
|
import { Decoration, DecorationSet, type EditorView } from '@tiptap/pm/view';
|
|
import { COLUMNS_FIT_MARGIN_PX } from './columns';
|
|
|
|
export type PageBreakDebugSnapshot = {
|
|
timestamp: string;
|
|
layout: {
|
|
PAGE_HEIGHT: number;
|
|
PAGE_GAP: number;
|
|
PAGE_MARGIN_TOP: number;
|
|
PAGE_MARGIN_BOTTOM: number;
|
|
CONTENT_HEIGHT: number;
|
|
CYCLE: number;
|
|
};
|
|
numPages: number;
|
|
leaves: Array<{
|
|
index: number;
|
|
tag: string;
|
|
kind: 'atomic' | 'splittable';
|
|
// inTableCell = leaf lives in a cell of a too-tall row (content split). tableRow
|
|
// = leaf is a whole table row (columns = colspan to bridge; isFirstRow breaks
|
|
// before the wrapper rather than mid-table).
|
|
inTableCell: boolean;
|
|
tableRow: { columns: number; isFirstRow: boolean } | null;
|
|
naturalTop: number;
|
|
naturalHeight: number;
|
|
textPreview: string;
|
|
intraSpacerHeights: number[];
|
|
effectiveTop: number;
|
|
effectiveBottom: number;
|
|
pageOfTop: number;
|
|
pageOfBottom: number;
|
|
contentStart: number;
|
|
contentEnd: number;
|
|
overflowsPageEnd: boolean;
|
|
}>;
|
|
placements: Array<{
|
|
leafIndex: number;
|
|
docPos: number | null;
|
|
height: number;
|
|
reason: string;
|
|
// How the gap was bridged: 'table-row' = borderless <tr> spacer inside the
|
|
// table (columns = its colspan), 'block' = normal <div> block spacer,
|
|
// 'none' = no spacer emitted (e.g. an over-tall leaf that couldn't be pushed).
|
|
spacerKind: 'block' | 'table-row' | 'none';
|
|
columns: number | null;
|
|
}>;
|
|
renderedSpacers: Array<{
|
|
height: number;
|
|
offsetTopInDoc: number;
|
|
viewportTop: number;
|
|
}>;
|
|
// In-cell table page breaks (where a too-tall cell's content flows across a page).
|
|
// Unscaled document px relative to .tiptap's top — same values handed to
|
|
// Editor.svelte via pm-pagecount to render the mask + gap overlay.
|
|
tableBreakBands: TableBreakBand[];
|
|
// Live snapshot of the rendered table-break overlay + table geometry, to check the
|
|
// band-layer actually masks the table borders bleeding through each gap. Rects are
|
|
// unscaled doc px relative to .tiptap (same space as leaves/bands). null before mount.
|
|
overlay: OverlayDebug | null;
|
|
};
|
|
|
|
export type OverlayDebug = {
|
|
scale: number; // measured .paper transform scale (1 at 100% zoom)
|
|
paperFound: boolean;
|
|
bandLayerFound: boolean;
|
|
// .band-layer's top/left in doc px relative to .tiptap. Should be ~(0,0): a non-zero
|
|
// value means the overlay's coordinate origin is offset from the page, so every band
|
|
// is painted off its intended gap (a prime suspect for "mask present but not covering").
|
|
bandLayerOrigin: { top: number; left: number } | null;
|
|
// Resolved page colours, to confirm the mask is opaque and the right colour.
|
|
cssVars: { pageBg: string; pageBorder: string; bg: string };
|
|
// Rendered .table-break-band mask rects (one per band) + their paint-relevant styles.
|
|
bands: Array<{
|
|
top: number; left: number; right: number; bottom: number;
|
|
width: number; height: number; background: string; zIndex: string; position: string;
|
|
}>;
|
|
// Rendered .page-gap-stripe rects.
|
|
stripes: Array<{ top: number; left: number; right: number; bottom: number; height: number }>;
|
|
// Every <table> in the doc: its rendered box + the x of each vertical cell border
|
|
// (the lines that bleed). A table taller than CONTENT_HEIGHT spans page gaps, so its
|
|
// verticalEdges are exactly the lines a band must cover in each gap.
|
|
tables: Array<{
|
|
top: number; left: number; right: number; bottom: number;
|
|
borderColor: string;
|
|
verticalEdges: number[];
|
|
}>;
|
|
};
|
|
|
|
// One page boundary crossed by a single continuous table box. All values are unscaled
|
|
// document px relative to .tiptap's top; Editor.svelte renders the mask + gap overlay
|
|
// from them inside the zoomed .paper. Carried on the pm-pagecount event detail.
|
|
export type TableBreakBand = {
|
|
// Rounded openY (page-content-top where the table resumes) — the dedup id, so two
|
|
// columns breaking at the same boundary collapse to one band.
|
|
key: number;
|
|
closeY: number; // content-end of the closing page (band/mask top)
|
|
height: number; // bandSpan = marginBottom + gap + marginTop
|
|
// True when the break falls between whole table rows: the rows' own cell borders
|
|
// already cap the table at the gap, so only the gap stripe is painted (no mask /
|
|
// close-open lines, which would double the real borders). False for in-cell splits.
|
|
rowBreak: boolean;
|
|
left: number; // content-area left (mask left)
|
|
width: number; // content-area width (mask width)
|
|
marginBottom: number;
|
|
gap: number;
|
|
};
|
|
|
|
const debugAccessors = new WeakMap<EditorView, () => PageBreakDebugSnapshot | null>();
|
|
|
|
export function getPageBreakDebug(view: EditorView): PageBreakDebugSnapshot | null {
|
|
return debugAccessors.get(view)?.() ?? null;
|
|
}
|
|
|
|
// A4 page layout constants (px @96dpi). Page height (orientation-dependent) and
|
|
// margins (user-adjustable) are read per pass from live CSS vars; the values below
|
|
// are only portrait fallbacks.
|
|
const PAGE_HEIGHT = 1123;
|
|
const PAGE_GAP = 20;
|
|
const DEFAULT_MARGIN_TOP = 96;
|
|
const DEFAULT_MARGIN_BOTTOM = 96;
|
|
// Word/LibreOffice widow-orphan control: a page break never leaves fewer than this
|
|
// many lines of a paragraph behind, nor carries fewer than this many over. On by
|
|
// default in both (OOXML `w:widowControl`), so it is not configurable here.
|
|
const MIN_KEPT_LINES = 2;
|
|
|
|
export type VMargins = {
|
|
top: number;
|
|
bottom: number;
|
|
contentHeight: number;
|
|
pageHeight: number;
|
|
cycle: number;
|
|
};
|
|
|
|
// Reads vertical page margins + page height (px) from the --user-* props the Layout
|
|
// panel writes (document-px, pairing directly with offsetTop below); side margins
|
|
// are ignored (they affect line wrapping, not pagination). Shared with columnsFlow.ts.
|
|
export function readVerticalMargins(dom: HTMLElement): VMargins {
|
|
const cs = getComputedStyle(dom);
|
|
// Header/footer-aware effective margins (Editor.svelte): equal the raw page margins
|
|
// unless a header/footer grows past them, in which case the content area shrinks so
|
|
// body text starts below the header / ends above the footer.
|
|
const topEff = parseFloat(cs.getPropertyValue('--pb-content-top-rest'));
|
|
const top = Number.isFinite(topEff) ? topEff : parseFloat(cs.getPropertyValue('--user-margin-top'));
|
|
const bottomEff = parseFloat(cs.getPropertyValue('--pb-content-bottom-rest'));
|
|
const bottom = Number.isFinite(bottomEff) ? bottomEff : parseFloat(cs.getPropertyValue('--user-margin-bottom'));
|
|
const ph = parseFloat(cs.getPropertyValue('--user-page-height'));
|
|
const mt = Number.isFinite(top) ? top : DEFAULT_MARGIN_TOP;
|
|
const mb = Number.isFinite(bottom) ? bottom : DEFAULT_MARGIN_BOTTOM;
|
|
const pageHeight = Number.isFinite(ph) ? ph : PAGE_HEIGHT;
|
|
return {
|
|
top: mt,
|
|
bottom: mb,
|
|
contentHeight: pageHeight - mt - mb,
|
|
pageHeight,
|
|
cycle: pageHeight + PAGE_GAP,
|
|
};
|
|
}
|
|
|
|
// Rendered page of an element: its offsetTop within the editor DOM (summed up the
|
|
// offsetParent chain, spacers included) divided by the page cycle. The TOC and every
|
|
// cross-reference resolve their page numbers with it.
|
|
export function pageOfElement(view: EditorView, el: HTMLElement, cycle: number): number {
|
|
const tiptap = view.dom as HTMLElement;
|
|
let top = 0;
|
|
let n: HTMLElement | null = el;
|
|
while (n && n !== tiptap) {
|
|
top += n.offsetTop;
|
|
n = n.offsetParent as HTMLElement | null;
|
|
}
|
|
return Math.max(1, Math.floor(top / cycle) + 1);
|
|
}
|
|
|
|
function pageContentStart(page: number, marginTop: number, cycle: number): number {
|
|
return (page - 1) * cycle + marginTop;
|
|
}
|
|
|
|
function pageContentEnd(page: number, marginTop: number, contentHeight: number, cycle: number): number {
|
|
return (page - 1) * cycle + marginTop + contentHeight;
|
|
}
|
|
|
|
function getPageForY(y: number, cycle: number): number {
|
|
return Math.floor(y / cycle) + 1;
|
|
}
|
|
|
|
// `recalc` counts forced recomputes, `edit` the document edits. Layout-only writes
|
|
// (addToHistory:false) bump neither, so the convergence brake in `update` can tell an
|
|
// answer to the last pass from a fresh change.
|
|
type PageBreakState = { recalc: number; edit: number };
|
|
|
|
const pageBreakKey = new PluginKey<PageBreakState>('pageBreaks');
|
|
|
|
// Transaction meta flag: set it (e.g. when page margins change) to force a
|
|
// pagination recompute even though the document content is unchanged.
|
|
export const FORCE_PAGE_RECALC = 'forcePageBreakRecalc';
|
|
|
|
type Leaf = {
|
|
el: HTMLElement;
|
|
kind: 'atomic' | 'splittable';
|
|
naturalTop: number;
|
|
naturalHeight: number;
|
|
// Set when the leaf is a <tr> of a paginated table; each row is atomic so the
|
|
// table breaks between rows across pages. `isFirstRow` pushes the whole table (block
|
|
// spacer before the wrapper); later rows push via a spacer <tr> inside the table.
|
|
tableRow?: { columns: number; wrapperEl: HTMLElement; isFirstRow: boolean };
|
|
// True for paragraph leaves from inside a too-tall cell whose content flows across
|
|
// pages. Their breaks get a full-width close/open mask so the single continuous
|
|
// table box looks closed at each page break (it can't break structurally).
|
|
inTableCell?: boolean;
|
|
// Manual page break before this block (ODF fo:break-before; pageBreak.ts): force the
|
|
// leaf to the next page's top even when it would otherwise fit on the current page.
|
|
forceBreakBefore?: boolean;
|
|
// Keep with next (DOCX w:keepNext, ODF fo:keep-with-next; pageBreak.ts): the leaf
|
|
// moves to the next page when its successor's first line no longer fits below it.
|
|
keepNext?: boolean;
|
|
// First block of a new section (pageBreak.ts `sectionBreak`): the page it lands on
|
|
// is where that section's header/footer starts repeating.
|
|
sectionStart?: boolean;
|
|
// Flow brackets for a too-tall row's cells (each cell is an independent flow from
|
|
// the row top, so placement resets cumulative shift per cell): cellStart = a cell's
|
|
// first leaf, rowStart = the row's first cell, rowEnd = last leaf of the last cell.
|
|
cellStart?: boolean;
|
|
rowStart?: boolean;
|
|
rowEnd?: boolean;
|
|
// A multi-column section fragment (columns.ts): pagination only pushes it when
|
|
// the first block alone can't fit the remaining space (else columnsFlow.ts splits
|
|
// the overflow at a block boundary).
|
|
columnsFragment?: { blockCount: number; firstBlockNeededPx: number };
|
|
};
|
|
|
|
const ATOMIC_TAGS = new Set(['H1', 'H2', 'H3', 'H4', 'H5', 'H6']);
|
|
const SPLITTABLE_TAGS = new Set(['P']);
|
|
const CONTAINER_TAGS = new Set(['UL', 'OL', 'LI', 'BLOCKQUOTE']);
|
|
|
|
export const PageBreaks = Extension.create({
|
|
name: 'pageBreaks',
|
|
|
|
addProseMirrorPlugins() {
|
|
let decorations = DecorationSet.empty;
|
|
let isUpdating = false;
|
|
let rafId: number | null = null;
|
|
let lastPlacementsKey = '';
|
|
// The layout before the current one. A block below a float's overhang moves further
|
|
// than the spacer the model accounts for, so two layouts can each imply the other —
|
|
// seeing the older one come back means a ping-pong, and the current one is kept.
|
|
let prevPlacementsKey = '';
|
|
// Each pass measures against the spacers left by the previous pass, so a changed
|
|
// result needs one more pass to re-measure and settle (see calculate). Bounded so
|
|
// a hypothetical two-layout ping-pong can't loop forever; reset per external change.
|
|
let convergePasses = 0;
|
|
const MAX_CONVERGE_PASSES = 4;
|
|
|
|
const plugin = new Plugin<PageBreakState>({
|
|
key: pageBreakKey,
|
|
// Counters `update` watches. The plugin's own decoration dispatches carry neither
|
|
// FORCE_PAGE_RECALC nor a doc change, so this never self-triggers.
|
|
state: {
|
|
init: () => ({ recalc: 0, edit: 0 }),
|
|
apply(tr, value) {
|
|
const recalc = value.recalc + (tr.getMeta(FORCE_PAGE_RECALC) ? 1 : 0);
|
|
const edit = value.edit
|
|
+ (tr.docChanged && tr.getMeta('addToHistory') !== false ? 1 : 0);
|
|
return recalc === value.recalc && edit === value.edit ? value : { recalc, edit };
|
|
},
|
|
},
|
|
props: {
|
|
decorations() {
|
|
return decorations;
|
|
},
|
|
},
|
|
view(editorView) {
|
|
let lastSnapshot: PageBreakDebugSnapshot | null = null;
|
|
|
|
debugAccessors.set(editorView, (): PageBreakDebugSnapshot | null => {
|
|
const snap: PageBreakDebugSnapshot | null = lastSnapshot;
|
|
if (snap === null) return null;
|
|
const dom = editorView.dom;
|
|
const tipRect = dom.getBoundingClientRect();
|
|
const renderedSpacers = Array.from(
|
|
dom.querySelectorAll<HTMLElement>('[data-page-break-spacer]'),
|
|
).map((sp) => {
|
|
const r = sp.getBoundingClientRect();
|
|
return {
|
|
height: sp.offsetHeight,
|
|
offsetTopInDoc: r.top - tipRect.top,
|
|
viewportTop: r.top,
|
|
};
|
|
});
|
|
return { ...snap, renderedSpacers, overlay: captureOverlay(tipRect) };
|
|
});
|
|
|
|
// Capture the rendered table-break overlay + table geometry from the live DOM.
|
|
// .band-layer is a sibling inside .paper, reached by climbing to .paper. Viewport
|
|
// rects are divided by the paper scale → unscaled doc px, same space as bands/leaves.
|
|
function captureOverlay(tipRect: DOMRect): OverlayDebug {
|
|
const dom = editorView.dom;
|
|
const offH = dom.offsetHeight;
|
|
const scale = offH ? tipRect.height / offH : 1;
|
|
const toDoc = (r: DOMRect) => ({
|
|
top: (r.top - tipRect.top) / scale,
|
|
bottom: (r.bottom - tipRect.top) / scale,
|
|
left: (r.left - tipRect.left) / scale,
|
|
right: (r.right - tipRect.left) / scale,
|
|
});
|
|
const paper = dom.closest('.paper') as HTMLElement | null;
|
|
const bandLayer = paper?.querySelector('.band-layer') as HTMLElement | null;
|
|
const bandEls = paper
|
|
? Array.from(paper.querySelectorAll<HTMLElement>('.table-break-band'))
|
|
: [];
|
|
const stripeEls = paper
|
|
? Array.from(paper.querySelectorAll<HTMLElement>('.page-gap-stripe'))
|
|
: [];
|
|
const cs = getComputedStyle(dom);
|
|
return {
|
|
scale,
|
|
paperFound: !!paper,
|
|
bandLayerFound: !!bandLayer,
|
|
bandLayerOrigin: bandLayer
|
|
? (() => { const d = toDoc(bandLayer.getBoundingClientRect()); return { top: d.top, left: d.left }; })()
|
|
: null,
|
|
cssVars: {
|
|
pageBg: cs.getPropertyValue('--color-page-bg').trim(),
|
|
pageBorder: cs.getPropertyValue('--color-page-border').trim(),
|
|
bg: cs.getPropertyValue('--color-bg').trim(),
|
|
},
|
|
bands: bandEls.map((e) => {
|
|
const d = toDoc(e.getBoundingClientRect());
|
|
const ecs = getComputedStyle(e);
|
|
return {
|
|
top: d.top, left: d.left, right: d.right, bottom: d.bottom,
|
|
width: d.right - d.left, height: d.bottom - d.top,
|
|
background: ecs.backgroundColor, zIndex: ecs.zIndex, position: ecs.position,
|
|
};
|
|
}),
|
|
stripes: stripeEls.map((e) => {
|
|
const d = toDoc(e.getBoundingClientRect());
|
|
return { top: d.top, left: d.left, right: d.right, bottom: d.bottom, height: d.bottom - d.top };
|
|
}),
|
|
tables: Array.from(dom.querySelectorAll<HTMLElement>('table')).map((t) => {
|
|
const d = toDoc(t.getBoundingClientRect());
|
|
// x of each vertical cell border: use the first body row's cells' left edges
|
|
// plus the row's right edge. These are the lines that bleed across gaps.
|
|
const firstRow = t.querySelector('tbody > tr:not([data-page-break-spacer])') as HTMLElement | null;
|
|
const cells = firstRow
|
|
? (Array.from(firstRow.children) as HTMLElement[]).filter(c => c.tagName === 'TD' || c.tagName === 'TH')
|
|
: [];
|
|
const verticalEdges: number[] = [];
|
|
for (const c of cells) verticalEdges.push(toDoc(c.getBoundingClientRect()).left);
|
|
if (cells.length) verticalEdges.push(toDoc(cells[cells.length - 1].getBoundingClientRect()).right);
|
|
const firstCell = cells[0];
|
|
return {
|
|
top: d.top, left: d.left, right: d.right, bottom: d.bottom,
|
|
borderColor: firstCell ? getComputedStyle(firstCell).borderTopColor : '',
|
|
verticalEdges,
|
|
};
|
|
}),
|
|
};
|
|
}
|
|
|
|
function docPosBeforeElement(el: HTMLElement): number | null {
|
|
const parent = el.parentNode;
|
|
if (!parent) return null;
|
|
const childIndex = Array.from(parent.childNodes).indexOf(el as ChildNode);
|
|
if (childIndex < 0) return null;
|
|
try {
|
|
return editorView.posAtDOM(parent as Node, childIndex);
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// The display scale (.paper has `transform: scale()`): the ratio of .tiptap's
|
|
// painted height to its unscaled offsetHeight. findLineSplit uses it to convert
|
|
// scaled glyph rects back to document px.
|
|
function getScaleFactor(): number {
|
|
const r = editorView.dom.getBoundingClientRect();
|
|
const h = editorView.dom.offsetHeight;
|
|
return h ? r.height / h : 1;
|
|
}
|
|
|
|
function previousNonSpacerSibling(el: HTMLElement): HTMLElement | null {
|
|
let prev = el.previousElementSibling as HTMLElement | null;
|
|
while (prev && prev.dataset?.pageBreakSpacer) {
|
|
prev = prev.previousElementSibling as HTMLElement | null;
|
|
}
|
|
return prev;
|
|
}
|
|
|
|
// Render the spacer OUTSIDE any <li> wrapper so the bullet marker stays
|
|
// aligned with its text. Walk up <li> ancestors, but stop once `target` has a
|
|
// prior sibling, or we'd also push earlier paragraphs already placed in the LI.
|
|
function preLeafDocPos(leafEl: HTMLElement): number | null {
|
|
let target = leafEl;
|
|
while (
|
|
target.parentElement &&
|
|
target.parentElement.tagName === 'LI' &&
|
|
!previousNonSpacerSibling(target)
|
|
) {
|
|
target = target.parentElement;
|
|
}
|
|
return docPosBeforeElement(target);
|
|
}
|
|
|
|
// Where to place a leaf's page-break spacer, and whether it must be a
|
|
// table row (so the widget is valid markup inside a <tbody>).
|
|
function leafSpacer(leaf: Leaf): { docPos: number | null; row: { columns: number } | null } {
|
|
if (leaf.tableRow) {
|
|
// First row crossing the boundary → push the whole table with a block
|
|
// spacer before the wrapper (otherwise the table's top would be
|
|
// orphaned above an in-table gap).
|
|
if (leaf.tableRow.isFirstRow) {
|
|
return { docPos: preLeafDocPos(leaf.tableRow.wrapperEl), row: null };
|
|
}
|
|
// Later rows → a spacer <tr> before the row pushes it (and the rows
|
|
// after it) to the next page while the table stays one element.
|
|
return { docPos: docPosBeforeElement(leaf.el), row: { columns: leaf.tableRow.columns } };
|
|
}
|
|
return { docPos: preLeafDocPos(leaf.el), row: null };
|
|
}
|
|
|
|
// Walks text nodes and inline images inside `el`, skipping any that live inside
|
|
// a spacer widget, and returns one rect per visual line (in viewport coords).
|
|
function getLineRects(el: HTMLElement): { top: number; bottom: number }[] {
|
|
const allRects: DOMRect[] = [];
|
|
// An as-character image is a line box of its own: without it a paragraph of
|
|
// images has no lines at all and can only paginate whole.
|
|
const atomRects = new Set<DOMRect>();
|
|
for (const img of Array.from(el.querySelectorAll<HTMLElement>('.image-node'))) {
|
|
if (img.style.float) continue;
|
|
const rect = img.getBoundingClientRect();
|
|
if (rect.width > 0 && rect.height > 0) {
|
|
allRects.push(rect);
|
|
atomRects.add(rect);
|
|
}
|
|
}
|
|
const walker = document.createTreeWalker(el, NodeFilter.SHOW_TEXT, {
|
|
acceptNode(node) {
|
|
let parent = node.parentElement;
|
|
while (parent && parent !== el) {
|
|
if ((parent as HTMLElement).dataset?.pageBreakSpacer) {
|
|
return NodeFilter.FILTER_REJECT;
|
|
}
|
|
parent = parent.parentElement;
|
|
}
|
|
return NodeFilter.FILTER_ACCEPT;
|
|
},
|
|
});
|
|
let textNode: Node | null;
|
|
while ((textNode = walker.nextNode())) {
|
|
if (!textNode.textContent || textNode.textContent.length === 0) continue;
|
|
const range = document.createRange();
|
|
range.selectNodeContents(textNode);
|
|
for (const rect of Array.from(range.getClientRects())) {
|
|
if (rect.width > 0 && rect.height > 0) allRects.push(rect);
|
|
}
|
|
}
|
|
allRects.sort((a, b) => a.top - b.top);
|
|
// Estimate the line advance (top-to-top distance) from the gaps between
|
|
// rects, ignoring near-zero gaps (multiple runs on one line).
|
|
const gaps: number[] = [];
|
|
for (let i = 1; i < allRects.length; i++) {
|
|
const g = allRects[i].top - allRects[i - 1].top;
|
|
if (g > 2) gaps.push(g);
|
|
}
|
|
gaps.sort((a, b) => a - b);
|
|
const advance = gaps.length ? gaps[gaps.length >> 1] : 0;
|
|
// Group rects into lines by top proximity, not overlap: decorative fonts (e.g.
|
|
// Trattatello) make ink boxes taller than the advance, so an overlap test would
|
|
// chain paragraphs into one phantom line. Tolerance is a fraction of the advance.
|
|
const tol = advance > 0 ? advance * 0.6 : 3;
|
|
const lines: { top: number; bottom: number }[] = [];
|
|
let lineTop = -Infinity;
|
|
// How far down the current line still reaches: an image's own box (text beside
|
|
// it starts well below the image top), otherwise the tolerance alone.
|
|
let lineEnd = -Infinity;
|
|
for (const r of allRects) {
|
|
const isAtom = atomRects.has(r);
|
|
if (r.top - lineTop > tol && r.top >= lineEnd) {
|
|
lines.push({ top: r.top, bottom: r.bottom });
|
|
lineTop = r.top;
|
|
lineEnd = isAtom ? r.bottom - 1 : r.top + tol;
|
|
} else {
|
|
const last = lines[lines.length - 1];
|
|
last.bottom = Math.max(last.bottom, r.bottom);
|
|
if (isAtom) lineEnd = Math.max(lineEnd, r.bottom - 1);
|
|
}
|
|
}
|
|
return lines;
|
|
}
|
|
|
|
// `minLines` is the widow-orphan minimum, or 1 for a leaf taller than one page
|
|
// slot — there the rule is unsatisfiable and splitting beats overflowing.
|
|
// What a keep-with-next block has to fit below itself: the successor's first
|
|
// line, in unscaled doc px. An empty block falls back to its whole height.
|
|
function firstLineHeight(el: HTMLElement, scale: number): number {
|
|
const first = getLineRects(el)[0];
|
|
return first ? (first.bottom - first.top) / scale : el.offsetHeight;
|
|
}
|
|
|
|
function findLineSplit(
|
|
el: HTMLElement,
|
|
overflowDistance: number,
|
|
scale: number,
|
|
minLines: number,
|
|
): { naturalLineTop: number; docPos: number } | null {
|
|
const lines = getLineRects(el);
|
|
if (lines.length === 0) return null;
|
|
const elRect = el.getBoundingClientRect();
|
|
|
|
// Pre-existing spacers inside this leaf distort the viewport y of lines below
|
|
// them. Build a map: viewport y → natural offset within the leaf (unscaled, no
|
|
// intra-spacers). offsetHeight is already unscaled, so it isn't divided.
|
|
const intraSpacers = Array.from(
|
|
el.querySelectorAll<HTMLElement>('[data-page-break-spacer]'),
|
|
)
|
|
.map((sp) => {
|
|
const r = sp.getBoundingClientRect();
|
|
return { viewportTop: r.top, height: sp.offsetHeight };
|
|
})
|
|
.sort((a, b) => a.viewportTop - b.viewportTop);
|
|
|
|
// Returns the line's offset within the leaf in unscaled document
|
|
// pixels, with intra-leaf spacers subtracted.
|
|
function toNatural(viewportY: number): number {
|
|
let dropped = 0;
|
|
for (const sp of intraSpacers) {
|
|
if (sp.viewportTop < viewportY) dropped += sp.height;
|
|
}
|
|
return (viewportY - elRect.top) / scale - dropped;
|
|
}
|
|
|
|
// Line-box bottom in natural coords. getClientRects reports glyph bottoms,
|
|
// which sit a hair above the layout line-box, missing sub-pixel overflows. Use
|
|
// the next line's top (and offsetHeight for the last line) as the boundary.
|
|
const intraSpacerTotal = intraSpacers.reduce((s, sp) => s + sp.height, 0);
|
|
const leafNaturalHeight = el.offsetHeight - intraSpacerTotal;
|
|
function lineBoxBottomNatural(i: number): number {
|
|
if (i + 1 < lines.length) return toNatural(lines[i + 1].top);
|
|
return leafNaturalHeight;
|
|
}
|
|
|
|
let k = -1;
|
|
for (let i = 0; i < lines.length; i++) {
|
|
if (lineBoxBottomNatural(i) > overflowDistance + 0.5) {
|
|
k = i;
|
|
break;
|
|
}
|
|
}
|
|
if (k <= 0) return null;
|
|
// Widow: too few lines would carry over, so take one more down with them.
|
|
if (lines.length - k < minLines) k = lines.length - minLines;
|
|
// Orphan: too few lines would stay behind — the caller pushes the whole
|
|
// block to the next page instead, which is what Word/LibreOffice do.
|
|
if (k < minLines) return null;
|
|
|
|
const naturalLineTop = toNatural(lines[k].top);
|
|
// Binary search runs in viewport space (coordsAtPos returns scaled
|
|
// viewport coords just like Range.getClientRects()), so the target
|
|
// stays unscaled-free here.
|
|
const targetViewportTop = lines[k].top;
|
|
|
|
let startPos: number;
|
|
let endPos: number;
|
|
try {
|
|
startPos = editorView.posAtDOM(el, 0);
|
|
const $start = editorView.state.doc.resolve(startPos);
|
|
endPos = startPos + $start.parent.content.size;
|
|
} catch {
|
|
return null;
|
|
}
|
|
|
|
let lo = startPos;
|
|
let hi = endPos;
|
|
while (lo < hi) {
|
|
const mid = (lo + hi) >> 1;
|
|
let midTop: number;
|
|
try {
|
|
midTop = editorView.coordsAtPos(mid).top;
|
|
} catch {
|
|
lo = mid + 1;
|
|
continue;
|
|
}
|
|
if (midTop >= targetViewportTop - 0.5) {
|
|
hi = mid;
|
|
} else {
|
|
lo = mid + 1;
|
|
}
|
|
}
|
|
return { naturalLineTop, docPos: lo };
|
|
}
|
|
|
|
function collectLeaves(contentHeight: number, scaleFactor: number): Leaf[] {
|
|
const dom = editorView.dom;
|
|
const leaves: Leaf[] = [];
|
|
// cumulativeSpacerHeight accumulates spacer offsetHeights (unscaled
|
|
// layout px), matching the offsetHeight-based naturalHeight.
|
|
let cumulativeSpacerHeight = 0;
|
|
|
|
// A leaf's border-box top within .tiptap, in document px. Summing offsetTop up
|
|
// the offsetParent chain is unaffected by .paper's transform:scale, so it's the
|
|
// same at every zoom; the chain ends at .tiptap so the origin is the page top.
|
|
function topWithin(el: HTMLElement): number {
|
|
let top = 0;
|
|
let node: HTMLElement | null = el;
|
|
while (node && node !== dom) {
|
|
top += node.offsetTop;
|
|
node = node.offsetParent as HTMLElement | null;
|
|
}
|
|
return top;
|
|
}
|
|
|
|
// Emit one atomic leaf per table row so the table breaks between rows across
|
|
// pages (a whole table is usually taller than a page). TipTap renders tables as
|
|
// <div class="tableWrapper"><table><colgroup><tbody>…, so walk the tbody rows.
|
|
function walkTableRows(wrapperEl: HTMLElement, inTableCell = false) {
|
|
const tableEl = (wrapperEl.tagName === 'TABLE'
|
|
? wrapperEl
|
|
: wrapperEl.querySelector('table')) as HTMLElement | null;
|
|
const tbody = tableEl?.querySelector('tbody') as HTMLElement | null;
|
|
const rowEls = tbody
|
|
? (Array.from(tbody.children) as HTMLElement[])
|
|
: [];
|
|
const realRows = rowEls.filter(r => r.tagName === 'TR' && !r.dataset?.pageBreakSpacer);
|
|
// Fallback: no rows found — measure the whole wrapper as one atomic leaf.
|
|
if (realRows.length === 0) {
|
|
leaves.push({
|
|
el: wrapperEl,
|
|
kind: 'atomic',
|
|
naturalTop: topWithin(wrapperEl) - cumulativeSpacerHeight,
|
|
naturalHeight: wrapperEl.offsetHeight,
|
|
});
|
|
return;
|
|
}
|
|
const colgroup = tableEl?.querySelector('colgroup');
|
|
const columns = colgroup?.children.length || realRows[0].children.length || 1;
|
|
let seenRealRow = false;
|
|
for (const tr of rowEls) {
|
|
if (tr.dataset?.pageBreakSpacer) {
|
|
cumulativeSpacerHeight += tr.offsetHeight;
|
|
continue;
|
|
}
|
|
if (tr.tagName !== 'TR') continue;
|
|
const rowHeight = tr.offsetHeight;
|
|
if (rowHeight <= contentHeight) {
|
|
// Row fits on a page → atomic leaf; the table breaks between rows.
|
|
leaves.push({
|
|
el: tr,
|
|
kind: 'atomic',
|
|
naturalTop: topWithin(tr) - cumulativeSpacerHeight,
|
|
naturalHeight: rowHeight,
|
|
tableRow: { columns, wrapperEl, isFirstRow: !seenRealRow },
|
|
});
|
|
} else {
|
|
// Row taller than a page: each cell is an independent flow from the row
|
|
// top, breaking in its own column. Walk every cell, resetting the spacer
|
|
// baseline per cell; the row consumes the tallest cell's spacers.
|
|
const cells = (Array.from(tr.children) as HTMLElement[]).filter(
|
|
c => c.tagName === 'TD' || c.tagName === 'TH',
|
|
);
|
|
const baseline = cumulativeSpacerHeight;
|
|
let maxDelta = 0;
|
|
let rowStartSet = false;
|
|
let rowLastLeafIdx = -1;
|
|
for (const cell of cells) {
|
|
cumulativeSpacerHeight = baseline; // reset for this cell's flow
|
|
const startIdx = leaves.length;
|
|
walk(cell, true);
|
|
if (leaves.length > startIdx) {
|
|
leaves[startIdx].cellStart = true;
|
|
if (!rowStartSet) {
|
|
leaves[startIdx].rowStart = true;
|
|
rowStartSet = true;
|
|
}
|
|
rowLastLeafIdx = leaves.length - 1;
|
|
}
|
|
maxDelta = Math.max(maxDelta, cumulativeSpacerHeight - baseline);
|
|
}
|
|
// The row's height grows by the tallest cell's spacer total.
|
|
cumulativeSpacerHeight = baseline + maxDelta;
|
|
if (rowLastLeafIdx >= 0) leaves[rowLastLeafIdx].rowEnd = true;
|
|
}
|
|
seenRealRow = true;
|
|
}
|
|
}
|
|
|
|
function walk(container: HTMLElement, inTableCell = false) {
|
|
for (const child of Array.from(container.children) as HTMLElement[]) {
|
|
if (child.dataset?.pageBreakSpacer) {
|
|
cumulativeSpacerHeight += child.offsetHeight;
|
|
continue;
|
|
}
|
|
// Skip the resize-handle widgets (tableColumnResize/tableRowResize), which
|
|
// are position:absolute — not flow content, and measuring one yields garbage
|
|
// geometry. Out of flow, so skip without touching cumulativeSpacerHeight.
|
|
if (
|
|
child.classList.contains('column-resize-handle') ||
|
|
child.classList.contains('row-resize-handle')
|
|
) {
|
|
continue;
|
|
}
|
|
const tag = child.tagName;
|
|
// TipTap renders tables inside a <div class="tableWrapper"> node
|
|
// view (see extensions.ts Table config), so the top-level child is
|
|
// the wrapper DIV, not the TABLE. Break the table into per-row leaves.
|
|
if (tag === 'TABLE' || (tag === 'DIV' && child.classList.contains('tableWrapper'))) {
|
|
walkTableRows(child, inTableCell);
|
|
continue;
|
|
}
|
|
// The generated table of contents (tableOfContents.ts) is a block atom with
|
|
// no inner doc positions, so it can't be line-split — measure it atomically
|
|
// (pushed whole if it overflows; a TOC taller than a page can't be pushed).
|
|
if (child.dataset?.toc) {
|
|
leaves.push({
|
|
el: child,
|
|
kind: 'atomic',
|
|
naturalTop: topWithin(child) - cumulativeSpacerHeight,
|
|
naturalHeight: child.offsetHeight,
|
|
inTableCell,
|
|
});
|
|
continue;
|
|
}
|
|
// A text box paginates atomically: a line-split spacer can't render
|
|
// sanely inside a rotated/floated node view.
|
|
if (child.classList.contains('textbox-node')) {
|
|
leaves.push({
|
|
el: child,
|
|
kind: 'atomic',
|
|
naturalTop: topWithin(child) - cumulativeSpacerHeight,
|
|
naturalHeight: child.offsetHeight,
|
|
inTableCell,
|
|
});
|
|
continue;
|
|
}
|
|
// A multi-column section fragment: also atomic for spacer purposes (a
|
|
// spacer inside a multicol container rebalances around it), but the
|
|
// placement logic defers overflow to columnsFlow.ts via columnsFragment.
|
|
if (child.classList.contains('columns-node')) {
|
|
const count = Math.max(1, parseInt(child.dataset?.columns ?? '', 10) || 1);
|
|
const first = child.firstElementChild as HTMLElement | null;
|
|
let firstPx = 0;
|
|
if (first) {
|
|
for (const r of Array.from(first.getClientRects())) firstPx += r.height;
|
|
firstPx = firstPx / scaleFactor / count;
|
|
}
|
|
leaves.push({
|
|
el: child,
|
|
kind: 'atomic',
|
|
naturalTop: topWithin(child) - cumulativeSpacerHeight,
|
|
naturalHeight: child.offsetHeight,
|
|
inTableCell,
|
|
columnsFragment: {
|
|
blockCount: child.children.length,
|
|
firstBlockNeededPx: Math.max(firstPx, 16),
|
|
},
|
|
});
|
|
continue;
|
|
}
|
|
// A paragraph holding a floated image paginates atomically: a line-split
|
|
// spacer beside the float is dropped by ProseMirror. As-character images
|
|
// are ordinary line boxes, so their paragraph breaks between lines.
|
|
const splittableTag = SPLITTABLE_TAGS.has(tag);
|
|
const floats = Array.from(child.querySelectorAll<HTMLElement>('.image-node'))
|
|
.filter((img) => !!img.style.float);
|
|
const hasImage = splittableTag && floats.length > 0;
|
|
// Keep lines together (w:keepLines, fo:keep-together): the block moves
|
|
// whole. One taller than a page still splits — as it does in Word.
|
|
const keepLines = child.dataset?.keepLines === 'true' && child.offsetHeight <= contentHeight;
|
|
const isAtomic = ATOMIC_TAGS.has(tag) || hasImage || (splittableTag && keepLines);
|
|
const isSplittable = splittableTag && !hasImage && !keepLines;
|
|
if (isAtomic || isSplittable) {
|
|
let intraSpacerHeight = 0;
|
|
for (const sp of Array.from(
|
|
child.querySelectorAll<HTMLElement>('[data-page-break-spacer]'),
|
|
)) {
|
|
intraSpacerHeight += sp.offsetHeight;
|
|
}
|
|
// A float hangs out of its paragraph's box, so offsetHeight stops above
|
|
// it and the image would walk off the page bottom. Reach down to the
|
|
// lowest float instead — that space belongs to this leaf.
|
|
let floatBottom = 0;
|
|
if (floats.length) {
|
|
const top = child.getBoundingClientRect().top;
|
|
for (const img of floats) {
|
|
const below = (img.getBoundingClientRect().bottom - top) / scaleFactor;
|
|
floatBottom = Math.max(floatBottom, below);
|
|
}
|
|
}
|
|
leaves.push({
|
|
el: child,
|
|
kind: isAtomic ? 'atomic' : 'splittable',
|
|
naturalTop: topWithin(child) - cumulativeSpacerHeight,
|
|
naturalHeight: Math.max(child.offsetHeight, floatBottom) - intraSpacerHeight,
|
|
inTableCell,
|
|
// A manual page break is honored for top-level blocks only (not in
|
|
// a table cell, where the table breaks atomically between rows).
|
|
forceBreakBefore: !inTableCell && child.dataset?.pageBreakBefore === 'page',
|
|
// A heading keeps with the next block in both Word and LibreOffice,
|
|
// so their styles carry it and the attr only marks the other blocks.
|
|
keepNext: !inTableCell
|
|
&& (child.dataset?.keepNext === 'true' || /^H[1-5]$/.test(child.tagName)),
|
|
sectionStart: !inTableCell && child.dataset?.sectionBreak === 'true',
|
|
});
|
|
cumulativeSpacerHeight += intraSpacerHeight;
|
|
continue;
|
|
}
|
|
if (CONTAINER_TAGS.has(tag)) {
|
|
walk(child, inTableCell);
|
|
continue;
|
|
}
|
|
// Unknown block. Out-of-flow elements (absolute/fixed) can't be paginated
|
|
// and measure as garbage, so skip them. getComputedStyle is read only here,
|
|
// off the common path, to avoid a per-child reflow cost.
|
|
const position = getComputedStyle(child).position;
|
|
if (position === 'absolute' || position === 'fixed') continue;
|
|
// Otherwise measure as a splittable leaf with no intra-spacers.
|
|
leaves.push({
|
|
el: child,
|
|
kind: 'splittable',
|
|
naturalTop: topWithin(child) - cumulativeSpacerHeight,
|
|
naturalHeight: child.offsetHeight,
|
|
inTableCell,
|
|
});
|
|
}
|
|
}
|
|
|
|
walk(dom);
|
|
return leaves;
|
|
}
|
|
|
|
function calculate() {
|
|
rafId = null;
|
|
if (isUpdating || !editorView.dom.isConnected) return;
|
|
isUpdating = true;
|
|
|
|
const dom = editorView.dom;
|
|
void dom.offsetHeight; // force reflow
|
|
|
|
const vm = readVerticalMargins(dom);
|
|
const CONTENT_HEIGHT = vm.contentHeight;
|
|
const CYCLE_PX = vm.cycle;
|
|
|
|
// Side margins + page width (px) for table close/open bands. These don't
|
|
// affect pagination (only line wrapping), so readVerticalMargins ignores
|
|
// them; we read them here just to size the bands to the content width.
|
|
const csRoot = getComputedStyle(dom);
|
|
const mlRaw = parseFloat(csRoot.getPropertyValue('--user-margin-left'));
|
|
const mrRaw = parseFloat(csRoot.getPropertyValue('--user-margin-right'));
|
|
const pwRaw = parseFloat(csRoot.getPropertyValue('--user-page-width'));
|
|
const marginLeft = Number.isFinite(mlRaw) ? mlRaw : 80;
|
|
const contentWidth = (Number.isFinite(pwRaw) ? pwRaw : 794) - marginLeft - (Number.isFinite(mrRaw) ? mrRaw : 80);
|
|
// Page 1's own header/footer (different first page) may reach further than the
|
|
// others, so its content starts lower / ends sooner; each falls back to the
|
|
// shared effective margin.
|
|
const ctFirst = parseFloat(csRoot.getPropertyValue('--pb-content-top-first'));
|
|
const effTopFirst = Number.isFinite(ctFirst) ? ctFirst : vm.top;
|
|
const cbFirst = parseFloat(csRoot.getPropertyValue('--pb-content-bottom-first'));
|
|
const effBottomFirst = Number.isFinite(cbFirst) ? cbFirst : vm.bottom;
|
|
// Each section's own reaches (Editor.svelte), so a later section's tall header
|
|
// clears its own pages. Missing/short → the document-wide pair above.
|
|
const reach = csRoot.getPropertyValue('--pb-section-reach').split(',')
|
|
.map((g) => g.split('|').map(Number))
|
|
.filter((g) => g.length === 4 && g.every(Number.isFinite));
|
|
const reachAt = (i: number) => reach[Math.min(i, reach.length - 1)]
|
|
?? [effTopFirst, vm.top, effBottomFirst, vm.bottom];
|
|
|
|
const scale = getScaleFactor();
|
|
const leaves = collectLeaves(CONTENT_HEIGHT, scale);
|
|
|
|
let cumulativeShift = 0;
|
|
// Per-cell flow bracketing for a too-tall row (see Leaf flow markers): each
|
|
// cell restarts from the shift inherited at the row top; the row then
|
|
// advances the main shift by the tallest cell's added shift.
|
|
let rowBaseline = 0;
|
|
let maxCellDelta = 0;
|
|
// Lowest rendered content bottom across all leaves (incl. parallel cells),
|
|
// used for the page count — a single last-leaf reading misses taller cells.
|
|
let maxEffectiveBottom = 0;
|
|
// Page each section after the first begins on, in body order — the layer picks
|
|
// a page's header/footer set from it.
|
|
const sectionStartPages: number[] = [];
|
|
let sectionIndex = 0;
|
|
let sectionFirstPage = 1;
|
|
const placements: {
|
|
docPos: number;
|
|
height: number;
|
|
row: { columns: number } | null;
|
|
}[] = [];
|
|
// Node-decoration range collapsing the trailing empty paragraph after a
|
|
// document-final columns chain when it sits past the page content area.
|
|
let collapsedTrailing: { from: number; to: number } | null = null;
|
|
// Close/open bands for in-cell + between-rows table breaks. Keyed by the
|
|
// rounded openY (the grouping id) → the unrounded openY (so the band lands
|
|
// exactly on the page cycle) plus whether it's a between-rows break.
|
|
const tableBands = new Map<number, { openY: number; rowBreak: boolean }>();
|
|
const leavesDebug: PageBreakDebugSnapshot['leaves'] = [];
|
|
const placementsDebug: PageBreakDebugSnapshot['placements'] = [];
|
|
|
|
for (let i = 0; i < leaves.length; i++) {
|
|
const leaf = leaves[i];
|
|
// Enter a cell flow: capture the previous cell's added shift, then restart
|
|
// this cell from the row baseline so its measured tops align.
|
|
if (leaf.cellStart) {
|
|
if (leaf.rowStart) {
|
|
rowBaseline = cumulativeShift;
|
|
maxCellDelta = 0;
|
|
} else {
|
|
maxCellDelta = Math.max(maxCellDelta, cumulativeShift - rowBaseline);
|
|
}
|
|
cumulativeShift = rowBaseline;
|
|
}
|
|
const effectiveTop = leaf.naturalTop + cumulativeShift;
|
|
const effectiveBottom = effectiveTop + leaf.naturalHeight;
|
|
const page = getPageForY(effectiveTop, CYCLE_PX);
|
|
// A section's first page uses its "first" reaches, every other page its
|
|
// "rest" ones — page 1 is section 1's first page.
|
|
if (leaf.sectionStart) {
|
|
// Where the section really begins: a forced break moves its first block to
|
|
// the next page, and that page is the one its "first" zones belong to.
|
|
const prevStart = (page - 1) * CYCLE_PX + reachAt(sectionIndex)[1];
|
|
const pushed = !!leaf.forceBreakBefore && i > 0 && effectiveTop > prevStart + 0.5;
|
|
sectionIndex++;
|
|
sectionFirstPage = pushed ? page + 1 : page;
|
|
}
|
|
const [topFirst, topRest, bottomFirst, bottomRest] = reachAt(sectionIndex);
|
|
const onFirst = page === sectionFirstPage;
|
|
const pageTop = (page - 1) * CYCLE_PX;
|
|
const contentStart = pageTop + (onFirst ? topFirst : topRest);
|
|
const contentEnd = pageTop + vm.pageHeight - (onFirst ? bottomFirst : bottomRest);
|
|
|
|
// A leaf may need several spacers: a splittable block taller than one
|
|
// page crosses multiple boundaries, one break each.
|
|
const breaks: {
|
|
height: number;
|
|
docPos: number | null;
|
|
row: { columns: number } | null;
|
|
bandOpenY: number | null;
|
|
reason: string;
|
|
}[] = [];
|
|
// Set when a leaf overflows but no spacer can bridge it (block > one page).
|
|
let noPushReason: string | null = null;
|
|
|
|
// A sequential-fill chain's fragment box may run to the page bottom, which
|
|
// would shove this trailing empty paragraph onto a phantom extra page —
|
|
// leave it in place and out of the page count; typed text re-enables it.
|
|
if (
|
|
i === leaves.length - 1 &&
|
|
leaf.el.tagName === 'P' &&
|
|
!(leaf.el.textContent ?? '').length &&
|
|
leaves[i - 1]?.columnsFragment
|
|
) {
|
|
// Past the content area its height (+ .tiptap bottom padding) grows the
|
|
// element into the next page cycle, where the background gradient paints
|
|
// a phantom page top — collapse it visually (height:0 node decoration).
|
|
if (effectiveBottom > contentEnd) {
|
|
const from = docPosBeforeElement(leaf.el);
|
|
const node = from !== null ? editorView.state.doc.nodeAt(from) : null;
|
|
if (from !== null && node) collapsedTrailing = { from, to: from + node.nodeSize };
|
|
}
|
|
leavesDebug.push({
|
|
index: i,
|
|
tag: leaf.el.tagName,
|
|
kind: leaf.kind,
|
|
inTableCell: !!leaf.inTableCell,
|
|
tableRow: null,
|
|
naturalTop: leaf.naturalTop,
|
|
naturalHeight: leaf.naturalHeight,
|
|
textPreview: '',
|
|
intraSpacerHeights: [],
|
|
effectiveTop,
|
|
effectiveBottom,
|
|
pageOfTop: page,
|
|
pageOfBottom: getPageForY(effectiveBottom, CYCLE_PX),
|
|
contentStart,
|
|
contentEnd,
|
|
overflowsPageEnd: effectiveBottom > contentEnd,
|
|
});
|
|
placementsDebug.push({
|
|
leafIndex: i,
|
|
docPos: null,
|
|
height: 0,
|
|
reason: collapsedTrailing
|
|
? 'trailing-empty-after-columns-collapsed'
|
|
: 'trailing-empty-after-columns',
|
|
spacerKind: 'none',
|
|
columns: null,
|
|
});
|
|
continue;
|
|
}
|
|
|
|
// A manual page break forces the block to the next page's top (never the first
|
|
// leaf, so no leading blank page); once settled at a page top the guard stops.
|
|
// A forced block that then overflows is split by the normal logic next pass.
|
|
const forced = !!leaf.forceBreakBefore && i > 0 && effectiveTop > contentStart + 0.5;
|
|
|
|
if (forced) {
|
|
// The next page's own content start: a section beginning here brings its
|
|
// first-page header with it.
|
|
const nextTop = page + 1 === sectionFirstPage ? topFirst : topRest;
|
|
const target = pageContentStart(page + 1, nextTop, CYCLE_PX);
|
|
const { docPos, row } = leafSpacer(leaf);
|
|
breaks.push({
|
|
height: target - effectiveTop,
|
|
docPos,
|
|
row,
|
|
bandOpenY: target,
|
|
reason: 'forced-page-break',
|
|
});
|
|
} else if (effectiveTop < contentStart && (i > 0 || effectiveTop < contentStart - 1)) {
|
|
// i === 0 only reaches here when a tall header on page 1 pushes the very
|
|
// first block down below its content start (a >1px gap); otherwise the
|
|
// first block already sits at the content start.
|
|
const { docPos, row } = leafSpacer(leaf);
|
|
breaks.push({
|
|
height: contentStart - effectiveTop,
|
|
docPos,
|
|
row,
|
|
bandOpenY: contentStart,
|
|
reason: 'pre-leaf-push-to-content-start',
|
|
});
|
|
} else if (effectiveTop >= contentEnd) {
|
|
const target = pageContentStart(page + 1, vm.top, CYCLE_PX);
|
|
const { docPos, row } = leafSpacer(leaf);
|
|
breaks.push({
|
|
height: target - effectiveTop,
|
|
docPos,
|
|
row,
|
|
bandOpenY: target,
|
|
reason: 'leaf-jump-to-next-page',
|
|
});
|
|
} else if (effectiveBottom > contentEnd) {
|
|
if (leaf.kind === 'atomic') {
|
|
const cf = leaf.columnsFragment;
|
|
if (cf && cf.blockCount > 1 && cf.firstBlockNeededPx + COLUMNS_FIT_MARGIN_PX <= contentEnd - effectiveTop) {
|
|
// columnsFlow.ts will split the fragment so a prefix fills this
|
|
// page; pushing it whole here would fight that.
|
|
noPushReason = 'columns-await-flow';
|
|
} else if (cf && effectiveTop <= contentStart + 0.5) {
|
|
// Already at a page top and still too tall (a paragraph taller
|
|
// than the page slot): pushing just moves the problem one page
|
|
// down forever — the flow line-splits the paragraph instead.
|
|
noPushReason = 'columns-line-split-pending';
|
|
} else if (leaf.naturalHeight <= CONTENT_HEIGHT || cf) {
|
|
// A columns fragment may be pushed even when taller than a page:
|
|
// the flow splits it again once it sits at the next page top.
|
|
const target = pageContentStart(page + 1, vm.top, CYCLE_PX);
|
|
const { docPos, row } = leafSpacer(leaf);
|
|
breaks.push({
|
|
height: target - effectiveTop,
|
|
docPos,
|
|
row,
|
|
bandOpenY: target,
|
|
reason: 'atomic-push-to-next-page',
|
|
});
|
|
} else {
|
|
noPushReason = 'atomic-too-tall-no-push';
|
|
}
|
|
} else {
|
|
// A splittable leaf taller than one page crosses several boundaries:
|
|
// keep splitting until the rest fits. Boundaries are in the leaf's
|
|
// spacer-free natural coords, so successive splits stay correct.
|
|
let boundaryNatural = contentEnd - effectiveTop;
|
|
let targetPage = page + 1;
|
|
let extraShift = 0;
|
|
const guarded = leaf.naturalHeight <= CONTENT_HEIGHT
|
|
&& leaf.el.getAttribute('data-widow-control') !== 'false';
|
|
const minLines = guarded ? MIN_KEPT_LINES : 1;
|
|
while (boundaryNatural < leaf.naturalHeight) {
|
|
const split = findLineSplit(leaf.el, boundaryNatural, scale, minLines);
|
|
if (split === null) break;
|
|
const target = pageContentStart(targetPage, vm.top, CYCLE_PX);
|
|
const h = target - (effectiveTop + extraShift + split.naturalLineTop);
|
|
if (h <= 0) break;
|
|
breaks.push({
|
|
height: h,
|
|
docPos: split.docPos,
|
|
row: null,
|
|
bandOpenY: target,
|
|
reason: 'line-split',
|
|
});
|
|
extraShift += h;
|
|
boundaryNatural = split.naturalLineTop + CONTENT_HEIGHT;
|
|
targetPage++;
|
|
}
|
|
if (breaks.length === 0) {
|
|
if (leaf.naturalHeight <= CONTENT_HEIGHT) {
|
|
const target = pageContentStart(page + 1, vm.top, CYCLE_PX);
|
|
breaks.push({
|
|
height: target - effectiveTop,
|
|
docPos: preLeafDocPos(leaf.el),
|
|
row: null,
|
|
bandOpenY: target,
|
|
reason: 'split-fallback-push-whole-leaf',
|
|
});
|
|
} else {
|
|
noPushReason = 'splittable-too-tall-no-push';
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Keep with next: a heading that fits but whose successor's first line does
|
|
// not is left stranded at the page foot, so it goes down with it. One level
|
|
// only — a run of them would need the pass to reconsider earlier leaves.
|
|
if (
|
|
breaks.length === 0 && leaf.keepNext && i + 1 < leaves.length
|
|
&& effectiveTop > contentStart + 0.5
|
|
) {
|
|
const next = leaves[i + 1];
|
|
const needed = next.kind === 'atomic'
|
|
? Math.min(next.naturalHeight, CONTENT_HEIGHT)
|
|
: firstLineHeight(next.el, scale);
|
|
if (effectiveBottom + needed > contentEnd) {
|
|
const target = pageContentStart(page + 1, vm.top, CYCLE_PX);
|
|
const { docPos, row } = leafSpacer(leaf);
|
|
breaks.push({
|
|
height: target - effectiveTop,
|
|
docPos,
|
|
row,
|
|
bandOpenY: target,
|
|
reason: 'keep-with-next',
|
|
});
|
|
}
|
|
}
|
|
|
|
leavesDebug.push({
|
|
index: i,
|
|
tag: leaf.el.tagName,
|
|
kind: leaf.kind,
|
|
inTableCell: !!leaf.inTableCell,
|
|
tableRow: leaf.tableRow
|
|
? { columns: leaf.tableRow.columns, isFirstRow: leaf.tableRow.isFirstRow }
|
|
: null,
|
|
naturalTop: leaf.naturalTop,
|
|
naturalHeight: leaf.naturalHeight,
|
|
textPreview: (leaf.el.textContent ?? '').slice(0, 120),
|
|
intraSpacerHeights: Array.from(
|
|
leaf.el.querySelectorAll<HTMLElement>('[data-page-break-spacer]'),
|
|
).map((sp) => sp.offsetHeight),
|
|
effectiveTop,
|
|
effectiveBottom,
|
|
pageOfTop: page,
|
|
pageOfBottom: getPageForY(effectiveBottom, CYCLE_PX),
|
|
contentStart,
|
|
contentEnd,
|
|
overflowsPageEnd: effectiveBottom > contentEnd,
|
|
});
|
|
|
|
// Round each spacer to integer px (the browser renders spacers at integer
|
|
// height, so an unrounded model shakes 1px per keystroke at non-100% zoom).
|
|
let placedAny = false;
|
|
for (const br of breaks) {
|
|
if (br.docPos === null) continue;
|
|
const h = Math.round(br.height);
|
|
if (h <= 0) continue;
|
|
// In-cell or between-rows breaks sit inside the continuous table box,
|
|
// whose borders bleed through the gap, so they need a close/open band.
|
|
const inBand = !!leaf.inTableCell || br.row !== null;
|
|
if (inBand && br.bandOpenY !== null) {
|
|
const key = Math.round(br.bandOpenY);
|
|
const rowBreak = br.row !== null;
|
|
const existing = tableBands.get(key);
|
|
if (!existing) tableBands.set(key, { openY: br.bandOpenY, rowBreak });
|
|
// An in-cell break sharing the boundary needs the full mask, so a
|
|
// band stays rowBreak only if every break at this key is one.
|
|
else if (!rowBreak) existing.rowBreak = false;
|
|
}
|
|
placements.push({ docPos: br.docPos, height: h, row: br.row });
|
|
placementsDebug.push({
|
|
leafIndex: i,
|
|
docPos: br.docPos,
|
|
height: h,
|
|
reason: br.reason,
|
|
spacerKind: br.row ? 'table-row' : 'block',
|
|
columns: br.row ? br.row.columns : null,
|
|
});
|
|
cumulativeShift += h;
|
|
placedAny = true;
|
|
}
|
|
if (!placedAny && noPushReason !== null) {
|
|
placementsDebug.push({
|
|
leafIndex: i,
|
|
docPos: null,
|
|
height: 0,
|
|
reason: noPushReason,
|
|
spacerKind: 'none',
|
|
columns: null,
|
|
});
|
|
}
|
|
|
|
// Read after this leaf's own spacer, so the page is the one it really lands on.
|
|
if (leaf.sectionStart) {
|
|
sectionStartPages.push(getPageForY(leaf.naturalTop + cumulativeShift, CYCLE_PX));
|
|
}
|
|
// Track the lowest rendered content bottom (cumulativeShift now includes
|
|
// this leaf's own spacer, so a pushed/split leaf counts at its real spot).
|
|
maxEffectiveBottom = Math.max(
|
|
maxEffectiveBottom,
|
|
leaf.naturalTop + cumulativeShift + leaf.naturalHeight,
|
|
);
|
|
// Leave a cell flow: the row's added shift is its tallest cell's; the main
|
|
// flow continues below the row from there.
|
|
if (leaf.rowEnd) {
|
|
maxCellDelta = Math.max(maxCellDelta, cumulativeShift - rowBaseline);
|
|
cumulativeShift = rowBaseline + maxCellDelta;
|
|
}
|
|
}
|
|
|
|
// Skip the decoration rebuild + dispatch when placements are identical to the
|
|
// previous pass. Most keystrokes don't change pagination, and re-dispatching
|
|
// recreates the spacer DOM nodes (no `key` on the widgets) for no gain.
|
|
const placementsKey =
|
|
placements.map((p) => `${p.docPos}:${p.height}:${p.row ? p.row.columns : 'b'}`).join('|') +
|
|
(collapsedTrailing ? `|c${collapsedTrailing.from}` : '');
|
|
const placementsChanged =
|
|
placementsKey !== lastPlacementsKey && placementsKey !== prevPlacementsKey;
|
|
if (placementsChanged) {
|
|
prevPlacementsKey = lastPlacementsKey;
|
|
lastPlacementsKey = placementsKey;
|
|
const doc = editorView.state.doc;
|
|
const decoArray: Decoration[] = placements.map((p) => {
|
|
if (p.row) {
|
|
// A table breaks between rows: the spacer must be a <tr> so it's
|
|
// valid inside <tbody> and creates a borderless gap that pushes
|
|
// the following rows to the next page.
|
|
const trEl = document.createElement('tr');
|
|
trEl.dataset.pageBreakSpacer = 'true';
|
|
trEl.setAttribute('contenteditable', 'false');
|
|
const tdEl = document.createElement('td');
|
|
tdEl.dataset.pageBreakSpacerCell = 'true';
|
|
tdEl.setAttribute('colspan', String(p.row.columns));
|
|
tdEl.style.height = `${p.height}px`;
|
|
trEl.appendChild(tdEl);
|
|
return Decoration.widget(p.docPos, trEl, { side: -1 });
|
|
}
|
|
const spacerEl = document.createElement('div');
|
|
spacerEl.dataset.pageBreakSpacer = 'true';
|
|
spacerEl.style.height = `${p.height}px`;
|
|
spacerEl.style.pointerEvents = 'none';
|
|
spacerEl.style.userSelect = 'none';
|
|
spacerEl.setAttribute('contenteditable', 'false');
|
|
return Decoration.widget(p.docPos, spacerEl, { side: -1 });
|
|
});
|
|
if (collapsedTrailing) {
|
|
decoArray.push(Decoration.node(collapsedTrailing.from, collapsedTrailing.to, {
|
|
style: 'height:0;min-height:0;margin:0;overflow:hidden',
|
|
}));
|
|
}
|
|
|
|
decorations = decoArray.length > 0
|
|
? DecorationSet.create(doc, decoArray)
|
|
: DecorationSet.empty;
|
|
|
|
const tr = editorView.state.tr.setMeta('addToHistory', false).setMeta(pageBreakKey, true);
|
|
editorView.dispatch(tr);
|
|
}
|
|
|
|
// maxEffectiveBottom is the lowest rendered content across all leaves,
|
|
// including parallel cells of a too-tall row (a single last-leaf reading
|
|
// would miss a taller sibling column).
|
|
const numPages = Math.max(1, getPageForY(maxEffectiveBottom, CYCLE_PX));
|
|
const targetHeight = numPages * CYCLE_PX - PAGE_GAP;
|
|
dom.style.minHeight = `${targetHeight}px`;
|
|
|
|
// In-cell table breaks (all values in unscaled document px relative to
|
|
// .tiptap's top). Editor.svelte renders the mask + gap overlay from these.
|
|
const bandSpan = vm.bottom + PAGE_GAP + vm.top;
|
|
const tableBreakBands = Array.from(tableBands, ([key, info]) => ({
|
|
key,
|
|
closeY: info.openY - bandSpan,
|
|
height: bandSpan,
|
|
rowBreak: info.rowBreak,
|
|
left: marginLeft,
|
|
width: contentWidth,
|
|
marginBottom: vm.bottom,
|
|
gap: PAGE_GAP,
|
|
}));
|
|
|
|
// docHeight (document px) lets Editor.svelte size the scaled scroll footprint.
|
|
dom.dispatchEvent(new CustomEvent('pm-pagecount', {
|
|
bubbles: true,
|
|
detail: { numPages, docHeight: targetHeight, tableBreakBands, sectionStartPages },
|
|
}));
|
|
|
|
lastSnapshot = {
|
|
timestamp: new Date().toISOString(),
|
|
layout: {
|
|
PAGE_HEIGHT: vm.pageHeight,
|
|
PAGE_GAP,
|
|
PAGE_MARGIN_TOP: vm.top,
|
|
PAGE_MARGIN_BOTTOM: vm.bottom,
|
|
CONTENT_HEIGHT,
|
|
CYCLE: CYCLE_PX,
|
|
},
|
|
numPages,
|
|
leaves: leavesDebug,
|
|
placements: placementsDebug,
|
|
renderedSpacers: [],
|
|
tableBreakBands,
|
|
overlay: null, // filled in live by the debug accessor (captureOverlay)
|
|
};
|
|
|
|
isUpdating = false;
|
|
|
|
// Each pass measures against the spacers present at its start, so a changed
|
|
// result needs another pass to re-measure and settle (e.g. after an orientation
|
|
// switch). Bounded by MAX_CONVERGE_PASSES against a two-layout ping-pong.
|
|
if (placementsChanged && convergePasses < MAX_CONVERGE_PASSES) {
|
|
convergePasses++;
|
|
schedule();
|
|
}
|
|
}
|
|
|
|
function schedule() {
|
|
if (rafId !== null) cancelAnimationFrame(rafId);
|
|
rafId = requestAnimationFrame(calculate);
|
|
}
|
|
|
|
// Initial calculation
|
|
schedule();
|
|
|
|
return {
|
|
update(_view, prevState) {
|
|
const before = pageBreakKey.getState(prevState);
|
|
const after = pageBreakKey.getState(editorView.state);
|
|
const forced = before?.recalc !== after?.recalc;
|
|
const isEditTr = before?.edit !== after?.edit;
|
|
if (!isUpdating && (prevState.doc !== editorView.state.doc || forced)) {
|
|
convergePasses = 0; // fresh convergence budget per external change
|
|
// Layout-only writes — the TOC rewriting its page numbers on every
|
|
// pm-pagecount — answer the last pass, so forgetting the ping-pong
|
|
// memory on them would leave the guard with nothing to catch.
|
|
if (forced || isEditTr) prevPlacementsKey = '';
|
|
schedule();
|
|
}
|
|
},
|
|
destroy() {
|
|
if (rafId !== null) cancelAnimationFrame(rafId);
|
|
debugAccessors.delete(editorView);
|
|
},
|
|
};
|
|
},
|
|
});
|
|
|
|
return [plugin];
|
|
},
|
|
});
|