@beyondwork/docx-react-component 1.0.36 → 1.0.38

package/src/runtime/document-navigation.ts

@@ -17,34 +17,20 @@ import type {
   EditorStoryTarget,
   EditorSurfaceSnapshot,
   SurfaceBlockSnapshot,
-  SurfaceInlineSegment,
 } from "../api/public-types";
-import type {
-  FootnoteCollection,
-} from "../model/canonical-document.ts";
 import type { CanonicalDocumentEnvelope } from "../core/state/editor-state.ts";
 import { createSelectionSnapshot } from "../core/state/editor-state.ts";
 import { MAIN_STORY_TARGET } from "../core/selection/mapping.ts";
 import { createEditorSurfaceSnapshot } from "./surface-projection.ts";
 import {
-  estimateBlockHeight,
-  estimateParagraphHeight,
-  getUsableColumnMetrics,
-  getUsableColumnWidth,
-  getUsablePageHeight,
-} from "./page-layout-estimation.ts";
-import {
-  buildPageLayoutSnapshot,
   buildResolvedSections,
   findSectionForPosition as resolveSectionForPosition,
   resolveSectionForStoryTarget,
   type ResolvedDocumentSection,
 } from "./document-layout.ts";
+import { buildPageStack } from "./layout/paginated-layout-engine.ts";
 import { findNoteReferencePosition } from "./view-state.ts";
 
-const MIN_BLOCK_HEIGHT_TWIPS = 240;
-const FOOTNOTE_REFERENCE_RESERVATION_TWIPS = 180;
-
 interface NavigationBaseSnapshot {
   mainSurface: EditorSurfaceSnapshot;
   sections: ResolvedDocumentSection[];
@@ -152,186 +138,6 @@ export function findSectionForOffset(
   return sections.length > 0 ? resolveSectionForPosition(sections, offset).index : 0;
 }
 
-function buildPageStack(
-  document: CanonicalDocumentEnvelope,
-  sections: ResolvedDocumentSection[],
-  mainSurface: EditorSurfaceSnapshot,
-): DocumentPageSnapshot[] {
-  const pages: DocumentPageSnapshot[] = [];
-  let globalPageIndex = 0;
-
-  for (const section of sections) {
-    const layout = buildPageLayoutSnapshot(
-      section.index,
-      section.properties ?? document.subParts?.finalSectionProperties,
-      document.subParts,
-    );
-    const sectionBlocks = collectSectionBlocks(mainSurface.blocks, section.start, section.end);
-    const paginated = paginateSectionBlocks(
-      section,
-      sectionBlocks,
-      layout,
-      document.subParts?.footnoteCollection,
-    );
-
-    for (const page of paginated) {
-      pages.push({
-        ...page,
-        pageIndex: globalPageIndex,
-      });
-      globalPageIndex += 1;
-    }
-  }
-
-  // Guarantee at least one page
-  if (pages.length === 0) {
-    pages.push({
-      pageIndex: 0,
-      sectionIndex: 0,
-      pageInSection: 0,
-      startOffset: 0,
-      endOffset: mainSurface.storySize,
-      layout: buildPageLayoutSnapshot(
-        0,
-        document.subParts?.finalSectionProperties,
-        document.subParts,
-      ),
-    });
-  }
-
-  return pages;
-}
-
-function collectSectionBlocks(
-  blocks: readonly SurfaceBlockSnapshot[],
-  start: number,
-  end: number,
-): SurfaceBlockSnapshot[] {
-  return blocks.filter((block) => block.to > start && block.from < end);
-}
-
-function paginateSectionBlocks(
-  section: ResolvedDocumentSection,
-  blocks: readonly SurfaceBlockSnapshot[],
-  layout: DocumentPageSnapshot["layout"],
-  footnotes: FootnoteCollection | undefined,
-): Omit<DocumentPageSnapshot, "pageIndex">[] {
-  if (blocks.length === 0) {
-    return [
-      {
-        sectionIndex: section.index,
-        pageInSection: 0,
-        startOffset: section.start,
-        endOffset: section.end,
-        layout,
-      },
-    ];
-  }
-
-  const pages: Omit<DocumentPageSnapshot, "pageIndex">[] = [];
-  const usableHeight = getUsablePageHeight(layout);
-  const columnMetrics = getUsableColumnMetrics(layout);
-  const maxColumns = Math.max(1, columnMetrics.length);
-  let pageStart = section.start;
-  let columnHeight = 0;
-  let columnIndex = 0;
-  let pageInSection = 0;
-  let reservedNoteHeight = 0;
-  const reservedNotes = new Set<string>();
-
-  const pushPage = (endOffset: number): void => {
-    const boundedEnd = Math.max(pageStart, Math.min(endOffset, section.end));
-    if (boundedEnd === pageStart && pages.length > 0) {
-      return;
-    }
-    pages.push({
-      sectionIndex: section.index,
-      pageInSection,
-      startOffset: pageStart,
-      endOffset: boundedEnd,
-      layout,
-    });
-    pageInSection += 1;
-    pageStart = boundedEnd;
-    columnHeight = 0;
-    columnIndex = 0;
-    reservedNoteHeight = 0;
-    reservedNotes.clear();
-  };
-
-  for (let index = 0; index < blocks.length; index += 1) {
-    const block = blocks[index]!;
-    const nextBoundary = blocks[index + 1]?.from ?? section.end;
-    while (true) {
-      const columnWidth =
-        columnMetrics[Math.min(columnIndex, columnMetrics.length - 1)]?.width ??
-        getUsableColumnWidth(layout);
-      const baseHeight = estimateBlockHeight(block, columnWidth);
-      const keepWithNextHeight =
-        block.kind === "paragraph" && block.keepNext
-          ? baseHeight + estimateBlockHeight(blocks[index + 1], columnWidth)
-          : baseHeight;
-      const noteHeight = estimateFootnoteReservation(block, footnotes, columnWidth, reservedNotes);
-      const projectedHeight = columnHeight + keepWithNextHeight + reservedNoteHeight + noteHeight;
-
-      if (block.kind === "paragraph" && block.pageBreakBefore && pageStart < block.from) {
-        pushPage(block.from);
-        continue;
-      }
-      if (projectedHeight > usableHeight && pageStart < block.from) {
-        if (columnIndex < maxColumns - 1) {
-          columnIndex += 1;
-          columnHeight = 0;
-          reservedNoteHeight = 0;
-          reservedNotes.clear();
-          continue;
-        }
-        pushPage(block.from);
-        continue;
-      }
-
-      const effectiveNoteHeight = estimateFootnoteReservation(
-        block,
-        footnotes,
-        columnWidth,
-        reservedNotes,
-      );
-      columnHeight += baseHeight;
-      reservedNoteHeight += effectiveNoteHeight;
-      currentPageNoteIds(block).forEach((noteKey) => reservedNotes.add(noteKey));
-
-      if (hasColumnBreak(block)) {
-        if (columnIndex < maxColumns - 1) {
-          columnIndex += 1;
-          columnHeight = 0;
-          reservedNoteHeight = 0;
-          reservedNotes.clear();
-        } else {
-          pushPage(nextBoundary);
-        }
-        break;
-      }
-
-      if (index === blocks.length - 1) {
-        pushPage(section.end);
-      }
-      break;
-    }
-  }
-
-  return pages.length > 0
-    ? pages
-    : [
-        {
-          sectionIndex: section.index,
-          pageInSection: 0,
-          startOffset: section.start,
-          endOffset: section.end,
-          layout,
-        },
-      ];
-}
-
 function resolveActiveNavigationContext(
   document: CanonicalDocumentEnvelope,
   pages: readonly DocumentPageSnapshot[],
@@ -383,116 +189,6 @@ function findFirstPageIndexForSection(
   return match >= 0 ? match : 0;
 }
 
-function estimateFootnoteReservation(
-  block: SurfaceBlockSnapshot,
-  footnotes: FootnoteCollection | undefined,
-  columnWidth: number,
-  reservedNotes: ReadonlySet<string>,
-): number {
-  if (!footnotes || block.kind !== "paragraph") {
-    return 0;
-  }
-
-  let reservation = 0;
-  for (const noteKey of currentPageNoteIds(block)) {
-    if (reservedNotes.has(noteKey)) {
-      continue;
-    }
-
-    const [noteKind, noteId] = noteKey.split(":");
-    const noteCollection =
-      noteKind === "endnote" ? footnotes.endnotes : footnotes.footnotes;
-    const note = noteCollection[noteId];
-    reservation += FOOTNOTE_REFERENCE_RESERVATION_TWIPS;
-    if (note) {
-      reservation += note.blocks.reduce(
-        (total, child) => total + estimateCanonicalNoteBlockHeight(child, columnWidth),
-        0,
-      );
-    }
-  }
-
-  return reservation;
-}
-
-function estimateCanonicalNoteBlockHeight(
-  block: FootnoteCollection["footnotes"][string]["blocks"][number],
-  columnWidth: number,
-): number {
-  switch (block.type) {
-    case "paragraph":
-      return estimateParagraphHeight(
-        {
-          blockId: "note",
-          kind: "paragraph",
-          from: 0,
-          to: 0,
-          ...(block.styleId ? { styleId: block.styleId } : {}),
-          segments: createEstimatedNoteSegments(block.children),
-        },
-        columnWidth,
-      );
-    case "table":
-      return MIN_BLOCK_HEIGHT_TWIPS * Math.max(1, block.rows.length);
-    default:
-      return MIN_BLOCK_HEIGHT_TWIPS;
-  }
-}
-
-function createEstimatedNoteSegments(
-  children: Extract<FootnoteCollection["footnotes"][string]["blocks"][number], { type: "paragraph" }>["children"],
-): SurfaceInlineSegment[] {
-  const segments: SurfaceInlineSegment[] = [];
-
-  children.forEach((child, index) => {
-    if (child.type === "text") {
-      segments.push({
-        segmentId: `note-${index}`,
-        kind: "text",
-        from: 0,
-        to: Array.from(child.text).length,
-        text: child.text,
-      });
-      return;
-    }
-
-    if (child.type === "hard_break" || child.type === "tab") {
-      segments.push({
-        segmentId: `note-${index}`,
-        kind: child.type,
-        from: 0,
-        to: 1,
-      });
-    }
-  });
-
-  return segments;
-}
-
-function currentPageNoteIds(
-  block: SurfaceBlockSnapshot,
-): Set<string> {
-  const notes = new Set<string>();
-  if (block.kind !== "paragraph") {
-    return notes;
-  }
-
-  for (const segment of block.segments) {
-    if (segment.kind === "note_ref" && segment.noteId) {
-      notes.add(`${segment.noteKind}:${segment.noteId}`);
-    }
-  }
-  return notes;
-}
-
-function hasColumnBreak(block: SurfaceBlockSnapshot): boolean {
-  return block.kind === "paragraph" && block.segments.some(
-    (segment) =>
-      segment.kind === "opaque_inline" &&
-      segment.label === "Column break",
-  );
-}
-
 // ---------------------------------------------------------------------------
 // Heading outline
 // ---------------------------------------------------------------------------
@@ -510,7 +206,7 @@ function headingLevelFromStyleId(styleId?: string): number | null {
   return null;
 }
 
-function buildHeadingOutline(
+export function buildHeadingOutline(
   document: CanonicalDocumentEnvelope,
   mainSurface: EditorSurfaceSnapshot,
   sections: ResolvedDocumentSection[],