@beyondwork/docx-react-component 1.0.106 → 1.0.108

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

@@ -113,13 +113,12 @@ export function resolveSelectionRects(
   if (lo === hi) {
     const caret = resolveCaretGeometry(frame, lo, range.story);
     if (!caret) return [];
-    // Caret rect for a collapsed range is an exact anchor-index read —
-    // the placeholder-grade metadata on `CaretGeometry` (direction,
+    // 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. Return the rect untagged so callers that iterate
-    // `getSelectionRects(...)` and expect pixel-exact carets see the
-    // expected `"exact"` default.
-    return [caret.rect];
+    // position, so make the rect precision explicit for downstream
+    // compositor consumers.
+    return [{ ...caret.rect, precision: "exact" }];
   }
 
   const lineRects = resolveLineSelectionRects(frame, lo, hi, range.story);

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

@@ -29,7 +29,7 @@ import type {
   PublicPageRegion,
   WordReviewEditorLayoutFacet,
 } from "../layout/public-facet.ts";
-import type { RenderKernel } from "../render/index.ts";
+import type { RenderFrame, RenderKernel } from "../render/index.ts";
 import { resolveScope } from "../workflow/scope-resolver.ts";
 import type { ScopeRailSegment } from "../workflow/rail/compose.ts";
 import type {
@@ -246,28 +246,78 @@ export function createGeometryFacet(
 ): GeometryFacet {
   const { layoutFacet } = input;
   const viewport = input.viewport ?? createViewport();
+  let geometryIndexCache:
+    | {
+        readonly revision: number;
+        readonly frame: RenderFrame;
+        readonly canonicalDocument:
+          | CanonicalDocument
+          | CanonicalDocumentEnvelope
+          | null;
+        readonly index: GeometryIndex | null;
+      }
+    | null = null;
+
+  const getCachedGeometryIndexForFrame = (
+    frame: RenderFrame,
+    canonicalDocument: CanonicalDocument | CanonicalDocumentEnvelope | null,
+  ): GeometryIndex | null => {
+    if (
+      geometryIndexCache &&
+      geometryIndexCache.revision === frame.revision &&
+      geometryIndexCache.frame === frame &&
+      geometryIndexCache.canonicalDocument === canonicalDocument
+    ) {
+      return geometryIndexCache.index;
+    }
+    const index = projectGeometryIndexFromFrame(frame, { canonicalDocument });
+    geometryIndexCache = {
+      revision: frame.revision,
+      frame,
+      canonicalDocument,
+      index,
+    };
+    return index;
+  };
+
+  const getCachedGeometryIndex = (): GeometryIndex | null => {
+    const kernel = input.renderKernel?.();
+    if (!kernel) {
+      geometryIndexCache = null;
+      return null;
+    }
+    return getCachedGeometryIndexForFrame(
+      kernel.getRenderFrame(),
+      input.getCanonicalDocument?.() ?? null,
+    );
+  };
 
   return {
     getGeometryIndex() {
-      const kernel = input.renderKernel?.();
-      if (!kernel) return null;
-      return projectGeometryIndexFromFrame(kernel.getRenderFrame(), {
-        canonicalDocument: input.getCanonicalDocument?.() ?? null,
-      });
+      return getCachedGeometryIndex();
     },
 
     getGeometryCoverage() {
       const kernel = input.renderKernel?.();
-      if (!kernel) return createUnavailableGeometryCoverage();
+      if (!kernel) {
+        geometryIndexCache = null;
+        return createUnavailableGeometryCoverage();
+      }
       const frame = kernel.getRenderFrame();
       const canonicalDocument = input.getCanonicalDocument?.() ?? null;
-      if (canonicalDocument) {
+      if (
+        geometryIndexCache &&
+        geometryIndexCache.revision === frame.revision &&
+        geometryIndexCache.frame === frame &&
+        geometryIndexCache.canonicalDocument === canonicalDocument
+      ) {
         return (
-          projectGeometryIndexFromFrame(frame, { canonicalDocument })?.coverage ??
+          geometryIndexCache.index?.coverage ??
           createUnavailableGeometryCoverage()
         );
       }
-      return summarizeGeometryCoverageFromFrame(frame);
+      const index = getCachedGeometryIndexForFrame(frame, canonicalDocument);
+      return index?.coverage ?? summarizeGeometryCoverageFromFrame(frame);
     },
 
     hitTest(point) {