@beyondwork/docx-react-component 1.0.28 → 1.0.29

package/src/legal/defined-terms.ts

@@ -1,203 +0,0 @@
-import { parseMainDocumentXml } from "../io/ooxml/parse-main-document.ts";
-import type {
-  CanonicalDocument,
-  DocumentNode,
-  ParagraphNode,
-} from "../model/canonical-document.ts";
-
-export interface DefinedTermOccurrence {
-  paragraphIndex: number;
-  label: string;
-  kind: "definition" | "reference";
-}
-
-export interface DefinedTerm {
-  term: string;
-  normalizedTerm: string;
-  definitionStyle: "quoted" | "bare";
-  definitions: DefinedTermOccurrence[];
-  references: DefinedTermOccurrence[];
-}
-
-const QUOTED_DEFINITION_PATTERN =
-  /["“]([A-Z][A-Za-z0-9]*(?:[ -][A-Z][A-Za-z0-9]*){0,5})["”]\s+(?:means|has the meaning(?: set forth)?|shall mean|refers to)\b/g;
-const BARE_DEFINITION_PATTERN =
-  /\b([A-Z][A-Za-z0-9]*(?:\s+[A-Z][A-Za-z0-9]*){0,5})\s+(?:means|has the meaning(?: set forth)?|shall mean|refers to)\b/g;
-const BLOCKED_BARE_TERMS = new Set([
-  "This Agreement",
-  "Such Term",
-  "The Company",
-  "This Section",
-  "This Clause",
-]);
-
-export function collectDefinedTermsFromDocumentXml(xml: string): DefinedTerm[] {
-  const parsed = parseMainDocumentXml(xml);
-  const paragraphs = parsed.blocks
-    .filter((block): block is typeof parsed.blocks[number] & { type: "paragraph" } => block.type === "paragraph")
-    .map((block) => flattenParagraphText(block as unknown as ParagraphNode));
-
-  return buildDefinedTermCatalog(paragraphs);
-}
-
-export function collectDefinedTermsFromCanonicalDocument(
-  document: Pick<CanonicalDocument, "content"> | DocumentNode,
-): DefinedTerm[] {
-  const root = "content" in document ? document.content : document;
-  const paragraphs: string[] = [];
-
-  walkDocument(root, (node) => {
-    if (node.type === "paragraph") {
-      paragraphs.push(flattenParagraphText(node));
-    }
-  });
-
-  return buildDefinedTermCatalog(paragraphs);
-}
-
-export function buildDefinedTermCatalog(paragraphs: readonly string[]): DefinedTerm[] {
-  const terms = new Map<string, DefinedTerm>();
-
-  paragraphs.forEach((paragraph, paragraphIndex) => {
-    for (const candidate of extractDefinitionCandidates(paragraph)) {
-      const normalized = normalizeTerm(candidate.term);
-      const existing = terms.get(normalized) ?? {
-        term: candidate.term,
-        normalizedTerm: normalized,
-        definitionStyle: candidate.definitionStyle,
-        definitions: [],
-        references: [],
-      };
-
-      if (!terms.has(normalized)) {
-        terms.set(normalized, existing);
-      }
-
-      existing.definitions.push({
-        paragraphIndex,
-        label: candidate.term,
-        kind: "definition",
-      });
-    }
-  });
-
-  paragraphs.forEach((paragraph, paragraphIndex) => {
-    for (const term of terms.values()) {
-      const references = findTermReferences(paragraph, term.term);
-      if (references === 0) {
-        continue;
-      }
-
-      const hasDefinitionInParagraph = term.definitions.some(
-        (definition) => definition.paragraphIndex === paragraphIndex,
-      );
-      const referenceCount = hasDefinitionInParagraph ? 0 : references;
-
-      for (let count = 0; count < referenceCount; count += 1) {
-        term.references.push({
-          paragraphIndex,
-          label: term.term,
-          kind: "reference",
-        });
-      }
-    }
-  });
-
-  return Array.from(terms.values()).sort((left, right) => left.term.localeCompare(right.term));
-}
-
-interface DefinitionCandidate {
-  term: string;
-  definitionStyle: DefinedTerm["definitionStyle"];
-}
-
-function extractDefinitionCandidates(paragraph: string): DefinitionCandidate[] {
-  const candidates: DefinitionCandidate[] = [];
-
-  for (const match of paragraph.matchAll(QUOTED_DEFINITION_PATTERN)) {
-    const term = match[1]?.trim();
-    if (!term) {
-      continue;
-    }
-
-    candidates.push({
-      term,
-      definitionStyle: "quoted",
-    });
-  }
-
-  for (const match of paragraph.matchAll(BARE_DEFINITION_PATTERN)) {
-    const term = match[1]?.trim();
-    if (!term || BLOCKED_BARE_TERMS.has(term) || isQuotedTerm(term, paragraph)) {
-      continue;
-    }
-
-    candidates.push({
-      term,
-      definitionStyle: "bare",
-    });
-  }
-
-  return candidates;
-}
-
-function normalizeTerm(term: string): string {
-  return term.trim().replace(/\s+/g, " ").toLowerCase();
-}
-
-function isQuotedTerm(term: string, paragraph: string): boolean {
-  return paragraph.includes(`"${term}"`) || paragraph.includes(`“${term}”`);
-}
-
-function findTermReferences(paragraph: string, term: string): number {
-  const escapedTerm = escapeRegExp(term);
-  const pattern = new RegExp(`(?:^|[^A-Za-z0-9])(?:\"|“)?(${escapedTerm})(?:\"|”)?(?=[^A-Za-z0-9]|$)`, "g");
-  return Array.from(paragraph.matchAll(pattern)).length;
-}
-
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-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 walkDocument(node: DocumentNode, visit: (node: DocumentNode) => void): void {
-  visit(node);
-
-  if ("children" in node && Array.isArray(node.children)) {
-    for (const child of node.children) {
-      walkDocument(child, visit);
-    }
-  }
-
-  if (node.type === "table") {
-    for (const row of node.rows) {
-      walkDocument(row, visit);
-    }
-  } else if (node.type === "table_row") {
-    for (const cell of node.cells) {
-      walkDocument(cell, visit);
-    }
-  }
-}

package/src/legal/index.ts

@@ -1,32 +0,0 @@
-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

@@ -1,259 +0,0 @@
-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

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