@beyondwork/docx-react-component 1.0.103 → 1.0.105

package/src/runtime/layout/project-block-fragments.ts

@@ -235,11 +235,27 @@ function emitSlicedParagraph(
       ...deriveStyleMetadata(block),
       kind: "paragraph-slice",
       paragraphLineRange: slice.lineRange,
+      continuation: buildParagraphContinuationCursor(slice, i, slices.length),
     };
     emit(slice.pageIndex, fragment);
   }
 }
 
+function buildParagraphContinuationCursor(
+  slice: ParagraphLineSlice,
+  sequenceIndex: number,
+  sliceCount: number,
+): NonNullable<RuntimeBlockFragment["continuation"]> {
+  return {
+    kind: "paragraph",
+    sequenceIndex,
+    sliceCount,
+    lineRange: slice.lineRange,
+    continuesFromPreviousPage: slice.lineRange.from > 0,
+    continuesToNextPage: slice.lineRange.to < slice.lineRange.totalLines,
+  };
+}
+
 function estimateSliceHeightFromLines(lineRange: {
   from: number;
   to: number;
@@ -259,7 +275,7 @@ function estimateSliceHeightFromLines(lineRange: {
  * every continuation page.
  */
 function emitSlicedTable(
-  block: SurfaceBlockSnapshot,
+  block: Extract<SurfaceBlockSnapshot, { kind: "table" }>,
   slices: readonly TableRowSlice[],
   emit: (pageIndex: number, fragment: FragmentWithoutPageId) => void,
 ): void {
@@ -276,12 +292,96 @@ function emitSlicedTable(
       ...deriveStyleMetadata(block),
       kind: "table-slice",
       tableRowRange: slice.rowRange,
+      continuation: buildTableContinuationCursor(block, slice, i, slices.length),
       ...(slice.columnIndex !== undefined ? { columnIndex: slice.columnIndex } : {}),
     };
     emit(slice.pageIndex, fragment);
   }
 }
 
+function buildTableContinuationCursor(
+  block: Extract<SurfaceBlockSnapshot, { kind: "table" }>,
+  slice: TableRowSlice,
+  sequenceIndex: number,
+  sliceCount: number,
+): NonNullable<RuntimeBlockFragment["continuation"]> {
+  return {
+    kind: "table",
+    sequenceIndex,
+    sliceCount,
+    rowRange: slice.rowRange,
+    continuesFromPreviousPage: slice.rowRange.from > 0,
+    continuesToNextPage: slice.rowRange.to < slice.rowRange.totalRows,
+    repeatedHeaderRowIndexes:
+      slice.rowRange.from > 0
+        ? collectRepeatedHeaderRowIndexes(block, slice.rowRange.from)
+        : [],
+    verticalMergeCarry: collectVerticalMergeCarry(block, slice.rowRange.from),
+  };
+}
+
+function collectRepeatedHeaderRowIndexes(
+  block: Extract<SurfaceBlockSnapshot, { kind: "table" }>,
+  startRow: number,
+): number[] {
+  const headerRows: number[] = [];
+  for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex += 1) {
+    if (rowIndex >= startRow) break;
+    if (block.rows[rowIndex]?.isHeader === true) headerRows.push(rowIndex);
+  }
+  return headerRows;
+}
+
+function collectVerticalMergeCarry(
+  block: Extract<SurfaceBlockSnapshot, { kind: "table" }>,
+  startRow: number,
+): Array<{ columnIndex: number; restartRowIndex: number }> {
+  if (startRow <= 0) return [];
+
+  const activeByColumn = new Map<number, number>();
+  for (let rowIndex = 0; rowIndex < startRow; rowIndex += 1) {
+    visitRowCells(block.rows[rowIndex], (columnIndex, span, verticalMerge) => {
+      for (let column = columnIndex; column < columnIndex + span; column += 1) {
+        if (verticalMerge === "restart") {
+          activeByColumn.set(column, rowIndex);
+        } else if (verticalMerge !== "continue") {
+          activeByColumn.delete(column);
+        }
+      }
+    });
+  }
+
+  const carried = new Map<number, number>();
+  visitRowCells(block.rows[startRow], (columnIndex, span, verticalMerge) => {
+    if (verticalMerge !== "continue") return;
+    for (let column = columnIndex; column < columnIndex + span; column += 1) {
+      const restartRowIndex = activeByColumn.get(column);
+      if (restartRowIndex !== undefined) carried.set(column, restartRowIndex);
+    }
+  });
+
+  return [...carried]
+    .sort(([a], [b]) => a - b)
+    .map(([columnIndex, restartRowIndex]) => ({ columnIndex, restartRowIndex }));
+}
+
+function visitRowCells(
+  row: Extract<SurfaceBlockSnapshot, { kind: "table" }>["rows"][number] | undefined,
+  visit: (
+    columnIndex: number,
+    span: number,
+    verticalMerge: "restart" | "continue" | null,
+  ) => void,
+): void {
+  if (!row) return;
+  let columnIndex = Math.max(0, row.gridBefore ?? 0);
+  for (const cell of row.cells) {
+    const span = Math.max(1, cell.gridSpan || cell.colspan || 1);
+    visit(columnIndex, span, cell.verticalMerge);
+    columnIndex += span;
+  }
+}
+
 function estimateSliceHeightFromRows(rowRange: {
   from: number;
   to: number;

package/src/runtime/layout/public-facet.ts

@@ -25,12 +25,16 @@ import type {
 } from "./page-story-resolver.ts";
 import type {
   RuntimeBlockFragment,
+  RuntimeLayoutContinuationCursor,
+  RuntimeLayoutDivergence,
   RuntimeLineBox,
   RuntimeNoteAllocation,
+  RuntimePageFrame,
   RuntimePageGraph,
   RuntimePageNode,
   RuntimePageRegion,
   RuntimePageRegions,
+  RuntimeTwipsRect,
 } from "./page-graph.ts";
 import type {
   ResolvedFormattingState,
@@ -132,6 +136,40 @@ export function emitLayoutGuardWarning(
 // Public read model types (shape-stable, cloned at the facet boundary)
 // ---------------------------------------------------------------------------
 
+export interface PublicTwipsRect {
+  xTwips: number;
+  yTwips: number;
+  widthTwips: number;
+  heightTwips: number;
+}
+
+export interface PublicLayoutDivergence {
+  divergenceId: string;
+  kind: RuntimeLayoutDivergence["kind"];
+  source: RuntimeLayoutDivergence["source"];
+  severity: RuntimeLayoutDivergence["severity"];
+  message: string;
+  regionKinds?: readonly RuntimePageRegion["kind"][];
+  fragmentIds?: readonly string[];
+}
+
+export interface PublicPageFrame {
+  frameId: string;
+  pageId: string;
+  pageIndex: number;
+  sectionIndex: number;
+  displayPageNumber: number;
+  physicalBoundsTwips: PublicTwipsRect;
+  divergenceIds: readonly string[];
+  signature: string;
+  exclusionZoneCount: number;
+  regionFrames: readonly {
+    kind: RuntimePageRegion["kind"];
+    rectTwips?: PublicTwipsRect;
+    fragmentIds: readonly string[];
+  }[];
+}
+
 export interface PublicPageNode {
   pageId: string;
   pageIndex: number;
@@ -157,6 +195,10 @@ export interface PublicPageNode {
   lineBoxCount: number;
   /** Footnotes reserved at the bottom of the page, if any. */
   noteAllocations: readonly PublicNoteAllocation[];
+  /** PE2 page-frame graph projection, when emitted by the L04 graph. */
+  frame?: PublicPageFrame;
+  /** Typed layout divergences detected while building this page. */
+  divergences?: readonly PublicLayoutDivergence[];
 }
 
 export interface PublicResolvedPageStories {
@@ -187,6 +229,8 @@ export interface PublicPageRegion {
   widthTwips: number;
   heightTwips: number;
   fragmentCount: number;
+  /** PE2 semantic twips rect, when populated by the L04 page-frame graph. */
+  rectTwips?: PublicTwipsRect;
 }
 
 /**
@@ -208,8 +252,23 @@ export interface PublicBlockFragment {
   to: number;
   heightTwips: number;
   orderInRegion: number;
+  kind?: "whole" | "paragraph-slice" | "table-slice";
+  paragraphLineRange?: {
+    from: number;
+    to: number;
+    totalLines: number;
+  };
+  tableRowRange?: {
+    from: number;
+    to: number;
+    totalRows: number;
+  };
+  columnIndex?: number;
+  continuation?: PublicLayoutContinuationCursor;
 }
 
+export type PublicLayoutContinuationCursor = RuntimeLayoutContinuationCursor;
+
 /**
  * P8 — One block snapshot rendered into a region of a page.  Returned by
  * `WordReviewEditorLayoutFacet.getStoryBlocksForRegion` and
@@ -245,6 +304,7 @@ export interface PublicNoteAllocation {
   noteKind: "footnote" | "endnote";
   noteId: string;
   reservedHeightTwips: number;
+  fragmentId?: string;
 }
 
 export interface PublicPageAnchor {
@@ -1367,12 +1427,74 @@ function toPublicPageNode(
     regions: toPublicPageRegions(node.regions),
     lineBoxCount: node.lineBoxes.length,
     noteAllocations: node.noteAllocations.map(toPublicNoteAllocation),
+    ...(node.frame ? { frame: toPublicPageFrame(node.frame) } : {}),
+    ...(node.divergences && node.divergences.length > 0
+      ? { divergences: node.divergences.map(toPublicLayoutDivergence) }
+      : {}),
   };
   publicPageNodeCache.set(node, built);
   void graph; // reserved for future cross-page derivations
   return built;
 }
 
+function toPublicTwipsRect(rect: RuntimeTwipsRect): PublicTwipsRect {
+  return {
+    xTwips: rect.xTwips,
+    yTwips: rect.yTwips,
+    widthTwips: rect.widthTwips,
+    heightTwips: rect.heightTwips,
+  };
+}
+
+function frameRegionEntries(
+  frame: RuntimePageFrame,
+): PublicPageFrame["regionFrames"] {
+  const regions: PublicPageFrame["regionFrames"][number][] = [];
+  const push = (region: RuntimePageRegion | undefined) => {
+    if (!region) return;
+    regions.push({
+      kind: region.kind,
+      ...(region.rectTwips ? { rectTwips: toPublicTwipsRect(region.rectTwips) } : {}),
+      fragmentIds: [...region.fragmentIds],
+    });
+  };
+  push(frame.regions.header);
+  push(frame.regions.body);
+  for (const column of frame.regions.columns ?? []) push(column);
+  push(frame.regions.footer);
+  for (const footnote of frame.regions.footnotes ?? []) push(footnote);
+  return regions;
+}
+
+function toPublicPageFrame(frame: RuntimePageFrame): PublicPageFrame {
+  return {
+    frameId: frame.frameId,
+    pageId: frame.pageId,
+    pageIndex: frame.pageIndex,
+    sectionIndex: frame.sectionIndex,
+    displayPageNumber: frame.displayPageNumber,
+    physicalBoundsTwips: toPublicTwipsRect(frame.physicalBoundsTwips),
+    divergenceIds: [...frame.divergenceIds],
+    signature: frame.signature,
+    exclusionZoneCount: frame.regions.exclusionZones.length,
+    regionFrames: frameRegionEntries(frame),
+  };
+}
+
+function toPublicLayoutDivergence(
+  divergence: RuntimeLayoutDivergence,
+): PublicLayoutDivergence {
+  return {
+    divergenceId: divergence.divergenceId,
+    kind: divergence.kind,
+    source: divergence.source,
+    severity: divergence.severity,
+    message: divergence.message,
+    ...(divergence.regionKinds !== undefined ? { regionKinds: [...divergence.regionKinds] } : {}),
+    ...(divergence.fragmentIds !== undefined ? { fragmentIds: [...divergence.fragmentIds] } : {}),
+  };
+}
+
 function toPublicResolvedPageStories(
   stories: ResolvedPageStories,
 ): PublicResolvedPageStories {
@@ -1404,6 +1526,7 @@ function toPublicPageRegion(region: RuntimePageRegion): PublicPageRegion {
     widthTwips: region.widthTwips,
     heightTwips: region.heightTwips,
     fragmentCount: region.fragmentIds.length,
+    ...(region.rectTwips ? { rectTwips: toPublicTwipsRect(region.rectTwips) } : {}),
   };
 }
 
@@ -1422,6 +1545,34 @@ function toPublicBlockFragment(
     to: fragment.to,
     heightTwips: fragment.heightTwips,
     orderInRegion: fragment.orderInRegion,
+    ...(fragment.kind !== undefined ? { kind: fragment.kind } : {}),
+    ...(fragment.paragraphLineRange !== undefined
+      ? { paragraphLineRange: { ...fragment.paragraphLineRange } }
+      : {}),
+    ...(fragment.tableRowRange !== undefined
+      ? { tableRowRange: { ...fragment.tableRowRange } }
+      : {}),
+    ...(fragment.columnIndex !== undefined ? { columnIndex: fragment.columnIndex } : {}),
+    ...(fragment.continuation !== undefined
+      ? { continuation: cloneContinuationCursor(fragment.continuation) }
+      : {}),
+  };
+}
+
+function cloneContinuationCursor(
+  cursor: RuntimeLayoutContinuationCursor,
+): RuntimeLayoutContinuationCursor {
+  if (cursor.kind === "paragraph") {
+    return {
+      ...cursor,
+      lineRange: { ...cursor.lineRange },
+    };
+  }
+  return {
+    ...cursor,
+    rowRange: { ...cursor.rowRange },
+    repeatedHeaderRowIndexes: [...cursor.repeatedHeaderRowIndexes],
+    verticalMergeCarry: cursor.verticalMergeCarry.map((carry) => ({ ...carry })),
   };
 }
 
@@ -1440,6 +1591,7 @@ function toPublicNoteAllocation(note: RuntimeNoteAllocation): PublicNoteAllocati
     noteKind: note.noteKind,
     noteId: note.noteId,
     reservedHeightTwips: note.reservedHeightTwips,
+    ...(note.fragmentId !== undefined ? { fragmentId: note.fragmentId } : {}),
   };
 }
 

package/src/runtime/prerender/graph-canonicalize.ts

@@ -1,7 +1,9 @@
 import type {
   RuntimeBlockFragment,
   RuntimePageAnchor,
+  RuntimePageFrame,
   RuntimePageGraph,
+  RuntimePageLocalStoryInstance,
   RuntimePageNode,
   RuntimePageRegion,
   RuntimePageRegions,
@@ -54,6 +56,9 @@ export function canonicalizeGraph(graph: RuntimePageGraph): RuntimePageGraph {
     ...page,
     pageId: rewriteId(page.pageId),
     regions: rewriteRegions(page.regions, rewriteId),
+    ...(page.frame === undefined
+      ? {}
+      : { frame: rewriteFrame(page.frame, rewriteId) }),
     lineBoxes: page.lineBoxes.map((line) => ({
       ...line,
       fragmentId: rewriteId(line.fragmentId),
@@ -86,6 +91,45 @@ export function canonicalizeGraph(graph: RuntimePageGraph): RuntimePageGraph {
   };
 }
 
+function rewriteFrame(
+  frame: RuntimePageFrame,
+  rewriteId: (id: string) => string,
+): RuntimePageFrame {
+  return {
+    ...frame,
+    pageId: rewriteId(frame.pageId),
+    pageLocalStories: frame.pageLocalStories.map((story) =>
+      rewritePageLocalStoryInstance(story, rewriteId),
+    ),
+    regions: {
+      ...frame.regions,
+      body: rewriteRegion(frame.regions.body, rewriteId),
+      ...(frame.regions.header
+        ? { header: rewriteRegion(frame.regions.header, rewriteId) }
+        : {}),
+      ...(frame.regions.footer
+        ? { footer: rewriteRegion(frame.regions.footer, rewriteId) }
+        : {}),
+      ...(frame.regions.columns
+        ? { columns: frame.regions.columns.map((region) => rewriteRegion(region, rewriteId)) }
+        : {}),
+      ...(frame.regions.footnotes
+        ? { footnotes: frame.regions.footnotes.map((region) => rewriteRegion(region, rewriteId)) }
+        : {}),
+    },
+  };
+}
+
+function rewritePageLocalStoryInstance(
+  story: RuntimePageLocalStoryInstance,
+  rewriteId: (id: string) => string,
+): RuntimePageLocalStoryInstance {
+  return {
+    ...story,
+    pageId: rewriteId(story.pageId),
+  };
+}
+
 function rewriteRegions(
   regions: RuntimePageRegions,
   rewriteId: (id: string) => string,

package/src/runtime/surface-projection.ts

@@ -6,6 +6,7 @@ import type {
   SurfaceDrawingAnchor,
   SurfaceInlineSegment,
   SurfacePictureEffects,
+  SurfacePreserveOnlyObjectSizing,
   SurfaceTableCellSnapshot,
   SurfaceTableRowSnapshot,
   SurfaceTextMark,
@@ -38,6 +39,7 @@ import type {
   TextMark,
   DrawingFrameNode,
   PictureContent,
+  PreserveOnlyObjectSizing,
   ShapeContent,
   VmlShapeNode,
   WordArtNode,
@@ -1549,6 +1551,9 @@ function appendInlineSegments(
           ...(c.line ? { line: c.line } : {}),
           ...(c.isTextBox ? { isTextBox: true } : {}),
           ...(c.textBoxBody ? { textBoxBody: c.textBoxBody } : {}),
+          ...(c.preserveOnlyObject
+            ? { preserveOnlyObject: surfacePreserveOnlyObject(c.preserveOnlyObject) }
+            : {}),
           ...(txbxText ? { txbxText } : {}),
           ...(txbxTextSegment?.marks && txbxTextSegment.marks.length > 0
             ? { txbxMarks: txbxTextSegment.marks }
@@ -1568,6 +1573,7 @@ function appendInlineSegments(
           {
             previewMediaId: c.previewMediaId,
             parsedChartId,
+            anchor: surfaceAnchorFromGeometry(node.anchor),
           },
         );
       }
@@ -1578,7 +1584,10 @@ function appendInlineSegments(
           start,
           "SmartArt diagram",
           `DrawingFrame smartart_preview (${node.anchor.wrapMode}).`,
-          { previewMediaId: c.previewMediaId },
+          {
+            previewMediaId: c.previewMediaId,
+            anchor: surfaceAnchorFromGeometry(node.anchor),
+          },
         );
       }
       return appendComplexPreviewSegment(
@@ -1587,6 +1596,7 @@ function appendInlineSegments(
         start,
         "Drawing frame",
         `DrawingFrame ${c.type} (${node.anchor.wrapMode}).`,
+        { anchor: surfaceAnchorFromGeometry(node.anchor) },
       );
     }
     case "symbol":
@@ -2109,12 +2119,19 @@ function extractTxbxFirstTextSegment(
 
 function appendComplexPreviewSegment(
   paragraph: ParagraphAccumulator,
-  node: { rawXml: string },
+  node: { rawXml: string; preserveOnlyObject?: PreserveOnlyObjectSizing },
   start: number,
   label: string,
   detail: string,
-  extras: { previewMediaId?: string; parsedChartId?: string } = {},
+  extras: {
+    previewMediaId?: string;
+    parsedChartId?: string;
+    anchor?: SurfaceDrawingAnchor;
+  } = {},
 ): { nextCursor: number; lockedFragmentIds: string[] } {
+  const preserveOnlyObject = node.preserveOnlyObject
+    ? surfacePreserveOnlyObject(node.preserveOnlyObject)
+    : undefined;
   paragraph.segments.push({
     segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
     kind: "opaque_inline",
@@ -2126,11 +2143,34 @@ function appendComplexPreviewSegment(
     detail,
     ...(extras.previewMediaId ? { previewMediaId: extras.previewMediaId } : {}),
     ...(extras.parsedChartId ? { parsedChartId: extras.parsedChartId } : {}),
+    ...(preserveOnlyObject ? { preserveOnlyObject } : {}),
+    ...(extras.anchor ? { anchor: extras.anchor } : {}),
     state: "locked-preserve-only",
   });
   return { nextCursor: start + 1, lockedFragmentIds: [] };
 }
 
+function surfacePreserveOnlyObject(
+  object: PreserveOnlyObjectSizing,
+): SurfacePreserveOnlyObjectSizing {
+  return {
+    ...(object.sourceId ? { sourceId: object.sourceId } : {}),
+    display: object.display,
+    ...(object.extentEmu
+      ? {
+          extentEmu: {
+            widthEmu: object.extentEmu.widthEmu,
+            heightEmu: object.extentEmu.heightEmu,
+          },
+        }
+      : {}),
+    fallbackHint: object.fallbackHint,
+    ...(object.relationshipIds && object.relationshipIds.length > 0
+      ? { relationshipIds: [...object.relationshipIds] }
+      : {}),
+  };
+}
+
 function appendTextBoxSegment(
   paragraph: ParagraphAccumulator,
   start: number,