@beyondwork/docx-react-component 1.0.1 → 1.0.2

package/src/legal/defined-terms.ts

@@ -0,0 +1,203 @@
+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(flattenParagraphText);
+
+  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/model/README.md

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