@beyondwork/docx-react-component 1.0.1 → 1.0.3

package/src/legal/bookmarks.ts

@@ -0,0 +1,196 @@
+import { extractBookmarksFromBodyXml } from "../io/ooxml/parse-fields.ts";
+import type {
+  BookmarkEndNode,
+  BookmarkStartNode,
+  CanonicalDocument,
+  DocumentNode,
+} from "../model/canonical-document.ts";
+
+export interface LegalBookmark {
+  bookmarkId: string;
+  name?: string;
+  hidden: boolean;
+  source: "ooxml" | "canonical";
+  status: "paired" | "start-only" | "end-only";
+  startIndex?: number;
+  endIndex?: number;
+}
+
+interface OpenBookmark {
+  bookmarkId: string;
+  name?: string;
+  hidden: boolean;
+  startIndex: number;
+}
+
+export function parseBookmarksFromDocumentXml(xml: string): LegalBookmark[] {
+  const bookmarks = extractBookmarksFromBodyXml(xml);
+  const openBookmarks = new Map<string, OpenBookmark[]>();
+  const results: LegalBookmark[] = [];
+
+  for (let index = 0; index < bookmarks.length; index += 1) {
+    const bookmark = bookmarks[index];
+
+    if (bookmark.type === "bookmark_start") {
+      const entry: OpenBookmark = {
+        bookmarkId: bookmark.bookmarkId,
+        name: bookmark.name,
+        hidden: isHiddenBookmarkName(bookmark.name),
+        startIndex: index,
+      };
+      const stack = openBookmarks.get(bookmark.bookmarkId) ?? [];
+      stack.push(entry);
+      openBookmarks.set(bookmark.bookmarkId, stack);
+      continue;
+    }
+
+    const stack = openBookmarks.get(bookmark.bookmarkId);
+    const open = stack?.pop();
+    if (stack && stack.length === 0) {
+      openBookmarks.delete(bookmark.bookmarkId);
+    }
+
+    if (open) {
+      results.push({
+        bookmarkId: bookmark.bookmarkId,
+        name: open.name,
+        hidden: open.hidden,
+        source: "ooxml",
+        status: "paired",
+        startIndex: open.startIndex,
+        endIndex: index,
+      });
+      continue;
+    }
+
+    results.push({
+      bookmarkId: bookmark.bookmarkId,
+      hidden: false,
+      source: "ooxml",
+      status: "end-only",
+      endIndex: index,
+    });
+  }
+
+  for (const stack of openBookmarks.values()) {
+    for (const open of stack) {
+      results.push({
+        bookmarkId: open.bookmarkId,
+        name: open.name,
+        hidden: open.hidden,
+        source: "ooxml",
+        status: "start-only",
+        startIndex: open.startIndex,
+      });
+    }
+  }
+
+  return results.sort(compareBookmarks);
+}
+
+export function collectBookmarksFromCanonicalDocument(
+  document: Pick<CanonicalDocument, "content"> | DocumentNode,
+): LegalBookmark[] {
+  const root = "content" in document ? document.content : document;
+  const sequence: Array<BookmarkStartNode | BookmarkEndNode> = [];
+
+  walkDocument(root, (node) => {
+    if (node.type === "bookmark_start" || node.type === "bookmark_end") {
+      sequence.push(node);
+    }
+  });
+
+  const openBookmarks = new Map<string, OpenBookmark[]>();
+  const results: LegalBookmark[] = [];
+
+  for (let index = 0; index < sequence.length; index += 1) {
+    const bookmark = sequence[index];
+
+    if (bookmark.type === "bookmark_start") {
+      const entry: OpenBookmark = {
+        bookmarkId: bookmark.bookmarkId,
+        name: bookmark.name,
+        hidden: isHiddenBookmarkName(bookmark.name),
+        startIndex: index,
+      };
+      const stack = openBookmarks.get(bookmark.bookmarkId) ?? [];
+      stack.push(entry);
+      openBookmarks.set(bookmark.bookmarkId, stack);
+      continue;
+    }
+
+    const stack = openBookmarks.get(bookmark.bookmarkId);
+    const open = stack?.pop();
+    if (stack && stack.length === 0) {
+      openBookmarks.delete(bookmark.bookmarkId);
+    }
+
+    if (open) {
+      results.push({
+        bookmarkId: bookmark.bookmarkId,
+        name: open.name,
+        hidden: open.hidden,
+        source: "canonical",
+        status: "paired",
+        startIndex: open.startIndex,
+        endIndex: index,
+      });
+      continue;
+    }
+
+    results.push({
+      bookmarkId: bookmark.bookmarkId,
+      hidden: false,
+      source: "canonical",
+      status: "end-only",
+      endIndex: index,
+    });
+  }
+
+  for (const stack of openBookmarks.values()) {
+    for (const open of stack) {
+      results.push({
+        bookmarkId: open.bookmarkId,
+        name: open.name,
+        hidden: open.hidden,
+        source: "canonical",
+        status: "start-only",
+        startIndex: open.startIndex,
+      });
+    }
+  }
+
+  return results.sort(compareBookmarks);
+}
+
+export function isHiddenBookmarkName(name: string | undefined): boolean {
+  return Boolean(name && name.startsWith("_"));
+}
+
+function compareBookmarks(left: LegalBookmark, right: LegalBookmark): number {
+  return (
+    (left.startIndex ?? left.endIndex ?? Number.MAX_SAFE_INTEGER) -
+      (right.startIndex ?? right.endIndex ?? Number.MAX_SAFE_INTEGER) ||
+    left.bookmarkId.localeCompare(right.bookmarkId)
+  );
+}
+
+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/cross-references.ts

@@ -0,0 +1,356 @@
+import {
+  extractComplexFieldsFromBodyXml,
+  parseFieldsFromParagraphXml,
+} from "../io/ooxml/parse-fields.ts";
+import { parseMainDocumentXml } from "../io/ooxml/parse-main-document.ts";
+import type {
+  CanonicalDocument,
+  DocumentNode,
+  FieldNode,
+  HyperlinkNode,
+  ParagraphNode,
+} from "../model/canonical-document.ts";
+
+export interface CrossReferencePattern {
+  kind: "section" | "clause" | "article" | "schedule" | "exhibit" | "appendix";
+  label: string;
+  targetHint: string;
+}
+
+export interface CrossReference {
+  source: "hyperlink" | "field" | "w:ref" | "text-pattern";
+  kind: "bookmark" | "section" | "clause" | "article" | "schedule" | "exhibit" | "appendix";
+  target?: string;
+  instruction?: string;
+  label: string;
+  paragraphIndex?: number;
+  confidence: "high" | "medium";
+}
+
+interface FieldReference {
+  kind: "REF" | "PAGEREF" | "NOTEREF";
+  target: string;
+  instruction: string;
+}
+
+const CROSS_REFERENCE_PATTERN =
+  /\b(Section|Clause|Article|Schedule|Exhibit|Appendix)\s+(\d+(?:\.\d+)*|[A-Z]-\d+|[A-Z])(?=[^A-Za-z0-9]|$)/g;
+const W_REF_PATTERN = /<w:ref\b([^>]*)\/?>/g;
+const ATTRIBUTE_PATTERN = /(?:^|\s)(?:w:)?([A-Za-z][\w-]*)="([^"]*)"/g;
+const COMPLEX_FIELD_PATTERN =
+  /<w:instrText\b[^>]*>([\s\S]*?)<\/w:instrText>[\s\S]*?<w:fldChar\b[^>]*w:fldCharType="separate"[^>]*\/>[\s\S]*?<w:t\b[^>]*>([\s\S]*?)<\/w:t>[\s\S]*?<w:fldChar\b[^>]*w:fldCharType="end"[^>]*\/>/g;
+
+export function parseCrossReferencesFromDocumentXml(xml: string): CrossReference[] {
+  const parsed = parseMainDocumentXml(xml);
+  const results: CrossReference[] = [];
+
+  parsed.blocks.forEach((block, paragraphIndex) => {
+    if (block.type !== "paragraph") {
+      return;
+    }
+
+    for (const child of block.children) {
+      if (child.type === "hyperlink" && child.href.startsWith("#")) {
+        results.push({
+          source: "hyperlink",
+          kind: "bookmark",
+          target: child.href.slice(1),
+          label: flattenInlineText(child.children).trim() || child.href.slice(1),
+          paragraphIndex,
+          confidence: "high",
+        });
+      }
+    }
+
+    const { simpleFields } = parseFieldsFromParagraphXml(block.rawXml);
+    for (const field of simpleFields) {
+      const reference = parseFieldReferenceInstruction(field.instruction);
+      if (!reference) {
+        continue;
+      }
+
+      results.push({
+        source: "field",
+        kind: "bookmark",
+        target: reference.target,
+        instruction: reference.instruction,
+        label: stripXml(field.contentXml) || reference.target,
+        paragraphIndex,
+        confidence: "high",
+      });
+    }
+
+    for (const pattern of detectCrossReferencePatterns(flattenParagraphText(block))) {
+      results.push({
+        source: "text-pattern",
+        kind: pattern.kind,
+        target: pattern.targetHint,
+        label: pattern.label,
+        paragraphIndex,
+        confidence: "medium",
+      });
+    }
+  });
+
+  for (const field of extractComplexFieldsFromBodyXml(xml)) {
+    const reference = parseFieldReferenceInstruction(field.instruction);
+    if (!reference) {
+      continue;
+    }
+    results.push({
+      source: "field",
+      kind: "bookmark",
+      target: reference.target,
+      instruction: reference.instruction,
+      label: stripXml(field.contentXml) || reference.target,
+      confidence: "high",
+    });
+  }
+
+  for (const field of extractComplexFieldsWithRegex(xml)) {
+    const reference = parseFieldReferenceInstruction(field.instruction);
+    if (!reference) {
+      continue;
+    }
+
+    results.push({
+      source: "field",
+      kind: "bookmark",
+      target: reference.target,
+      instruction: reference.instruction,
+      label: field.label || reference.target,
+      confidence: "high",
+    });
+  }
+
+  for (const element of extractWRefElements(xml)) {
+    results.push({
+      source: "w:ref",
+      kind: "bookmark",
+      target: element.target,
+      label: element.label || element.target || "w:ref",
+      confidence: element.target ? "high" : "medium",
+    });
+  }
+
+  return dedupeCrossReferences(results);
+}
+
+export function collectCrossReferencesFromCanonicalDocument(
+  document: Pick<CanonicalDocument, "content"> | DocumentNode,
+): CrossReference[] {
+  const root = "content" in document ? document.content : document;
+  const results: CrossReference[] = [];
+  let paragraphIndex = -1;
+
+  walkDocument(root, (node) => {
+    if (node.type === "paragraph") {
+      paragraphIndex += 1;
+      for (const child of node.children) {
+        if (child.type === "hyperlink" && child.href.startsWith("#")) {
+          results.push({
+            source: "hyperlink",
+            kind: "bookmark",
+            target: child.href.slice(1),
+            label: flattenInlineText(child.children).trim() || child.href.slice(1),
+            paragraphIndex,
+            confidence: "high",
+          });
+          continue;
+        }
+
+        if (child.type === "field") {
+          const reference = parseFieldReferenceInstruction(child.instruction);
+          if (!reference) {
+            continue;
+          }
+          results.push({
+            source: "field",
+            kind: "bookmark",
+            target: reference.target,
+            instruction: reference.instruction,
+            label: flattenInlineText(child.children).trim() || reference.target,
+            paragraphIndex,
+            confidence: "high",
+          });
+        }
+      }
+
+      for (const pattern of detectCrossReferencePatterns(flattenParagraphText(node))) {
+        results.push({
+          source: "text-pattern",
+          kind: pattern.kind,
+          target: pattern.targetHint,
+          label: pattern.label,
+          paragraphIndex,
+          confidence: "medium",
+        });
+      }
+    }
+  });
+
+  return dedupeCrossReferences(results);
+}
+
+export function detectCrossReferencePatterns(text: string): CrossReferencePattern[] {
+  const matches: CrossReferencePattern[] = [];
+
+  for (const match of text.matchAll(CROSS_REFERENCE_PATTERN)) {
+    const referenceType = match[1]?.toLowerCase();
+    const target = match[2];
+    const label = `${match[1]} ${target}`.trim();
+
+    if (!referenceType || !target) {
+      continue;
+    }
+
+    matches.push({
+      kind: referenceType as CrossReferencePattern["kind"],
+      label,
+      targetHint: target,
+    });
+  }
+
+  return matches;
+}
+
+export function parseFieldReferenceInstruction(instruction: string): FieldReference | undefined {
+  const trimmedInstruction = instruction.trim().replace(/\s+/g, " ");
+  const match = /^(REF|PAGEREF|NOTEREF)\s+(?:"([^"]+)"|([^\s\\]+))/i.exec(trimmedInstruction);
+  if (!match) {
+    return undefined;
+  }
+
+  return {
+    kind: match[1].toUpperCase() as FieldReference["kind"],
+    target: (match[2] ?? match[3] ?? "").trim(),
+    instruction: trimmedInstruction,
+  };
+}
+
+function extractWRefElements(xml: string): Array<{ target?: string; label?: string }> {
+  const matches: Array<{ target?: string; label?: string }> = [];
+
+  for (const match of xml.matchAll(W_REF_PATTERN)) {
+    const attributes = readAttributes(match[1] ?? "");
+    matches.push({
+      target: attributes.anchor ?? attributes.name ?? attributes.id,
+      label: attributes.displayText ?? attributes.text,
+    });
+  }
+
+  return matches;
+}
+
+function extractComplexFieldsWithRegex(xml: string): Array<{ instruction: string; label: string }> {
+  const matches: Array<{ instruction: string; label: string }> = [];
+
+  for (const match of xml.matchAll(COMPLEX_FIELD_PATTERN)) {
+    const instruction = stripXml(match[1] ?? "");
+    const label = stripXml(match[2] ?? "");
+    if (!instruction) {
+      continue;
+    }
+    matches.push({ instruction, label });
+  }
+
+  return matches;
+}
+
+function readAttributes(source: string): Record<string, string> {
+  const attributes: Record<string, string> = {};
+
+  for (const match of source.matchAll(ATTRIBUTE_PATTERN)) {
+    const [, key, value] = match;
+    attributes[key] = value;
+  }
+
+  return attributes;
+}
+
+function stripXml(xml: string): string {
+  return xml.replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim();
+}
+
+function flattenParagraphText(paragraph: ParagraphNode): string {
+  return paragraph.children
+    .map((child) => {
+      switch (child.type) {
+        case "text":
+          return child.text;
+        case "hyperlink":
+          return flattenInlineText(child.children);
+        case "field":
+          return flattenInlineText(child.children);
+        case "tab":
+          return "\t";
+        case "hard_break":
+        case "column_break":
+          return "\n";
+        default:
+          return "";
+      }
+    })
+    .join("");
+}
+
+function flattenInlineText(children: HyperlinkNode["children"] | FieldNode["children"]): string {
+  return children
+    .map((child) => {
+      if (child.type === "text") {
+        return child.text;
+      }
+      if (child.type === "tab") {
+        return "\t";
+      }
+      if (child.type === "hard_break" || child.type === "column_break") {
+        return "\n";
+      }
+      return "";
+    })
+    .join("");
+}
+
+function dedupeCrossReferences(references: CrossReference[]): CrossReference[] {
+  const seen = new Set<string>();
+  const deduped: CrossReference[] = [];
+
+  for (const reference of references) {
+    const key = [
+      reference.source,
+      reference.kind,
+      reference.target ?? "",
+      reference.label,
+      String(reference.paragraphIndex ?? -1),
+    ].join("|");
+
+    if (seen.has(key)) {
+      continue;
+    }
+
+    seen.add(key);
+    deduped.push(reference);
+  }
+
+  return deduped;
+}
+
+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);
+    }
+  }
+}