@beyondwork/docx-react-component 1.0.60 → 1.0.62

package/src/runtime/document-runtime.ts

@@ -23,6 +23,7 @@ import type {
   AddCommentResult,
   AddScopeParams,
   AddScopeResult,
+  ClearHighlightOptions,
   CommentSidebarSnapshot,
   CommentSidebarThreadSnapshot,
   CompatibilityReport,
@@ -159,6 +160,7 @@ import {
   insertScopeMarkers,
   removeScopeMarkers,
 } from "../core/commands/add-scope.ts";
+import { applyFormattingOperationToDocument } from "../core/commands/formatting-commands.ts";
 import { buildCompatibilityReport } from "../validation/compatibility-engine.ts";
 import { mergeCompatibilityReports } from "../validation/compatibility-report.ts";
 import { createEditorSurfaceSnapshot } from "./surface-projection.ts";
@@ -481,6 +483,22 @@ export interface DocumentRuntime {
   rejectChange(changeId: string): void;
   acceptAllChanges(): void;
   rejectAllChanges(): void;
+  /**
+   * Clears the highlight (background color) on a range in the currently
+   * active story. The caller's selection is NOT moved.
+   *
+   * When `options.range` is omitted, the current document selection is used.
+   *
+   * Tracked-changes / suggesting mode is honored: in suggesting mode the
+   * clear is recorded as an `rPrChange` property-change suggestion when the
+   * resolved range is a single bounded text segment, and is reported via
+   * `command_blocked` when the range spans multiple segments.
+   *
+   * When `options.expandToFullHighlight` is `true`, the resolved range is
+   * grown outward before clearing to cover the entire contiguous highlighted
+   * span it touches. Expansion stops at paragraph and table-cell boundaries.
+   */
+  clearHighlight(options?: ClearHighlightOptions): void;
   openStory(target: EditorStoryTarget): boolean;
   closeStory(): void;
   getActiveStory(): EditorStoryTarget;
@@ -3705,6 +3723,143 @@ export function createDocumentRuntime(
         origin: createOrigin("api", clock()),
       });
     },
+    clearHighlight(options) {
+      const resolvedRange = resolveClearHighlightRange(
+        options?.range,
+        state.selection,
+      );
+      if (!resolvedRange) {
+        return;
+      }
+      if (viewState.documentMode === "viewing") {
+        this.emitBlockedCommand("clearHighlight", [{
+          code: "document_viewing_mode",
+          message: "Cannot clear highlight in viewing mode.",
+        }]);
+        return;
+      }
+
+      const surfaceBlocks = getActiveStorySurfaceBlocks();
+      if (!surfaceBlocks) {
+        return;
+      }
+
+      const inputFrom = Math.min(resolvedRange.from, resolvedRange.to);
+      const inputTo = Math.max(resolvedRange.from, resolvedRange.to);
+      let targetFrom = inputFrom;
+      let targetTo = inputTo;
+      if (options?.expandToFullHighlight === true) {
+        const expanded = expandRangeToHighlightExtent(
+          surfaceBlocks,
+          inputFrom,
+          inputTo,
+        );
+        targetFrom = expanded.from;
+        targetTo = expanded.to;
+      }
+      if (targetFrom === targetTo) {
+        return;
+      }
+
+      const activeStoryDocument =
+        activeStory.kind === "main"
+          ? state.document
+          : {
+              ...state.document,
+              content: {
+                type: "doc" as const,
+                children: [...getStoryBlocks(state.document, activeStory)],
+              },
+            };
+      const syntheticSnapshot: RuntimeRenderSnapshot = {
+        ...cachedRenderSnapshot,
+        ...(activeStory.kind === "main" ? {} : { activeStory: MAIN_STORY_TARGET }),
+        selection: {
+          anchor: targetFrom,
+          head: targetTo,
+          isCollapsed: false,
+          activeRange: {
+            kind: "range",
+            from: targetFrom,
+            to: targetTo,
+            assoc: { start: -1, end: 1 },
+          },
+        },
+      };
+
+      const suggesting =
+        getEffectiveDocumentMode(state.selection) === "suggesting";
+      if (suggesting) {
+        if (activeStory.kind !== "main") {
+          this.emitBlockedCommand("clearHighlight", [{
+            code: "suggesting_unsupported",
+            message: `"clearHighlight" is not supported in suggesting mode for this story.`,
+          }]);
+          return;
+        }
+        const segment = findSingleSelectedTextSegment(syntheticSnapshot);
+        if (!segment) {
+          this.emitBlockedCommand("clearHighlight", [{
+            code: "suggesting_unsupported",
+            message: `"clearHighlight" requires one bounded text segment in suggesting mode.`,
+          }]);
+          return;
+        }
+        const beforeXml = buildRunPropertyBeforeXml(segment);
+        const mutation = applyFormattingOperationToDocument(
+          activeStoryDocument,
+          syntheticSnapshot,
+          { type: "set-highlight-color", color: null },
+        );
+        if (!mutation.changed) {
+          return;
+        }
+        const timestamp = clock();
+        const nextDocument = appendPropertyChangeSuggestion(
+          mutation.document,
+          { from: segment.from, to: segment.to },
+          {
+            originalRevisionType: "rPrChange",
+            xmlTag: "rPrChange",
+            beforeXml,
+            semanticKind: "formatting-change",
+            storyTarget: activeStory,
+            authorId: defaultAuthorId ?? undefined,
+          },
+          timestamp,
+        );
+        this.dispatch({
+          type: "document.replace",
+          document: nextDocument,
+          mapping: createEmptyMapping(),
+          origin: createOrigin("api", timestamp),
+        });
+        return;
+      }
+
+      const result = applyFormattingOperationToDocument(
+        activeStoryDocument,
+        syntheticSnapshot,
+        { type: "set-highlight-color", color: null },
+      );
+      if (!result.changed) {
+        return;
+      }
+      const nextDocument =
+        activeStory.kind === "main"
+          ? result.document
+          : replaceStoryBlocks(
+              state.document,
+              activeStory,
+              result.document.content.children,
+            );
+      this.dispatch({
+        type: "document.replace",
+        document: nextDocument,
+        mapping: createEmptyMapping(),
+        origin: createOrigin("api", clock()),
+      });
+    },
     openStory(target) {
       const normalizedTarget =
         target.kind === "header" || target.kind === "footer"
@@ -3815,6 +3970,7 @@ export function createDocumentRuntime(
         collection,
         collectSectionPropertiesInOrder(state.document),
         state.document,
+        state.document.subParts?.settings,
       );
     },
     layout: layoutFacet,
@@ -7468,3 +7624,271 @@ async function upgradeMeasurementProvider(
     // fall through — the empirical backend remains in place
   }
 }
+
+function rangesOverlap(
+  leftFrom: number,
+  leftTo: number,
+  rightFrom: number,
+  rightTo: number,
+): boolean {
+  return leftFrom < rightTo && rightFrom < leftTo;
+}
+
+function resolveClearHighlightRange(
+  inputRange: EditorAnchorProjection | undefined,
+  selection: import("../core/state/editor-state.ts").SelectionSnapshot,
+): { from: number; to: number } | null {
+  if (inputRange !== undefined) {
+    if (inputRange.kind !== "range") return null;
+    return { from: inputRange.from, to: inputRange.to };
+  }
+  const active = selection.activeRange;
+  if (active.kind !== "range") return null;
+  return { from: active.range.from, to: active.range.to };
+}
+
+function expandRangeToHighlightExtent(
+  blocks: readonly SurfaceBlockSnapshot[],
+  inputFrom: number,
+  inputTo: number,
+): { from: number; to: number } {
+  let from = inputFrom;
+  let to = inputTo;
+  forEachParagraphBlock(blocks, (paragraph) => {
+    if (!rangesOverlap(from, to, paragraph.from, paragraph.to)) {
+      return;
+    }
+    const textSegments = paragraph.segments.filter(
+      (segment): segment is Extract<SurfaceInlineSegment, { kind: "text" }> =>
+        segment.kind === "text",
+    );
+    const expanded = expandRangeWithinParagraph(textSegments, inputFrom, inputTo);
+    if (expanded.from < from) from = expanded.from;
+    if (expanded.to > to) to = expanded.to;
+  });
+  return { from, to };
+}
+
+function expandRangeWithinParagraph(
+  segments: Array<Extract<SurfaceInlineSegment, { kind: "text" }>>,
+  inputFrom: number,
+  inputTo: number,
+): { from: number; to: number } {
+  let from = inputFrom;
+  let to = inputTo;
+  let touchedLeftIndex = -1;
+  let touchedRightIndex = -1;
+  for (let i = 0; i < segments.length; i += 1) {
+    const segment = segments[i]!;
+    if (!isHighlightedSegment(segment)) continue;
+    if (rangesOverlap(inputFrom, inputTo, segment.from, segment.to)) {
+      if (touchedLeftIndex === -1) touchedLeftIndex = i;
+      touchedRightIndex = i;
+    }
+  }
+  if (touchedLeftIndex === -1) {
+    return { from, to };
+  }
+  for (let i = touchedLeftIndex; i >= 0; i -= 1) {
+    const segment = segments[i]!;
+    if (!isHighlightedSegment(segment)) break;
+    if (segment.to < from) break;
+    if (segment.from < from) from = segment.from;
+  }
+  for (let i = touchedRightIndex; i < segments.length; i += 1) {
+    const segment = segments[i]!;
+    if (!isHighlightedSegment(segment)) break;
+    if (segment.from > to) break;
+    if (segment.to > to) to = segment.to;
+  }
+  return { from, to };
+}
+
+function isHighlightedSegment(
+  segment: Extract<SurfaceInlineSegment, { kind: "text" }>,
+): boolean {
+  const bg = segment.markAttrs?.backgroundColor;
+  return typeof bg === "string" && bg.length > 0;
+}
+
+function forEachParagraphBlock(
+  blocks: readonly SurfaceBlockSnapshot[],
+  visit: (paragraph: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>) => void,
+): void {
+  for (const block of blocks) {
+    if (block.kind === "paragraph") {
+      visit(block);
+      continue;
+    }
+    if (block.kind === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          forEachParagraphBlock(cell.content, visit);
+        }
+      }
+      continue;
+    }
+    if (block.kind === "sdt_block") {
+      forEachParagraphBlock(block.children, visit);
+    }
+  }
+}
+
+function findSingleSelectedTextSegment(
+  snapshot: Pick<RuntimeRenderSnapshot, "surface" | "selection">,
+): Extract<SurfaceInlineSegment, { kind: "text" }> | null {
+  if (
+    !snapshot.surface ||
+    snapshot.selection.activeRange.kind !== "range" ||
+    snapshot.selection.isCollapsed
+  ) {
+    return null;
+  }
+  const selectionFrom = Math.min(snapshot.selection.anchor, snapshot.selection.head);
+  const selectionTo = Math.max(snapshot.selection.anchor, snapshot.selection.head);
+  const segments = collectSelectedTextSegments(
+    snapshot.surface.blocks,
+    selectionFrom,
+    selectionTo,
+  );
+  if (segments.length !== 1) {
+    return null;
+  }
+  const [segment] = segments;
+  if (!segment || segment.from !== selectionFrom || segment.to !== selectionTo) {
+    return null;
+  }
+  return segment;
+}
+
+function collectSelectedTextSegments(
+  blocks: readonly SurfaceBlockSnapshot[],
+  selectionFrom: number,
+  selectionTo: number,
+  output: Array<Extract<SurfaceInlineSegment, { kind: "text" }>> = [],
+): Array<Extract<SurfaceInlineSegment, { kind: "text" }>> {
+  for (const block of blocks) {
+    if (block.kind === "paragraph") {
+      for (const segment of block.segments) {
+        if (
+          segment.kind === "text" &&
+          rangesOverlap(selectionFrom, selectionTo, segment.from, segment.to)
+        ) {
+          output.push(segment);
+        }
+      }
+      continue;
+    }
+    if (block.kind === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          collectSelectedTextSegments(cell.content, selectionFrom, selectionTo, output);
+        }
+      }
+      continue;
+    }
+    if (block.kind === "sdt_block") {
+      collectSelectedTextSegments(block.children, selectionFrom, selectionTo, output);
+    }
+  }
+  return output;
+}
+
+function buildRunPropertyBeforeXml(
+  segment: Extract<SurfaceInlineSegment, { kind: "text" }>,
+): string {
+  const parts: string[] = [];
+  const marks = new Set(segment.marks ?? []);
+  if (marks.has("bold")) parts.push("<w:b/>");
+  if (marks.has("italic")) parts.push("<w:i/>");
+  if (marks.has("underline")) parts.push("<w:u w:val=\"single\"/>");
+  if (marks.has("strikethrough")) parts.push("<w:strike/>");
+  if (marks.has("superscript")) parts.push("<w:vertAlign w:val=\"superscript\"/>");
+  if (marks.has("subscript")) parts.push("<w:vertAlign w:val=\"subscript\"/>");
+  if (segment.markAttrs?.fontFamily) {
+    parts.push(
+      `<w:rFonts w:ascii="${escapeAttributeXml(segment.markAttrs.fontFamily)}" w:hAnsi="${escapeAttributeXml(segment.markAttrs.fontFamily)}"/>`,
+    );
+  }
+  if (segment.markAttrs?.fontSize !== undefined) {
+    parts.push(`<w:sz w:val="${segment.markAttrs.fontSize}"/>`);
+  }
+  if (segment.markAttrs?.textColor) {
+    parts.push(`<w:color w:val="${escapeAttributeXml(segment.markAttrs.textColor)}"/>`);
+  }
+  if (segment.markAttrs?.backgroundColor) {
+    parts.push(
+      `<w:shd w:val="clear" w:color="auto" w:fill="${escapeAttributeXml(segment.markAttrs.backgroundColor)}"/>`,
+    );
+  }
+  return `<w:rPr>${parts.join("")}</w:rPr>`;
+}
+
+function escapeAttributeXml(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+function appendPropertyChangeSuggestion(
+  document: CanonicalDocumentEnvelope,
+  anchor: { from: number; to: number },
+  input: {
+    originalRevisionType: "rPrChange" | "pPrChange";
+    xmlTag: "rPrChange" | "pPrChange";
+    beforeXml: string;
+    semanticKind: "formatting-change" | "paragraph-property-change";
+    storyTarget: EditorStoryTarget;
+    authorId?: string;
+  },
+  timestamp: string,
+): CanonicalDocumentEnvelope {
+  const existing = document.review.revisions;
+  const changeId = createRuntimeSuggestionChangeId(existing, timestamp);
+  const resolvedAuthorId = input.authorId ?? "unknown";
+  return {
+    ...document,
+    review: {
+      ...document.review,
+      revisions: {
+        ...existing,
+        [changeId]: {
+          changeId,
+          kind: "property-change",
+          anchor: createRangeAnchor(anchor.from, anchor.to, { start: 1, end: -1 }),
+          authorId: resolvedAuthorId,
+          createdAt: timestamp,
+          warningIds: [],
+          metadata: {
+            source: "runtime",
+            storyTarget: input.storyTarget,
+            suggestionId: changeId,
+            semanticKind: input.semanticKind,
+            originalRevisionType: input.originalRevisionType,
+            propertyChangeData: {
+              xmlTag: input.xmlTag,
+              beforeXml: input.beforeXml,
+            },
+          },
+          status: "open",
+        },
+      },
+    },
+  };
+}
+
+function createRuntimeSuggestionChangeId(
+  existing: CanonicalDocumentEnvelope["review"]["revisions"],
+  timestamp: string,
+): string {
+  const base = `change-${timestamp.replace(/[^0-9]/gu, "")}`;
+  let counter = Object.keys(existing).length + 1;
+  let candidate = `${base}-p${counter}`;
+  while (existing[candidate]) {
+    counter += 1;
+    candidate = `${base}-p${counter}`;
+  }
+  return candidate;
+}

package/src/runtime/footnote-resolver.ts

@@ -1,6 +1,7 @@
 import type {
   BlockNode,
   CanonicalDocument,
+  DocumentSettings,
   EndnoteProperties,
   FootnoteCollection,
   FootnoteProperties,
@@ -15,14 +16,13 @@ export interface FootnoteResolver {
   getEndnoteCount(): number;
   /**
    * Resolve the effective `<w:footnotePr>` for a given section. Returns the
-   * section's typed properties when present, or `undefined` when the section
-   * has no override (callers should fall back to Word defaults). File-level
-   * defaults from `settings.xml` are not yet wired in — that's a later slice.
+   * section's typed properties when present, otherwise the settings-level
+   * default from `settings.xml` when available.
    */
   getFootnoteProperties(sectionIndex?: number): FootnoteProperties | undefined;
   /**
    * Resolve the effective `<w:endnotePr>` for a given section. Same semantics
-   * as `getFootnoteProperties` but reads `endnotePr` from the section list.
+   * as `getFootnoteProperties` but reads `endnotePr`.
    */
   getEndnoteProperties(sectionIndex?: number): EndnoteProperties | undefined;
   /**
@@ -70,6 +70,7 @@ export function createFootnoteResolver(
   collection: FootnoteCollection,
   sections?: readonly SectionProperties[],
   document?: CanonicalDocument,
+  settings?: DocumentSettings,
 ): FootnoteResolver {
   return {
     getContinuationSeparatorContent(kind) {
@@ -87,12 +88,20 @@ export function createFootnoteResolver(
       return Object.keys(collection.endnotes).length;
     },
     getFootnoteProperties(sectionIndex) {
-      if (sectionIndex === undefined || !sections) return undefined;
-      return sections[sectionIndex]?.footnotePr;
+      return resolveFootnoteLikeProperties(
+        sectionIndex,
+        sections,
+        settings?.footnotePr,
+        "footnotePr",
+      );
     },
     getEndnoteProperties(sectionIndex) {
-      if (sectionIndex === undefined || !sections) return undefined;
-      return sections[sectionIndex]?.endnotePr;
+      return resolveFootnoteLikeProperties(
+        sectionIndex,
+        sections,
+        settings?.endnotePr,
+        "endnotePr",
+      );
     },
     getEndnotesForSection(sectionIndex) {
       if (!sections || !document) return EMPTY_READONLY_STRING_ARRAY;
@@ -107,6 +116,21 @@ export function createFootnoteResolver(
 
 const EMPTY_READONLY_STRING_ARRAY: readonly string[] = Object.freeze([]);
 
+function resolveFootnoteLikeProperties<T extends FootnoteProperties | EndnoteProperties>(
+  sectionIndex: number | undefined,
+  sections: readonly SectionProperties[] | undefined,
+  defaultProps: T | undefined,
+  key: "footnotePr" | "endnotePr",
+): T | undefined {
+  if (sectionIndex !== undefined && sections) {
+    const sectionProps = sections[sectionIndex]?.[key];
+    if (sectionProps) {
+      return sectionProps as T;
+    }
+  }
+  return defaultProps;
+}
+
 /**
  * Walk the document's top-level block children and collect endnote IDs
  * referenced from the block range belonging to `targetSectionIndex`.

package/src/runtime/layout/layout-engine-version.ts

@@ -215,8 +215,14 @@
  *       CO3.8 `isStaleParaInd` heuristic with a broader `isDegenerateParaInd`
  *       guard (hanging===left → use level geometry) that fixes the APS
  *       Supply paragraph pattern. Cache envelopes from v22 invalidate.
+ *  24 — Merge from `main` after the non-SDT closeout. The layout measurement
+ *       and resolved-formatting stack changed in `measurement-backend-canvas`,
+ *       `measurement-backend-empirical`, `paginated-layout-engine`,
+ *       `resolved-formatting-document`, and `resolved-formatting-state`.
+ *       Persisted prerender/layout caches must invalidate so geometry derived
+ *       under v23 is never reused against the merged layout pipeline.
  */
-export const LAYOUT_ENGINE_VERSION = 23 as const;
+export const LAYOUT_ENGINE_VERSION = 24 as const;
 
 /**
  * Serialization schema version for the LayCache payload (the cache envelope

package/src/runtime/layout/measurement-backend-canvas.ts

@@ -188,7 +188,7 @@ export function createCanvasBackend(
         case "tab": {
           // Advance to the next tab stop (in twips).
           const avgCharWidth = formatting.averageCharWidthTwips;
-          const defaultTabInterval = 720;
+          const defaultTabInterval = formatting.defaultTabInterval;
           const position = currentLineWidth + formatting.indentLeft;
           let nextTab = Math.ceil((position + 1) / defaultTabInterval) * defaultTabInterval;
           for (const tab of formatting.tabStops) {

package/src/runtime/layout/measurement-backend-empirical.ts

@@ -187,7 +187,7 @@ function resolveTabAdvance(
   currentChars: number,
 ): number {
   const avgCharWidth = formatting.averageCharWidthTwips;
-  const defaultTabInterval = 720;
+  const defaultTabInterval = formatting.defaultTabInterval;
   const currentPosition = currentChars * avgCharWidth + formatting.indentLeft;
 
   if (formatting.tabStops.length === 0) {