@beyondwork/docx-react-component 1.0.86 → 1.0.88

package/src/io/ooxml/parse-fields.ts

@@ -312,6 +312,7 @@ export function parseBookmarkEnd(
 
 import type {
   CanonicalDocument,
+  BlockNode,
   DocumentNode,
   FieldFamily,
   FieldNode,
@@ -322,13 +323,16 @@ import type {
   ParagraphNode,
   SubPartsCatalog,
   SupportedFieldFamily,
+  TocCachedEntry,
   TocEntry,
+  TocInstructionModel,
+  TocRegion,
   TocStructure,
 } from "../../model/canonical-document.ts";
 import { parseFieldSwitches } from "./parse-field-switches.ts";
 
 const FIELD_FAMILY_PATTERN =
-  /^\s*(REF|PAGEREF|NOTEREF|TOC|PAGE|NUMPAGES|DATE|TIME|AUTHOR|FILENAME|MERGEFIELD|IF|SEQ|INDEX|TC|STYLEREF|SECTIONPAGES)\b/i;
+  /^\s*(REF|PAGEREF|NOTEREF|TOC|PAGE|NUMPAGES|DATE|TIME|AUTHOR|FILENAME|MERGEFIELD|IF|SEQ|INDEX|TC|FORMTEXT|FORMCHECKBOX|FORMDROPDOWN|STYLEREF|SECTIONPAGES)\b/i;
 
 const SUPPORTED_FAMILIES = new Set<string>([
   "REF",
@@ -415,9 +419,9 @@ export function buildFieldRegistry(
   const root = document.content;
   const supported: FieldRegistryEntry[] = [];
   const preserveOnly: FieldRegistryEntry[] = [];
+  const tocFieldEntries: FieldRegistryEntry[] = [];
   let fieldIndex = 0;
   let paragraphIndex = -1;
-  let tocInstruction: string | undefined;
 
   walkFieldDocument(root, (node, pIdx) => {
     paragraphIndex = pIdx;
@@ -439,8 +443,8 @@ export function buildFieldRegistry(
       };
       if (classification.supported) {
         supported.push(entry);
-        if (classification.family === "TOC" && !tocInstruction) {
-          tocInstruction = node.instruction;
+        if (classification.family === "TOC") {
+          tocFieldEntries.push(entry);
         }
       } else {
         preserveOnly.push(entry);
@@ -477,13 +481,23 @@ export function buildFieldRegistry(
     });
   }
 
-  const tocStructure = tocInstruction
-    ? buildTocStructure(document, tocInstruction)
-    : undefined;
+  const tocRegions = buildTocRegions(document, tocFieldEntries);
+  const firstToc = tocRegions[0];
+  const tocStructure = firstToc
+    ? {
+        instruction: firstToc.instruction.raw,
+        levelRange: firstToc.instruction.outlineRange,
+        entries: firstToc.generatedEntries,
+        status: firstToc.status,
+      }
+    : tocFieldEntries[0]
+      ? buildTocStructure(document, tocFieldEntries[0].instruction)
+      : undefined;
 
   return {
     supported,
     preserveOnly,
+    ...(tocRegions.length > 0 ? { tocRegions } : {}),
     ...(tocStructure ? { tocStructure } : {}),
   };
 }
@@ -494,11 +508,120 @@ export function buildFieldRegistry(
  * Defaults to 1-9 if no \\o switch is present.
  */
 export function parseTocLevelRange(instruction: string): { from: number; to: number } {
-  const match = /\\o\s+"(\d+)-(\d+)"/.exec(instruction);
-  if (match) {
-    return { from: Number.parseInt(match[1], 10), to: Number.parseInt(match[2], 10) };
+  return parseTocInstruction(instruction).outlineRange;
+}
+
+export function parseTocInstruction(instruction: string): TocInstructionModel {
+  const model: TocInstructionModel = {
+    raw: instruction,
+    outlineRange: { from: 1, to: 9 },
+  };
+  const unsupportedSwitches: string[] = [];
+
+  for (const sw of readFieldSwitches(instruction)) {
+    const code = sw.code.toLowerCase();
+    switch (code) {
+      case "o": {
+        const range = parseLevelRangeValue(sw.value);
+        if (range) {
+          model.outlineRange = range;
+        }
+        break;
+      }
+      case "h":
+        model.hyperlink = true;
+        break;
+      case "z":
+        model.hidePageNumbersInWeb = true;
+        break;
+      case "u":
+        model.useOutlineLevels = true;
+        break;
+      case "t": {
+        const styleMap = parseTocStyleMap(sw.value);
+        if (styleMap && styleMap.length > 0) {
+          model.styleMap = styleMap;
+        }
+        break;
+      }
+      case "b":
+        if (sw.value) model.bookmarkName = sw.value;
+        break;
+      case "c":
+        if (sw.value) model.sequenceIdentifier = sw.value;
+        break;
+      case "f":
+        if (sw.value) model.tcIdentifier = sw.value;
+        break;
+      case "p":
+        if (sw.value) model.entryPageSeparator = sw.value;
+        break;
+      case "d":
+        if (sw.value) model.sequenceSeparator = sw.value;
+        break;
+      case "n": {
+        const range = parseLevelRangeValue(sw.value);
+        model.omitPageNumbers = range ?? true;
+        break;
+      }
+      default:
+        unsupportedSwitches.push(sw.code);
+        break;
+    }
+  }
+
+  if (unsupportedSwitches.length > 0) {
+    model.unsupportedSwitches = unsupportedSwitches;
+  }
+  return model;
+}
+
+function readFieldSwitches(instruction: string): Array<{ code: string; value?: string }> {
+  const switches: Array<{ code: string; value?: string }> = [];
+  const re = /\\([A-Za-z])(?:\s+(?:"([^"]*)"|([^\\\s]+)))?/gu;
+  let match: RegExpExecArray | null;
+  while ((match = re.exec(instruction)) !== null) {
+    const code = match[1] ?? "";
+    const rawValue = match[2] !== undefined ? match[2] : match[3]?.trim();
+    switches.push({
+      code,
+      ...(rawValue !== undefined ? { value: rawValue } : {}),
+    });
+  }
+  return switches;
+}
+
+function parseLevelRangeValue(value: string | undefined): { from: number; to: number } | undefined {
+  if (!value) return undefined;
+  const match = /^\s*(\d+)\s*-\s*(\d+)\s*$/u.exec(value);
+  if (!match) return undefined;
+  const from = Number.parseInt(match[1]!, 10);
+  const to = Number.parseInt(match[2]!, 10);
+  if (!Number.isFinite(from) || !Number.isFinite(to)) return undefined;
+  return {
+    from: Math.max(1, Math.min(9, from)),
+    to: Math.max(1, Math.min(9, to)),
+  };
+}
+
+function parseTocStyleMap(
+  value: string | undefined,
+): TocInstructionModel["styleMap"] {
+  if (!value) return undefined;
+  const tokens = value
+    .split(",")
+    .map((token) => token.trim())
+    .filter((token) => token.length > 0);
+  const entries: NonNullable<TocInstructionModel["styleMap"]> = [];
+  for (let index = 0; index + 1 < tokens.length; index += 2) {
+    const styleName = tokens[index]!;
+    const level = Number.parseInt(tokens[index + 1]!, 10);
+    if (!Number.isInteger(level) || level < 1 || level > 9) {
+      continue;
+    }
+    entries.push({ styleName, level });
   }
-  return { from: 1, to: 9 };
+  return entries.length > 0 ? entries : undefined;
 }
 
 /**
@@ -562,6 +685,281 @@ export function buildTocStructure(
   };
 }
 
+function buildTocRegions(
+  document: Pick<CanonicalDocument, "content" | "styles">,
+  tocFields: readonly FieldRegistryEntry[],
+): TocRegion[] {
+  if (tocFields.length === 0) {
+    return [];
+  }
+
+  const paragraphIndexByNode = new WeakMap<ParagraphNode, number>();
+  walkFieldDocument(document.content, (node, pIdx) => {
+    if (node.type === "paragraph") {
+      paragraphIndexByNode.set(node as ParagraphNode, pIdx);
+    }
+  });
+
+  const tocFieldByParagraph = new Map<number, FieldRegistryEntry>();
+  for (const entry of tocFields) {
+    if (!tocFieldByParagraph.has(entry.paragraphIndex)) {
+      tocFieldByParagraph.set(entry.paragraphIndex, entry);
+    }
+  }
+
+  const regions: TocRegion[] = [];
+  collectTocRegionsFromBlocks(
+    document,
+    document.content.children,
+    paragraphIndexByNode,
+    tocFieldByParagraph,
+    regions,
+    "body",
+    "body",
+  );
+
+  const seenFieldIndexes = new Set(regions.map((region) => region.sourceFieldIndex));
+  for (const entry of tocFields) {
+    if (seenFieldIndexes.has(entry.fieldIndex)) continue;
+    const generated = buildTocStructure(document, entry.instruction).entries;
+    regions.push({
+      tocId: `toc-${regions.length + 1}`,
+      sourceFieldIndex: entry.fieldIndex,
+      instruction: parseTocInstruction(entry.instruction),
+      resultRange: {
+        fromParagraphIndex: entry.paragraphIndex,
+        toParagraphIndex: entry.paragraphIndex,
+      },
+      parentKind: "body",
+      sourcePath: `field:${entry.fieldIndex}`,
+      cachedEntries: [],
+      generatedEntries: generated,
+      status: "stale",
+    });
+  }
+
+  return regions;
+}
+
+function collectTocRegionsFromBlocks(
+  document: Pick<CanonicalDocument, "content" | "styles">,
+  blocks: readonly BlockNode[],
+  paragraphIndexByNode: WeakMap<ParagraphNode, number>,
+  tocFieldByParagraph: ReadonlyMap<number, FieldRegistryEntry>,
+  regions: TocRegion[],
+  parentKind: TocRegion["parentKind"],
+  sourcePath: string,
+): void {
+  for (let index = 0; index < blocks.length; index += 1) {
+    const block = blocks[index];
+
+    if (block.type === "paragraph") {
+      const paragraphIndex = paragraphIndexByNode.get(block);
+      const tocField = paragraphIndex === undefined
+        ? undefined
+        : tocFieldByParagraph.get(paragraphIndex);
+      if (tocField && startsTocParagraphRegion(blocks, index)) {
+        const endIndex = findTocParagraphRegionEnd(blocks, index);
+        const paragraphs = blocks
+          .slice(index, endIndex + 1)
+          .filter((candidate): candidate is ParagraphNode => candidate.type === "paragraph");
+        const cachedEntries = paragraphs
+          .map((paragraph) => extractCachedTocEntry(paragraph, paragraphIndexByNode))
+          .filter((entry): entry is TocCachedEntry => Boolean(entry));
+        const generatedEntries = buildTocStructure(document, tocField.instruction).entries;
+        const firstParagraph = paragraphs[0];
+        const lastParagraph = paragraphs[paragraphs.length - 1];
+        const fromParagraphIndex = firstParagraph
+          ? paragraphIndexByNode.get(firstParagraph) ?? tocField.paragraphIndex
+          : tocField.paragraphIndex;
+        const toParagraphIndex = lastParagraph
+          ? paragraphIndexByNode.get(lastParagraph) ?? fromParagraphIndex
+          : fromParagraphIndex;
+        regions.push({
+          tocId: `toc-${regions.length + 1}`,
+          sourceFieldIndex: tocField.fieldIndex,
+          instruction: parseTocInstruction(tocField.instruction),
+          resultRange: { fromParagraphIndex, toParagraphIndex },
+          parentKind,
+          sourcePath: `${sourcePath}/${index}`,
+          cachedEntries,
+          generatedEntries,
+          status: tocEntriesMatch(cachedEntries, generatedEntries) ? "current" : "stale",
+        });
+        index = endIndex;
+        continue;
+      }
+    }
+
+    if (block.type === "sdt") {
+      collectTocRegionsFromBlocks(
+        document,
+        block.children,
+        paragraphIndexByNode,
+        tocFieldByParagraph,
+        regions,
+        "sdt",
+        `${sourcePath}/sdt[${index}]`,
+      );
+      continue;
+    }
+
+    if (block.type === "custom_xml") {
+      collectTocRegionsFromBlocks(
+        document,
+        block.children,
+        paragraphIndexByNode,
+        tocFieldByParagraph,
+        regions,
+        "custom_xml",
+        `${sourcePath}/customXml[${index}]`,
+      );
+      continue;
+    }
+
+    if (block.type === "table") {
+      block.rows.forEach((row, rowIndex) => {
+        row.cells.forEach((cell, cellIndex) => {
+          collectTocRegionsFromBlocks(
+            document,
+            cell.children,
+            paragraphIndexByNode,
+            tocFieldByParagraph,
+            regions,
+            "table_cell",
+            `${sourcePath}/table[${index}]/row[${rowIndex}]/cell[${cellIndex}]`,
+          );
+        });
+      });
+    }
+  }
+}
+
+function startsTocParagraphRegion(blocks: readonly BlockNode[], index: number): boolean {
+  const current = blocks[index];
+  if (current?.type === "paragraph" && isTocParagraphStyle(current.styleId)) {
+    return true;
+  }
+  const next = blocks[index + 1];
+  return next?.type === "paragraph" && isTocParagraphStyle(next.styleId);
+}
+
+function findTocParagraphRegionEnd(blocks: readonly BlockNode[], startIndex: number): number {
+  let endIndex = startIndex;
+  while (endIndex + 1 < blocks.length) {
+    const next = blocks[endIndex + 1];
+    if (next?.type !== "paragraph" || !isTocParagraphStyle(next.styleId)) {
+      break;
+    }
+    endIndex += 1;
+  }
+  return endIndex;
+}
+
+function isTocParagraphStyle(styleId: string | undefined): boolean {
+  return /^TOC\d+$/u.test(styleId ?? "");
+}
+
+function tocLevelFromStyle(styleId: string | undefined): number {
+  const match = /^TOC(\d+)$/u.exec(styleId ?? "");
+  if (!match) return 1;
+  return Math.max(1, Math.min(9, Number.parseInt(match[1]!, 10)));
+}
+
+function extractCachedTocEntry(
+  paragraph: ParagraphNode,
+  paragraphIndexByNode: WeakMap<ParagraphNode, number>,
+): TocCachedEntry | undefined {
+  if (!isTocParagraphStyle(paragraph.styleId)) {
+    return undefined;
+  }
+  const parts = flattenTocResultParts(paragraph.children);
+  const displayText = parts.map((part) => part.kind === "tab" ? "\t" : part.text).join("");
+  const trimmedDisplay = displayText.trim();
+  if (trimmedDisplay.length === 0) {
+    return undefined;
+  }
+  const lastTabIndex = parts.map((part) => part.kind).lastIndexOf("tab");
+  const titleParts = lastTabIndex >= 0 ? parts.slice(0, lastTabIndex) : parts;
+  const pageParts = lastTabIndex >= 0 ? parts.slice(lastTabIndex + 1) : [];
+  const text = titleParts
+    .filter((part): part is { kind: "text"; text: string; bookmarkName?: string } => part.kind === "text")
+    .map((part) => part.text)
+    .join("")
+    .trim();
+  const pageText = pageParts
+    .filter((part): part is { kind: "text"; text: string; bookmarkName?: string } => part.kind === "text")
+    .map((part) => part.text)
+    .join("")
+    .trim();
+  const bookmarkName = parts.find(
+    (part): part is { kind: "text"; text: string; bookmarkName: string } =>
+      part.kind === "text" && Boolean(part.bookmarkName),
+  )?.bookmarkName;
+  return {
+    text: text || trimmedDisplay,
+    level: tocLevelFromStyle(paragraph.styleId),
+    paragraphIndex: paragraphIndexByNode.get(paragraph) ?? -1,
+    ...(paragraph.styleId ? { styleId: paragraph.styleId } : {}),
+    ...(bookmarkName ? { bookmarkName } : {}),
+    ...(pageText ? { pageText } : {}),
+    displayText,
+  };
+}
+
+function flattenTocResultParts(
+  children: readonly InlineNode[],
+): Array<{ kind: "text"; text: string; bookmarkName?: string } | { kind: "tab" }> {
+  const parts: Array<{ kind: "text"; text: string; bookmarkName?: string } | { kind: "tab" }> = [];
+  for (const child of children) {
+    switch (child.type) {
+      case "text":
+        parts.push({ kind: "text", text: child.text });
+        break;
+      case "tab":
+        parts.push({ kind: "tab" });
+        break;
+      case "hard_break":
+        parts.push({ kind: "text", text: "\n" });
+        break;
+      case "hyperlink": {
+        const bookmarkName = child.href?.startsWith("#") ? child.href.slice(1) : undefined;
+        const nested = flattenTocResultParts(child.children);
+        for (const part of nested) {
+          parts.push(part.kind === "text" && bookmarkName ? { ...part, bookmarkName } : part);
+        }
+        break;
+      }
+      case "field":
+        if (child.fieldFamily !== "TOC") {
+          parts.push(...flattenTocResultParts(child.children));
+        }
+        break;
+      default:
+        break;
+    }
+  }
+  return parts;
+}
+
+function tocEntriesMatch(
+  cachedEntries: readonly TocCachedEntry[],
+  generatedEntries: readonly TocEntry[],
+): boolean {
+  if (cachedEntries.length !== generatedEntries.length) {
+    return false;
+  }
+  return cachedEntries.every((entry, index) => {
+    const generated = generatedEntries[index];
+    if (!generated) return false;
+    return entry.level === generated.level && normalizeTocText(entry.text) === normalizeTocText(generated.text);
+  });
+}
+
+function normalizeTocText(text: string): string {
+  return text.replace(/\s+/gu, " ").trim();
+}
+
 /**
  * Deterministic refresh helper for REF fields.
  * Given a bookmark name map and the document content, resolves the display
@@ -627,6 +1025,7 @@ export function refreshFieldRegistry(
   return {
     supported: refreshed,
     preserveOnly: registry.preserveOnly,
+    ...(registry.tocRegions ? { tocRegions: registry.tocRegions } : {}),
     ...(registry.tocStructure ? { tocStructure: registry.tocStructure } : {}),
   };
 }
@@ -838,4 +1237,3 @@ function findFirstChildEl(node: XmlElementNode, childLocalName: string): XmlElem
     (c): c is XmlElementNode => c.type === "element" && localName(c.name) === childLocalName,
   );
 }
-