@beyondwork/docx-react-component 1.0.29 → 1.0.31

package/src/io/export/serialize-footnotes.ts

@@ -0,0 +1,394 @@
+import type {
+  FootnoteCollection,
+  FootnoteDefinition,
+  InlineNode,
+  ParagraphNode,
+  TableCellNode,
+  TableNode,
+  TableRowNode,
+  TextMark,
+} from "../../model/canonical-document.ts";
+import type { RevisionRecord as ReviewRevisionRecord } from "../../review/store/revision-types.ts";
+import { serializeRuntimeRevisionsIntoStoryXml } from "./serialize-runtime-revisions.ts";
+import { splitStoryBlocksForRuntimeRevisions } from "./split-story-blocks-for-runtime-revisions.ts";
+import {
+  serializeTableCellPropertiesXml,
+  serializeTablePropertiesXml,
+  serializeTableRowPropertiesXml,
+} from "./table-properties-xml.ts";
+
+export const WORD_FOOTNOTES_CONTENT_TYPE =
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml";
+export const WORD_ENDNOTES_CONTENT_TYPE =
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+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"`;
+
+/**
+ * Serialize the footnotes portion of a FootnoteCollection to footnotes.xml.
+ * Includes the required separator and continuation-separator stubs.
+ */
+export function serializeFootnotesXml(
+  collection: FootnoteCollection,
+  revisionsByNoteId: Record<string, readonly ReviewRevisionRecord[]> = {},
+): string {
+  const entries = Object.values(collection.footnotes).sort(compareNoteIds);
+  const body = [
+    serializeSeparatorStub("footnote", "-1", "separator"),
+    serializeSeparatorStub("footnote", "0", "continuationSeparator"),
+    ...entries.map((entry) =>
+      serializeNoteDefinition("footnote", entry, revisionsByNoteId[entry.noteId] ?? [])),
+  ].join("");
+
+  return [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<w:footnotes ${W_NS} ${R_NS}>${body}</w:footnotes>`,
+  ].join("\n");
+}
+
+/**
+ * Serialize the endnotes portion of a FootnoteCollection to endnotes.xml.
+ * Includes the required separator and continuation-separator stubs.
+ */
+export function serializeEndnotesXml(
+  collection: FootnoteCollection,
+  revisionsByNoteId: Record<string, readonly ReviewRevisionRecord[]> = {},
+): string {
+  const entries = Object.values(collection.endnotes).sort(compareNoteIds);
+  const body = [
+    serializeSeparatorStub("endnote", "-1", "separator"),
+    serializeSeparatorStub("endnote", "0", "continuationSeparator"),
+    ...entries.map((entry) =>
+      serializeNoteDefinition("endnote", entry, revisionsByNoteId[entry.noteId] ?? [])),
+  ].join("");
+
+  return [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<w:endnotes ${W_NS} ${R_NS}>${body}</w:endnotes>`,
+  ].join("\n");
+}
+
+// ---- Internal serialization ----
+
+function serializeSeparatorStub(
+  kind: "footnote" | "endnote",
+  id: string,
+  type: "separator" | "continuationSeparator",
+): string {
+  const tag = kind === "footnote" ? "w:footnote" : "w:endnote";
+  return `<${tag} w:type="${type}" w:id="${id}"><w:p/></${tag}>`;
+}
+
+function serializeNoteDefinition(
+  kind: "footnote" | "endnote",
+  definition: FootnoteDefinition,
+  revisions: readonly ReviewRevisionRecord[] = [],
+): string {
+  const tag = kind === "footnote" ? "w:footnote" : "w:endnote";
+  const revisionReadyBlocks = splitStoryBlocksForRuntimeRevisions(definition.blocks, revisions);
+  const blocks = revisionReadyBlocks
+    .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 note sub-parts.`);
+    })
+    .join("");
+
+  const body = blocks || `<w:p><w:r><w:t></w:t></w:r></w:p>`;
+  const noteXml = `<${tag} w:id="${escapeAttribute(definition.noteId)}">${body}</${tag}>`;
+  if (revisions.length === 0) {
+    return noteXml;
+  }
+  const serialized = serializeRuntimeRevisionsIntoStoryXml(noteXml, revisions);
+  if (serialized.skippedRevisionIds.length > 0) {
+    throw new Error(
+      `Cannot safely serialize ${serialized.skippedRevisionIds.length} revisions for ${kind} ${definition.noteId}.`,
+    );
+  }
+  return serialized.documentXml;
+}
+
+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 note 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.alignment) {
+    parts.push(`<w:jc w:val="${escapeAttribute(paragraph.alignment)}"/>`);
+  }
+  if (paragraph.spacing) {
+    const attrs: string[] = [];
+    if (paragraph.spacing.before !== undefined) attrs.push(`w:before="${paragraph.spacing.before}"`);
+    if (paragraph.spacing.after !== undefined) attrs.push(`w:after="${paragraph.spacing.after}"`);
+    if (paragraph.spacing.line !== undefined) attrs.push(`w:line="${paragraph.spacing.line}"`);
+    if (paragraph.spacing.lineRule) attrs.push(`w:lineRule="${escapeAttribute(paragraph.spacing.lineRule)}"`);
+    if (attrs.length > 0) {
+      parts.push(`<w:spacing ${attrs.join(" ")}/>`);
+    }
+  }
+  if (paragraph.indentation) {
+    const attrs: string[] = [];
+    if (paragraph.indentation.left !== undefined) attrs.push(`w:left="${paragraph.indentation.left}"`);
+    if (paragraph.indentation.right !== undefined) attrs.push(`w:right="${paragraph.indentation.right}"`);
+    if (paragraph.indentation.firstLine !== undefined) attrs.push(`w:firstLine="${paragraph.indentation.firstLine}"`);
+    if (paragraph.indentation.hanging !== undefined) attrs.push(`w:hanging="${paragraph.indentation.hanging}"`);
+    if (attrs.length > 0) {
+      parts.push(`<w:ind ${attrs.join(" ")}/>`);
+    }
+  }
+
+  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)}"/>`;
+      const styleVal =
+        node.noteKind === "footnote"
+          ? "FootnoteReference"
+          : "EndnoteReference";
+      return `<w:r><w:rPr><w:rStyle w:val="${styleVal}"/></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 "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 "opaque_inline":
+      throw new Error(`Cannot safely serialize ${node.type} content in note sub-parts.`);
+    default:
+      throw new Error(`Cannot safely serialize ${node.type} content in note sub-parts.`);
+  }
+}
+
+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 "smallCaps":
+        parts.push("<w:smallCaps/>");
+        break;
+      case "allCaps":
+        parts.push("<w:caps/>");
+        break;
+      default:
+        throw new Error(`Cannot safely serialize ${mark.type} marks in note sub-parts.`);
+    }
+  }
+
+  return parts.length > 0 ? `<w:rPr>${parts.join("")}</w:rPr>` : "";
+}
+
+function compareNoteIds(
+  left: FootnoteDefinition,
+  right: FootnoteDefinition,
+): number {
+  return Number.parseInt(left.noteId, 10) - Number.parseInt(right.noteId, 10);
+}
+
+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 note hyperlinks without relationship context.");
+  }
+  return `<w:hyperlink r:id="${escapeAttribute(node.href)}">${childrenXml}</w:hyperlink>`;
+}
+
+function buildTableCellPropertiesXml(cell: TableCellNode): string {
+  return serializeTableCellPropertiesXml(cell);
+}