@beyondwork/docx-react-component 1.0.29 → 1.0.31

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/model/README.md

@@ -0,0 +1,3 @@
+# Model
+
+Canonical document envelope types, schema versions, persisted snapshots, and migration contracts belong here.