@beyondwork/docx-react-component 1.0.14 → 1.0.16

package/src/io/ooxml/parse-main-document.ts

@@ -754,17 +754,17 @@ function readTableGridColumns(node: XmlElementNode): number[] {
  * Check if a table's raw XML contains content that cannot safely round-trip
  * through the parsed table path yet. This includes:
  * - Revision markup (tracked changes inside cells)
- * - Hyperlink relationships (original relationship IDs would be lost)
- * - Comment ranges, bookmarks, and other annotation markup
+ * - Field syntax and smart tags that still lack a safe table-local live model
+ * - Grid geometry tags that the table serializer does not reconstruct yet
  *
  * Tables matching this check stay opaque until the respective features
  * are implemented in the table editing path.
  */
 function tableRequiresOpaquePreservation(rawXml: string): boolean {
-  // Tables with revision markup, complex content, or structural tags stay opaque.
-  // Safe tags (hyperlinks, bookmarks, comments, basic formatting) are now allowed
-  // since they are handled by the paragraph parser within table cells.
-  return /<w:(ins|del|rPrChange|pPrChange|tblPrChange|trPrChange|tcPrChange|sectPrChange|cellIns|cellDel|cellMerge|pict|fldChar|fldSimple|smartTag|gridAfter|gridBefore|tblCellSpacing)\b/.test(rawXml);
+  // Safe table-local content now includes hyperlinks, bookmarks, comments,
+  // nested tables, floating images, and VML preview atoms because the parser
+  // and serializer can preserve them without degrading the whole table.
+  return /<w:(ins|del|rPrChange|pPrChange|tblPrChange|trPrChange|tcPrChange|sectPrChange|cellIns|cellDel|cellMerge|fldChar|fldSimple|smartTag|gridAfter|gridBefore|tblCellSpacing)\b/.test(rawXml);
 }
 
 function readCellGridSpan(node: XmlElementNode): number | undefined {

package/src/io/ooxml/parse-revisions.ts

@@ -68,7 +68,7 @@ interface RevisionMetadata {
 
 const SUPPORTED_CONTAINER_TYPES = new Set(["ins", "del"]);
 const PRESERVE_ONLY_CONTAINER_TYPES = new Set(["moveFrom", "moveTo"]);
-const FORMATTING_REVISION_TYPES = new Set(["rPrChange", "pPrChange"]);
+const PROPERTY_CHANGE_REVISION_TYPES = new Set(["rPrChange", "pPrChange"]);
 
 export function parseRevisionsFromDocumentXml(
   documentXml: string,
@@ -158,16 +158,17 @@ function parseParagraphMarkRevisions(
 
     const type = localName(child.name);
     if (type === "pPrChange") {
-      const metadata = readRevisionMetadata(child, state, "formatting");
+      const metadata = readRevisionMetadata(child, state, "property-change");
       const innerPPr = findChildElement(child, "pPr");
+      const beforeXml = innerPPr ? state.documentXml.slice(innerPPr.start, innerPPr.end) : "";
       const propertyChangeData: PropertyChangeData = {
         xmlTag: "pPrChange",
-        beforeXml: innerPPr ? state.documentXml.slice(innerPPr.start, innerPPr.end) : "",
+        beforeXml,
       };
       state.revisions.push(
         createRevisionRecord({
           revisionId: metadata.revisionId,
-          kind: "formatting",
+          kind: "property-change",
           anchor: paragraphRange,
           authorId: metadata.authorId,
           createdAt: metadata.createdAt,
@@ -175,7 +176,6 @@ function parseParagraphMarkRevisions(
             source: "import",
             originalRevisionType: "pPrChange",
             ooxmlRevisionId: metadata.ooxmlRevisionId,
-            preserveOnlyReason: "Imported preserve-only revision.",
             propertyChangeData,
           },
         }),
@@ -186,12 +186,9 @@ function parseParagraphMarkRevisions(
         xmlStart: child.start,
         xmlEnd: child.end,
         originalRevisionType: "pPrChange",
-      });
-      state.diagnostics.push({
-        revisionId: metadata.revisionId,
-        code: "preserve_only_formatting_revision",
-        message: "Paragraph property revisions remain preserve-only for Wave 6.",
-        featureClass: "preserve-only",
+        containerXmlStart: paragraphProperties.start,
+        containerXmlEnd: paragraphProperties.end,
+        beforeContainerXml: beforeXml,
       });
     }
   }
@@ -356,7 +353,7 @@ function walkContentNode(
       state.diagnostics.push({
         revisionId: metadata.revisionId,
         code: "preserve_only_move_revision",
-        message: "Tracked move revisions remain preserve-only for Wave 6.",
+        message: "Tracked move revisions are preserve-only. Content is preserved for round-trip but cannot be accepted or rejected.",
         featureClass: "preserve-only",
       });
       advanceCursor(node, setCursor, getCursor);
@@ -432,21 +429,22 @@ function parseRunFormattingRevisions(
       : createDetachedAnchor({ from: runStart, to: runStart }, "importAmbiguity");
 
   for (const child of runProperties.children) {
-    if (child.type !== "element" || !FORMATTING_REVISION_TYPES.has(localName(child.name))) {
+    if (child.type !== "element" || !PROPERTY_CHANGE_REVISION_TYPES.has(localName(child.name))) {
       continue;
     }
 
     const childLocalName = localName(child.name) as "rPrChange" | "pPrChange";
-    const metadata = readRevisionMetadata(child, state, "formatting");
+    const metadata = readRevisionMetadata(child, state, "property-change");
     const innerRPr = findChildElement(child, "rPr");
+    const beforeXml = innerRPr ? state.documentXml.slice(innerRPr.start, innerRPr.end) : "";
     const propertyChangeData: PropertyChangeData = {
       xmlTag: childLocalName === "rPrChange" ? "rPrChange" : "pPrChange",
-      beforeXml: innerRPr ? state.documentXml.slice(innerRPr.start, innerRPr.end) : "",
+      beforeXml,
     };
     state.revisions.push(
       createRevisionRecord({
         revisionId: metadata.revisionId,
-        kind: "formatting",
+        kind: "property-change",
         anchor,
         authorId: metadata.authorId,
         createdAt: metadata.createdAt,
@@ -454,7 +452,6 @@ function parseRunFormattingRevisions(
           source: "import",
           originalRevisionType: childLocalName,
           ooxmlRevisionId: metadata.ooxmlRevisionId,
-          preserveOnlyReason: "Imported preserve-only revision.",
           propertyChangeData,
         },
       }),
@@ -465,12 +462,9 @@ function parseRunFormattingRevisions(
       xmlStart: child.start,
       xmlEnd: child.end,
       originalRevisionType: childLocalName,
-    });
-    state.diagnostics.push({
-      revisionId: metadata.revisionId,
-      code: "preserve_only_formatting_revision",
-      message: "Formatting revisions remain preserve-only for Wave 6.",
-      featureClass: "preserve-only",
+      containerXmlStart: runProperties.start,
+      containerXmlEnd: runProperties.end,
+      beforeContainerXml: beforeXml,
     });
   }
 }
@@ -616,7 +610,7 @@ function containsNestedRevision(node: XmlElementNode): boolean {
       child.type === "element" &&
       (SUPPORTED_CONTAINER_TYPES.has(localName(child.name)) ||
         PRESERVE_ONLY_CONTAINER_TYPES.has(localName(child.name)) ||
-        FORMATTING_REVISION_TYPES.has(localName(child.name)) ||
+        PROPERTY_CHANGE_REVISION_TYPES.has(localName(child.name)) ||
         containsNestedRevision(child)),
   );
 }

package/src/legal/bookmarks.ts

@@ -167,6 +167,41 @@ export function isHiddenBookmarkName(name: string | undefined): boolean {
   return Boolean(name && name.startsWith("_"));
 }
 
+export interface BookmarkIntegrityResult {
+  totalCount: number;
+  pairedCount: number;
+  startOnlyCount: number;
+  endOnlyCount: number;
+  hiddenCount: number;
+  namedCount: number;
+  integrityScore: "complete" | "partial" | "degraded";
+}
+
+export function assessBookmarkIntegrity(bookmarks: LegalBookmark[]): BookmarkIntegrityResult {
+  const pairedCount = bookmarks.filter((b) => b.status === "paired").length;
+  const startOnlyCount = bookmarks.filter((b) => b.status === "start-only").length;
+  const endOnlyCount = bookmarks.filter((b) => b.status === "end-only").length;
+  const hiddenCount = bookmarks.filter((b) => b.hidden).length;
+  const namedCount = bookmarks.filter((b) => b.name && !b.hidden).length;
+  const totalCount = bookmarks.length;
+  const unpairedCount = startOnlyCount + endOnlyCount;
+
+  return {
+    totalCount,
+    pairedCount,
+    startOnlyCount,
+    endOnlyCount,
+    hiddenCount,
+    namedCount,
+    integrityScore:
+      unpairedCount === 0
+        ? "complete"
+        : unpairedCount <= pairedCount
+          ? "partial"
+          : "degraded",
+  };
+}
+
 function compareBookmarks(left: LegalBookmark, right: LegalBookmark): number {
   return (
     (left.startIndex ?? left.endIndex ?? Number.MAX_SAFE_INTEGER) -

package/src/legal/index.ts

@@ -0,0 +1,32 @@
+export {
+  parseBookmarksFromDocumentXml,
+  collectBookmarksFromCanonicalDocument,
+  assessBookmarkIntegrity,
+  isHiddenBookmarkName,
+  type BookmarkIntegrityResult,
+  type LegalBookmark,
+} from "./bookmarks.ts";
+
+export {
+  parseCrossReferencesFromDocumentXml,
+  collectCrossReferencesFromCanonicalDocument,
+  detectCrossReferencePatterns,
+  parseFieldReferenceInstruction,
+  type CrossReference,
+  type CrossReferencePattern,
+} from "./cross-references.ts";
+
+export {
+  collectDefinedTermsFromDocumentXml,
+  collectDefinedTermsFromCanonicalDocument,
+  buildDefinedTermCatalog,
+  type DefinedTerm,
+  type DefinedTermOccurrence,
+} from "./defined-terms.ts";
+
+export {
+  detectSignatureBlocksFromCanonicalDocument,
+  type SignatureBlockCandidate,
+  type SignatureBlockReport,
+  type SignatureParty,
+} from "./signature-blocks.ts";

package/src/legal/signature-blocks.ts

@@ -0,0 +1,259 @@
+import type {
+  BlockNode,
+  CanonicalDocument,
+  DocumentNode,
+  ParagraphNode,
+} from "../model/canonical-document.ts";
+
+export interface SignatureBlockCandidate {
+  startIndex: number;
+  endIndex: number;
+  kind: "execution-block" | "witness-block" | "notary-block";
+  parties: SignatureParty[];
+  confidence: "high" | "medium";
+}
+
+export interface SignatureParty {
+  roleLabel?: string;
+  nameLabel?: string;
+  paragraphIndex: number;
+}
+
+export interface SignatureBlockReport {
+  reportVersion: "signature-block-report/1";
+  candidates: SignatureBlockCandidate[];
+  preservationSafe: boolean;
+  warnings: string[];
+}
+
+const EXECUTION_TRIGGER_PATTERN =
+  /\b(?:IN WITNESS WHEREOF|EXECUTED|AGREED AND ACCEPTED|SIGNATURES FOLLOW)\b/i;
+const ROLE_LINE_PATTERN =
+  /^\s*(?:By|Name|Title|Date|Witness|Authorized Signatory|Signature)\s*[:\-]?\s*/i;
+const PARTY_LABEL_PATTERN =
+  /^(?:(?:The |)[A-Z][A-Za-z0-9 ,.'&()-]{2,60})\s*$/;
+const WITNESS_PATTERN = /\bWITNESS(?:ED|ES)?\b/i;
+const NOTARY_PATTERN = /\bNOTARY\s+PUBLIC\b/i;
+const UNDERLINE_PLACEHOLDER_PATTERN = /_{4,}|\.{4,}/;
+
+export function detectSignatureBlocksFromCanonicalDocument(
+  document: Pick<CanonicalDocument, "content" | "preservation"> | DocumentNode,
+): SignatureBlockReport {
+  const root = "content" in document ? document.content : document;
+  const paragraphs: Array<{ text: string; node: ParagraphNode }> = [];
+  const warnings: string[] = [];
+
+  walkBlocks(root, (node) => {
+    if (node.type === "paragraph") {
+      paragraphs.push({ text: flattenParagraphText(node), node });
+    }
+  });
+
+  const candidates = findSignatureBlockCandidates(paragraphs);
+
+  const hasPreservation =
+    "preservation" in document &&
+    document.preservation !== undefined;
+  const preservationSafe = hasPreservation
+    ? !hasOpaqueFragmentsInSignatureRanges(
+        document as Pick<CanonicalDocument, "content" | "preservation">,
+        candidates,
+      )
+    : true;
+
+  if (!preservationSafe) {
+    warnings.push(
+      "One or more signature block regions overlap with preserve-only opaque fragments. Export fidelity may be degraded.",
+    );
+  }
+
+  return {
+    reportVersion: "signature-block-report/1",
+    candidates,
+    preservationSafe,
+    warnings,
+  };
+}
+
+function findSignatureBlockCandidates(
+  paragraphs: ReadonlyArray<{ text: string; node: ParagraphNode }>,
+): SignatureBlockCandidate[] {
+  const candidates: SignatureBlockCandidate[] = [];
+  let index = 0;
+
+  while (index < paragraphs.length) {
+    const text = paragraphs[index].text;
+
+    if (EXECUTION_TRIGGER_PATTERN.test(text)) {
+      const block = scanSignatureBlock(paragraphs, index);
+      if (block) {
+        candidates.push(block);
+        index = block.endIndex + 1;
+        continue;
+      }
+    }
+
+    index += 1;
+  }
+
+  return candidates;
+}
+
+function scanSignatureBlock(
+  paragraphs: ReadonlyArray<{ text: string; node: ParagraphNode }>,
+  triggerIndex: number,
+): SignatureBlockCandidate | undefined {
+  const parties: SignatureParty[] = [];
+  let endIndex = triggerIndex;
+  let kind: SignatureBlockCandidate["kind"] = "execution-block";
+  let hasSignatureContent = false;
+
+  for (
+    let index = triggerIndex + 1;
+    index < paragraphs.length && index <= triggerIndex + 40;
+    index += 1
+  ) {
+    const text = paragraphs[index].text.trim();
+
+    if (text.length === 0) {
+      endIndex = index;
+      continue;
+    }
+
+    if (WITNESS_PATTERN.test(text)) {
+      kind = "witness-block";
+    }
+    if (NOTARY_PATTERN.test(text)) {
+      kind = "notary-block";
+    }
+
+    if (ROLE_LINE_PATTERN.test(text)) {
+      hasSignatureContent = true;
+      endIndex = index;
+      continue;
+    }
+
+    if (UNDERLINE_PLACEHOLDER_PATTERN.test(text)) {
+      hasSignatureContent = true;
+      endIndex = index;
+      continue;
+    }
+
+    if (PARTY_LABEL_PATTERN.test(text) && !isBodyParagraph(text)) {
+      parties.push({
+        roleLabel: text.trim(),
+        paragraphIndex: index,
+      });
+      hasSignatureContent = true;
+      endIndex = index;
+      continue;
+    }
+
+    if (hasSignatureContent && isBodyParagraph(text)) {
+      break;
+    }
+
+    endIndex = index;
+  }
+
+  if (!hasSignatureContent) {
+    return undefined;
+  }
+
+  return {
+    startIndex: triggerIndex,
+    endIndex,
+    kind,
+    parties,
+    confidence: parties.length > 0 ? "high" : "medium",
+  };
+}
+
+function isBodyParagraph(text: string): boolean {
+  return text.length > 120 && /[.;]/.test(text);
+}
+
+function hasOpaqueFragmentsInSignatureRanges(
+  document: Pick<CanonicalDocument, "content" | "preservation">,
+  candidates: readonly SignatureBlockCandidate[],
+): boolean {
+  if (candidates.length === 0) {
+    return false;
+  }
+
+  const opaqueCount = Object.keys(document.preservation.opaqueFragments).length;
+  if (opaqueCount === 0) {
+    return false;
+  }
+
+  let paragraphIndex = 0;
+  const opaqueIndices = new Set<number>();
+
+  for (const block of document.content.children) {
+    if (block.type === "paragraph") {
+      paragraphIndex += 1;
+      continue;
+    }
+    if (block.type === "opaque_block") {
+      opaqueIndices.add(paragraphIndex);
+    }
+    paragraphIndex += 1;
+  }
+
+  return candidates.some((candidate) => {
+    for (let index = candidate.startIndex; index <= candidate.endIndex; index += 1) {
+      if (opaqueIndices.has(index)) {
+        return true;
+      }
+    }
+    return false;
+  });
+}
+
+function flattenParagraphText(paragraph: ParagraphNode): string {
+  return paragraph.children
+    .map((child) => {
+      switch (child.type) {
+        case "text":
+          return child.text;
+        case "hyperlink":
+        case "field":
+          return child.children
+            .map((nested) =>
+              nested.type === "text" ? nested.text : nested.type === "tab" ? "\t" : "",
+            )
+            .join("");
+        case "tab":
+          return "\t";
+        case "hard_break":
+        case "column_break":
+          return "\n";
+        default:
+          return "";
+      }
+    })
+    .join("");
+}
+
+function walkBlocks(
+  node: DocumentNode,
+  visit: (node: DocumentNode) => void,
+): void {
+  visit(node);
+
+  if ("children" in node && Array.isArray(node.children)) {
+    for (const child of node.children) {
+      walkBlocks(child, visit);
+    }
+  }
+
+  if (node.type === "table") {
+    for (const row of node.rows) {
+      walkBlocks(row, visit);
+    }
+  } else if (node.type === "table_row") {
+    for (const cell of node.cells) {
+      walkBlocks(cell, visit);
+    }
+  }
+}

package/src/runtime/document-runtime.ts

@@ -1,5 +1,6 @@
 import {
   createEditorState,
+  createSelectionSnapshot,
   createPersistedEditorSnapshot,
   deriveDocumentStats,
   type CanonicalDocumentEnvelope,
@@ -35,6 +36,7 @@ import {
   type EditorCommand,
   type EditorTransaction,
 } from "../core/commands/index.ts";
+import { insertText } from "../core/commands/text-commands.ts";
 import {
   createDetachedAnchor,
   createNodeAnchor,
@@ -51,6 +53,7 @@ import {
 import { buildCompatibilityReport } from "../validation/compatibility-engine.ts";
 import { mergeCompatibilityReports } from "../validation/compatibility-report.ts";
 import { createEditorSurfaceSnapshot } from "./surface-projection.ts";
+import { getFormattingStateFromRenderSnapshot } from "../core/commands/formatting-commands.ts";
 
 export type Unsubscribe = () => void;
 
@@ -58,11 +61,13 @@ export interface DocumentRuntime {
   subscribe(listener: () => void): Unsubscribe;
   subscribeToEvents(listener: (event: WordReviewEditorEvent) => void): Unsubscribe;
   getRenderSnapshot(): RuntimeRenderSnapshot;
+  getFormattingState(): import("../api/public-types").FormattingStateSnapshot;
   dispatch(command: EditorCommand): void;
   undo(): void;
   redo(): void;
   focus(): void;
   blur(): void;
+  replaceText(text: string, target?: EditorAnchorProjection): void;
   addComment(params: AddCommentParams): string;
   openComment(commentId: string): void;
   resolveComment(commentId: string): void;
@@ -162,6 +167,9 @@ export function createDocumentRuntime(
     getRenderSnapshot() {
       return cachedRenderSnapshot;
     },
+    getFormattingState() {
+      return getFormattingStateFromRenderSnapshot(cachedRenderSnapshot);
+    },
     dispatch(command) {
       if (command.type === "history.undo") {
         applyHistory("undo");
@@ -208,6 +216,25 @@ export function createDocumentRuntime(
         origin: createOrigin("api", clock()),
       });
     },
+    replaceText(text, target) {
+      try {
+        const timestamp = clock();
+        const selection = target
+          ? createSelectionFromPublicAnchor(target)
+          : state.selection;
+        const result = insertText(state.document, selection, text, { timestamp });
+
+        this.dispatch({
+          type: "document.replace",
+          document: result.document,
+          mapping: result.mapping,
+          selection: result.selection,
+          origin: createOrigin("api", timestamp),
+        });
+      } catch (error) {
+        emitError(toRuntimeError(error));
+      }
+    },
     addComment(params) {
       const commentId = createEntityId("comment", state.document.review.comments, clock());
       const anchor = params.anchor
@@ -694,6 +721,22 @@ function toInternalAnchorProjection(
   }
 }
 
+function createSelectionFromPublicAnchor(
+  anchor: EditorAnchorProjection,
+): import("../core/state/editor-state.ts").SelectionSnapshot {
+  switch (anchor.kind) {
+    case "range":
+      return createSelectionSnapshot(anchor.from, anchor.to);
+    case "node":
+      return createSelectionSnapshot(anchor.at, anchor.at);
+    case "detached":
+      return createSelectionSnapshot(
+        anchor.lastKnownRange.from,
+        anchor.lastKnownRange.to,
+      );
+  }
+}
+
 function toPublicCompatibilityReport(
   report: InternalCompatibilityReport,
 ): CompatibilityReport {