@beyondwork/docx-react-component 1.0.35 → 1.0.37

package/src/model/canonical-document.ts

@@ -372,6 +372,17 @@ export interface ParagraphNode {
   bidi?: boolean;
   suppressLineNumbers?: boolean;
   cnfStyle?: string;
+  /**
+   * Preserved w14 extension identifiers for this paragraph.
+   * Round-trip (§2 A.7) requires these to survive import → export so the
+   * `w14:paraId` / `w14:textId` attributes that Word places on paragraph
+   * and run boundaries are re-emitted with the same values. Both ids are
+   * 8-hex uppercase strings per ECMA-376 Part 1 Appendix A.
+   */
+  wordExtensionIds?: {
+    paraId?: string;
+    textId?: string;
+  };
   children: InlineNode[];
 }
 

package/src/review/store/scope-tag-diff.ts

@@ -0,0 +1,130 @@
+import type { ScopeTagTouch } from "../../api/public-types.ts";
+import type {
+  CanonicalAnchor,
+  CommentThread,
+  RevisionRecord,
+} from "../../model/canonical-document.ts";
+
+/**
+ * Diff prior vs next review state and emit one `ScopeTagTouch` per changed
+ * comment or revision anchor. The predicted-text lane consumes these touches
+ * to classify a text command's ack as `equivalent` (no touches), `adjusted`
+ * (anchors shifted), or to feed decoration redraws without a PM rebuild.
+ *
+ * Notes
+ *  - Newly created annotations show up as "extended" (revisions) or "split"
+ *    (comments) so the lane knows to redraw them.
+ *  - Detached annotations show up as "detached".
+ *  - Anchors whose range is byte-identical across the diff are omitted.
+ */
+export function collectScopeTagTouches(
+  priorComments: Readonly<Record<string, CommentThread>>,
+  nextComments: Readonly<Record<string, CommentThread>>,
+  priorRevisions: Readonly<Record<string, RevisionRecord>>,
+  nextRevisions: Readonly<Record<string, RevisionRecord>>,
+): ScopeTagTouch[] {
+  const touches: ScopeTagTouch[] = [];
+
+  for (const [id, prior] of Object.entries(priorComments)) {
+    const next = nextComments[id];
+    if (!next) {
+      touches.push({
+        tagType: "comment",
+        tagId: id,
+        behavior: "detached",
+        range: anchorRange(prior.anchor),
+      });
+      continue;
+    }
+    const behavior = classifyAnchorChange(prior.anchor, next.anchor);
+    if (behavior !== "unchanged") {
+      touches.push({
+        tagType: "comment",
+        tagId: id,
+        behavior,
+        range: anchorRange(next.anchor),
+      });
+    }
+  }
+
+  for (const [id, next] of Object.entries(nextComments)) {
+    if (!priorComments[id]) {
+      touches.push({
+        tagType: "comment",
+        tagId: id,
+        behavior: "split",
+        range: anchorRange(next.anchor),
+      });
+    }
+  }
+
+  for (const [id, prior] of Object.entries(priorRevisions)) {
+    const next = nextRevisions[id];
+    if (!next) {
+      touches.push({
+        tagType: "revision",
+        tagId: id,
+        behavior: "detached",
+        range: anchorRange(prior.anchor),
+      });
+      continue;
+    }
+    const behavior = classifyAnchorChange(prior.anchor, next.anchor);
+    if (behavior !== "unchanged") {
+      touches.push({
+        tagType: "revision",
+        tagId: id,
+        behavior,
+        range: anchorRange(next.anchor),
+      });
+    }
+  }
+
+  for (const [id, next] of Object.entries(nextRevisions)) {
+    if (!priorRevisions[id]) {
+      touches.push({
+        tagType: "revision",
+        tagId: id,
+        behavior: "extended",
+        range: anchorRange(next.anchor),
+      });
+    }
+  }
+
+  return touches;
+}
+
+function anchorRange(anchor: CanonicalAnchor): { from: number; to: number } {
+  if (anchor.kind === "range") {
+    return { from: anchor.range.from, to: anchor.range.to };
+  }
+  if (anchor.kind === "node") {
+    return { from: anchor.at, to: anchor.at };
+  }
+  return { from: anchor.lastKnownRange.from, to: anchor.lastKnownRange.to };
+}
+
+function classifyAnchorChange(
+  prior: CanonicalAnchor,
+  next: CanonicalAnchor,
+): "unchanged" | "extended" | "trimmed" | "split" | "detached" {
+  if (prior.kind === "detached" && next.kind === "detached") {
+    const pr = prior.lastKnownRange;
+    const nr = next.lastKnownRange;
+    return pr.from === nr.from && pr.to === nr.to ? "unchanged" : "detached";
+  }
+  if (prior.kind !== "detached" && next.kind === "detached") {
+    return "detached";
+  }
+  if (prior.kind === "detached" && next.kind !== "detached") {
+    return "extended";
+  }
+  const priorR = anchorRange(prior);
+  const nextR = anchorRange(next);
+  if (priorR.from === nextR.from && priorR.to === nextR.to) return "unchanged";
+  const priorLen = priorR.to - priorR.from;
+  const nextLen = nextR.to - nextR.from;
+  if (nextLen > priorLen) return "extended";
+  if (nextLen < priorLen) return "trimmed";
+  return "split";
+}

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
 // ---------------------------------------------------------------------------