@beyondwork/docx-react-component 1.0.0 → 1.0.1

package/test/io/footnotes-roundtrip.test.ts

@@ -1,318 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import {
-  parseFootnotesXml,
-  parseEndnotesXml,
-} from "../../src/io/ooxml/parse-footnotes.ts";
-import {
-  serializeFootnotesXml,
-  serializeEndnotesXml,
-} from "../../src/io/export/serialize-footnotes.ts";
-import type { FootnoteCollection } from "../../src/model/canonical-document.ts";
-
-// ---- Fixtures ----
-
-const FOOTNOTES_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<w:footnotes xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
-  <w:footnote w:type="separator" w:id="-1">
-    <w:p/>
-  </w:footnote>
-  <w:footnote w:type="continuationSeparator" w:id="0">
-    <w:p/>
-  </w:footnote>
-  <w:footnote w:id="1">
-    <w:p>
-      <w:pPr><w:pStyle w:val="FootnoteText"/></w:pPr>
-      <w:r><w:t>This is the first footnote.</w:t></w:r>
-    </w:p>
-  </w:footnote>
-  <w:footnote w:id="2">
-    <w:p>
-      <w:r><w:rPr><w:b/></w:rPr><w:t>Bold footnote</w:t></w:r>
-    </w:p>
-  </w:footnote>
-  <w:footnote w:id="3">
-    <w:p>
-      <w:r><w:t xml:space="preserve">Multi-word </w:t></w:r>
-      <w:r><w:rPr><w:i/></w:rPr><w:t>italic</w:t></w:r>
-      <w:r><w:t xml:space="preserve"> footnote text.</w:t></w:r>
-    </w:p>
-  </w:footnote>
-</w:footnotes>`;
-
-const ENDNOTES_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<w:endnotes xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
-  <w:endnote w:type="separator" w:id="-1">
-    <w:p/>
-  </w:endnote>
-  <w:endnote w:type="continuationSeparator" w:id="0">
-    <w:p/>
-  </w:endnote>
-  <w:endnote w:id="1">
-    <w:p>
-      <w:pPr><w:pStyle w:val="EndnoteText"/></w:pPr>
-      <w:r><w:t>This is an endnote.</w:t></w:r>
-    </w:p>
-  </w:endnote>
-  <w:endnote w:id="2">
-    <w:p>
-      <w:r><w:t>Second endnote.</w:t></w:r>
-    </w:p>
-  </w:endnote>
-</w:endnotes>`;
-
-const EMPTY_FOOTNOTES_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<w:footnotes xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
-  <w:footnote w:type="separator" w:id="-1"><w:p/></w:footnote>
-  <w:footnote w:type="continuationSeparator" w:id="0"><w:p/></w:footnote>
-</w:footnotes>`;
-
-// ---- Tests: parseFootnotesXml ----
-
-test("parseFootnotesXml skips separator stubs and parses user footnotes only", () => {
-  const collection = parseFootnotesXml(FOOTNOTES_XML);
-
-  assert.equal(Object.keys(collection.footnotes).length, 3, "expected 3 user footnotes");
-  assert.equal(Object.keys(collection.endnotes).length, 0, "footnotes.xml should not produce endnotes");
-
-  assert.ok("1" in collection.footnotes, "footnote id 1 should be present");
-  assert.ok("2" in collection.footnotes, "footnote id 2 should be present");
-  assert.ok("3" in collection.footnotes, "footnote id 3 should be present");
-  assert.ok(!("-1" in collection.footnotes), "separator -1 should be excluded");
-  assert.ok(!("0" in collection.footnotes), "separator 0 should be excluded");
-});
-
-test("parseFootnotesXml parses paragraph content and style from footnote body", () => {
-  const collection = parseFootnotesXml(FOOTNOTES_XML);
-  const note1 = collection.footnotes["1"];
-
-  assert.ok(note1, "footnote 1 should exist");
-  assert.equal(note1?.noteId, "1");
-  assert.equal(note1?.kind, "footnote");
-  assert.equal(note1?.blocks.length, 1);
-
-  const para = note1?.blocks[0];
-  assert.equal(para?.type, "paragraph");
-  if (para?.type === "paragraph") {
-    assert.equal(para.styleId, "FootnoteText");
-    assert.equal(para.children.length, 1);
-    const text = para.children[0];
-    assert.equal(text?.type, "text");
-    if (text?.type === "text") {
-      assert.equal(text.text, "This is the first footnote.");
-    }
-  }
-});
-
-test("parseFootnotesXml captures bold mark in footnote run", () => {
-  const collection = parseFootnotesXml(FOOTNOTES_XML);
-  const note2 = collection.footnotes["2"];
-
-  const para = note2?.blocks[0];
-  if (para?.type === "paragraph") {
-    const boldText = para.children[0];
-    assert.equal(boldText?.type, "text");
-    if (boldText?.type === "text") {
-      assert.equal(boldText.text, "Bold footnote");
-      assert.ok(boldText.marks?.some((m) => m.type === "bold"), "expected bold mark");
-    }
-  }
-});
-
-test("parseFootnotesXml parses multi-run footnote with italic", () => {
-  const collection = parseFootnotesXml(FOOTNOTES_XML);
-  const note3 = collection.footnotes["3"];
-
-  const para = note3?.blocks[0];
-  if (para?.type === "paragraph") {
-    assert.equal(para.children.length, 3, "expected 3 inline nodes");
-    const italicNode = para.children[1];
-    if (italicNode?.type === "text") {
-      assert.equal(italicNode.text, "italic");
-      assert.ok(italicNode.marks?.some((m) => m.type === "italic"), "expected italic mark");
-    }
-  }
-});
-
-test("parseFootnotesXml returns empty collections for separator-only XML", () => {
-  const collection = parseFootnotesXml(EMPTY_FOOTNOTES_XML);
-  assert.equal(Object.keys(collection.footnotes).length, 0);
-  assert.equal(Object.keys(collection.endnotes).length, 0);
-});
-
-// ---- Tests: parseEndnotesXml ----
-
-test("parseEndnotesXml parses endnotes and merges into existing collection", () => {
-  const footnoteCollection = parseFootnotesXml(FOOTNOTES_XML);
-  const merged = parseEndnotesXml(ENDNOTES_XML, footnoteCollection);
-
-  assert.equal(Object.keys(merged.footnotes).length, 3, "footnotes should be preserved");
-  assert.equal(Object.keys(merged.endnotes).length, 2, "expected 2 endnotes");
-
-  const endnote1 = merged.endnotes["1"];
-  assert.ok(endnote1, "endnote 1 should exist");
-  assert.equal(endnote1?.kind, "endnote");
-  assert.equal(endnote1?.noteId, "1");
-
-  const para = endnote1?.blocks[0];
-  if (para?.type === "paragraph") {
-    assert.equal(para.styleId, "EndnoteText");
-    const text = para.children[0];
-    if (text?.type === "text") {
-      assert.equal(text.text, "This is an endnote.");
-    }
-  }
-});
-
-test("parseEndnotesXml without existing collection creates fresh collection", () => {
-  const collection = parseEndnotesXml(ENDNOTES_XML);
-  assert.equal(Object.keys(collection.footnotes).length, 0);
-  assert.equal(Object.keys(collection.endnotes).length, 2);
-});
-
-// ---- Tests: serializeFootnotesXml / serializeEndnotesXml ----
-
-test("serializeFootnotesXml emits required separator stubs and user footnotes", () => {
-  const collection = parseFootnotesXml(FOOTNOTES_XML);
-  const xml = serializeFootnotesXml(collection);
-
-  assert.ok(xml.includes(`w:type="separator"`), "should include separator stub");
-  assert.ok(xml.includes(`w:type="continuationSeparator"`), "should include continuationSeparator stub");
-  assert.ok(xml.includes("This is the first footnote."), "should include footnote text");
-  assert.ok(xml.includes("Bold footnote"), "should include bold footnote text");
-  assert.ok(xml.includes("<w:footnotes"), "should emit footnotes root element");
-  assert.ok(xml.includes("</w:footnotes>"), "should close footnotes root element");
-});
-
-test("serializeEndnotesXml emits required separator stubs and user endnotes", () => {
-  const merged = parseEndnotesXml(ENDNOTES_XML);
-  const xml = serializeEndnotesXml(merged);
-
-  assert.ok(xml.includes(`w:type="separator"`), "should include separator stub");
-  assert.ok(xml.includes("This is an endnote."), "should include endnote text");
-  assert.ok(xml.includes("<w:endnotes"), "should emit endnotes root element");
-  assert.ok(xml.includes("</w:endnotes>"), "should close endnotes root element");
-});
-
-test("serializeFootnotesXml with empty collection emits stubs only", () => {
-  const emptyCollection: FootnoteCollection = {
-    footnotes: {},
-    endnotes: {},
-  };
-  const xml = serializeFootnotesXml(emptyCollection);
-  assert.ok(xml.includes(`w:type="separator"`));
-  assert.ok(xml.includes(`w:type="continuationSeparator"`));
-  // Only stubs — no user footnote elements
-  const footnoteCount = (xml.match(/<w:footnote\b/g) ?? []).length;
-  assert.equal(footnoteCount, 2, "should have exactly 2 stubs");
-});
-
-// ---- Tests: parse → serialize → reparse round-trip ----
-
-test("footnotes parse-serialize-reparse roundtrip preserves footnote count and IDs", () => {
-  const original = parseFootnotesXml(FOOTNOTES_XML);
-  const serialized = serializeFootnotesXml(original);
-  const reparsed = parseFootnotesXml(serialized);
-
-  const originalIds = Object.keys(original.footnotes).sort();
-  const reparsedIds = Object.keys(reparsed.footnotes).sort();
-  assert.deepEqual(reparsedIds, originalIds, "footnote IDs should be stable after roundtrip");
-});
-
-test("footnotes parse-serialize-reparse roundtrip preserves text content", () => {
-  const original = parseFootnotesXml(FOOTNOTES_XML);
-  const serialized = serializeFootnotesXml(original);
-  const reparsed = parseFootnotesXml(serialized);
-
-  for (const [id, originalNote] of Object.entries(original.footnotes)) {
-    const reparsedNote = reparsed.footnotes[id];
-    assert.ok(reparsedNote, `footnote ${id} should survive roundtrip`);
-    assert.equal(reparsedNote?.kind, originalNote.kind);
-    assert.equal(reparsedNote?.blocks.length, originalNote.blocks.length);
-
-    const originalPara = originalNote.blocks[0];
-    const reparsedPara = reparsedNote?.blocks[0];
-    if (originalPara?.type === "paragraph" && reparsedPara?.type === "paragraph") {
-      assert.equal(
-        reparsedPara.styleId,
-        originalPara.styleId,
-        `footnote ${id} paragraph style should survive roundtrip`,
-      );
-    }
-  }
-});
-
-test("endnotes parse-serialize-reparse roundtrip preserves endnote count and IDs", () => {
-  const original = parseEndnotesXml(ENDNOTES_XML);
-  const serialized = serializeEndnotesXml(original);
-  const reparsed = parseEndnotesXml(serialized);
-
-  const originalIds = Object.keys(original.endnotes).sort();
-  const reparsedIds = Object.keys(reparsed.endnotes).sort();
-  assert.deepEqual(reparsedIds, originalIds, "endnote IDs should be stable after roundtrip");
-});
-
-test("merged footnote+endnote collection roundtrip keeps both note types intact", () => {
-  const footnoteColl = parseFootnotesXml(FOOTNOTES_XML);
-  const merged = parseEndnotesXml(ENDNOTES_XML, footnoteColl);
-
-  const footnoteXml = serializeFootnotesXml(merged);
-  const endnoteXml = serializeEndnotesXml(merged);
-
-  const reparsedFn = parseFootnotesXml(footnoteXml);
-  const reparsedEn = parseEndnotesXml(endnoteXml);
-
-  assert.deepEqual(
-    Object.keys(reparsedFn.footnotes).sort(),
-    Object.keys(merged.footnotes).sort(),
-  );
-  assert.deepEqual(
-    Object.keys(reparsedEn.endnotes).sort(),
-    Object.keys(merged.endnotes).sort(),
-  );
-});
-
-test("footnote serializer preserves text marks (bold, italic, underline) through roundtrip", () => {
-  const collection: FootnoteCollection = {
-    footnotes: {
-      "10": {
-        noteId: "10",
-        kind: "footnote",
-        blocks: [
-          {
-            type: "paragraph",
-            children: [
-              { type: "text", text: "Bold", marks: [{ type: "bold" }] },
-              { type: "text", text: " and ", marks: [] },
-              { type: "text", text: "italic", marks: [{ type: "italic" }] },
-              { type: "text", text: " underlined", marks: [{ type: "underline" }] },
-            ],
-          },
-        ],
-      },
-    },
-    endnotes: {},
-  };
-
-  const xml = serializeFootnotesXml(collection);
-  const reparsed = parseFootnotesXml(xml);
-  const note = reparsed.footnotes["10"];
-
-  const para = note?.blocks[0];
-  if (para?.type === "paragraph") {
-    const boldNode = para.children[0];
-    const italicNode = para.children[2];
-    const underlineNode = para.children[3];
-
-    if (boldNode?.type === "text") {
-      assert.ok(boldNode.marks?.some((m) => m.type === "bold"), "bold should survive roundtrip");
-    }
-    if (italicNode?.type === "text") {
-      assert.ok(italicNode.marks?.some((m) => m.type === "italic"), "italic should survive roundtrip");
-    }
-    if (underlineNode?.type === "text") {
-      assert.ok(underlineNode.marks?.some((m) => m.type === "underline"), "underline should survive roundtrip");
-    }
-  }
-});