@beyondwork/docx-react-component 1.0.1 → 1.0.2

package/src/io/ooxml/parse-headers-footers.ts

@@ -0,0 +1,483 @@
+import type {
+  BlockNode,
+  FootnoteRefNode,
+  HeaderFooterVariant,
+  InlineNode,
+  ParagraphNode,
+  TextMark,
+} from "../../model/canonical-document.ts";
+
+// ---- Public types ----
+
+export interface ParsedHeaderFooterReference {
+  variant: HeaderFooterVariant;
+  relationshipId: string;
+  kind: "header" | "footer";
+}
+
+export interface ParsedHeaderFooterDocument {
+  blocks: BlockNode[];
+}
+
+// ---- XML node types (inline, no external dep) ----
+
+interface XmlElementNode {
+  type: "element";
+  name: string;
+  attributes: Record<string, string>;
+  children: XmlNode[];
+}
+
+interface XmlTextNode {
+  type: "text";
+  text: string;
+}
+
+type XmlNode = XmlElementNode | XmlTextNode;
+
+// ---- Public API ----
+
+/**
+ * Scan a document body XML for w:headerReference / w:footerReference elements
+ * inside w:sectPr and return the relationship references.
+ */
+export function parseHeaderFooterReferences(
+  documentXml: string,
+): ParsedHeaderFooterReference[] {
+  const root = parseXml(documentXml);
+  const documentElement = findChildElementOptional(root, "document");
+  if (!documentElement) {
+    return [];
+  }
+
+  const bodyElement = findChildElementOptional(documentElement, "body");
+  if (!bodyElement) {
+    return [];
+  }
+
+  const refs: ParsedHeaderFooterReference[] = [];
+
+  // Collect all sectPr elements (can appear in paragraph pPr and at body level)
+  collectSectPrReferences(bodyElement, refs);
+
+  return refs;
+}
+
+/**
+ * Parse a headerN.xml part (<w:hdr> root) into block nodes.
+ */
+export function parseHeaderXml(xml: string): ParsedHeaderFooterDocument {
+  return parseHdrFtrXml(xml, "hdr");
+}
+
+/**
+ * Parse a footerN.xml part (<w:ftr> root) into block nodes.
+ */
+export function parseFooterXml(xml: string): ParsedHeaderFooterDocument {
+  return parseHdrFtrXml(xml, "ftr");
+}
+
+// ---- Internal helpers ----
+
+function collectSectPrReferences(
+  element: XmlElementNode,
+  refs: ParsedHeaderFooterReference[],
+): void {
+  for (const child of element.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    const name = localName(child.name);
+
+    if (name === "sectPr") {
+      extractSectPrRefs(child, refs);
+    } else if (name === "p") {
+      // Check paragraph properties for sectPr
+      const pPr = findChildElementOptional(child, "pPr");
+      if (pPr) {
+        const sectPr = findChildElementOptional(pPr, "sectPr");
+        if (sectPr) {
+          extractSectPrRefs(sectPr, refs);
+        }
+      }
+    }
+  }
+}
+
+function extractSectPrRefs(
+  sectPr: XmlElementNode,
+  refs: ParsedHeaderFooterReference[],
+): void {
+  for (const child of sectPr.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    const name = localName(child.name);
+    if (name === "headerReference" || name === "footerReference") {
+      const kind: "header" | "footer" = name === "headerReference" ? "header" : "footer";
+      const rawType =
+        child.attributes["w:type"] ?? child.attributes.type ?? "default";
+      const variant = toHeaderFooterVariant(rawType);
+      const relationshipId =
+        child.attributes["r:id"] ??
+        child.attributes["r:Id"] ??
+        child.attributes.id ??
+        child.attributes.Id ??
+        "";
+
+      if (relationshipId) {
+        // Avoid duplicates (multiple sectPr may reference same header)
+        const alreadyAdded = refs.some(
+          (ref) => ref.relationshipId === relationshipId && ref.kind === kind,
+        );
+        if (!alreadyAdded) {
+          refs.push({ variant, relationshipId, kind });
+        }
+      }
+    }
+  }
+}
+
+function toHeaderFooterVariant(raw: string): HeaderFooterVariant {
+  if (raw === "first") {
+    return "first";
+  }
+  if (raw === "even") {
+    return "even";
+  }
+  return "default";
+}
+
+function parseHdrFtrXml(
+  xml: string,
+  rootLocalName: "hdr" | "ftr",
+): ParsedHeaderFooterDocument {
+  const root = parseXml(xml);
+  const hdrFtrElement = findChildElementOptional(root, rootLocalName);
+  if (!hdrFtrElement) {
+    return { blocks: [] };
+  }
+
+  const blocks: BlockNode[] = [];
+
+  for (const child of hdrFtrElement.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    const name = localName(child.name);
+
+    if (name === "p") {
+      blocks.push(parseParagraphElement(child));
+    } else if (name === "tbl") {
+      // Table in header/footer: store as opaque to preserve fidelity
+      blocks.push({
+        type: "opaque_block",
+        fragmentId: "fragment:hdrftr-tbl",
+        warningId: "warning:hdrftr-opaque-table",
+      });
+    } else {
+      // Other block-level elements: treat as opaque
+      blocks.push({
+        type: "opaque_block",
+        fragmentId: "fragment:hdrftr-opaque",
+        warningId: "warning:hdrftr-opaque-block",
+      });
+    }
+  }
+
+  return { blocks };
+}
+
+function parseParagraphElement(pElement: XmlElementNode): ParagraphNode {
+  let styleId: string | undefined;
+  let alignment: ParagraphNode["alignment"];
+  const children: InlineNode[] = [];
+
+  for (const child of pElement.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    const name = localName(child.name);
+
+    if (name === "pPr") {
+      const pStyle = findChildElementOptional(child, "pStyle");
+      styleId = pStyle?.attributes["w:val"] ?? pStyle?.attributes.val;
+      const jc = findChildElementOptional(child, "jc");
+      const jcVal = jc?.attributes["w:val"] ?? jc?.attributes.val;
+      if (jcVal === "left" || jcVal === "center" || jcVal === "right" || jcVal === "both" || jcVal === "distribute") {
+        alignment = jcVal;
+      }
+    } else if (name === "r") {
+      children.push(...parseRunElement(child));
+    } else if (name === "hyperlink") {
+      // Simplified: collect text children from hyperlink runs
+      for (const hChild of child.children) {
+        if (hChild.type === "element" && localName(hChild.name) === "r") {
+          children.push(...parseRunElement(hChild));
+        }
+      }
+    } else if (name === "bookmarkStart" || name === "bookmarkEnd") {
+      // Skip bookmark nodes in headers/footers
+    } else if (name === "fldChar" || name === "instrText") {
+      // Skip field chars, handled via run parsing
+    }
+  }
+
+  return {
+    type: "paragraph",
+    ...(styleId ? { styleId } : {}),
+    ...(alignment ? { alignment } : {}),
+    children,
+  };
+}
+
+function parseRunElement(rElement: XmlElementNode): InlineNode[] {
+  const nodes: InlineNode[] = [];
+  const marks: TextMark[] = parseRunProperties(rElement);
+
+  for (const child of rElement.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    const name = localName(child.name);
+
+    if (name === "t") {
+      const text = extractTextContent(child);
+      if (text.length > 0) {
+        nodes.push({
+          type: "text",
+          text,
+          ...(marks.length > 0 ? { marks } : {}),
+        });
+      }
+    } else if (name === "br") {
+      nodes.push({ type: "hard_break" });
+    } else if (name === "tab") {
+      nodes.push({ type: "tab" });
+    } else if (name === "footnoteReference") {
+      const noteId =
+        child.attributes["w:id"] ?? child.attributes.id ?? "";
+      if (noteId) {
+        const ref: FootnoteRefNode = {
+          type: "footnote_ref",
+          noteId,
+          noteKind: "footnote",
+        };
+        nodes.push(ref);
+      }
+    } else if (name === "endnoteReference") {
+      const noteId =
+        child.attributes["w:id"] ?? child.attributes.id ?? "";
+      if (noteId) {
+        const ref: FootnoteRefNode = {
+          type: "footnote_ref",
+          noteId,
+          noteKind: "endnote",
+        };
+        nodes.push(ref);
+      }
+    }
+  }
+
+  return nodes;
+}
+
+function parseRunProperties(rElement: XmlElementNode): TextMark[] {
+  const rPr = findChildElementOptional(rElement, "rPr");
+  if (!rPr) {
+    return [];
+  }
+
+  const marks: TextMark[] = [];
+
+  for (const child of rPr.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    const name = localName(child.name);
+    const val = child.attributes["w:val"] ?? child.attributes.val ?? "true";
+
+    switch (name) {
+      case "b":
+        if (val !== "0" && val !== "false") {
+          marks.push({ type: "bold" });
+        }
+        break;
+      case "i":
+        if (val !== "0" && val !== "false") {
+          marks.push({ type: "italic" });
+        }
+        break;
+      case "u":
+        if (val !== "none" && val !== "0") {
+          marks.push({ type: "underline" });
+        }
+        break;
+      case "strike":
+        if (val !== "0" && val !== "false") {
+          marks.push({ type: "strikethrough" });
+        }
+        break;
+      case "dstrike":
+        if (val !== "0" && val !== "false") {
+          marks.push({ type: "doubleStrikethrough" });
+        }
+        break;
+    }
+  }
+
+  return marks;
+}
+
+function extractTextContent(tElement: XmlElementNode): string {
+  let text = "";
+  for (const child of tElement.children) {
+    if (child.type === "text") {
+      text += child.text;
+    }
+  }
+  return text;
+}
+
+function findChildElementOptional(
+  node: XmlElementNode,
+  childLocalName: string,
+): XmlElementNode | undefined {
+  return node.children.find(
+    (entry): entry is XmlElementNode =>
+      entry.type === "element" && localName(entry.name) === childLocalName,
+  );
+}
+
+function localName(name: string): string {
+  const separatorIndex = name.indexOf(":");
+  return separatorIndex >= 0 ? name.slice(separatorIndex + 1) : name;
+}
+
+// ---- Minimal XML parser (same pattern as parse-numbering.ts) ----
+
+function parseXml(xml: string): XmlElementNode {
+  const root: XmlElementNode = {
+    type: "element",
+    name: "__root__",
+    attributes: {},
+    children: [],
+  };
+  const stack: XmlElementNode[] = [root];
+  let cursor = 0;
+
+  while (cursor < xml.length) {
+    if (xml.startsWith("<!--", cursor)) {
+      const end = xml.indexOf("-->", cursor);
+      cursor = end >= 0 ? end + 3 : xml.length;
+      continue;
+    }
+
+    if (xml.startsWith("<?", cursor)) {
+      const end = xml.indexOf("?>", cursor);
+      cursor = end >= 0 ? end + 2 : xml.length;
+      continue;
+    }
+
+    if (xml.startsWith("<![CDATA[", cursor)) {
+      const end = xml.indexOf("]]>", cursor);
+      const textEnd = end >= 0 ? end : xml.length;
+      stack[stack.length - 1]?.children.push({
+        type: "text",
+        text: xml.slice(cursor + 9, textEnd),
+      });
+      cursor = end >= 0 ? end + 3 : xml.length;
+      continue;
+    }
+
+    if (xml[cursor] !== "<") {
+      const nextTag = xml.indexOf("<", cursor);
+      const end = nextTag >= 0 ? nextTag : xml.length;
+      const text = decodeXmlEntities(xml.slice(cursor, end));
+      if (text.trim().length > 0 || (text.length > 0 && stack.length > 1)) {
+        stack[stack.length - 1]?.children.push({ type: "text", text });
+      }
+      cursor = end;
+      continue;
+    }
+
+    // Closing tag
+    if (xml[cursor + 1] === "/") {
+      const end = xml.indexOf(">", cursor);
+      if (end < 0) {
+        break;
+      }
+      stack.pop();
+      cursor = end + 1;
+      continue;
+    }
+
+    // Open or self-closing tag
+    const tagEnd = xml.indexOf(">", cursor);
+    if (tagEnd < 0) {
+      break;
+    }
+
+    const tagContent = xml.slice(cursor + 1, tagEnd);
+    const selfClosing = tagContent.endsWith("/");
+    const normalized = selfClosing ? tagContent.slice(0, -1).trimEnd() : tagContent;
+
+    const spaceIndex = normalized.search(/\s/);
+    const tagName =
+      spaceIndex >= 0 ? normalized.slice(0, spaceIndex) : normalized;
+    const attrString =
+      spaceIndex >= 0 ? normalized.slice(spaceIndex + 1) : "";
+    const attributes = parseAttributes(attrString);
+
+    const element: XmlElementNode = {
+      type: "element",
+      name: tagName,
+      attributes,
+      children: [],
+    };
+
+    stack[stack.length - 1]?.children.push(element);
+
+    if (!selfClosing) {
+      stack.push(element);
+    }
+
+    cursor = tagEnd + 1;
+  }
+
+  return root;
+}
+
+function parseAttributes(attrString: string): Record<string, string> {
+  const attrs: Record<string, string> = {};
+  const pattern = /([A-Za-z_:][A-Za-z0-9:._-]*)\s*=\s*("([^"]*)"|'([^']*)')/gu;
+
+  for (const match of attrString.matchAll(pattern)) {
+    const name = match[1];
+    const value = match[3] ?? match[4] ?? "";
+    if (name) {
+      attrs[name] = decodeXmlEntities(value);
+    }
+  }
+
+  return attrs;
+}
+
+function decodeXmlEntities(text: string): string {
+  return text
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&#(\d+);/g, (_, dec) => String.fromCodePoint(Number.parseInt(dec, 10)))
+    .replace(/&#x([0-9a-fA-F]+);/g, (_, hex) =>
+      String.fromCodePoint(Number.parseInt(hex, 16)),
+    );
+}