@beyondwork/docx-react-component 1.0.109 → 1.0.111

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@beyondwork/docx-react-component",
   "publisher": "beyondwork",
-  "version": "1.0.109",
+  "version": "1.0.111",
   "description": "Embeddable React Word (docx) editor with review, comments, tracked changes, and round-trip OOXML fidelity.",
   "type": "module",
   "sideEffects": [

package/src/api/public-types.ts

@@ -177,6 +177,7 @@ export type {
   PublicBlockMeasurement,
   PublicFieldDirtinessReport,
   PublicLineBox,
+  PublicLineRunAnchor,
   PublicLayoutDivergence,
   PublicMeasurementFidelity,
   PublicNoteAllocation,
@@ -184,9 +185,11 @@ export type {
   PublicPageFrame,
   PublicPageLocalStoryInstance,
   PublicPageNode,
+  PublicPagePaginationTelemetry,
   PublicPageRegion,
   PublicPageRegions,
   PublicPageSpan,
+  PublicPaginationTelemetry,
   PublicRegionBlock,
   PublicRegionKind,
   PublicResolvedPageStories,

package/src/model/layout/page-graph-types.ts

@@ -189,6 +189,12 @@ export interface RuntimeStoryAnchoredObject {
     widthTwips: number;
     heightTwips: number;
   };
+  /**
+   * Page/frame-local object bbox in twips when L04 can place the object from
+   * canonical anchor metadata. This is semantic layout placement, not a
+   * rendered pixel bbox; L05 owns projection to px/object handles.
+   */
+  anchorRectTwips?: RuntimeTwipsRect;
   relationshipIds?: readonly string[];
   mediaIds?: readonly string[];
   preserveOnly: boolean;
@@ -444,10 +450,37 @@ export interface RuntimeLineBox {
   lineIndex: number;
   /** Baseline twips from the region's origin. */
   baselineTwips: number;
+  /** Page-local baseline twips from the physical page top. */
+  baselinePageYTwips?: number;
   /** Line height twips. */
   heightTwips: number;
   /** Approximate inline width consumed on this line. */
   widthTwips: number;
+  /** Page-local twips rect for the line box. */
+  rectTwips?: RuntimeTwipsRect;
+  /** Dominant paragraph direction for this line. */
+  direction?: "ltr" | "rtl";
+  /**
+   * Per-run/page-local anchor estimates for caret/selection projection. These
+   * are produced from L04 line breaking + run ids, not Word/UIA rectangles.
+   */
+  runAnchors?: readonly RuntimeLineRunAnchor[];
+}
+
+export interface RuntimeLineRunAnchor {
+  anchorId: string;
+  runId: string;
+  segmentId: string;
+  blockId: string;
+  fragmentId: string;
+  lineIndex: number;
+  direction: "ltr" | "rtl";
+  baselinePageYTwips: number;
+  lineRectTwips: RuntimeTwipsRect;
+  firstGlyphRectTwips: RuntimeTwipsRect;
+  lastGlyphRectTwips: RuntimeTwipsRect;
+  runRectTwips: RuntimeTwipsRect;
+  precision: "layout-estimate";
 }
 
 export interface RuntimeNoteAllocation {

package/src/model/layout/runtime-page-graph-types.ts

@@ -56,6 +56,26 @@ export interface RuntimePageGraph {
   sections: ResolvedDocumentSection[];
   /** Total non-blank page count. */
   contentPageCount: number;
+  /**
+   * Lazy-pagination status for this graph. Absent/`complete` means every
+   * returned page has been paginated. `viewport-window` means some page nodes
+   * are placeholders with `materialization: "unpaginated"`.
+   */
+  materialization?: RuntimePageGraphMaterialization;
+}
+
+export type RuntimePageMaterialization = "paginated" | "unpaginated";
+
+export interface RuntimePageGraphMaterialization {
+  kind: "complete" | "viewport-window";
+  requestedWindow?: RuntimePageWindowRange;
+  paginatedRange?: RuntimePageWindowRange;
+  estimatedPageCount?: number;
+}
+
+export interface RuntimePageWindowRange {
+  startPageIndex: number;
+  endPageIndex: number;
 }
 
 export interface RuntimePageNode {
@@ -83,6 +103,11 @@ export interface RuntimePageNode {
   noteAllocations: RuntimeNoteAllocation[];
   /** Whether this page is a blank filler (from even/odd page breaks). */
   isBlankFiller: boolean;
+  /**
+   * Whether L04 actually paginated this page. Windowed graph reads keep
+   * placeholder nodes for pages that exist but have not been measured yet.
+   */
+  materialization?: RuntimePageMaterialization;
 }
 
 export interface BuildPageGraphInput {

package/src/runtime/document-runtime.ts

@@ -231,6 +231,7 @@ import {
   setActiveLayoutWarningEmitter,
   type DocxFontLoader,
   type LayoutEngineInstance,
+  type LayoutEngineQueryInput,
   type LayoutFacet,
   type LayoutMeasurementProvider,
   type WordReviewEditorLayoutFacet,
@@ -1409,6 +1410,7 @@ export function createDocumentRuntime(
         workspaceMode: viewState.workspaceMode,
         zoomLevel: viewState.zoomLevel,
       },
+      viewportPageWindow: getViewportPageWindow(),
     }),
     canonicalDocument: () => state.document,
     renderKernel: () => renderKernelRef,
@@ -1463,6 +1465,50 @@ export function createDocumentRuntime(
   let viewportRangesKey: string = serializeViewportRanges(null);
   const EDITING_CORRIDOR_BLOCK_RADIUS = 8;
   const EDITING_CORRIDOR_MIN_BLOCKS = 24;
+  const VIEWPORT_PAGE_WINDOW_BLOCKS_PER_PAGE = 50;
+  const VIEWPORT_PAGE_WINDOW_BUFFER_PAGES = 0;
+
+  function getViewportPageWindow(): LayoutEngineQueryInput["viewportPageWindow"] | undefined {
+    if (!viewportBlockRanges || viewportBlockRanges.length === 0) return undefined;
+
+    const blockCount = state.document.content.children.length;
+    if (blockCount <= 0) return undefined;
+
+    let startBlock = Number.POSITIVE_INFINITY;
+    let endBlockInclusive = -1;
+    for (const range of viewportBlockRanges) {
+      const start = Math.max(0, Math.min(blockCount, Math.floor(range.start)));
+      const endExclusive = Math.max(
+        start,
+        Math.min(blockCount, Math.floor(range.end)),
+      );
+      if (endExclusive <= start) continue;
+      startBlock = Math.min(startBlock, start);
+      endBlockInclusive = Math.max(endBlockInclusive, endExclusive - 1);
+    }
+
+    if (!Number.isFinite(startBlock) || endBlockInclusive < 0) return undefined;
+
+    const startPageIndex = Math.max(
+      0,
+      Math.floor(startBlock / VIEWPORT_PAGE_WINDOW_BLOCKS_PER_PAGE),
+    );
+    const endPageIndex = Math.max(
+      startPageIndex,
+      Math.floor(endBlockInclusive / VIEWPORT_PAGE_WINDOW_BLOCKS_PER_PAGE),
+    );
+    const estimatedPageCount = Math.max(
+      endPageIndex + 1,
+      Math.ceil(blockCount / VIEWPORT_PAGE_WINDOW_BLOCKS_PER_PAGE),
+    );
+
+    return {
+      startPageIndex,
+      endPageIndex,
+      bufferPages: VIEWPORT_PAGE_WINDOW_BUFFER_PAGES,
+      estimatedPageCount,
+    };
+  }
 
   function applyViewportRanges(
     incoming: readonly { start: number; end: number }[] | null,