@beyondwork/docx-react-component 1.0.14 → 1.0.15

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/numbering-prefix.ts

@@ -0,0 +1,195 @@
+import type {
+  NumberingCatalog,
+  NumberingLevelDefinition,
+  ParagraphNode,
+} from "../model/canonical-document.ts";
+
+interface NumberingSequenceState {
+  counters: Array<number | undefined>;
+  lastLevel: number | null;
+}
+
+export interface NumberingPrefixResolver {
+  resolve(numbering: ParagraphNode["numbering"] | undefined): string | null;
+}
+
+const DEFAULT_START_AT = 1;
+
+export function createNumberingPrefixResolver(
+  catalog: NumberingCatalog,
+): NumberingPrefixResolver {
+  const sequenceStates = new Map<string, NumberingSequenceState>();
+
+  return {
+    resolve(numbering) {
+      if (!numbering) {
+        return null;
+      }
+
+      const instance = catalog.instances[numbering.numberingInstanceId];
+      if (!instance) {
+        return null;
+      }
+
+      const definition = catalog.abstractDefinitions[instance.abstractNumberingId];
+      if (!definition) {
+        return null;
+      }
+
+      const levelDefinitions = new Map(
+        definition.levels.map((level) => [level.level, level] as const),
+      );
+      const levelDefinition = levelDefinitions.get(numbering.level);
+      if (!levelDefinition || levelDefinition.format === "none") {
+        return null;
+      }
+
+      const sequenceState = getSequenceState(sequenceStates, numbering.numberingInstanceId);
+      advanceSequence(sequenceState, numbering.level, levelDefinitions, instance.overrides);
+
+      return renderLevelText(levelDefinition.text, sequenceState.counters, levelDefinitions);
+    },
+  };
+}
+
+function getSequenceState(
+  states: Map<string, NumberingSequenceState>,
+  numberingInstanceId: string,
+): NumberingSequenceState {
+  const existing = states.get(numberingInstanceId);
+  if (existing) {
+    return existing;
+  }
+
+  const created: NumberingSequenceState = {
+    counters: [],
+    lastLevel: null,
+  };
+  states.set(numberingInstanceId, created);
+  return created;
+}
+
+function advanceSequence(
+  state: NumberingSequenceState,
+  currentLevel: number,
+  levelDefinitions: Map<number, NumberingLevelDefinition>,
+  overrides: NumberingCatalog["instances"][string]["overrides"],
+): void {
+  if (state.lastLevel !== null && currentLevel <= state.lastLevel) {
+    state.counters.length = currentLevel + 1;
+  }
+
+  const startAt = getLevelStartAt(currentLevel, levelDefinitions, overrides);
+  const currentValue = state.counters[currentLevel];
+  state.counters[currentLevel] =
+    currentValue === undefined ? startAt : currentValue + 1;
+  state.lastLevel = currentLevel;
+}
+
+function getLevelStartAt(
+  level: number,
+  levelDefinitions: Map<number, NumberingLevelDefinition>,
+  overrides: NumberingCatalog["instances"][string]["overrides"],
+): number {
+  const override = overrides.find((entry) => entry.level === level);
+  if (override?.startAt !== undefined) {
+    return override.startAt;
+  }
+
+  return levelDefinitions.get(level)?.startAt ?? DEFAULT_START_AT;
+}
+
+function renderLevelText(
+  text: string,
+  counters: Array<number | undefined>,
+  levelDefinitions: Map<number, NumberingLevelDefinition>,
+): string | null {
+  if (!text) {
+    return null;
+  }
+
+  if (!text.includes("%")) {
+    return text;
+  }
+
+  const rendered = text.replace(/%([1-9])/g, (_match, token) => {
+    const level = Number.parseInt(token, 10) - 1;
+    const counter = counters[level];
+    if (counter === undefined) {
+      return "";
+    }
+
+    const format = levelDefinitions.get(level)?.format ?? "decimal";
+    return formatCounter(counter, format);
+  });
+
+  return rendered.trim().length > 0 ? rendered : null;
+}
+
+function formatCounter(value: number, format: string): string {
+  switch (format) {
+    case "decimal":
+      return String(value);
+    case "decimalZero":
+      return String(value).padStart(2, "0");
+    case "upperLetter":
+      return toAlphabetic(value).toUpperCase();
+    case "lowerLetter":
+      return toAlphabetic(value).toLowerCase();
+    case "upperRoman":
+      return toRoman(value).toUpperCase();
+    case "lowerRoman":
+      return toRoman(value).toLowerCase();
+    case "none":
+      return "";
+    default:
+      return String(value);
+  }
+}
+
+function toAlphabetic(value: number): string {
+  if (value <= 0) {
+    return String(value);
+  }
+
+  let remainder = value;
+  let result = "";
+  while (remainder > 0) {
+    remainder -= 1;
+    result = String.fromCharCode(65 + (remainder % 26)) + result;
+    remainder = Math.floor(remainder / 26);
+  }
+  return result;
+}
+
+function toRoman(value: number): string {
+  if (value <= 0 || value >= 4000) {
+    return String(value);
+  }
+
+  const numerals: Array<[number, string]> = [
+    [1000, "M"],
+    [900, "CM"],
+    [500, "D"],
+    [400, "CD"],
+    [100, "C"],
+    [90, "XC"],
+    [50, "L"],
+    [40, "XL"],
+    [10, "X"],
+    [9, "IX"],
+    [5, "V"],
+    [4, "IV"],
+    [1, "I"],
+  ];
+
+  let remaining = value;
+  let result = "";
+  for (const [amount, numeral] of numerals) {
+    while (remaining >= amount) {
+      remaining -= amount;
+      result += numeral;
+    }
+  }
+  return result;
+}