@beyondwork/docx-react-component 1.0.109 → 1.0.111

package/src/runtime/geometry/caret-geometry.ts

@@ -34,9 +34,14 @@
  */
 
 import type { EditorStoryTarget } from "../../api/public-types";
+import type {
+  PublicLineRunAnchor,
+  PublicTwipsRect,
+} from "../layout/public-facet.ts";
 import type {
   RenderFrame,
   RenderFrameRect,
+  RenderLine,
   RenderStoryRegion,
 } from "../render/index.ts";
 import type {
@@ -58,6 +63,9 @@ export function resolveCaretGeometry(
   if (!frame) return null;
   if (!Number.isFinite(offset)) return null;
 
+  const projectedCaret = resolveProducerCaretGeometry(frame, offset, story);
+  if (projectedCaret) return projectedCaret;
+
   const anchorRect = frame.anchorIndex.byRuntimeOffset(offset, story);
   if (!anchorRect) return null;
 
@@ -113,12 +121,7 @@ export function resolveSelectionRects(
   if (lo === hi) {
     const caret = resolveCaretGeometry(frame, lo, range.story);
     if (!caret) return [];
-    // Caret rect position for a collapsed range is an exact anchor-index
-    // read. The placeholder-grade metadata on `CaretGeometry` (direction,
-    // baseline) applies to the caret as a whole, not to the rect's
-    // position, so make the rect precision explicit for downstream
-    // compositor consumers.
-    return [{ ...caret.rect, precision: "exact" }];
+    return [{ ...caret.rect, precision: caret.rect.precision ?? "exact" }];
   }
 
   const lineRects = resolveLineSelectionRects(frame, lo, hi, range.story);
@@ -178,7 +181,10 @@ function resolveLineSelectionRects(
               : blockFrom +
                 Math.floor((span * (i + 1)) / Math.max(1, lineCount));
           if (lineTo <= from || lineFrom >= to) continue;
-          rects.push(toGeometryRect(line.frame, "within-tolerance"));
+          rects.push(
+            resolveProducerSelectionRect(line, lineFrom, lineTo, from, to) ??
+              toGeometryRect(line.frame, "within-tolerance"),
+          );
         }
       }
     }
@@ -186,6 +192,212 @@ function resolveLineSelectionRects(
   return rects;
 }
 
+function resolveProducerCaretGeometry(
+  frame: RenderFrame,
+  offset: number,
+  story?: EditorStoryTarget,
+): CaretGeometry | null {
+  const located = findProducerLineForOffset(frame, offset, story);
+  if (!located) return null;
+  const { line, lineFrom, lineTo } = located;
+  const lineRectTwips = producerLineRectTwips(line);
+  if (!lineRectTwips) return null;
+  const contentRectTwips = producerLineContentRectTwips(line) ?? lineRectTwips;
+  const direction = producerLineDirection(line);
+  const span = Math.max(1, lineTo - lineFrom);
+  const ratio = clamp((offset - lineFrom) / span, 0, 1);
+  const inlineRatio = direction === "rtl" ? 1 - ratio : ratio;
+  const caretXTwips =
+    contentRectTwips.xTwips + contentRectTwips.widthTwips * inlineRatio;
+  const caretFrame = projectLineTwipsRect(line, lineRectTwips, {
+    xTwips: caretXTwips,
+    yTwips: lineRectTwips.yTwips,
+    widthTwips: 0,
+    heightTwips: lineRectTwips.heightTwips,
+  });
+  if (!caretFrame) return null;
+  const baseline =
+    line.line.baselinePageYTwips !== undefined
+      ? projectPageYToLineOffsetPx(
+          line,
+          lineRectTwips,
+          line.line.baselinePageYTwips,
+        )
+      : producerRunBaselinePageYTwips(line) !== undefined
+        ? projectPageYToLineOffsetPx(
+            line,
+            lineRectTwips,
+            producerRunBaselinePageYTwips(line)!,
+          )
+        : resolveBaselinePx(caretFrame);
+  return {
+    rect: {
+      ...toGeometryRect(caretFrame, "within-tolerance"),
+      widthPx: 0,
+    },
+    baseline,
+    height: caretFrame.heightPx,
+    direction,
+    precision: "within-tolerance",
+  };
+}
+
+function findProducerLineForOffset(
+  frame: RenderFrame,
+  offset: number,
+  story?: EditorStoryTarget,
+):
+  | {
+      line: RenderLine;
+      lineFrom: number;
+      lineTo: number;
+    }
+  | null {
+  if (!Array.isArray(frame.pages)) return null;
+  for (const page of frame.pages) {
+    for (const region of collectRegions(page.regions)) {
+      if (!storyMatches(region.storyTarget, story)) continue;
+      for (const block of region.blocks) {
+        const blockFrom = block.fragment.from;
+        const blockTo = block.fragment.to;
+        if (offset < blockFrom || offset > blockTo) continue;
+        if (block.lines.length === 0) continue;
+        const span = Math.max(1, blockTo - blockFrom);
+        const lineCount = block.lines.length;
+        for (let i = 0; i < lineCount; i += 1) {
+          const lineFrom =
+            blockFrom + Math.floor((span * i) / Math.max(1, lineCount));
+          const lineTo =
+            i === lineCount - 1
+              ? blockTo
+              : blockFrom +
+                Math.floor((span * (i + 1)) / Math.max(1, lineCount));
+          const contains =
+            i === lineCount - 1
+              ? offset >= lineFrom && offset <= lineTo
+              : offset >= lineFrom && offset < lineTo;
+          if (!contains) continue;
+          const line = block.lines[i]!;
+          if (!producerLineRectTwips(line)) continue;
+          return { line, lineFrom, lineTo };
+        }
+      }
+    }
+  }
+  return null;
+}
+
+function resolveProducerSelectionRect(
+  line: RenderLine,
+  lineFrom: number,
+  lineTo: number,
+  from: number,
+  to: number,
+): GeometryRect | null {
+  const lineRectTwips = producerLineRectTwips(line);
+  if (!lineRectTwips) return null;
+  const contentRectTwips = producerLineContentRectTwips(line) ?? lineRectTwips;
+  const span = Math.max(1, lineTo - lineFrom);
+  const startRatio = clamp((Math.max(from, lineFrom) - lineFrom) / span, 0, 1);
+  const endRatio = clamp((Math.min(to, lineTo) - lineFrom) / span, 0, 1);
+  if (endRatio <= startRatio) return null;
+  const direction = producerLineDirection(line);
+  const leftRatio = direction === "rtl" ? 1 - endRatio : startRatio;
+  const rightRatio = direction === "rtl" ? 1 - startRatio : endRatio;
+  const leftTwips =
+    contentRectTwips.xTwips + contentRectTwips.widthTwips * leftRatio;
+  const rightTwips =
+    contentRectTwips.xTwips + contentRectTwips.widthTwips * rightRatio;
+  const frameRect = projectLineTwipsRect(line, lineRectTwips, {
+    xTwips: leftTwips,
+    yTwips: contentRectTwips.yTwips,
+    widthTwips: Math.max(0, rightTwips - leftTwips),
+    heightTwips: contentRectTwips.heightTwips,
+  });
+  return frameRect ? toGeometryRect(frameRect, "within-tolerance") : null;
+}
+
+function producerLineRectTwips(line: RenderLine): PublicTwipsRect | undefined {
+  return line.line.rectTwips ?? line.line.runAnchors?.[0]?.lineRectTwips;
+}
+
+function producerLineContentRectTwips(
+  line: RenderLine,
+): PublicTwipsRect | undefined {
+  const anchors = line.line.runAnchors ?? [];
+  if (anchors.length === 0) return undefined;
+  return unionRunRectTwips(anchors);
+}
+
+function producerLineDirection(line: RenderLine): "ltr" | "rtl" {
+  return line.line.direction ?? line.line.runAnchors?.[0]?.direction ?? "ltr";
+}
+
+function producerRunBaselinePageYTwips(
+  line: RenderLine,
+): number | undefined {
+  return line.line.runAnchors?.[0]?.baselinePageYTwips;
+}
+
+function unionRunRectTwips(
+  anchors: readonly PublicLineRunAnchor[],
+): PublicTwipsRect | undefined {
+  let left = Number.POSITIVE_INFINITY;
+  let top = Number.POSITIVE_INFINITY;
+  let right = Number.NEGATIVE_INFINITY;
+  let bottom = Number.NEGATIVE_INFINITY;
+  for (const anchor of anchors) {
+    const rect = anchor.runRectTwips;
+    left = Math.min(left, rect.xTwips);
+    top = Math.min(top, rect.yTwips);
+    right = Math.max(right, rect.xTwips + rect.widthTwips);
+    bottom = Math.max(bottom, rect.yTwips + rect.heightTwips);
+  }
+  if (!Number.isFinite(left) || !Number.isFinite(top)) return undefined;
+  return {
+    xTwips: left,
+    yTwips: top,
+    widthTwips: Math.max(0, right - left),
+    heightTwips: Math.max(0, bottom - top),
+  };
+}
+
+function projectLineTwipsRect(
+  line: RenderLine,
+  lineRectTwips: PublicTwipsRect,
+  rect: PublicTwipsRect,
+): RenderFrameRect | null {
+  if (lineRectTwips.widthTwips <= 0 || lineRectTwips.heightTwips <= 0) {
+    return null;
+  }
+  const scaleX = line.frame.widthPx / lineRectTwips.widthTwips;
+  const scaleY = line.frame.heightPx / lineRectTwips.heightTwips;
+  return {
+    leftPx: line.frame.leftPx + (rect.xTwips - lineRectTwips.xTwips) * scaleX,
+    topPx: line.frame.topPx + (rect.yTwips - lineRectTwips.yTwips) * scaleY,
+    widthPx: rect.widthTwips * scaleX,
+    heightPx: rect.heightTwips * scaleY,
+  };
+}
+
+function projectPageYToLineOffsetPx(
+  line: RenderLine,
+  lineRectTwips: PublicTwipsRect,
+  pageYTwips: number,
+): number {
+  if (lineRectTwips.heightTwips <= 0) return resolveBaselinePx(line.frame);
+  const scaleY = line.frame.heightPx / lineRectTwips.heightTwips;
+  return clamp(
+    (pageYTwips - lineRectTwips.yTwips) * scaleY,
+    0,
+    line.frame.heightPx,
+  );
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(Math.max(value, min), max);
+}
+
 function collectRegions(
   regions: RenderFrame["pages"][number]["regions"],
 ): readonly RenderStoryRegion[] {

package/src/runtime/geometry/geometry-index.ts

@@ -27,6 +27,7 @@ import {
   type CanonicalTableCellLayoutInput,
   type CanonicalTableRowLayoutInput,
 } from "../../model/canonical-layout-inputs.ts";
+import type { PublicTwipsRect } from "../layout/public-facet.ts";
 import type {
   RenderFrame,
   RenderFrameRect,
@@ -106,6 +107,7 @@ export function projectGeometryIndexFromFrame(
   let splitRowCarryCount = 0;
 
   for (const page of frame.pages) {
+    if (!isPageGeometryMaterialized(page)) continue;
     const pageMetadata = pageFrameMetadata(page);
     pageFrameCompleteness[pageMetadata.frameCompleteness] += 1;
     layoutDivergenceObjectCount += pageMetadata.layoutDivergenceObjectIds.length;
@@ -313,7 +315,7 @@ export function projectGeometryIndexFromFrame(
 
   const objectHandles = finalizeObjectHandleEntries(objectHandleEntries);
   const coverage: GeometryIndexCoverage = {
-    status: "realized",
+    status: coverageStatusForProjectedPages(frame, pages.length),
     pageCount: pages.length,
     pageFrameCompleteness,
     regionCount: regions.length,
@@ -367,6 +369,7 @@ export function summarizeGeometryCoverageFromFrame(
   let splitRowCarryCount = 0;
 
   for (const page of frame.pages) {
+    if (!isPageGeometryMaterialized(page)) continue;
     const pageMetadata = pageFrameMetadata(page);
     pageCount += 1;
     pageFrameCompleteness[pageMetadata.frameCompleteness] += 1;
@@ -407,7 +410,7 @@ export function summarizeGeometryCoverageFromFrame(
   }
 
   return {
-    status: "realized",
+    status: coverageStatusForProjectedPages(frame, pageCount),
     pageCount,
     pageFrameCompleteness,
     regionCount,
@@ -433,6 +436,19 @@ interface PageFrameMetadata {
   divergenceIdsByObjectId: ReadonlyMap<string, readonly string[]>;
 }
 
+function isPageGeometryMaterialized(page: RenderPage): boolean {
+  return page.page.materialization !== "unpaginated";
+}
+
+function coverageStatusForProjectedPages(
+  frame: RenderFrame,
+  projectedPageCount: number,
+): GeometryRehydrationStatus {
+  return frame.pages.length > 0 && projectedPageCount === 0
+    ? "unavailable"
+    : "realized";
+}
+
 function pageFrameMetadata(page: RenderPage): PageFrameMetadata {
   const frame = page.page.frame;
   const divergenceIds = frame?.divergenceIds ? [...frame.divergenceIds] : [];
@@ -1294,25 +1310,32 @@ function appendPageLocalObjectHandleEntries(input: {
       story.kind === "header" ? page.regions.header?.frame : page.regions.footer?.frame;
     if (!regionFrame) continue;
     for (const object of story.anchoredObjects) {
-      const objectFrame = pageLocalObjectFrame(
-        regionFrame,
-        object.extentTwips,
-        pxPerTwip,
+      const objectFrame = object.anchorRectTwips
+        ? pageLocalObjectAnchorFrame(page, object.anchorRectTwips)
+        : pageLocalObjectFrame(regionFrame, object.extentTwips, pxPerTwip);
+      const entryPrecision: GeometryPrecision = object.anchorRectTwips
+        ? "within-tolerance"
+        : "heuristic";
+      const entryStatus: GeometryRehydrationStatus = object.anchorRectTwips
+        ? "realized"
+        : "requires-rehydration";
+      const handleRects = buildObjectHandleRectsFromRect(
+        objectFrame,
+        entryPrecision,
       );
-      const handleRects = buildObjectHandleRectsFromRect(objectFrame, "heuristic");
       const sourceIdentity: GeometrySourceIdentity = {
         storyKey: story.storyKey,
         objectKey: object.objectId,
         objectKind: object.sourceType,
         editPosture: object.preserveOnly ? "preserve-only" : "editable",
-        joinKind: "block-scoped",
+        joinKind: object.anchorRectTwips ? "direct" : "block-scoped",
       };
       const existing = entries.get(object.objectId);
       if (existing) {
         appendUnique(existing.pageIds, page.page.pageId);
         existing.rects.push(...handleRects);
         appendDivergenceIds(existing, divergenceIdsByObjectId.get(object.objectId));
-        if (existing.precision !== "heuristic") {
+        if (existing.precision !== "heuristic" && entryPrecision === "heuristic") {
           existing.precision = "heuristic";
           existing.status = "requires-rehydration";
           existing.sourceIdentity = sourceIdentity;
@@ -1323,16 +1346,33 @@ function appendPageLocalObjectHandleEntries(input: {
         objectId: object.objectId,
         pageIds: [page.page.pageId],
         rects: [...handleRects],
-        status: "requires-rehydration",
-        precision: "heuristic",
+        status: entryStatus,
+        precision: entryPrecision,
         ...mutableLayoutDivergenceIds(divergenceIdsByObjectId.get(object.objectId)),
         sourceIdentity,
       });
-      recordPrecision(precision, "heuristic");
+      recordPrecision(precision, entryPrecision);
     }
   }
 }
 
+function pageLocalObjectAnchorFrame(
+  page: RenderPage,
+  rect: PublicTwipsRect,
+): RenderFrameRect {
+  const pageWidthTwips = page.page.layout.pageWidth;
+  const pageHeightTwips = page.page.layout.pageHeight;
+  const scaleX = pageWidthTwips > 0 ? page.frame.widthPx / pageWidthTwips : 1;
+  const scaleY =
+    pageHeightTwips > 0 ? page.frame.heightPx / pageHeightTwips : scaleX;
+  return {
+    leftPx: page.frame.leftPx + rect.xTwips * scaleX,
+    topPx: page.frame.topPx + rect.yTwips * scaleY,
+    widthPx: rect.widthTwips * scaleX,
+    heightPx: rect.heightTwips * scaleY,
+  };
+}
+
 function pageLocalObjectFrame(
   regionFrame: RenderFrameRect,
   extentTwips:

package/src/runtime/geometry/object-handles.ts

@@ -26,7 +26,12 @@
  *   index 8 — rotate anchor (20 px above the top-center handle)
  */
 
-import type { RenderFrame, RenderFrameRect } from "../render/index.ts";
+import type { PublicTwipsRect } from "../layout/public-facet.ts";
+import type {
+  RenderFrame,
+  RenderFrameRect,
+  RenderPage,
+} from "../render/index.ts";
 import type { GeometryPrecision, GeometryRect } from "./geometry-types.ts";
 
 const ROTATE_HANDLE_OFFSET_PX = 20;
@@ -36,6 +41,10 @@ export function resolveObjectHandles(
   objectId: string,
 ): readonly GeometryRect[] {
   if (!frame) return [];
+  const pageLocalBBox = resolvePageLocalObjectFrame(frame, objectId);
+  if (pageLocalBBox) {
+    return buildObjectHandleRectsFromRect(pageLocalBBox, "within-tolerance");
+  }
   const bbox = frame.anchorIndex.byObjectId(objectId);
   if (!bbox) return [];
   return buildObjectHandleRectsFromRect(bbox);
@@ -78,3 +87,35 @@ export function buildObjectHandleRectsFromRect(
     point(midX, topPx - ROTATE_HANDLE_OFFSET_PX), // 8 rotate
   ];
 }
+
+function resolvePageLocalObjectFrame(
+  frame: RenderFrame,
+  objectId: string,
+): RenderFrameRect | null {
+  if (!Array.isArray(frame.pages)) return null;
+  for (const page of frame.pages) {
+    for (const story of page.page.frame?.pageLocalStories ?? []) {
+      for (const object of story.anchoredObjects) {
+        if (object.objectId !== objectId || !object.anchorRectTwips) continue;
+        return projectPageTwipsRect(page, object.anchorRectTwips);
+      }
+    }
+  }
+  return null;
+}
+
+function projectPageTwipsRect(
+  page: RenderPage,
+  rect: PublicTwipsRect,
+): RenderFrameRect {
+  const pageWidthTwips = page.page.layout.pageWidth;
+  const pageHeightTwips = page.page.layout.pageHeight;
+  const scaleX = pageWidthTwips > 0 ? page.frame.widthPx / pageWidthTwips : 1;
+  const scaleY = pageHeightTwips > 0 ? page.frame.heightPx / pageHeightTwips : scaleX;
+  return {
+    leftPx: page.frame.leftPx + rect.xTwips * scaleX,
+    topPx: page.frame.topPx + rect.yTwips * scaleY,
+    widthPx: rect.widthTwips * scaleX,
+    heightPx: rect.heightTwips * scaleY,
+  };
+}

package/src/runtime/layout/index.ts

@@ -181,11 +181,14 @@ export {
   type PublicRegionKind,
   type PublicBlockFragment,
   type PublicLineBox,
+  type PublicLineRunAnchor,
   type PublicNoteAllocation,
   type PublicPageAnchor,
   type PublicPageFrame,
   type PublicPageLocalStoryInstance,
+  type PublicPagePaginationTelemetry,
   type PublicPageSpan,
+  type PublicPaginationTelemetry,
   type PublicSectionNode,
   type PublicResolvedPageStories,
   type PublicResolvedStoryField,

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

@@ -10,6 +10,7 @@ import type {
   LayoutFacetEvent,
   PublicFieldDirtinessReport,
   PublicMeasurementFidelity,
+  PublicPaginationTelemetry,
   WordReviewEditorLayoutFacet,
 } from "./public-facet.ts";
 import { MARGIN_PRESET_CATALOG } from "./margin-preset-catalog.ts";
@@ -20,6 +21,17 @@ export function createInertLayoutFacet(): WordReviewEditorLayoutFacet {
     families: [],
     revision: 0,
   };
+  const emptyPaginationTelemetry: PublicPaginationTelemetry = {
+    revision: 0,
+    pageCount: 0,
+    materializedPageCount: 0,
+    unpaginatedPageCount: 0,
+    bodyFragmentCount: 0,
+    bodyBlockReferenceCount: 0,
+    averageBodyFragmentsPerMaterializedPage: 0,
+    averageBodyBlockReferencesPerMaterializedPage: 0,
+    pages: [],
+  };
   const fidelity: PublicMeasurementFidelity = "empirical";
   return {
     getPageCount: () => 0,
@@ -39,6 +51,7 @@ export function createInertLayoutFacet(): WordReviewEditorLayoutFacet {
     getStoryBlocksForRegion: () => [],
     getDocumentEndnoteBlocks: () => [],
     getFragmentsForPage: () => [],
+    getPaginationTelemetry: () => emptyPaginationTelemetry,
     getPageFormatCatalog: () => PAGE_FORMAT_CATALOG,
     getActivePageFormat: () => null,
     getMarginPresetCatalog: () => MARGIN_PRESET_CATALOG,