@beyondwork/docx-react-component 1.0.29 → 1.0.31

package/{dist/chunk-RMH72RZI.js → src/legal/bookmarks.ts}

@@ -1,31 +1,57 @@
-import {
-  extractBookmarksFromBodyXml
-} from "./chunk-TLCEAQDQ.js";
+import { extractBookmarksFromBodyXml } from "../io/ooxml/parse-fields.ts";
+import type {
+  BookmarkEndNode,
+  BookmarkStartNode,
+  CanonicalDocument,
+  DocumentNode,
+  FieldRegistry,
+  FieldRegistryEntry,
+} from "../model/canonical-document.ts";
 
-// src/legal/bookmarks.ts
-function parseBookmarksFromDocumentXml(xml) {
+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 = /* @__PURE__ */ new Map();
-  const results = [];
+  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 = {
+      const entry: OpenBookmark = {
         bookmarkId: bookmark.bookmarkId,
         name: bookmark.name,
         hidden: isHiddenBookmarkName(bookmark.name),
-        startIndex: index
+        startIndex: index,
       };
-      const stack2 = openBookmarks.get(bookmark.bookmarkId) ?? [];
-      stack2.push(entry);
-      openBookmarks.set(bookmark.bookmarkId, stack2);
+      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,
@@ -34,18 +60,20 @@ function parseBookmarksFromDocumentXml(xml) {
         source: "ooxml",
         status: "paired",
         startIndex: open.startIndex,
-        endIndex: index
+        endIndex: index,
       });
       continue;
     }
+
     results.push({
       bookmarkId: bookmark.bookmarkId,
       hidden: false,
       source: "ooxml",
       status: "end-only",
-      endIndex: index
+      endIndex: index,
     });
   }
+
   for (const stack of openBookmarks.values()) {
     for (const open of stack) {
       results.push({
@@ -54,41 +82,51 @@ function parseBookmarksFromDocumentXml(xml) {
         hidden: open.hidden,
         source: "ooxml",
         status: "start-only",
-        startIndex: open.startIndex
+        startIndex: open.startIndex,
       });
     }
   }
+
   return results.sort(compareBookmarks);
 }
-function collectBookmarksFromCanonicalDocument(document) {
+
+export function collectBookmarksFromCanonicalDocument(
+  document: Pick<CanonicalDocument, "content"> | DocumentNode,
+): LegalBookmark[] {
   const root = "content" in document ? document.content : document;
-  const sequence = [];
+  const sequence: Array<BookmarkStartNode | BookmarkEndNode> = [];
+
   walkDocument(root, (node) => {
     if (node.type === "bookmark_start" || node.type === "bookmark_end") {
       sequence.push(node);
     }
   });
-  const openBookmarks = /* @__PURE__ */ new Map();
-  const results = [];
+
+  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 = {
+      const entry: OpenBookmark = {
         bookmarkId: bookmark.bookmarkId,
         name: bookmark.name,
         hidden: isHiddenBookmarkName(bookmark.name),
-        startIndex: index
+        startIndex: index,
       };
-      const stack2 = openBookmarks.get(bookmark.bookmarkId) ?? [];
-      stack2.push(entry);
-      openBookmarks.set(bookmark.bookmarkId, stack2);
+      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,
@@ -97,18 +135,20 @@ function collectBookmarksFromCanonicalDocument(document) {
         source: "canonical",
         status: "paired",
         startIndex: open.startIndex,
-        endIndex: index
+        endIndex: index,
       });
       continue;
     }
+
     results.push({
       bookmarkId: bookmark.bookmarkId,
       hidden: false,
       source: "canonical",
       status: "end-only",
-      endIndex: index
+      endIndex: index,
     });
   }
+
   for (const stack of openBookmarks.values()) {
     for (const open of stack) {
       results.push({
@@ -117,16 +157,29 @@ function collectBookmarksFromCanonicalDocument(document) {
         hidden: open.hidden,
         source: "canonical",
         status: "start-only",
-        startIndex: open.startIndex
+        startIndex: open.startIndex,
       });
     }
   }
+
   return results.sort(compareBookmarks);
 }
-function isHiddenBookmarkName(name) {
+
+export function isHiddenBookmarkName(name: string | undefined): boolean {
   return Boolean(name && name.startsWith("_"));
 }
-function assessBookmarkIntegrity(bookmarks) {
+
+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;
@@ -134,6 +187,7 @@ function assessBookmarkIntegrity(bookmarks) {
   const namedCount = bookmarks.filter((b) => b.name && !b.hidden).length;
   const totalCount = bookmarks.length;
   const unpairedCount = startOnlyCount + endOnlyCount;
+
   return {
     totalCount,
     pairedCount,
@@ -141,16 +195,34 @@ function assessBookmarkIntegrity(bookmarks) {
     endOnlyCount,
     hiddenCount,
     namedCount,
-    integrityScore: unpairedCount === 0 ? "complete" : unpairedCount <= pairedCount ? "partial" : "degraded"
+    integrityScore:
+      unpairedCount === 0
+        ? "complete"
+        : unpairedCount <= pairedCount
+          ? "partial"
+          : "degraded",
   };
 }
-function compareBookmarks(left, right) {
-  return (left.startIndex ?? left.endIndex ?? Number.MAX_SAFE_INTEGER) - (right.startIndex ?? right.endIndex ?? Number.MAX_SAFE_INTEGER) || left.bookmarkId.localeCompare(right.bookmarkId);
+
+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 buildBookmarkNameMap(document) {
+
+/**
+ * Build a lookup map from bookmark name to bookmarkId for the document.
+ * Used by the field refresh runtime to resolve REF/PAGEREF/NOTEREF targets.
+ */
+export function buildBookmarkNameMap(
+  document: Pick<CanonicalDocument, "content"> | DocumentNode,
+): Map<string, { bookmarkId: string; paragraphIndex: number }> {
   const root = "content" in document ? document.content : document;
-  const map = /* @__PURE__ */ new Map();
+  const map = new Map<string, { bookmarkId: string; paragraphIndex: number }>();
   let paragraphIndex = -1;
+
   walkDocument(root, (node) => {
     if (node.type === "paragraph") {
       paragraphIndex += 1;
@@ -159,15 +231,38 @@ function buildBookmarkNameMap(document) {
       map.set(node.name, { bookmarkId: node.bookmarkId, paragraphIndex });
     }
   });
+
   return map;
 }
-function walkDocument(node, visit) {
+
+/**
+ * Resolve field-to-bookmark dependencies from a field registry.
+ * Returns a map of bookmark names to the field entries that reference them.
+ * This enables the runtime to determine which fields need refresh when
+ * a bookmark's content changes.
+ */
+export function resolveBookmarkFieldDependencies(
+  registry: FieldRegistry,
+): Map<string, FieldRegistryEntry[]> {
+  const deps = new Map<string, FieldRegistryEntry[]>();
+  for (const entry of registry.supported) {
+    if (!entry.fieldTarget) continue;
+    const existing = deps.get(entry.fieldTarget) ?? [];
+    existing.push(entry);
+    deps.set(entry.fieldTarget, existing);
+  }
+  return deps;
+}
+
+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);
@@ -178,12 +273,3 @@ function walkDocument(node, visit) {
     }
   }
 }
-
-export {
-  parseBookmarksFromDocumentXml,
-  collectBookmarksFromCanonicalDocument,
-  isHiddenBookmarkName,
-  assessBookmarkIntegrity,
-  buildBookmarkNameMap
-};
-//# sourceMappingURL=chunk-RMH72RZI.js.map