@beyondwork/docx-react-component 1.0.29 → 1.0.31

package/src/io/export/serialize-headers-footers.ts

@@ -0,0 +1,368 @@
+import type {
+  BlockNode,
+  FooterDocument,
+  HeaderDocument,
+  InlineNode,
+  ParagraphNode,
+  TableCellNode,
+  TableNode,
+  TableRowNode,
+  TextMark,
+} from "../../model/canonical-document.ts";
+import type { RevisionRecord as ReviewRevisionRecord } from "../../review/store/revision-types.ts";
+import { splitStoryBlocksForRuntimeRevisions } from "./split-story-blocks-for-runtime-revisions.ts";
+import {
+  serializeTableCellPropertiesXml,
+  serializeTablePropertiesXml,
+  serializeTableRowPropertiesXml,
+} from "./table-properties-xml.ts";
+
+export const WORD_HEADER_CONTENT_TYPE =
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml";
+export const WORD_FOOTER_CONTENT_TYPE =
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml";
+
+const W_NS = `xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"`;
+const R_NS = `xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"`;
+const MC_NS = `xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"`;
+const O_NS = `xmlns:o="urn:schemas-microsoft-com:office:office"`;
+const V_NS = `xmlns:v="urn:schemas-microsoft-com:vml"`;
+const WP_NS = `xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"`;
+const WPS_NS = `xmlns:wps="http://schemas.microsoft.com/office/word/2010/wordprocessingShape"`;
+const A_NS = `xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"`;
+const W10_NS = `xmlns:w10="urn:schemas-microsoft-com:office:word"`;
+const W14_NS = `xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml"`;
+const W15_NS = `xmlns:w15="http://schemas.microsoft.com/office/word/2012/wordml"`;
+const WP14_NS = `xmlns:wp14="http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing"`;
+const EXTENDED_ROOT_ATTRS = `${MC_NS} ${O_NS} ${V_NS} ${WP_NS} ${WPS_NS} ${A_NS} ${W10_NS} ${W14_NS} ${W15_NS} ${WP14_NS} mc:Ignorable="wps wp14 w14 w15"`;
+
+/**
+ * Serialize a HeaderDocument into a headerN.xml string.
+ */
+export function serializeHeaderXml(header: HeaderDocument): string {
+  const body = serializeBlocks(header.blocks);
+  return [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<w:hdr ${W_NS} ${R_NS} ${EXTENDED_ROOT_ATTRS}>${body}</w:hdr>`,
+  ].join("\n");
+}
+
+export function serializeHeaderXmlWithRevisions(
+  header: HeaderDocument,
+  revisions: readonly ReviewRevisionRecord[] = [],
+): string {
+  const body = serializeBlocks(splitStoryBlocksForRuntimeRevisions(header.blocks, revisions));
+  return [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<w:hdr ${W_NS} ${R_NS} ${EXTENDED_ROOT_ATTRS}>${body}</w:hdr>`,
+  ].join("\n");
+}
+
+/**
+ * Serialize a FooterDocument into a footerN.xml string.
+ */
+export function serializeFooterXml(footer: FooterDocument): string {
+  const body = serializeBlocks(footer.blocks);
+  return [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<w:ftr ${W_NS} ${R_NS} ${EXTENDED_ROOT_ATTRS}>${body}</w:ftr>`,
+  ].join("\n");
+}
+
+export function serializeFooterXmlWithRevisions(
+  footer: FooterDocument,
+  revisions: readonly ReviewRevisionRecord[] = [],
+): string {
+  const body = serializeBlocks(splitStoryBlocksForRuntimeRevisions(footer.blocks, revisions));
+  return [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<w:ftr ${W_NS} ${R_NS} ${EXTENDED_ROOT_ATTRS}>${body}</w:ftr>`,
+  ].join("\n");
+}
+
+// ---- Internal serialization ----
+
+function serializeBlocks(
+  blocks: HeaderDocument["blocks"] | FooterDocument["blocks"],
+): string {
+  if (blocks.length === 0) {
+    // A valid header/footer must have at least one paragraph
+    return `<w:p><w:r><w:t></w:t></w:r></w:p>`;
+  }
+
+  return blocks
+    .map((block) => {
+      if (block.type === "paragraph") {
+        return serializeParagraph(block);
+      }
+      if (block.type === "table") {
+        return serializeTable(block);
+      }
+      if (block.type === "opaque_block" && typeof block.rawXml === "string") {
+        return block.rawXml;
+      }
+      throw new Error(`Cannot safely serialize ${block.type} content in header/footer sub-parts.`);
+    })
+    .join("");
+}
+
+function serializeParagraph(paragraph: ParagraphNode): string {
+  let xml = "<w:p>";
+
+  const propertiesXml = buildParagraphPropertiesXml(paragraph);
+  if (propertiesXml) {
+    xml += propertiesXml;
+  }
+
+  const childrenXml = paragraph.children
+    .map((child) => serializeInlineNode(child))
+    .join("");
+  xml += childrenXml || "<w:r><w:t></w:t></w:r>";
+  xml += "</w:p>";
+
+  return xml;
+}
+
+function serializeTable(table: TableNode): string {
+  let xml = "<w:tbl>";
+  const propertiesXml = serializeTablePropertiesXml(table);
+  if (propertiesXml) {
+    xml += propertiesXml;
+  }
+  if (table.gridColumns.length > 0) {
+    xml += "<w:tblGrid>";
+    for (const width of table.gridColumns) {
+      xml += `<w:gridCol w:w="${width}"/>`;
+    }
+    xml += "</w:tblGrid>";
+  }
+  for (const row of table.rows) {
+    xml += serializeTableRow(row);
+  }
+  xml += "</w:tbl>";
+  return xml;
+}
+
+function serializeTableRow(row: TableRowNode): string {
+  let xml = "<w:tr>";
+  const propertiesXml = serializeTableRowPropertiesXml(row);
+  if (propertiesXml) {
+    xml += propertiesXml;
+  }
+  for (const cell of row.cells) {
+    xml += serializeTableCell(cell);
+  }
+  xml += "</w:tr>";
+  return xml;
+}
+
+function serializeTableCell(cell: TableCellNode): string {
+  let xml = "<w:tc>";
+  const propertiesXml = buildTableCellPropertiesXml(cell);
+  if (propertiesXml) {
+    xml += propertiesXml;
+  }
+  for (const child of cell.children) {
+    if (child.type === "paragraph") {
+      xml += serializeParagraph(child);
+    } else {
+      throw new Error(`Cannot safely serialize ${child.type} content in header/footer table cells.`);
+    }
+  }
+  xml += "</w:tc>";
+  return xml;
+}
+
+function buildParagraphPropertiesXml(paragraph: ParagraphNode): string {
+  const parts: string[] = [];
+
+  if (paragraph.styleId) {
+    parts.push(`<w:pStyle w:val="${escapeAttribute(paragraph.styleId)}"/>`);
+  }
+  if (paragraph.spacing) {
+    const s = paragraph.spacing;
+    const attrs: string[] = [];
+    if (s.before !== undefined) attrs.push(`w:before="${s.before}"`);
+    if (s.after !== undefined) attrs.push(`w:after="${s.after}"`);
+    if (s.line !== undefined) attrs.push(`w:line="${s.line}"`);
+    if (s.lineRule) attrs.push(`w:lineRule="${escapeAttribute(s.lineRule)}"`);
+    if (attrs.length > 0) parts.push(`<w:spacing ${attrs.join(" ")}/>`);
+  }
+  if (paragraph.indentation) {
+    const ind = paragraph.indentation;
+    const attrs: string[] = [];
+    if (ind.left !== undefined) attrs.push(`w:left="${ind.left}"`);
+    if (ind.right !== undefined) attrs.push(`w:right="${ind.right}"`);
+    if (ind.firstLine !== undefined) attrs.push(`w:firstLine="${ind.firstLine}"`);
+    if (ind.hanging !== undefined) attrs.push(`w:hanging="${ind.hanging}"`);
+    if (attrs.length > 0) parts.push(`<w:ind ${attrs.join(" ")}/>`);
+  }
+  if (paragraph.alignment) {
+    parts.push(`<w:jc w:val="${escapeAttribute(paragraph.alignment)}"/>`);
+  }
+  if (paragraph.tabStops && paragraph.tabStops.length > 0) {
+    const tabsXml = paragraph.tabStops.map((tab) => {
+      const leaderAttr = tab.leader ? ` w:leader="${escapeAttribute(tab.leader)}"` : "";
+      return `<w:tab w:val="${tab.align}" w:pos="${tab.position}"${leaderAttr}/>`;
+    }).join("");
+    parts.push(`<w:tabs>${tabsXml}</w:tabs>`);
+  }
+
+  return parts.length > 0 ? `<w:pPr>${parts.join("")}</w:pPr>` : "";
+}
+
+function serializeInlineNode(node: InlineNode): string {
+  switch (node.type) {
+    case "text": {
+      const properties = buildRunPropertiesXml(node.marks);
+      const preserve = requiresPreservedSpace(node.text)
+        ? ` xml:space="preserve"`
+        : "";
+      return `<w:r>${properties}<w:t${preserve}>${escapeXml(node.text)}</w:t></w:r>`;
+    }
+    case "tab":
+      return "<w:r><w:tab/></w:r>";
+    case "hard_break":
+      return "<w:r><w:br/></w:r>";
+    case "footnote_ref": {
+      const refElement =
+        node.noteKind === "footnote"
+          ? `<w:footnoteReference w:id="${escapeAttribute(node.noteId)}"/>`
+          : `<w:endnoteReference w:id="${escapeAttribute(node.noteId)}"/>`;
+      return `<w:r><w:rPr><w:rStyle w:val="${node.noteKind === "footnote" ? "FootnoteReference" : "EndnoteReference"}"/></w:rPr>${refElement}</w:r>`;
+    }
+    case "bookmark_start":
+      return `<w:bookmarkStart w:id="${escapeAttribute(node.bookmarkId)}" w:name="${escapeAttribute(node.name)}"/>`;
+    case "bookmark_end":
+      return `<w:bookmarkEnd w:id="${escapeAttribute(node.bookmarkId)}"/>`;
+    case "field":
+      if (node.children && node.children.length > 0) {
+        const childrenXml = node.children.map((child) => serializeInlineNode(child)).join("");
+        if (node.fieldType === "complex") {
+          return (
+            `<w:r><w:fldChar w:fldCharType="begin"/></w:r>` +
+            `<w:r><w:instrText xml:space="preserve">${escapeXml(node.instruction)}</w:instrText></w:r>` +
+            `<w:r><w:fldChar w:fldCharType="separate"/></w:r>` +
+            childrenXml +
+            `<w:r><w:fldChar w:fldCharType="end"/></w:r>`
+          );
+        }
+        return `<w:fldSimple w:instr="${escapeAttribute(node.instruction)}">${childrenXml}</w:fldSimple>`;
+      }
+      if (node.fieldType === "simple") {
+        return `<w:fldSimple w:instr="${escapeAttribute(node.instruction)}"/>`;
+      }
+      return `<w:r><w:fldChar w:fldCharType="begin"/></w:r><w:r><w:instrText xml:space="preserve">${escapeXml(node.instruction)}</w:instrText></w:r><w:r><w:fldChar w:fldCharType="separate"/></w:r><w:r><w:fldChar w:fldCharType="end"/></w:r>`;
+    case "hyperlink":
+      return serializeHyperlinkNode(node);
+    case "chart_preview":
+    case "smartart_preview":
+    case "shape":
+    case "wordart":
+    case "vml_shape":
+      return wrapInlineRawXml(node.rawXml);
+    case "opaque_inline":
+      throw new Error(`Cannot safely serialize ${node.type} content in header/footer sub-parts.`);
+    case "image":
+    case "column_break":
+    case "symbol":
+    default:
+      throw new Error(`Cannot safely serialize ${node.type} content in header/footer sub-parts.`);
+  }
+}
+
+function wrapInlineRawXml(rawXml: string): string {
+  const trimmed = rawXml.trimStart();
+  return trimmed.startsWith("<w:r") ? rawXml : `<w:r>${rawXml}</w:r>`;
+}
+
+function buildRunPropertiesXml(marks: TextMark[] | undefined): string {
+  if (!marks || marks.length === 0) {
+    return "";
+  }
+
+  const parts: string[] = [];
+  for (const mark of marks) {
+    switch (mark.type) {
+      case "bold":
+        parts.push("<w:b/>");
+        break;
+      case "italic":
+        parts.push("<w:i/>");
+        break;
+      case "underline":
+        parts.push("<w:u w:val=\"single\"/>");
+        break;
+      case "strikethrough":
+        parts.push("<w:strike/>");
+        break;
+      case "doubleStrikethrough":
+        parts.push("<w:dstrike/>");
+        break;
+      case "fontFamily":
+        parts.push(`<w:rFonts w:ascii="${escapeAttribute(mark.val)}" w:hAnsi="${escapeAttribute(mark.val)}"/>`);
+        break;
+      case "fontSize":
+        parts.push(`<w:sz w:val="${mark.val}"/>`);
+        break;
+      case "textColor":
+        parts.push(`<w:color w:val="${escapeAttribute(mark.color)}"/>`);
+        break;
+      case "highlight":
+        parts.push(`<w:highlight w:val="${escapeAttribute(mark.val)}"/>`);
+        break;
+      case "backgroundColor":
+        parts.push(`<w:shd w:val="clear" w:color="auto" w:fill="${escapeAttribute(mark.color)}"/>`);
+        break;
+      case "smallCaps":
+        parts.push("<w:smallCaps/>");
+        break;
+      case "allCaps":
+        parts.push("<w:caps/>");
+        break;
+      default:
+        // Marks outside the secondary-story contract are silently dropped
+        // to avoid export failure on content the parser extracted safely.
+        break;
+    }
+  }
+
+  return parts.length > 0 ? `<w:rPr>${parts.join("")}</w:rPr>` : "";
+}
+
+function requiresPreservedSpace(text: string): boolean {
+  return (
+    text.length > 0 &&
+    (text[0] === " " || text[text.length - 1] === " " || text.includes("  "))
+  );
+}
+
+function escapeXml(text: string): string {
+  return text
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}
+
+function escapeAttribute(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+function serializeHyperlinkNode(node: Extract<InlineNode, { type: "hyperlink" }>): string {
+  const childrenXml = node.children.map((child) => serializeInlineNode(child)).join("");
+  if (node.href.startsWith("#")) {
+    return `<w:hyperlink w:anchor="${escapeAttribute(node.href.slice(1))}">${childrenXml}</w:hyperlink>`;
+  }
+  if (!/^rId[A-Za-z0-9._-]+$/u.test(node.href)) {
+    throw new Error("Cannot safely serialize URL-backed header/footer hyperlinks without relationship context.");
+  }
+  return `<w:hyperlink r:id="${escapeAttribute(node.href)}">${childrenXml}</w:hyperlink>`;
+}
+
+function buildTableCellPropertiesXml(cell: TableCellNode): string {
+  return serializeTableCellPropertiesXml(cell);
+}