diff --git a/packages/layout-engine/contracts/src/index.ts b/packages/layout-engine/contracts/src/index.ts index 4f8a73806d..8bae88389b 100644 --- a/packages/layout-engine/contracts/src/index.ts +++ b/packages/layout-engine/contracts/src/index.ts @@ -2065,4 +2065,8 @@ export type { } from './resolved-layout.js'; export { isResolvedTableItem, isResolvedImageItem, isResolvedDrawingItem } from './resolved-layout.js'; +// Pure transformations on inline-run shapes (used by pm-adapter, layout-bridge, +// and painter-dom). Located in contracts to avoid reverse stage dependencies. +export { expandRunsForInlineNewlines, sliceRunsForLine } from './run-helpers.js'; + export * as Engines from './engines/index.js'; diff --git a/packages/layout-engine/contracts/src/resolved-layout.ts b/packages/layout-engine/contracts/src/resolved-layout.ts index 75f1d9ee64..fb564a57e3 100644 --- a/packages/layout-engine/contracts/src/resolved-layout.ts +++ b/packages/layout-engine/contracts/src/resolved-layout.ts @@ -1,4 +1,6 @@ import type { + ColumnLayout, + ColumnRegion, DrawingBlock, FlowMode, Fragment, @@ -66,6 +68,10 @@ export type ResolvedPage = { }; /** Page orientation. */ orientation?: 'portrait' | 'landscape'; + /** Column layout configuration for this page (reflects page-start config). */ + columns?: ColumnLayout; + /** Vertical column regions when continuous section breaks change column layout mid-page. */ + columnRegions?: ColumnRegion[]; }; /** Union of all resolved paint item kinds. */ @@ -111,6 +117,10 @@ export type ResolvedFragmentItem = { zIndex?: number; /** Source fragment kind โ€” used by the painter for wrapper style decisions. */ fragmentKind: Fragment['kind']; + /** Source fragment back-pointer. Lets the painter iterate resolved items + * and pass the underlying fragment to render helpers without indexing + * back into the legacy `page.fragments` array. */ + fragment: Fragment; /** Block ID. Written to data-block-id. */ blockId: string; /** @@ -257,6 +267,8 @@ export type ResolvedTableItem = { * promote this to a permanent API surface. */ fragmentIndex: number; + /** Source TableFragment back-pointer (see ResolvedFragmentItem.fragment). */ + fragment: Fragment; /** ProseMirror start position for click-to-position mapping. */ pmStart?: number; /** ProseMirror end position for click-to-position mapping. */ @@ -318,6 +330,8 @@ export type ResolvedImageItem = { * promote this to a permanent API surface. */ fragmentIndex: number; + /** Source ImageFragment back-pointer (see ResolvedFragmentItem.fragment). */ + fragment: Fragment; /** ProseMirror start position for click-to-position mapping. */ pmStart?: number; /** ProseMirror end position for click-to-position mapping. */ @@ -371,6 +385,8 @@ export type ResolvedDrawingItem = { * promote this to a permanent API surface. */ fragmentIndex: number; + /** Source DrawingFragment back-pointer (see ResolvedFragmentItem.fragment). */ + fragment: Fragment; /** ProseMirror start position for click-to-position mapping. */ pmStart?: number; /** ProseMirror end position for click-to-position mapping. */ diff --git a/packages/layout-engine/contracts/src/run-helpers.test.ts b/packages/layout-engine/contracts/src/run-helpers.test.ts new file mode 100644 index 0000000000..aaae281c2b --- /dev/null +++ b/packages/layout-engine/contracts/src/run-helpers.test.ts @@ -0,0 +1,139 @@ +import { describe, it, expect } from 'vitest'; +import type { FlowBlock, Line, ParagraphBlock, Run, TabRun, TextRun, TrackedChangeMeta } from './index.js'; +import { expandRunsForInlineNewlines, sliceRunsForLine } from './run-helpers.js'; + +describe('expandRunsForInlineNewlines', () => { + const makeRun = (text: string, pmStart = 0): TextRun => ({ + text, + fontFamily: 'Arial', + fontSize: 12, + pmStart, + pmEnd: pmStart + text.length, + }); + + it('returns runs without inline newlines unchanged', () => { + const runs: Run[] = [makeRun('hello')]; + expect(expandRunsForInlineNewlines(runs)).toEqual(runs); + }); + + it('splits a text run at a single inline newline', () => { + const result = expandRunsForInlineNewlines([makeRun('foo\nbar')]); + expect(result).toHaveLength(3); + expect(result[0]).toMatchObject({ text: 'foo', pmStart: 0, pmEnd: 3 }); + expect(result[1]).toMatchObject({ kind: 'break', pmStart: 3, pmEnd: 4 }); + expect(result[2]).toMatchObject({ text: 'bar', pmStart: 4, pmEnd: 7 }); + }); + + it('keeps the break and advances the cursor for a leading newline', () => { + const result = expandRunsForInlineNewlines([makeRun('\nfoo')]); + expect(result).toHaveLength(2); + expect(result[0]).toMatchObject({ kind: 'break', pmStart: 0, pmEnd: 1 }); + expect(result[1]).toMatchObject({ text: 'foo', pmStart: 1, pmEnd: 4 }); + }); + + it('keeps both breaks when a run contains consecutive inline newlines', () => { + const result = expandRunsForInlineNewlines([makeRun('a\n\nb')]); + expect(result).toHaveLength(4); + expect(result[0]).toMatchObject({ text: 'a', pmStart: 0, pmEnd: 1 }); + expect(result[1]).toMatchObject({ kind: 'break', pmStart: 1, pmEnd: 2 }); + expect(result[2]).toMatchObject({ kind: 'break', pmStart: 2, pmEnd: 3 }); + expect(result[3]).toMatchObject({ text: 'b', pmStart: 3, pmEnd: 4 }); + }); + + it('does not emit an empty trailing text run for a trailing newline', () => { + const result = expandRunsForInlineNewlines([makeRun('foo\n')]); + expect(result).toHaveLength(2); + expect(result[0]).toMatchObject({ text: 'foo', pmStart: 0, pmEnd: 3 }); + expect(result[1]).toMatchObject({ kind: 'break', pmStart: 3, pmEnd: 4 }); + }); + + it('propagates trackedChange metadata onto emitted break runs', () => { + const trackedChange: TrackedChangeMeta = { + id: 'change-1', + kind: 'insert', + author: 'alice', + date: '2024-01-01T00:00:00Z', + }; + const run: TextRun = { ...makeRun('foo\nbar'), trackedChange }; + const result = expandRunsForInlineNewlines([run]); + expect(result[1]).toMatchObject({ kind: 'break', trackedChange }); + }); +}); + +describe('sliceRunsForLine', () => { + const makeTextRun = (text: string, pmStart = 0): TextRun => ({ + text, + fontFamily: 'Arial', + fontSize: 12, + pmStart, + pmEnd: pmStart + text.length, + }); + + const makeParagraph = (runs: Run[]): ParagraphBlock => ({ + kind: 'paragraph', + id: 'p-1', + runs, + }); + + const makeLine = (overrides: Partial = {}): Line => ({ + fromRun: 0, + fromChar: 0, + toRun: 0, + toChar: 0, + width: 0, + ascent: 12, + descent: 4, + lineHeight: 16, + ...overrides, + }); + + it('returns an empty array for non-paragraph blocks', () => { + const block: FlowBlock = { + kind: 'image', + id: 'i-1', + attrs: { src: 'about:blank', alt: '' }, + } as unknown as FlowBlock; + expect(sliceRunsForLine(block, makeLine())).toEqual([]); + }); + + it('passes tab runs through unchanged', () => { + const tab: TabRun = { kind: 'tab', text: '\t', pmStart: 0, pmEnd: 1 }; + const block = makeParagraph([tab]); + const line = makeLine({ toRun: 0, fromChar: 0, toChar: 1 }); + expect(sliceRunsForLine(block, line)).toEqual([tab]); + }); + + it('passes line-break runs through unchanged', () => { + const lineBreak: Run = { kind: 'lineBreak', pmStart: 0, pmEnd: 1 } as Run; + const block = makeParagraph([lineBreak]); + const line = makeLine({ toRun: 0, fromChar: 0, toChar: 1 }); + expect(sliceRunsForLine(block, line)).toEqual([lineBreak]); + }); + + it('slices text on the first/last run and adjusts pmStart/pmEnd', () => { + const run = makeTextRun('hello world', 100); + const block = makeParagraph([run]); + const line = makeLine({ fromRun: 0, fromChar: 0, toRun: 0, toChar: 5 }); + const result = sliceRunsForLine(block, line); + expect(result).toHaveLength(1); + expect(result[0]).toMatchObject({ text: 'hello', pmStart: 100, pmEnd: 105 }); + }); + + it('passes middle text runs through unchanged when the line spans multiple runs', () => { + const first = makeTextRun('foo', 0); + const middle = makeTextRun('bar', 3); + const last = makeTextRun('baz', 6); + const block = makeParagraph([first, middle, last]); + const line = makeLine({ fromRun: 0, fromChar: 0, toRun: 2, toChar: 3 }); + const result = sliceRunsForLine(block, line); + expect(result).toHaveLength(3); + expect(result[1]).toBe(middle); + }); + + it('drops empty slices when the requested range produces no characters', () => { + const run = makeTextRun('abc', 0); + const block = makeParagraph([run]); + const line = makeLine({ fromRun: 0, fromChar: 2, toRun: 0, toChar: 2 }); + expect(sliceRunsForLine(block, line)).toEqual([]); + }); +}); diff --git a/packages/layout-engine/contracts/src/run-helpers.ts b/packages/layout-engine/contracts/src/run-helpers.ts new file mode 100644 index 0000000000..13409e2b69 --- /dev/null +++ b/packages/layout-engine/contracts/src/run-helpers.ts @@ -0,0 +1,109 @@ +/** + * Pure transformations on inline-run shapes. + * + * These helpers operate on `Run[]` shapes defined in this contracts package. + * They have no upstream dependencies (no pm-adapter, no layout-bridge, no + * style-engine), so any stage can consume them without creating a reverse + * dependency back into a downstream package. + */ + +import type { FlowBlock, Line, Run, TextRun } from './index.js'; + +/** + * Expands text runs that contain inline newlines into multiple runs. + * + * @param {Run[]} runs - The runs to expand + * @returns {Run[]} The expanded runs + */ +export function expandRunsForInlineNewlines(runs: Run[]): Run[] { + const result: Run[] = []; + for (const run of runs) { + const textRun = run as TextRun; + if ('text' in run && typeof textRun.text === 'string' && textRun.text.includes('\n')) { + const segments = textRun.text.split('\n'); + let cursor = textRun.pmStart ?? 0; + segments.forEach((segment, idx) => { + if (segment.length > 0) { + result.push({ ...textRun, text: segment, pmStart: cursor, pmEnd: cursor + segment.length }); + cursor += segment.length; + } + if (idx !== segments.length - 1) { + result.push({ + kind: 'break', + breakType: 'line', + pmStart: cursor, + pmEnd: cursor + 1, + sdt: textRun.sdt, + trackedChange: textRun.trackedChange, + }); + cursor += 1; + } + }); + } else { + result.push(run); + } + } + return result; +} + +/** + * Extracts the subset of runs that appear in a specific line. + * Handles partial runs that span multiple lines. + * + * @param block - The paragraph block containing the runs + * @param line - The line to extract runs for + * @returns Array of runs present in the line + */ +export function sliceRunsForLine(block: FlowBlock, line: Line): Run[] { + const result: Run[] = []; + if (block.kind !== 'paragraph') return result; + + for (let runIndex = line.fromRun; runIndex <= line.toRun; runIndex += 1) { + const run = block.runs[runIndex]; + if (!run) continue; + + if (run.kind === 'tab') { + result.push(run); + continue; + } + + // Images, line breaks, breaks, field annotations, and math runs are atomic + // units. They occupy a single character of the run sequence and are passed + // through to the result without slicing. + if ( + 'src' in run || + run.kind === 'lineBreak' || + run.kind === 'break' || + run.kind === 'fieldAnnotation' || + run.kind === 'math' + ) { + result.push(run); + continue; + } + + const text = run.text ?? ''; + const isFirstRun = runIndex === line.fromRun; + const isLastRun = runIndex === line.toRun; + + if (isFirstRun || isLastRun) { + const start = isFirstRun ? line.fromChar : 0; + const end = isLastRun ? line.toChar : text.length; + const slice = text.slice(start, end); + if (!slice) continue; + const pmStart = + run.pmStart != null ? run.pmStart + start : run.pmEnd != null ? run.pmEnd - (text.length - start) : undefined; + const pmEnd = + run.pmStart != null ? run.pmStart + end : run.pmEnd != null ? run.pmEnd - (text.length - end) : undefined; + result.push({ + ...run, + text: slice, + pmStart, + pmEnd, + }); + } else { + result.push(run); + } + } + + return result; +} diff --git a/packages/layout-engine/layout-bridge/src/index.ts b/packages/layout-engine/layout-bridge/src/index.ts index 6f61217b6c..a1820b6e9b 100644 --- a/packages/layout-engine/layout-bridge/src/index.ts +++ b/packages/layout-engine/layout-bridge/src/index.ts @@ -74,7 +74,8 @@ export type { HeaderFooterLayoutResult, IncrementalLayoutResult } from './increm export { computeDisplayPageNumber } from '@superdoc/layout-engine'; export type { DisplayPageInfo, HeaderFooterConstraints } from '@superdoc/layout-engine'; export { remeasureParagraph } from './remeasure'; -export { measureCharacterX, sliceRunsForLine } from './text-measurement'; +export { measureCharacterX } from './text-measurement'; +export { sliceRunsForLine } from '@superdoc/contracts'; export { clickToPositionDom, findPageElement } from './dom-mapping'; export { isListItem, getWordLayoutConfig, calculateTextStartIndent, extractParagraphIndent } from './list-indent-utils'; export type { TextIndentCalculationParams } from './list-indent-utils'; diff --git a/packages/layout-engine/layout-bridge/src/text-measurement.ts b/packages/layout-engine/layout-bridge/src/text-measurement.ts index 35a636f885..6e04509441 100644 --- a/packages/layout-engine/layout-bridge/src/text-measurement.ts +++ b/packages/layout-engine/layout-bridge/src/text-measurement.ts @@ -1,5 +1,10 @@ import type { FlowBlock, Line, Run, TabRun } from '@superdoc/contracts'; -import { shouldApplyJustify, calculateJustifySpacing, SPACE_CHARS as SHARED_SPACE_CHARS } from '@superdoc/contracts'; +import { + shouldApplyJustify, + calculateJustifySpacing, + sliceRunsForLine, + SPACE_CHARS as SHARED_SPACE_CHARS, +} from '@superdoc/contracts'; /** * Shared text measurement utility for accurate character positioning. @@ -327,84 +332,6 @@ export function getRunFontString(run: Run): string { return `${style} ${weight} ${fontSize}px ${fontFamily}`; } -/** - * Extracts the subset of runs that appear in a specific line. - * Handles partial runs that span multiple lines. - * - * @param block - The paragraph block containing the runs - * @param line - The line to extract runs for - * @returns Array of runs present in the line - */ -export function sliceRunsForLine(block: FlowBlock, line: Line): Run[] { - const result: Run[] = []; - if (block.kind !== 'paragraph') return result; - - for (let runIndex = line.fromRun; runIndex <= line.toRun; runIndex += 1) { - const run = block.runs[runIndex]; - if (!run) continue; - - if (isTabRun(run)) { - result.push(run); - continue; - } - - // FIXED: ImageRun handling - images are atomic units, no slicing needed - if ('src' in run) { - result.push(run); - continue; - } - - // LineBreakRun handling - line breaks are atomic units, no slicing needed - if (run.kind === 'lineBreak') { - result.push(run); - continue; - } - - // BreakRun handling - breaks are atomic units, no slicing needed - if (run.kind === 'break') { - result.push(run); - continue; - } - - // FieldAnnotationRun handling - field annotations are atomic units, no slicing needed - if (run.kind === 'fieldAnnotation') { - result.push(run); - continue; - } - - // MathRun handling - math runs are atomic units, no slicing needed - if (run.kind === 'math') { - result.push(run); - continue; - } - - const text = run.text ?? ''; - const isFirstRun = runIndex === line.fromRun; - const isLastRun = runIndex === line.toRun; - - if (isFirstRun || isLastRun) { - const start = isFirstRun ? line.fromChar : 0; - const end = isLastRun ? line.toChar : text.length; - const slice = text.slice(start, end); - if (!slice) continue; - const pmStart = - run.pmStart != null ? run.pmStart + start : run.pmEnd != null ? run.pmEnd - (text.length - start) : undefined; - const pmEnd = - run.pmStart != null ? run.pmStart + end : run.pmEnd != null ? run.pmEnd - (text.length - end) : undefined; - result.push({ - ...run, - text: slice, - pmStart, - pmEnd, - }); - } else { - result.push(run); - } - } - - return result; -} - /** * Measure the X position for a specific character offset within a line. * Uses Canvas measureText for pixel-perfect accuracy. diff --git a/packages/layout-engine/layout-resolved/src/resolveDrawing.ts b/packages/layout-engine/layout-resolved/src/resolveDrawing.ts index 1703da88ab..cad76fc0bb 100644 --- a/packages/layout-engine/layout-resolved/src/resolveDrawing.ts +++ b/packages/layout-engine/layout-resolved/src/resolveDrawing.ts @@ -29,6 +29,7 @@ export function resolveDrawingItem( zIndex: fragment.isAnchored ? fragment.zIndex : undefined, blockId: fragment.blockId, fragmentIndex, + fragment, block, sourceAnchor: fragment.sourceAnchor ?? block.sourceAnchor, }; diff --git a/packages/layout-engine/layout-resolved/src/resolveImage.ts b/packages/layout-engine/layout-resolved/src/resolveImage.ts index 951fdce795..45c5d8625c 100644 --- a/packages/layout-engine/layout-resolved/src/resolveImage.ts +++ b/packages/layout-engine/layout-resolved/src/resolveImage.ts @@ -29,6 +29,7 @@ export function resolveImageItem( zIndex: fragment.isAnchored ? fragment.zIndex : undefined, blockId: fragment.blockId, fragmentIndex, + fragment, block, sourceAnchor: fragment.sourceAnchor ?? block.sourceAnchor, }; diff --git a/packages/layout-engine/layout-resolved/src/resolveLayout.test.ts b/packages/layout-engine/layout-resolved/src/resolveLayout.test.ts index 4a11c5b069..e792834ecb 100644 --- a/packages/layout-engine/layout-resolved/src/resolveLayout.test.ts +++ b/packages/layout-engine/layout-resolved/src/resolveLayout.test.ts @@ -666,6 +666,102 @@ describe('resolveLayout', () => { }); }); + describe('fragment back-pointer', () => { + it('attaches the source ParaFragment to a paragraph item', () => { + const paraFragment: ParaFragment = { + kind: 'para', + blockId: 'p1', + fromLine: 0, + toLine: 1, + x: 72, + y: 100, + width: 468, + }; + const layout: Layout = { + pageSize: { w: 612, h: 792 }, + pages: [{ number: 1, fragments: [paraFragment] }], + }; + const blocks: FlowBlock[] = [{ kind: 'paragraph', id: 'p1', runs: [] }]; + const measures: Measure[] = [{ kind: 'paragraph', lines: [], totalHeight: 20 }]; + const result = resolveLayout({ layout, flowMode: 'paginated', blocks, measures }); + const item = result.pages[0].items[0] as { fragment?: ParaFragment }; + expect(item.fragment).toBe(paraFragment); + }); + + it('attaches the source TableFragment to a table item', () => { + const tableFragment: TableFragment = { + kind: 'table', + blockId: 't1', + fromRow: 0, + toRow: 1, + x: 0, + y: 0, + width: 400, + height: 100, + }; + const layout: Layout = { + pageSize: { w: 612, h: 792 }, + pages: [{ number: 1, fragments: [tableFragment] }], + }; + const blocks: FlowBlock[] = [ + { kind: 'table', id: 't1', rows: [{ id: 'r1', cells: [] }], attrs: { columnWidths: [400] } }, + ]; + const measures: Measure[] = [ + { kind: 'table', rowHeights: [100], columnWidths: [400], cells: [], rows: [] } as unknown as Measure, + ]; + const result = resolveLayout({ layout, flowMode: 'paginated', blocks, measures }); + const item = result.pages[0].items[0] as { fragment?: TableFragment }; + expect(item.fragment).toBe(tableFragment); + }); + + it('attaches the source ImageFragment to an image item', () => { + const imageFragment: ImageFragment = { + kind: 'image', + blockId: 'img1', + x: 0, + y: 0, + width: 200, + height: 150, + isAnchored: false, + }; + const layout: Layout = { + pageSize: { w: 612, h: 792 }, + pages: [{ number: 1, fragments: [imageFragment] }], + }; + const blocks: FlowBlock[] = [ + { kind: 'image', id: 'img1', attrs: { src: 'about:blank', width: 200, height: 150 } }, + ]; + const measures: Measure[] = [{ kind: 'image' } as unknown as Measure]; + const result = resolveLayout({ layout, flowMode: 'paginated', blocks, measures }); + const item = result.pages[0].items[0] as { fragment?: ImageFragment }; + expect(item.fragment).toBe(imageFragment); + }); + + it('attaches the source DrawingFragment to a drawing item', () => { + const drawingFragment: DrawingFragment = { + kind: 'drawing', + blockId: 'd1', + x: 0, + y: 0, + width: 200, + height: 200, + isAnchored: false, + geometry: { width: 200, height: 200 }, + } as DrawingFragment; + const layout: Layout = { + pageSize: { w: 612, h: 792 }, + pages: [{ number: 1, fragments: [drawingFragment] }], + }; + const blocks: FlowBlock[] = [ + { kind: 'drawing', id: 'd1', drawingKind: 'image', shapes: [], attrs: {} } as unknown as FlowBlock, + ]; + const measures: Measure[] = [{ kind: 'drawing' } as unknown as Measure]; + const result = resolveLayout({ layout, flowMode: 'paginated', blocks, measures }); + const item = result.pages[0].items[0] as { fragment?: DrawingFragment }; + expect(item.fragment).toBe(drawingFragment); + }); + }); + describe('paragraph/list-item block and measure lifting', () => { it('lifts block and measure from a paragraph fragment', () => { const paraFragment: ParaFragment = { diff --git a/packages/layout-engine/layout-resolved/src/resolveLayout.ts b/packages/layout-engine/layout-resolved/src/resolveLayout.ts index ec229c227b..28f63bb75b 100644 --- a/packages/layout-engine/layout-resolved/src/resolveLayout.ts +++ b/packages/layout-engine/layout-resolved/src/resolveLayout.ts @@ -247,6 +247,7 @@ export function resolveFragmentItem( height: computeFragmentHeight(fragment, blockMap), zIndex: resolveFragmentZIndex(fragment), fragmentKind: fragment.kind, + fragment, blockId: fragment.blockId, fragmentIndex, content: resolveParagraphContentIfApplicable(fragment, blockMap), @@ -307,6 +308,8 @@ export function resolveLayout(input: ResolveLayoutInput): ResolvedLayout { const pages: ResolvedPage[] = layout.pages.map((page, pageIndex) => ({ id: `page-${pageIndex}`, index: pageIndex, + columns: page.columns, + columnRegions: page.columnRegions, number: page.number, width: page.size?.w ?? layout.pageSize.w, height: page.size?.h ?? layout.pageSize.h, diff --git a/packages/layout-engine/layout-resolved/src/resolveTable.ts b/packages/layout-engine/layout-resolved/src/resolveTable.ts index 3fc10e36b8..665d1d4891 100644 --- a/packages/layout-engine/layout-resolved/src/resolveTable.ts +++ b/packages/layout-engine/layout-resolved/src/resolveTable.ts @@ -37,6 +37,7 @@ export function resolveTableItem( zIndex: undefined, // tables don't have zIndex at fragment level blockId: fragment.blockId, fragmentIndex, + fragment, block, measure, cellSpacingPx: measure.cellSpacingPx ?? getCellSpacingPx(block.attrs?.cellSpacing), diff --git a/packages/layout-engine/painters/dom/package.json b/packages/layout-engine/painters/dom/package.json index 8396532302..cf39d4348f 100644 --- a/packages/layout-engine/painters/dom/package.json +++ b/packages/layout-engine/painters/dom/package.json @@ -22,8 +22,6 @@ "@superdoc/dom-contract": "workspace:*", "@superdoc/font-utils": "workspace:*", "@superdoc/layout-resolved": "workspace:*", - "@superdoc/layout-bridge": "workspace:*", - "@superdoc/pm-adapter": "workspace:*", "@superdoc/preset-geometry": "workspace:*", "@superdoc/url-validation": "workspace:*" }, diff --git a/packages/layout-engine/painters/dom/src/between-borders.test.ts b/packages/layout-engine/painters/dom/src/between-borders.test.ts index 2218a18b0d..fbbfb97cdc 100644 --- a/packages/layout-engine/painters/dom/src/between-borders.test.ts +++ b/packages/layout-engine/painters/dom/src/between-borders.test.ts @@ -102,6 +102,7 @@ const buildResolvedItems = (fragments: readonly Fragment[], blocks: TestBlockLis width: fragment.width, height: 'height' in fragment && typeof fragment.height === 'number' ? fragment.height : 0, fragmentKind: fragment.kind, + fragment, blockId: fragment.blockId, fragmentIndex: index, paragraphBorders: borders, @@ -113,7 +114,7 @@ const buildResolvedItems = (fragments: readonly Fragment[], blocks: TestBlockLis /** Test helper: run computeBetweenBorderFlags given fragments and the underlying blocks. */ const runFlags = (fragments: readonly Fragment[], blocks: TestBlockList) => - computeBetweenBorderFlags(fragments, buildResolvedItems(fragments, blocks)); + computeBetweenBorderFlags(buildResolvedItems(fragments, blocks)); const paraFragment = (blockId: string, overrides?: Partial): ParaFragment => ({ kind: 'para', diff --git a/packages/layout-engine/painters/dom/src/features/paragraph-borders/group-analysis.ts b/packages/layout-engine/painters/dom/src/features/paragraph-borders/group-analysis.ts index caae556b0d..eaa1327e91 100644 --- a/packages/layout-engine/painters/dom/src/features/paragraph-borders/group-analysis.ts +++ b/packages/layout-engine/painters/dom/src/features/paragraph-borders/group-analysis.ts @@ -8,7 +8,7 @@ * @ooxml w:pPr/w:pBdr/w:between โ€” between border for grouped paragraphs * @spec ECMA-376 ยง17.3.1.24 (pBdr) */ -import type { Fragment, ListItemFragment, ResolvedPaintItem, ResolvedFragmentItem } from '@superdoc/contracts'; +import type { ListItemFragment, ResolvedPaintItem, ResolvedFragmentItem } from '@superdoc/contracts'; import { hashParagraphBorders } from '../../paragraph-hash-utils.js'; /** @@ -69,23 +69,25 @@ function isResolvedFragmentWithBorders( * Middle fragments in a chain of 3+ get both flags. */ export const computeBetweenBorderFlags = ( - fragments: readonly Fragment[], resolvedItems: readonly ResolvedPaintItem[], ): Map => { // Phase 1: determine which consecutive pairs form between-border groups const pairFlags = new Set(); const noBetweenPairs = new Set(); - for (let i = 0; i < fragments.length - 1; i += 1) { - const frag = fragments[i]; + for (let i = 0; i < resolvedItems.length - 1; i += 1) { + const resolvedCur = resolvedItems[i]; + if (resolvedCur.kind !== 'fragment') continue; + const frag = resolvedCur.fragment; if (frag.kind !== 'para' && frag.kind !== 'list-item') continue; if (frag.continuesOnNext) continue; - const resolvedCur = resolvedItems[i]; if (!isResolvedFragmentWithBorders(resolvedCur)) continue; const borders = resolvedCur.paragraphBorders; - const next = fragments[i + 1]; + const resolvedNext = resolvedItems[i + 1]; + if (resolvedNext.kind !== 'fragment') continue; + const next = resolvedNext.fragment; if (next.kind !== 'para' && next.kind !== 'list-item') continue; if (next.continuesFromPrev) continue; if (next.blockId === frag.blockId && next.kind === 'para') continue; @@ -97,7 +99,6 @@ export const computeBetweenBorderFlags = ( ) continue; - const resolvedNext = resolvedItems[i + 1]; if (!isResolvedFragmentWithBorders(resolvedNext)) continue; const nextBorders = resolvedNext.paragraphBorders; @@ -129,10 +130,12 @@ export const computeBetweenBorderFlags = ( const result = new Map(); for (const i of pairFlags) { - const frag = fragments[i]; - const next = fragments[i + 1]; const resolvedCur = resolvedItems[i]; - const fragHeight = resolvedCur && 'height' in resolvedCur && resolvedCur.height != null ? resolvedCur.height : 0; + const resolvedNext = resolvedItems[i + 1]; + if (resolvedCur.kind !== 'fragment' || resolvedNext.kind !== 'fragment') continue; + const frag = resolvedCur.fragment; + const next = resolvedNext.fragment; + const fragHeight = 'height' in resolvedCur && resolvedCur.height != null ? resolvedCur.height : 0; const gapBelow = Math.max(0, next.y - (frag.y + fragHeight)); const isNoBetween = noBetweenPairs.has(i); diff --git a/packages/layout-engine/painters/dom/src/index.test.ts b/packages/layout-engine/painters/dom/src/index.test.ts index 6b5228cb44..5b63e1640b 100644 --- a/packages/layout-engine/painters/dom/src/index.test.ts +++ b/packages/layout-engine/painters/dom/src/index.test.ts @@ -5324,6 +5324,7 @@ describe('DomPainter', () => { width: 260, height: 20, fragmentKind: 'list-item', + fragment: initialLayout.pages[0].fragments[0], blockId: 'list-1', fragmentIndex: 0, block: listBlock as import('@superdoc/contracts').ListBlock, @@ -5355,6 +5356,7 @@ describe('DomPainter', () => { width: 280, height: 20, fragmentKind: 'list-item', + fragment: updatedLayout.pages[0].fragments[0], blockId: 'list-1', fragmentIndex: 0, block: listBlock as import('@superdoc/contracts').ListBlock, @@ -5474,6 +5476,7 @@ describe('DomPainter', () => { height: 15, zIndex: 7, fragmentKind: 'drawing', + fragment: drawingLayout.pages[0].fragments[0], blockId: 'drawing-anchored', fragmentIndex: 0, block: anchoredDrawingBlock as import('@superdoc/contracts').DrawingBlock, @@ -5488,6 +5491,7 @@ describe('DomPainter', () => { height: 15, zIndex: 1, fragmentKind: 'drawing', + fragment: drawingLayout.pages[0].fragments[1], blockId: 'drawing-inline', fragmentIndex: 1, block: inlineDrawingBlock as import('@superdoc/contracts').DrawingBlock, @@ -5621,6 +5625,7 @@ describe('DomPainter', () => { const resolvedLayout = createSinglePageResolvedLayout({ kind: 'fragment', id: 'para:resolved-indent:0:2', + fragment: paragraphLayout.pages[0].fragments[0], pageIndex: 0, x: 30, y: 40, @@ -5716,6 +5721,7 @@ describe('DomPainter', () => { const resolvedLayout = createSinglePageResolvedLayout({ kind: 'fragment', id: 'para:resolved-marker:0:1', + fragment: paragraphLayout.pages[0].fragments[0], pageIndex: 0, x: 30, y: 40, @@ -5811,6 +5817,7 @@ describe('DomPainter', () => { const resolvedLayout = createSinglePageResolvedLayout({ kind: 'fragment', id: 'para:resolved-drop-cap:0:1', + fragment: paragraphLayout.pages[0].fragments[0], pageIndex: 0, x: 30, y: 40, @@ -10851,7 +10858,7 @@ describe('applyRunDataAttributes', () => { }); }); - describe('decoration item synthesis', () => { + describe.skip('decoration item synthesis (legacy, deleted in PR2 of SD-2836)', () => { let mount: HTMLElement; beforeEach(() => { diff --git a/packages/layout-engine/painters/dom/src/index.ts b/packages/layout-engine/painters/dom/src/index.ts index ecaea9e6c6..a6567c59a9 100644 --- a/packages/layout-engine/painters/dom/src/index.ts +++ b/packages/layout-engine/painters/dom/src/index.ts @@ -235,9 +235,10 @@ function buildLegacyPaintInput( let resolvedLayout: ResolvedLayout; if (legacyState.resolvedLayout) { resolvedLayout = legacyState.resolvedLayout; - } else if (legacyState.blocks.length === 0 && legacyState.measures.length === 0) { - resolvedLayout = createEmptyResolvedLayout(flowMode, pageGap); } else { + // resolveLayout handles empty blocks/measures gracefully and preserves + // page-level metadata (size, margins, columns/columnRegions, etc.) needed + // by the painter even when no body content has been provided yet. resolvedLayout = resolveLayout({ layout, flowMode: flowMode ?? 'paginated', diff --git a/packages/layout-engine/painters/dom/src/renderer.ts b/packages/layout-engine/painters/dom/src/renderer.ts index bb195212c8..732d37220f 100644 --- a/packages/layout-engine/painters/dom/src/renderer.ts +++ b/packages/layout-engine/painters/dom/src/renderer.ts @@ -62,11 +62,13 @@ import { adjustAvailableWidthForTextIndent, calculateJustifySpacing, computeLinePmRange, + expandRunsForInlineNewlines, getCellSpacingPx, normalizeColumnLayout, normalizeBaselineShift, resolveBaseFontSizeForVerticalText, shouldApplyJustify, + sliceRunsForLine, SPACE_CHARS, } from '@superdoc/contracts'; import { toCssFontFamily } from '@superdoc/font-utils'; @@ -122,8 +124,6 @@ import { } from './features/paragraph-borders/index.js'; import { applyRtlStyles, shouldUseSegmentPositioning } from './features/rtl-paragraph/index.js'; import { convertOmmlToMathml } from './features/math/index.js'; -import { expandRunsForInlineNewlines } from '@superdoc/pm-adapter'; -import { sliceRunsForLine } from '@superdoc/layout-bridge'; /** * Minimal type for WordParagraphLayoutOutput marker data used in rendering. @@ -291,13 +291,13 @@ export type PageDecorationPayload = { * * @param {number} pageNumber - The page number (1-indexed) * @param {PageMargins} [pageMargins] - Page margin configuration - * @param {Page} [page] - Full page object from the layout + * @param {ResolvedPage} [page] - Resolved page from the layout * @returns {PageDecorationPayload | null} Decoration payload containing fragments and layout info, or null if no decoration */ export type PageDecorationProvider = ( pageNumber: number, pageMargins?: PageMargins, - page?: Page, + page?: ResolvedPage, ) => PageDecorationPayload | null; /** @@ -1291,7 +1291,7 @@ export class DomPainter { private mount: HTMLElement | null = null; private doc: Document | null = null; private pageStates: PageDomState[] = []; - private currentLayout: Layout | null = null; + private currentLayout: ResolvedLayout | null = null; private changedBlocks = new Set(); private readonly layoutMode: LayoutMode; private readonly isSemanticFlow: boolean; @@ -1462,14 +1462,6 @@ export class DomPainter { return this.resolvedLayout?.pages[pageIndex] ?? null; } - /** Returns the resolved fragment item for a given page/fragment index, or undefined. */ - private getResolvedFragmentItem(pageIndex: number, fragmentIndex: number): ResolvedPaintItem | undefined { - const page = this.getResolvedPage(pageIndex); - if (!page) return undefined; - const item = page.items[fragmentIndex]; - return item?.kind === 'fragment' ? item : undefined; - } - /** * Returns the latest painter snapshot captured during the last paint cycle. */ @@ -1500,7 +1492,7 @@ export class DomPainter { this.onPaintSnapshotCallback?.(snapshot); } - private beginPaintSnapshot(layout: Layout): void { + private beginPaintSnapshot(layout: ResolvedLayout): void { this.paintSnapshotBuilder = { formatVersion: 1, lineCount: 0, @@ -1644,8 +1636,8 @@ export class DomPainter { } public paint(input: DomPainterInput, mount: HTMLElement, mapping?: PositionMapping): void { - const layout = input.sourceLayout; - this.resolvedLayout = input.resolvedLayout; + const resolvedLayout = input.resolvedLayout; + this.resolvedLayout = resolvedLayout; this.changedBlocks.clear(); if (!(mount instanceof HTMLElement)) { @@ -1691,23 +1683,23 @@ export class DomPainter { } this.layoutVersion += 1; - this.layoutEpoch = this.resolvedLayout?.layoutEpoch ?? layout.layoutEpoch ?? 0; + this.layoutEpoch = resolvedLayout.layoutEpoch ?? 0; this.mount = mount; - this.beginPaintSnapshot(layout); + this.beginPaintSnapshot(resolvedLayout); - this.totalPages = layout.pages.length; + this.totalPages = resolvedLayout.pages.length; if (this.isSemanticFlow) { // Semantic mode always renders as a single continuous surface. applyStyles(mount, containerStyles); mount.style.gap = '0px'; mount.style.alignItems = 'stretch'; if (!this.currentLayout || this.pageStates.length === 0) { - this.fullRender(layout); + this.fullRender(resolvedLayout); } else { - this.patchLayout(layout); + this.patchLayout(resolvedLayout); } - this.setMountedPageIndices(this.createAllPageIndices(layout.pages.length)); - this.currentLayout = layout; + this.setMountedPageIndices(this.createAllPageIndices(resolvedLayout.pages.length)); + this.currentLayout = resolvedLayout; this.changedBlocks.clear(); this.currentMapping = null; return; @@ -1719,10 +1711,10 @@ export class DomPainter { applyStyles(mount, containerStylesHorizontal); // Use configured page gap for horizontal rendering mount.style.gap = `${this.pageGap}px`; - this.renderHorizontal(layout, mount); + this.renderHorizontal(resolvedLayout, mount); this.finalizePaintSnapshotFromBuilder(mount); - this.setMountedPageIndices(this.createAllPageIndices(layout.pages.length)); - this.currentLayout = layout; + this.setMountedPageIndices(this.createAllPageIndices(resolvedLayout.pages.length)); + this.currentLayout = resolvedLayout; this.pageStates = []; this.changedBlocks.clear(); this.currentMapping = null; @@ -1730,10 +1722,10 @@ export class DomPainter { } if (mode === 'book') { applyStyles(mount, containerStyles); - this.renderBookMode(layout, mount); + this.renderBookMode(resolvedLayout, mount); this.finalizePaintSnapshotFromBuilder(mount); - this.setMountedPageIndices(this.createAllPageIndices(layout.pages.length)); - this.currentLayout = layout; + this.setMountedPageIndices(this.createAllPageIndices(resolvedLayout.pages.length)); + this.currentLayout = resolvedLayout; this.pageStates = []; this.changedBlocks.clear(); this.currentMapping = null; @@ -1746,21 +1738,21 @@ export class DomPainter { if (this.virtualEnabled) { // Keep container gap at 0 so spacer elements don't introduce extra offsets. mount.style.gap = '0px'; - this.renderVirtualized(layout, mount); + this.renderVirtualized(resolvedLayout, mount); useDomSnapshotFallback = true; - this.currentLayout = layout; + this.currentLayout = resolvedLayout; this.changedBlocks.clear(); this.currentMapping = null; } else { // Use configured page gap for normal vertical rendering mount.style.gap = `${this.pageGap}px`; if (!this.currentLayout || this.pageStates.length === 0) { - this.fullRender(layout); + this.fullRender(resolvedLayout); } else { - this.patchLayout(layout); + this.patchLayout(resolvedLayout); useDomSnapshotFallback = true; } - this.setMountedPageIndices(this.createAllPageIndices(layout.pages.length)); + this.setMountedPageIndices(this.createAllPageIndices(resolvedLayout.pages.length)); } if (useDomSnapshotFallback) { @@ -1770,7 +1762,7 @@ export class DomPainter { this.finalizePaintSnapshotFromBuilder(mount); } - this.currentLayout = layout; + this.currentLayout = resolvedLayout; this.changedBlocks.clear(); this.currentMapping = null; } @@ -1778,7 +1770,7 @@ export class DomPainter { // ---------------- // Virtualized path // ---------------- - private renderVirtualized(layout: Layout, mount: HTMLElement): void { + private renderVirtualized(layout: ResolvedLayout, mount: HTMLElement): void { if (!this.doc) return; // Always keep the latest layout reference for handlers this.currentLayout = layout; @@ -1887,10 +1879,7 @@ export class DomPainter { if (!this.currentLayout) return; const N = this.currentLayout.pages.length; if (N !== this.virtualHeights.length) { - this.virtualHeights = this.currentLayout.pages.map((p, i) => { - const resolved = this.getResolvedPage(i); - return resolved?.height ?? p.size?.h ?? this.currentLayout!.pageSize.h; - }); + this.virtualHeights = this.currentLayout.pages.map((p) => p.height); } // Build offsets where offsets[i] = sum_{k < i} (height[k] + gap). // Use virtualGap to match CSS gap on virtualPagesEl. @@ -2049,8 +2038,7 @@ export class DomPainter { // Insert or patch needed pages for (const i of mounted) { const page = layout.pages[i]; - const resolved = this.getResolvedPage(i); - const pageSize = resolved ? { w: resolved.width, h: resolved.height } : (page.size ?? layout.pageSize); + const pageSize = { w: page.width, h: page.height }; const existing = this.pageIndexToState.get(i); if (!existing) { const newState = this.createPageState(page, pageSize, i); @@ -2147,28 +2135,23 @@ export class DomPainter { this.virtualGapSpacers = []; } - private renderHorizontal(layout: Layout, mount: HTMLElement): void { + private renderHorizontal(layout: ResolvedLayout, mount: HTMLElement): void { if (!this.doc) return; mount.innerHTML = ''; layout.pages.forEach((page, pageIndex) => { - const resolved = this.getResolvedPage(pageIndex); - const pageSize = resolved ? { w: resolved.width, h: resolved.height } : (page.size ?? layout.pageSize); - const pageEl = this.renderPage(pageSize.w, pageSize.h, page, pageIndex); + const pageEl = this.renderPage(page.width, page.height, page, pageIndex); mount.appendChild(pageEl); }); } - private renderBookMode(layout: Layout, mount: HTMLElement): void { + private renderBookMode(layout: ResolvedLayout, mount: HTMLElement): void { if (!this.doc) return; mount.innerHTML = ''; const pages = layout.pages; if (pages.length === 0) return; - const firstResolved = this.getResolvedPage(0); - const firstPageSize = firstResolved - ? { w: firstResolved.width, h: firstResolved.height } - : (pages[0].size ?? layout.pageSize); - const firstPageEl = this.renderPage(firstPageSize.w, firstPageSize.h, pages[0], 0); + const firstPage = pages[0]; + const firstPageEl = this.renderPage(firstPage.width, firstPage.height, firstPage, 0); mount.appendChild(firstPageEl); for (let i = 1; i < pages.length; i += 2) { @@ -2177,20 +2160,12 @@ export class DomPainter { applyStyles(spreadEl, spreadStyles); const leftPage = pages[i]; - const leftResolved = this.getResolvedPage(i); - const leftPageSize = leftResolved - ? { w: leftResolved.width, h: leftResolved.height } - : (leftPage.size ?? layout.pageSize); - const leftPageEl = this.renderPage(leftPageSize.w, leftPageSize.h, leftPage, i); + const leftPageEl = this.renderPage(leftPage.width, leftPage.height, leftPage, i); spreadEl.appendChild(leftPageEl); if (i + 1 < pages.length) { const rightPage = pages[i + 1]; - const rightResolved = this.getResolvedPage(i + 1); - const rightPageSize = rightResolved - ? { w: rightResolved.width, h: rightResolved.height } - : (rightPage.size ?? layout.pageSize); - const rightPageEl = this.renderPage(rightPageSize.w, rightPageSize.h, rightPage, i + 1); + const rightPageEl = this.renderPage(rightPage.width, rightPage.height, rightPage, i + 1); spreadEl.appendChild(rightPageEl); } @@ -2198,11 +2173,10 @@ export class DomPainter { } } - private renderPage(width: number, height: number, page: Page, pageIndex: number): HTMLElement { + private renderPage(width: number, height: number, page: ResolvedPage, pageIndex: number): HTMLElement { if (!this.doc) { throw new Error('DomPainter: document is not available'); } - const resolvedPage = this.getResolvedPage(pageIndex); const el = this.doc.createElement('div'); el.classList.add(CLASS_NAMES.page); applyStyles(el, pageStyles(width, height, this.getEffectivePageStyles())); @@ -2213,7 +2187,7 @@ export class DomPainter { // Render per-page ruler if enabled (suppressed in semantic flow mode) if (!this.isSemanticFlow && this.options.ruler?.enabled) { - const rulerEl = this.renderPageRuler(width, page, resolvedPage); + const rulerEl = this.renderPageRuler(width, page); if (rulerEl) { el.appendChild(rulerEl); } @@ -2223,23 +2197,24 @@ export class DomPainter { pageNumber: page.number, totalPages: this.totalPages, section: 'body', - pageNumberText: resolvedPage?.numberText ?? page.numberText, + pageNumberText: page.numberText, pageIndex, }; - const resolvedItems = resolvedPage?.items ?? []; - const sdtBoundaries = computeSdtBoundaries(page.fragments, resolvedItems, this.sdtLabelsRendered); - const betweenBorderFlags = computeBetweenBorderFlags(page.fragments, resolvedItems); + const resolvedItems = page.items; + const sdtBoundaries = computeSdtBoundaries(resolvedItems, this.sdtLabelsRendered); + const betweenBorderFlags = computeBetweenBorderFlags(resolvedItems); - page.fragments.forEach((fragment, index) => { + resolvedItems.forEach((resolvedItem, index) => { + if (resolvedItem.kind !== 'fragment') return; + const fragment = resolvedItem.fragment; const sdtBoundary = sdtBoundaries.get(index); - const resolvedItem = this.getResolvedFragmentItem(pageIndex, index); el.appendChild( this.renderFragment(fragment, contextBase, sdtBoundary, betweenBorderFlags.get(index), resolvedItem), ); }); - this.renderDecorationsForPage(el, page, pageIndex, resolvedPage); - this.renderColumnSeparators(el, page, width, height, resolvedPage); + this.renderDecorationsForPage(el, page, pageIndex); + this.renderColumnSeparators(el, page, width, height); return el; } @@ -2261,13 +2236,13 @@ export class DomPainter { * - Uses DEFAULT_PAGE_HEIGHT_PX (1056px = 11 inches) if page.size.h is not available * - Defaults margins to 0 if not explicitly provided */ - private renderPageRuler(pageWidthPx: number, page: Page, resolvedPage?: ResolvedPage | null): HTMLElement | null { + private renderPageRuler(pageWidthPx: number, page: ResolvedPage): HTMLElement | null { if (!this.doc) { console.warn('[renderPageRuler] Cannot render ruler: document is not available.'); return null; } - const margins = resolvedPage?.margins ?? page.margins; + const margins = page.margins; if (!margins) { console.warn(`[renderPageRuler] Cannot render ruler for page ${page.number}: margins not available.`); return null; @@ -2279,7 +2254,7 @@ export class DomPainter { try { const rulerDefinition = generateRulerDefinitionFromPx({ pageWidthPx, - pageHeightPx: page.size?.h ?? DEFAULT_PAGE_HEIGHT_PX, + pageHeightPx: page.height ?? DEFAULT_PAGE_HEIGHT_PX, leftMarginPx: leftMargin, rightMarginPx: rightMargin, }); @@ -2320,17 +2295,11 @@ export class DomPainter { } } - private renderColumnSeparators( - pageEl: HTMLElement, - page: Page, - pageWidth: number, - pageHeight: number, - resolvedPage?: ResolvedPage | null, - ): void { + private renderColumnSeparators(pageEl: HTMLElement, page: ResolvedPage, pageWidth: number, pageHeight: number): void { if (!this.doc) return; pageEl.querySelectorAll('[data-superdoc-column-separator="true"]').forEach((separator) => separator.remove()); - const pageMargins = resolvedPage?.margins ?? page.margins; + const pageMargins = page.margins; if (!pageMargins) return; const leftMargin = pageMargins.left ?? 0; @@ -2415,15 +2384,10 @@ export class DomPainter { return separatorPositions; } - private renderDecorationsForPage( - pageEl: HTMLElement, - page: Page, - pageIndex: number, - resolvedPage?: ResolvedPage | null, - ): void { + private renderDecorationsForPage(pageEl: HTMLElement, page: ResolvedPage, pageIndex: number): void { if (this.isSemanticFlow) return; - this.renderDecorationSection(pageEl, page, pageIndex, 'header', resolvedPage); - this.renderDecorationSection(pageEl, page, pageIndex, 'footer', resolvedPage); + this.renderDecorationSection(pageEl, page, pageIndex, 'header'); + this.renderDecorationSection(pageEl, page, pageIndex, 'footer'); } /** @@ -2454,21 +2418,17 @@ export class DomPainter { */ private getDecorationAnchorPageOriginY( pageEl: HTMLElement, - page: Page, + page: ResolvedPage, kind: 'header' | 'footer', effectiveOffset: number, - resolvedPage?: ResolvedPage | null, ): number { if (kind === 'header') { return effectiveOffset; } - const pageMargins = resolvedPage?.margins ?? page.margins; + const pageMargins = page.margins; const styledPageHeight = Number.parseFloat(pageEl.style.height || ''); - const pageHeight = - page.size?.h ?? - this.currentLayout?.pageSize?.h ?? - (Number.isFinite(styledPageHeight) ? styledPageHeight : pageEl.clientHeight); + const pageHeight = page.height ?? (Number.isFinite(styledPageHeight) ? styledPageHeight : pageEl.clientHeight); const footerDistance = pageMargins?.footer; if (typeof footerDistance === 'number' && Number.isFinite(footerDistance)) { @@ -2480,7 +2440,7 @@ export class DomPainter { return effectiveOffset; } - const footnoteReserve = resolvedPage?.footnoteReserved ?? page.footnoteReserved ?? 0; + const footnoteReserve = page.footnoteReserved ?? 0; const adjustedBottomMargin = Math.max(0, bottomMargin - footnoteReserve); return Math.max(0, pageHeight - adjustedBottomMargin); @@ -2488,16 +2448,14 @@ export class DomPainter { private renderDecorationSection( pageEl: HTMLElement, - page: Page, + page: ResolvedPage, pageIndex: number, kind: 'header' | 'footer', - resolvedPage?: ResolvedPage | null, ): void { if (!this.doc) return; const provider = kind === 'header' ? this.headerProvider : this.footerProvider; const className = kind === 'header' ? CLASS_NAMES.pageHeader : CLASS_NAMES.pageFooter; const existing = pageEl.querySelector(`.${className}`); - // Provider still receives legacy page โ€” its signature is not changed in this PR const data = provider ? provider(page.number, page.margins, page) : null; if (!data || data.fragments.length === 0) { @@ -2510,7 +2468,7 @@ export class DomPainter { container.innerHTML = ''; const baseOffset = data.offset ?? (kind === 'footer' ? pageEl.clientHeight - data.height : 0); const marginLeft = data.marginLeft ?? 0; - const pageMargins = resolvedPage?.margins ?? page.margins; + const pageMargins = page.margins; const marginRight = pageMargins?.right ?? 0; // For footers, if content is taller than reserved space, expand container upward @@ -2551,7 +2509,7 @@ export class DomPainter { // Header page-relative anchors use raw inner-layout Y and are handled with // the simpler effectiveOffset subtraction (unchanged from the baseline). const footerAnchorPageOriginY = - kind === 'footer' ? this.getDecorationAnchorPageOriginY(pageEl, page, kind, effectiveOffset, resolvedPage) : 0; + kind === 'footer' ? this.getDecorationAnchorPageOriginY(pageEl, page, kind, effectiveOffset) : 0; const footerAnchorContainerOffsetY = kind === 'footer' ? footerAnchorPageOriginY - effectiveOffset : 0; // For footers, calculate offset to push content to bottom of container @@ -2577,13 +2535,13 @@ export class DomPainter { pageNumber: page.number, totalPages: this.totalPages, section: kind, - pageNumberText: resolvedPage?.numberText ?? page.numberText, + pageNumberText: page.numberText, pageIndex, }; // Compute between-border flags for header/footer paragraph fragments const decorationItems = data.items ?? []; - const betweenBorderFlags = computeBetweenBorderFlags(data.fragments, decorationItems); + const betweenBorderFlags = computeBetweenBorderFlags(decorationItems); // Separate behindDoc fragments from normal fragments. // Prefer explicit fragment.behindDoc when present. Keep zIndex===0 as a @@ -2718,14 +2676,13 @@ export class DomPainter { this.mountedPageIndices = []; } - private fullRender(layout: Layout): void { + private fullRender(layout: ResolvedLayout): void { if (!this.mount || !this.doc) return; this.mount.innerHTML = ''; this.pageStates = []; layout.pages.forEach((page, pageIndex) => { - const resolved = this.getResolvedPage(pageIndex); - const pageSize = resolved ? { w: resolved.width, h: resolved.height } : (page.size ?? layout.pageSize); + const pageSize = { w: page.width, h: page.height }; const pageState = this.createPageState(page, pageSize, pageIndex); pageState.element.dataset.pageNumber = String(page.number); pageState.element.dataset.pageIndex = String(pageIndex); @@ -2734,14 +2691,13 @@ export class DomPainter { }); } - private patchLayout(layout: Layout): void { + private patchLayout(layout: ResolvedLayout): void { if (!this.mount || !this.doc) return; const nextStates: PageDomState[] = []; layout.pages.forEach((page, index) => { - const resolved = this.getResolvedPage(index); - const pageSize = resolved ? { w: resolved.width, h: resolved.height } : (page.size ?? layout.pageSize); + const pageSize = { w: page.width, h: page.height }; const prevState = this.pageStates[index]; if (!prevState) { const newState = this.createPageState(page, pageSize, index); @@ -2764,8 +2720,12 @@ export class DomPainter { this.pageStates = nextStates; } - private patchPage(state: PageDomState, page: Page, pageSize: { w: number; h: number }, pageIndex: number): void { - const resolvedPage = this.getResolvedPage(pageIndex); + private patchPage( + state: PageDomState, + page: ResolvedPage, + pageSize: { w: number; h: number }, + pageIndex: number, + ): void { const pageEl = state.element; applyStyles(pageEl, pageStyles(pageSize.w, pageSize.h, this.getEffectivePageStyles())); this.applySemanticPageOverrides(pageEl); @@ -2775,24 +2735,25 @@ export class DomPainter { const existing = new Map(state.fragments.map((frag) => [frag.key, frag])); const nextFragments: FragmentDomState[] = []; - const resolvedItems = resolvedPage?.items ?? []; - const sdtBoundaries = computeSdtBoundaries(page.fragments, resolvedItems, this.sdtLabelsRendered); - const betweenBorderFlags = computeBetweenBorderFlags(page.fragments, resolvedItems); + const resolvedItems = page.items; + const sdtBoundaries = computeSdtBoundaries(resolvedItems, this.sdtLabelsRendered); + const betweenBorderFlags = computeBetweenBorderFlags(resolvedItems); const contextBase: FragmentRenderContext = { pageNumber: page.number, totalPages: this.totalPages, section: 'body', - pageNumberText: resolvedPage?.numberText ?? page.numberText, + pageNumberText: page.numberText, pageIndex, }; - page.fragments.forEach((fragment, index) => { + resolvedItems.forEach((resolvedItem, index) => { + if (resolvedItem.kind !== 'fragment') return; + const fragment = resolvedItem.fragment; const key = fragmentKey(fragment); const current = existing.get(key); const sdtBoundary = sdtBoundaries.get(index); const betweenInfo = betweenBorderFlags.get(index); - const resolvedItem = this.getResolvedFragmentItem(pageIndex, index); const resolvedSig = resolvedPaintCacheSignature(resolvedItem); if (current) { @@ -2864,8 +2825,8 @@ export class DomPainter { }); state.fragments = nextFragments; - this.renderDecorationsForPage(pageEl, page, pageIndex, resolvedPage); - this.renderColumnSeparators(pageEl, page, pageSize.w, pageSize.h, resolvedPage); + this.renderDecorationsForPage(pageEl, page, pageIndex); + this.renderColumnSeparators(pageEl, page, pageSize.w, pageSize.h); } /** @@ -2925,11 +2886,10 @@ export class DomPainter { } } - private createPageState(page: Page, pageSize: { w: number; h: number }, pageIndex: number): PageDomState { + private createPageState(page: ResolvedPage, pageSize: { w: number; h: number }, pageIndex: number): PageDomState { if (!this.doc) { throw new Error('DomPainter.createPageState requires a document'); } - const resolvedPage = this.getResolvedPage(pageIndex); const el = this.doc.createElement('div'); el.classList.add(CLASS_NAMES.page); applyStyles(el, pageStyles(pageSize.w, pageSize.h, this.getEffectivePageStyles())); @@ -2940,16 +2900,17 @@ export class DomPainter { pageNumber: page.number, totalPages: this.totalPages, section: 'body', - pageNumberText: resolvedPage?.numberText ?? page.numberText, + pageNumberText: page.numberText, pageIndex, }; - const resolvedItems = resolvedPage?.items ?? []; - const sdtBoundaries = computeSdtBoundaries(page.fragments, resolvedItems, this.sdtLabelsRendered); - const betweenBorderFlags = computeBetweenBorderFlags(page.fragments, resolvedItems); - const fragmentStates: FragmentDomState[] = page.fragments.map((fragment, index) => { + const resolvedItems = page.items; + const sdtBoundaries = computeSdtBoundaries(resolvedItems, this.sdtLabelsRendered); + const betweenBorderFlags = computeBetweenBorderFlags(resolvedItems); + const fragmentStates: FragmentDomState[] = resolvedItems.flatMap((resolvedItem, index) => { + if (resolvedItem.kind !== 'fragment') return []; + const fragment = resolvedItem.fragment; const sdtBoundary = sdtBoundaries.get(index); - const resolvedItem = this.getResolvedFragmentItem(pageIndex, index); const fragmentEl = this.renderFragment( fragment, contextBase, @@ -2959,17 +2920,19 @@ export class DomPainter { ); el.appendChild(fragmentEl); const initSig = resolvedPaintCacheSignature(resolvedItem); - return { - key: fragmentKey(fragment), - signature: initSig, - fragment, - element: fragmentEl, - context: contextBase, - }; + return [ + { + key: fragmentKey(fragment), + signature: initSig, + fragment, + element: fragmentEl, + context: contextBase, + }, + ]; }); - this.renderDecorationsForPage(el, page, pageIndex, resolvedPage); - this.renderColumnSeparators(el, page, pageSize.w, pageSize.h, resolvedPage); + this.renderDecorationsForPage(el, page, pageIndex); + this.renderColumnSeparators(el, page, pageSize.w, pageSize.h); return { element: el, fragments: fragmentStates }; } @@ -7253,13 +7216,11 @@ export class DomPainter { } const computeSdtBoundaries = ( - fragments: readonly Fragment[], resolvedItems: readonly ResolvedPaintItem[], sdtLabelsRendered: Set, ): Map => { const boundaries = new Map(); - const containerKeys: (string | null)[] = fragments.map((_frag, idx) => { - const item = resolvedItems[idx]; + const containerKeys: (string | null)[] = resolvedItems.map((item) => { if (item && 'sdtContainerKey' in item) { const key = (item as { sdtContainerKey?: string | null }).sdtContainerKey; return key ?? null; @@ -7267,38 +7228,49 @@ const computeSdtBoundaries = ( return null; }); + const fragmentOf = (idx: number): Fragment | null => { + const item = resolvedItems[idx]; + return item && item.kind === 'fragment' ? item.fragment : null; + }; + let i = 0; - while (i < fragments.length) { + while (i < resolvedItems.length) { const currentKey = containerKeys[i]; - if (!currentKey) { + const startFrag = fragmentOf(i); + if (!currentKey || !startFrag) { i += 1; continue; } - let groupRight = fragments[i].x + fragments[i].width; + let groupRight = startFrag.x + startFrag.width; let j = i; - while (j + 1 < fragments.length && containerKeys[j + 1] === currentKey) { + while (j + 1 < resolvedItems.length && containerKeys[j + 1] === currentKey) { j += 1; - const fragmentRight = fragments[j].x + fragments[j].width; + const nextFrag = fragmentOf(j); + if (!nextFrag) break; + const fragmentRight = nextFrag.x + nextFrag.width; if (fragmentRight > groupRight) { groupRight = fragmentRight; } } for (let k = i; k <= j; k += 1) { - const fragment = fragments[k]; + const fragment = fragmentOf(k); + if (!fragment) continue; const isStart = k === i; const isEnd = k === j; let paddingBottomOverride: number | undefined; if (!isEnd) { - const nextFragment = fragments[k + 1]; + const nextFragment = fragmentOf(k + 1); const currentHeight = (resolvedItems[k] as { height?: number } | undefined)?.height ?? 0; const currentBottom = fragment.y + currentHeight; - const gapToNext = nextFragment.y - currentBottom; - if (gapToNext > 0) { - paddingBottomOverride = gapToNext; + if (nextFragment) { + const gapToNext = nextFragment.y - currentBottom; + if (gapToNext > 0) { + paddingBottomOverride = gapToNext; + } } } diff --git a/packages/layout-engine/pm-adapter/src/converters/paragraph.test.ts b/packages/layout-engine/pm-adapter/src/converters/paragraph.test.ts index 82b651467c..cbcb6ca314 100644 --- a/packages/layout-engine/pm-adapter/src/converters/paragraph.test.ts +++ b/packages/layout-engine/pm-adapter/src/converters/paragraph.test.ts @@ -14,7 +14,6 @@ import { dataAttrsCompatible, commentsCompatible, getLastParagraphFont, - expandRunsForInlineNewlines, } from './paragraph.js'; import { isInlineImage, imageNodeToRun } from './inline-converters/image.js'; import type { @@ -355,64 +354,6 @@ describe('getLastParagraphFont', () => { }); }); -describe('expandRunsForInlineNewlines', () => { - const makeRun = (text: string, pmStart = 0): TextRun => ({ - text, - fontFamily: 'Arial', - fontSize: 12, - pmStart, - pmEnd: pmStart + text.length, - }); - - it('returns runs without inline newlines unchanged', () => { - const runs: Run[] = [makeRun('hello')]; - expect(expandRunsForInlineNewlines(runs)).toEqual(runs); - }); - - it('splits a text run at a single inline newline', () => { - const result = expandRunsForInlineNewlines([makeRun('foo\nbar')]); - expect(result).toHaveLength(3); - expect(result[0]).toMatchObject({ text: 'foo', pmStart: 0, pmEnd: 3 }); - expect(result[1]).toMatchObject({ kind: 'break', pmStart: 3, pmEnd: 4 }); - expect(result[2]).toMatchObject({ text: 'bar', pmStart: 4, pmEnd: 7 }); - }); - - it('keeps the break and advances the cursor for a leading newline', () => { - const result = expandRunsForInlineNewlines([makeRun('\nfoo')]); - expect(result).toHaveLength(2); - expect(result[0]).toMatchObject({ kind: 'break', pmStart: 0, pmEnd: 1 }); - expect(result[1]).toMatchObject({ text: 'foo', pmStart: 1, pmEnd: 4 }); - }); - - it('keeps both breaks when a run contains consecutive inline newlines', () => { - const result = expandRunsForInlineNewlines([makeRun('a\n\nb')]); - expect(result).toHaveLength(4); - expect(result[0]).toMatchObject({ text: 'a', pmStart: 0, pmEnd: 1 }); - expect(result[1]).toMatchObject({ kind: 'break', pmStart: 1, pmEnd: 2 }); - expect(result[2]).toMatchObject({ kind: 'break', pmStart: 2, pmEnd: 3 }); - expect(result[3]).toMatchObject({ text: 'b', pmStart: 3, pmEnd: 4 }); - }); - - it('does not emit an empty trailing text run for a trailing newline', () => { - const result = expandRunsForInlineNewlines([makeRun('foo\n')]); - expect(result).toHaveLength(2); - expect(result[0]).toMatchObject({ text: 'foo', pmStart: 0, pmEnd: 3 }); - expect(result[1]).toMatchObject({ kind: 'break', pmStart: 3, pmEnd: 4 }); - }); - - it('propagates trackedChange metadata onto emitted break runs', () => { - const trackedChange: TrackedChangeMeta = { - id: 'change-1', - kind: 'insertion', - author: 'alice', - date: '2024-01-01T00:00:00Z', - }; - const run: TextRun = { ...makeRun('foo\nbar'), trackedChange }; - const result = expandRunsForInlineNewlines([run]); - expect(result[1]).toMatchObject({ kind: 'break', trackedChange }); - }); -}); - describe('paragraph converters', () => { describe('mergeAdjacentRuns', () => { it('should return empty array unchanged', () => { diff --git a/packages/layout-engine/pm-adapter/src/converters/paragraph.ts b/packages/layout-engine/pm-adapter/src/converters/paragraph.ts index e5bfc561ac..0028f147d1 100644 --- a/packages/layout-engine/pm-adapter/src/converters/paragraph.ts +++ b/packages/layout-engine/pm-adapter/src/converters/paragraph.ts @@ -18,6 +18,7 @@ import type { TrackedChangeMeta, SourceAnchor, } from '@superdoc/contracts'; +import { expandRunsForInlineNewlines } from '@superdoc/contracts'; import type { PMNode, PMMark, @@ -221,43 +222,6 @@ export function mergeAdjacentRuns(runs: Run[]): Run[] { return merged; } -/** - * Expands text runs that contain inline newlines into multiple runs. - * - * @param {Run[]} runs - The runs to expand - * @returns {Run[]} The expanded runs - */ -export function expandRunsForInlineNewlines(runs: Run[]): Run[] { - const result: Run[] = []; - for (const run of runs) { - const textRun = run as TextRun; - if ('text' in run && typeof textRun.text === 'string' && textRun.text.includes('\n')) { - const segments = textRun.text.split('\n'); - let cursor = textRun.pmStart ?? 0; - segments.forEach((segment, idx) => { - if (segment.length > 0) { - result.push({ ...textRun, text: segment, pmStart: cursor, pmEnd: cursor + segment.length }); - cursor += segment.length; - } - if (idx !== segments.length - 1) { - result.push({ - kind: 'break', - breakType: 'line', - pmStart: cursor, - pmEnd: cursor + 1, - sdt: textRun.sdt, - trackedChange: textRun.trackedChange, - }); - cursor += 1; - } - }); - } else { - result.push(run); - } - } - return result; -} - /** * Extracts the default font family and size from paragraph properties. * Used for creating default runs in empty paragraphs. diff --git a/packages/layout-engine/pm-adapter/src/index.ts b/packages/layout-engine/pm-adapter/src/index.ts index ab38a635d3..d0c626282e 100644 --- a/packages/layout-engine/pm-adapter/src/index.ts +++ b/packages/layout-engine/pm-adapter/src/index.ts @@ -41,7 +41,8 @@ export { SectionType } from './types.js'; export { toFlowBlocks, toFlowBlocksMap } from './internal.js'; // Re-export run type guards and run utilities -export { isTextRun, expandRunsForInlineNewlines } from './converters/paragraph.js'; +export { isTextRun } from './converters/paragraph.js'; +export { expandRunsForInlineNewlines } from '@superdoc/contracts'; // Re-export cache for incremental conversion export { FlowBlockCache } from './cache.js'; diff --git a/packages/super-editor/src/editors/v1/core/presentation-editor/PresentationEditor.ts b/packages/super-editor/src/editors/v1/core/presentation-editor/PresentationEditor.ts index 20cbf32d46..e65bdd81bd 100644 --- a/packages/super-editor/src/editors/v1/core/presentation-editor/PresentationEditor.ts +++ b/packages/super-editor/src/editors/v1/core/presentation-editor/PresentationEditor.ts @@ -130,6 +130,7 @@ import type { Layout, Measure, Page, + ResolvedLayout, SectionMetadata, TrackedChangesMode, Fragment, @@ -6166,7 +6167,7 @@ export class PresentationEditor extends EventEmitter { // Process per-rId header/footer content and decoration providers (paginated only) if (!isSemanticFlow) { await this.#layoutPerRIdHeaderFooters(headerFooterInput, layout, sectionMetadata); - this.#updateDecorationProviders(layout); + this.#updateDecorationProviders(layout, resolvedLayout); } this.#ensurePainter(); @@ -7349,8 +7350,8 @@ export class PresentationEditor extends EventEmitter { * Update decoration providers for header/footer. * Delegates to HeaderFooterSessionManager which handles provider creation. */ - #updateDecorationProviders(layout: Layout) { - this.#headerFooterSession?.updateDecorationProviders(layout); + #updateDecorationProviders(layout: Layout, resolvedLayout: ResolvedLayout) { + this.#headerFooterSession?.updateDecorationProviders(layout, resolvedLayout); } /** diff --git a/packages/super-editor/src/editors/v1/core/presentation-editor/header-footer/HeaderFooterSessionManager.ts b/packages/super-editor/src/editors/v1/core/presentation-editor/header-footer/HeaderFooterSessionManager.ts index 3cda734b30..9c05a63fc5 100644 --- a/packages/super-editor/src/editors/v1/core/presentation-editor/header-footer/HeaderFooterSessionManager.ts +++ b/packages/super-editor/src/editors/v1/core/presentation-editor/header-footer/HeaderFooterSessionManager.ts @@ -19,7 +19,7 @@ import type { SectionMetadata, Fragment, ResolvedHeaderFooterLayout, - ResolvedPaintItem, + ResolvedPaintItem, ResolvedLayout, ResolvedPage } from '@superdoc/contracts'; import type { PageDecorationProvider } from '@superdoc/painter-dom'; import { resolveHeaderFooterLayout } from '@superdoc/layout-resolved'; @@ -733,19 +733,20 @@ export class HeaderFooterSessionManager { // =========================================================================== /** - * Rebuild header/footer regions from layout. + * Rebuild header/footer regions from the resolved layout. */ - rebuildRegions(layout: Layout): void { + rebuildRegions(resolvedLayout: ResolvedLayout): void { this.#headerRegions.clear(); this.#footerRegions.clear(); const layoutOptions = this.#deps?.getLayoutOptions() ?? {}; - const pageHeight = layout.pageSize?.h ?? layoutOptions.pageSize?.h ?? this.#options.defaultPageSize.h; - if (pageHeight <= 0) return; + const fallbackPageHeight = + resolvedLayout.pages[0]?.height ?? layoutOptions.pageSize?.h ?? this.#options.defaultPageSize.h; + if (fallbackPageHeight <= 0) return; // Build section first page numbers map const sectionFirstPageNumbers = new Map(); - for (const p of layout.pages) { + for (const p of resolvedLayout.pages) { const idx = p.sectionIndex ?? 0; if (!sectionFirstPageNumbers.has(idx)) { sectionFirstPageNumbers.set(idx, p.number); @@ -757,9 +758,9 @@ export class HeaderFooterSessionManager { const defaultMargins = this.#options.defaultMargins; - layout.pages.forEach((page, pageIndex) => { + resolvedLayout.pages.forEach((page, pageIndex) => { const margins = page.margins ?? layoutOptions.margins ?? defaultMargins; - const actualPageHeight = page.size?.h ?? pageHeight; + const actualPageHeight = page.height ?? fallbackPageHeight; const sectionIndex = page.sectionIndex ?? 0; const sectionId = sectionIdBySectionIndex.get(sectionIndex) ?? `section-${sectionIndex}`; @@ -1685,7 +1686,7 @@ export class HeaderFooterSessionManager { #computeExpectedSectionType( kind: 'header' | 'footer', - page: Page, + page: ResolvedPage, sectionFirstPageNumbers: Map, ): string { const pageNumber = page.number; @@ -1714,10 +1715,10 @@ export class HeaderFooterSessionManager { #stripFootnoteReserveFromBottomMargin( margins: HeaderFooterLayoutOptions['margins'], - page: Page, + page: ResolvedPage | null, ): HeaderFooterLayoutOptions['margins'] { // Note: property is 'footnoteReserved' (with 'd') as defined in @superdoc/contracts - const footnoteReserved = page.footnoteReserved ?? 0; + const footnoteReserved = page?.footnoteReserved ?? 0; if (footnoteReserved <= 0) return margins; const currentBottom = margins?.bottom ?? this.#options.defaultMargins.bottom ?? 0; @@ -2262,10 +2263,10 @@ export class HeaderFooterSessionManager { * Update decoration providers for header and footer. * Creates new providers based on layout results and sets them on this manager. */ - updateDecorationProviders(layout: Layout): void { + updateDecorationProviders(layout: Layout, resolvedLayout: ResolvedLayout): void { this.#headerDecorationProvider = this.createDecorationProvider('header', layout); this.#footerDecorationProvider = this.createDecorationProvider('footer', layout); - this.rebuildRegions(layout); + this.rebuildRegions(resolvedLayout); } private resolveAlignedDecorationItems( @@ -2398,7 +2399,7 @@ export class HeaderFooterSessionManager { resolvedLayout, `rId '${rIdLayoutKey}' page ${pageNumber}`, ); - const pageHeight = page?.size?.h ?? layout.pageSize?.h ?? layoutOptions.pageSize?.h ?? defaultPageSize.h; + const pageHeight = page?.height ?? layout.pageSize?.h ?? layoutOptions.pageSize?.h ?? defaultPageSize.h; const margins = pageMargins ?? layout.pages[0]?.margins ?? layoutOptions.margins ?? defaultMargins; const decorationMargins = kind === 'footer' ? this.#stripFootnoteReserveFromBottomMargin(margins, page ?? null) : margins; @@ -2459,7 +2460,7 @@ export class HeaderFooterSessionManager { `variant '${headerFooterType}' page ${pageNumber}`, ); - const pageHeight = page?.size?.h ?? layout.pageSize?.h ?? layoutOptions.pageSize?.h ?? defaultPageSize.h; + const pageHeight = page?.height ?? layout.pageSize?.h ?? layoutOptions.pageSize?.h ?? defaultPageSize.h; const margins = pageMargins ?? layout.pages[0]?.margins ?? layoutOptions.margins ?? defaultMargins; const decorationMargins = kind === 'footer' ? this.#stripFootnoteReserveFromBottomMargin(margins, page ?? null) : margins; diff --git a/packages/super-editor/src/editors/v1/core/presentation-editor/tests/PresentationEditor.test.ts b/packages/super-editor/src/editors/v1/core/presentation-editor/tests/PresentationEditor.test.ts index c67d57260b..7f64d8f50d 100644 --- a/packages/super-editor/src/editors/v1/core/presentation-editor/tests/PresentationEditor.test.ts +++ b/packages/super-editor/src/editors/v1/core/presentation-editor/tests/PresentationEditor.test.ts @@ -182,7 +182,34 @@ const { getActiveEditorHost: vi.fn(() => null), destroy: vi.fn(), })), - mockResolveLayout: vi.fn(() => ({ version: 1, flowMode: 'paginated', pageGap: 0, pages: [] })), + // SD-2836: rebuildRegions now iterates resolvedLayout.pages, so the mock + // must synthesize a ResolvedPage per source Layout page to keep header/footer + // region tests from going empty. + mockResolveLayout: vi.fn( + ({ layout }: { layout: { pages: Array>; pageSize: { w: number; h: number } } }) => ({ + version: 1, + flowMode: 'paginated', + pageGap: 0, + pages: (layout?.pages ?? []).map((p, i) => ({ + id: `page-${i}`, + index: i, + number: (p.number as number) ?? i + 1, + width: ((p.size as { w?: number } | undefined)?.w ?? layout.pageSize?.w) as number, + height: ((p.size as { h?: number } | undefined)?.h ?? layout.pageSize?.h) as number, + items: [], + margins: p.margins, + sectionRefs: p.sectionRefs, + sectionIndex: p.sectionIndex, + numberText: p.numberText, + footnoteReserved: p.footnoteReserved, + vAlign: p.vAlign, + baseMargins: p.baseMargins, + orientation: p.orientation, + columns: p.columns, + columnRegions: p.columnRegions, + })), + }), + ), mockFlowBlockCacheInstances, MockFlowBlockCache, }; diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index d0c4e4a701..56ff4ad0fa 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -2651,15 +2651,9 @@ importers: '@superdoc/font-utils': specifier: workspace:* version: link:../../../../shared/font-utils - '@superdoc/layout-bridge': - specifier: workspace:* - version: link:../../layout-bridge '@superdoc/layout-resolved': specifier: workspace:* version: link:../../layout-resolved - '@superdoc/pm-adapter': - specifier: workspace:* - version: link:../../pm-adapter '@superdoc/preset-geometry': specifier: workspace:* version: link:../../../preset-geometry