@beyondwork/docx-react-component 1.0.0

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

@@ -0,0 +1,347 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { serializeRuntimeRevisionsIntoDocumentXml } from "../../src/io/export/serialize-runtime-revisions.ts";
+import { serializeRevisionsIntoDocumentXml } from "../../src/io/export/serialize-revisions.ts";
+import { mapRevisionBoundaries } from "../../src/io/ooxml/revision-boundaries.ts";
+import { parseRevisionsFromDocumentXml } from "../../src/io/ooxml/parse-revisions.ts";
+
+const REVISION_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+  <w:body>
+    <w:p>
+      <w:r><w:t xml:space="preserve">Alpha </w:t></w:r>
+      <w:ins w:id="11" w:author="user:insert" w:date="2026-03-26T10:00:00.000Z">
+        <w:r><w:rPr><w:b/></w:rPr><w:t>Beta</w:t></w:r>
+      </w:ins>
+      <w:r>
+        <w:rPr>
+          <w:rPrChange w:id="41" w:author="user:format" w:date="2026-03-26T10:03:00.000Z">
+            <w:rPr><w:i/></w:rPr>
+          </w:rPrChange>
+        </w:rPr>
+        <w:t> Gamma</w:t>
+      </w:r>
+    </w:p>
+    <w:p>
+      <w:r><w:t>Delta </w:t></w:r>
+      <w:del w:id="12" w:author="user:delete" w:date="2026-03-26T10:01:00.000Z">
+        <w:r><w:delText>Epsilon</w:delText></w:r>
+      </w:del>
+      <w:moveFrom w:id="21" w:author="user:move" w:date="2026-03-26T10:02:00.000Z">
+        <w:r><w:t> Zeta</w:t></w:r>
+      </w:moveFrom>
+    </w:p>
+    <w:p>
+      <w:pPr>
+        <w:rPr>
+          <w:del w:id="31" w:author="user:paragraph-delete" w:date="2026-03-26T10:04:00.000Z"/>
+        </w:rPr>
+        <w:pPrChange w:id="42" w:author="user:paragraph-format" w:date="2026-03-26T10:05:00.000Z">
+          <w:pPr><w:jc w:val="center"/></w:pPr>
+        </w:pPrChange>
+      </w:pPr>
+      <w:r><w:t>Paragraph one.</w:t></w:r>
+    </w:p>
+    <w:p>
+      <w:pPr>
+        <w:rPr>
+          <w:ins w:id="32" w:author="user:paragraph-insert" w:date="2026-03-26T10:06:00.000Z"/>
+        </w:rPr>
+      </w:pPr>
+      <w:r><w:t>Paragraph two.</w:t></w:r>
+    </w:p>
+    <w:sectPr/>
+  </w:body>
+</w:document>`;
+
+test("revision import keeps supported and preserve-only OOXML distinct without dropping metadata", () => {
+  const parsed = parseRevisionsFromDocumentXml(REVISION_XML);
+  const byId = Object.fromEntries(parsed.revisions.map((revision) => [revision.revisionId, revision]));
+
+  assert.equal(parsed.revisions.length, 7);
+  assert.equal(parsed.preservedMarkup.length, 7);
+  assert.equal(parsed.diagnostics.length, 3);
+
+  assert.equal(byId["revision:ins-11"]?.kind, "insertion");
+  assert.deepEqual(byId["revision:ins-11"]?.anchor, {
+    kind: "range",
+    range: { from: 6, to: 10 },
+    assoc: { start: 1, end: -1 },
+  });
+  assert.equal(byId["revision:ins-11"]?.authorId, "user:insert");
+  assert.equal(byId["revision:ins-11"]?.createdAt, "2026-03-26T10:00:00.000Z");
+  assert.equal(byId["revision:ins-11"]?.metadata.ooxmlRevisionId, "11");
+
+  assert.equal(byId["revision:del-12"]?.kind, "deletion");
+  assert.deepEqual(byId["revision:del-12"]?.anchor, {
+    kind: "range",
+    range: { from: 23, to: 30 },
+    assoc: { start: 1, end: -1 },
+  });
+
+  assert.equal(byId["revision:move-21"]?.kind, "move");
+  assert.equal(byId["revision:move-21"]?.metadata.originalRevisionType, "moveFrom");
+
+  assert.equal(byId["revision:formatting-41"]?.kind, "formatting");
+  assert.equal(byId["revision:formatting-41"]?.metadata.originalRevisionType, "rPrChange");
+  assert.equal(byId["revision:formatting-42"]?.kind, "formatting");
+  assert.equal(byId["revision:formatting-42"]?.metadata.originalRevisionType, "pPrChange");
+
+  assert.equal(byId["revision:del-31"]?.metadata.originalRevisionType, "paragraph-del");
+  assert.deepEqual(byId["revision:del-31"]?.anchor, {
+    kind: "range",
+    range: { from: 50, to: 50 },
+    assoc: { start: 1, end: -1 },
+  });
+  assert.equal(byId["revision:ins-32"]?.metadata.originalRevisionType, "paragraph-ins");
+  assert.deepEqual(byId["revision:ins-32"]?.anchor, {
+    kind: "range",
+    range: { from: 65, to: 65 },
+    assoc: { start: 1, end: -1 },
+  });
+});
+
+test("revision export roundtrips unchanged OOXML and preserves move and formatting markup verbatim", () => {
+  const parsed = parseRevisionsFromDocumentXml(REVISION_XML);
+  const serialized = serializeRevisionsIntoDocumentXml(REVISION_XML, parsed);
+  const reparsed = parseRevisionsFromDocumentXml(serialized);
+
+  assert.equal(serialized, REVISION_XML);
+  assert.deepEqual(
+    reparsed.revisions.map((revision) => ({
+      revisionId: revision.revisionId,
+      kind: revision.kind,
+      status: revision.status,
+      anchor: revision.anchor,
+      authorId: revision.authorId,
+      createdAt: revision.createdAt,
+      metadata: revision.metadata,
+    })),
+    parsed.revisions.map((revision) => ({
+      revisionId: revision.revisionId,
+      kind: revision.kind,
+      status: revision.status,
+      anchor: revision.anchor,
+      authorId: revision.authorId,
+      createdAt: revision.createdAt,
+      metadata: revision.metadata,
+    })),
+  );
+  assert.deepEqual(reparsed.preservedMarkup, parsed.preservedMarkup);
+});
+
+test("revision export can unwrap accepted insertions and restore rejected deletions to plain runs", () => {
+  const parsed = parseRevisionsFromDocumentXml(REVISION_XML);
+  const updated = parsed.revisions.map((revision) => {
+    if (revision.revisionId === "revision:ins-11") {
+      return {
+        ...revision,
+        status: "accepted" as const,
+      };
+    }
+
+    if (revision.revisionId === "revision:del-12") {
+      return {
+        ...revision,
+        status: "rejected" as const,
+      };
+    }
+
+    return revision;
+  });
+
+  const serialized = serializeRevisionsIntoDocumentXml(REVISION_XML, {
+    revisions: updated,
+    preservedMarkup: parsed.preservedMarkup,
+  });
+
+  assert.ok(!serialized.includes("<w:ins w:id=\"11\""));
+  assert.ok(serialized.includes("<w:r><w:rPr><w:b/></w:rPr><w:t>Beta</w:t></w:r>"));
+  assert.ok(!serialized.includes("<w:del w:id=\"12\""));
+  assert.ok(serialized.includes("<w:r><w:t>Epsilon</w:t></w:r>"));
+  assert.ok(serialized.includes("<w:moveFrom w:id=\"21\""));
+  assert.ok(serialized.includes("<w:rPrChange w:id=\"41\""));
+});
+
+test("revision export can resolve paragraph-mark revisions by merging or retaining paragraph boundaries", () => {
+  const parsed = parseRevisionsFromDocumentXml(REVISION_XML);
+  const merged = serializeRevisionsIntoDocumentXml(REVISION_XML, {
+    revisions: parsed.revisions.map((revision) => {
+      if (revision.revisionId === "revision:del-31") {
+        return { ...revision, status: "accepted" as const };
+      }
+
+      if (revision.revisionId === "revision:ins-32") {
+        return { ...revision, status: "rejected" as const };
+      }
+
+      return revision;
+    }),
+    preservedMarkup: parsed.preservedMarkup,
+    boundaries: parsed.boundaries,
+  });
+
+  assert.ok(!merged.includes("<w:del w:id=\"31\""));
+  assert.ok(!merged.includes("<w:ins w:id=\"32\""));
+  assert.match(
+    merged,
+    /<w:p>[\s\S]*<w:t>Paragraph one\.<\/w:t>[\s\S]*<w:t>Paragraph two\.<\/w:t>[\s\S]*<\/w:p>/,
+  );
+  assert.ok(merged.includes("<w:del w:id=\"12\""));
+  assert.equal((merged.match(/<w:p>/g) ?? []).length, 3);
+
+  const separated = serializeRevisionsIntoDocumentXml(REVISION_XML, {
+    revisions: parsed.revisions.map((revision) => {
+      if (revision.revisionId === "revision:del-31") {
+        return { ...revision, status: "rejected" as const };
+      }
+
+      if (revision.revisionId === "revision:ins-32") {
+        return { ...revision, status: "accepted" as const };
+      }
+
+      return revision;
+    }),
+    preservedMarkup: parsed.preservedMarkup,
+    boundaries: parsed.boundaries,
+  });
+
+  assert.ok(!separated.includes("<w:del w:id=\"31\""));
+  assert.ok(!separated.includes("<w:ins w:id=\"32\""));
+  assert.equal((separated.match(/<w:p>/g) ?? []).length, 4);
+  assert.ok(separated.includes("<w:r><w:t>Paragraph one.</w:t></w:r>"));
+  assert.ok(separated.includes("<w:r><w:t>Paragraph two.</w:t></w:r>"));
+});
+
+test("runtime paragraph-mark revision serialization targets paragraph properties instead of run properties", () => {
+  const documentXml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+  <w:body>
+    <w:p>
+      <w:pPr><w:jc w:val="center"/></w:pPr>
+      <w:r><w:rPr><w:b/></w:rPr><w:t>Styled paragraph.</w:t></w:r>
+    </w:p>
+    <w:p>
+      <w:r><w:t>Second paragraph.</w:t></w:r>
+    </w:p>
+    <w:sectPr/>
+  </w:body>
+</w:document>`;
+  const boundaries = mapRevisionBoundaries(documentXml);
+  const firstParagraphBoundary = boundaries[0];
+  assert.ok(firstParagraphBoundary);
+
+  const serialized = serializeRuntimeRevisionsIntoDocumentXml(
+    documentXml,
+    [
+      {
+        revisionId: "revision:paragraph-ins-99",
+        kind: "insertion",
+        anchor: {
+          kind: "range",
+          range: {
+            from: firstParagraphBoundary.end,
+            to: firstParagraphBoundary.end,
+          },
+          assoc: { start: 1, end: -1 },
+        },
+        authorId: "user:paragraph",
+        createdAt: "2026-03-26T23:30:00.000Z",
+        status: "active",
+        warningIds: [],
+        metadata: {
+          source: "import",
+          importedRevisionForm: "paragraph-insertion",
+          originalRevisionType: "paragraph-ins",
+          ooxmlRevisionId: "99",
+        },
+      },
+    ],
+    boundaries,
+  );
+
+  assert.deepEqual(serialized.skippedRevisionIds, []);
+  assert.match(
+    serialized.documentXml,
+    /<w:p>\s*<w:pPr><w:jc w:val="center"\/><w:rPr><w:ins\b[^>]*w:id="99"[^>]*\/><\/w:rPr><\/w:pPr>/,
+  );
+  assert.doesNotMatch(
+    serialized.documentXml,
+    /<w:r><w:rPr><w:b\/><w:ins\b[^>]*w:id="99"[^>]*\/>/,
+  );
+});
+
+test("runtime paragraph-mark revision serialization coalesces multiple markers into one paragraph-properties block", () => {
+  const documentXml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+  <w:body>
+    <w:p>
+      <w:pPr><w:jc w:val="center"/></w:pPr>
+      <w:r><w:t>Styled paragraph.</w:t></w:r>
+    </w:p>
+    <w:sectPr/>
+  </w:body>
+</w:document>`;
+  const boundaries = mapRevisionBoundaries(documentXml);
+  const firstParagraphBoundary = boundaries[0];
+  assert.ok(firstParagraphBoundary);
+
+  const serialized = serializeRuntimeRevisionsIntoDocumentXml(
+    documentXml,
+    [
+      {
+        revisionId: "revision:paragraph-ins-99",
+        kind: "insertion",
+        anchor: {
+          kind: "range",
+          range: {
+            from: firstParagraphBoundary.end,
+            to: firstParagraphBoundary.end,
+          },
+          assoc: { start: 1, end: -1 },
+        },
+        authorId: "user:paragraph",
+        createdAt: "2026-03-26T23:30:00.000Z",
+        status: "active",
+        warningIds: [],
+        metadata: {
+          source: "import",
+          importedRevisionForm: "paragraph-insertion",
+          originalRevisionType: "paragraph-ins",
+          ooxmlRevisionId: "99",
+        },
+      },
+      {
+        revisionId: "revision:paragraph-del-100",
+        kind: "deletion",
+        anchor: {
+          kind: "range",
+          range: {
+            from: firstParagraphBoundary.end,
+            to: firstParagraphBoundary.end,
+          },
+          assoc: { start: 1, end: -1 },
+        },
+        authorId: "user:paragraph",
+        createdAt: "2026-03-26T23:31:00.000Z",
+        status: "active",
+        warningIds: [],
+        metadata: {
+          source: "import",
+          importedRevisionForm: "paragraph-deletion",
+          originalRevisionType: "paragraph-del",
+          ooxmlRevisionId: "100",
+        },
+      },
+    ],
+    boundaries,
+  );
+
+  assert.deepEqual(serialized.skippedRevisionIds, []);
+  assert.match(
+    serialized.documentXml,
+    /<w:p>\s*<w:pPr><w:jc w:val="center"\/><w:rPr><w:ins\b[^>]*w:id="99"[^>]*\/><w:del\b[^>]*w:id="100"[^>]*\/><\/w:rPr><\/w:pPr>/,
+  );
+  assert.doesNotMatch(serialized.documentXml, /<\/w:pPr>\s*<w:pPr>/);
+});

package/test/io/structural-blocks.test.ts

@@ -0,0 +1,202 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { CanonicalDocument } from "../../src/model/canonical-document.ts";
+import { CDS_SCHEMA_VERSION } from "../../src/model/cds-1.0.0.ts";
+import { normalizeParsedTextDocument } from "../../src/io/normalize/normalize-text.ts";
+import { parseMainDocumentXml } from "../../src/io/ooxml/parse-main-document.ts";
+import { serializeMainDocument } from "../../src/io/export/serialize-main-document.ts";
+import { createEditorSurfaceSnapshot } from "../../src/runtime/surface-projection.ts";
+import { createPMStateFromSnapshot } from "../../src/ui-tailwind/editor-surface/pm-state-from-snapshot.ts";
+
+const FIXTURE_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:document
+  xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
+  xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture"
+  xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+  xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"
+  xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+  <w:body>
+    <w:sdt>
+      <w:sdtPr>
+        <w:alias w:val="Client Clause"/>
+        <w:tag w:val="clause.client"/>
+        <w:lock w:val="sdtLocked"/>
+        <w:richText/>
+      </w:sdtPr>
+      <w:sdtContent>
+        <w:p><w:r><w:t>Controlled paragraph</w:t></w:r></w:p>
+      </w:sdtContent>
+    </w:sdt>
+    <w:customXml w:uri="urn:contract" w:element="party">
+      <w:p><w:r><w:t>Wrapped custom xml paragraph</w:t></w:r></w:p>
+    </w:customXml>
+    <w:altChunk r:id="rIdChunk1"/>
+    <w:tbl>
+      <w:tblGrid><w:gridCol w:w="2400"/><w:gridCol w:w="2400"/></w:tblGrid>
+      <w:tr>
+        <w:tc>
+          <w:p><w:r><w:t>Outer left</w:t></w:r></w:p>
+        </w:tc>
+        <w:tc>
+          <w:tbl>
+            <w:tblGrid><w:gridCol w:w="2400"/></w:tblGrid>
+            <w:tr>
+              <w:tc>
+                <w:p>
+                  <w:r>
+                    <w:drawing>
+                      <wp:anchor behindDoc="0" layoutInCell="1" allowOverlap="1">
+                        <wp:positionH relativeFrom="column"><wp:align>right</wp:align></wp:positionH>
+                        <wp:positionV relativeFrom="paragraph"><wp:posOffset>720</wp:posOffset></wp:positionV>
+                        <wp:wrapSquare wrapText="bothSides"/>
+                        <wp:docPr id="7" name="Signature" descr="Floating signature"/>
+                        <a:graphic>
+                          <a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture">
+                            <pic:pic>
+                              <pic:nvPicPr><pic:cNvPr id="0" name="sig.png"/><pic:cNvPicPr/></pic:nvPicPr>
+                              <pic:blipFill><a:blip r:embed="rIdImage1"/></pic:blipFill>
+                              <pic:spPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="9525" cy="9525"/></a:xfrm></pic:spPr>
+                            </pic:pic>
+                          </a:graphicData>
+                        </a:graphic>
+                      </wp:anchor>
+                    </w:drawing>
+                  </w:r>
+                </w:p>
+              </w:tc>
+            </w:tr>
+          </w:tbl>
+        </w:tc>
+      </w:tr>
+    </w:tbl>
+    <w:sectPr/>
+  </w:body>
+</w:document>`;
+
+const RELATIONSHIPS = [
+  {
+    id: "rIdImage1",
+    type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
+    target: "media/sig.png",
+    targetMode: "internal" as const,
+  },
+  {
+    id: "rIdChunk1",
+    type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/aFChunk",
+    target: "afchunk/chunk1.html",
+    targetMode: "internal" as const,
+  },
+];
+
+const MEDIA_PARTS = new Map([
+  [
+    "/word/media/sig.png",
+    {
+      path: "/word/media/sig.png",
+      contentType: "image/png",
+    },
+  ],
+]);
+
+test("structural blocks parse, project, and serialize with nested tables and floating images", () => {
+  const parsed = parseMainDocumentXml(FIXTURE_XML, RELATIONSHIPS, MEDIA_PARTS);
+  assert.deepEqual(
+    parsed.blocks.map((block) => block.type),
+    ["sdt", "custom_xml", "alt_chunk", "table", "opaque_block"],
+  );
+
+  const normalized = normalizeParsedTextDocument(parsed);
+  assert.equal(normalized.content.children[0]?.type, "sdt");
+  assert.equal(normalized.content.children[1]?.type, "custom_xml");
+  assert.equal(normalized.content.children[2]?.type, "alt_chunk");
+
+  const sdt = normalized.content.children[0];
+  assert.equal(sdt?.type, "sdt");
+  if (sdt?.type === "sdt") {
+    assert.equal(sdt.properties.alias, "Client Clause");
+    assert.equal(sdt.properties.tag, "clause.client");
+    assert.equal(sdt.properties.lock, "sdtLocked");
+    assert.equal(sdt.properties.sdtType, "richText");
+  }
+
+  const customXml = normalized.content.children[1];
+  assert.equal(customXml?.type, "custom_xml");
+  if (customXml?.type === "custom_xml") {
+    assert.equal(customXml.uri, "urn:contract");
+    assert.equal(customXml.element, "party");
+  }
+
+  const outerTable = normalized.content.children[3];
+  assert.equal(outerTable?.type, "table");
+  if (outerTable?.type === "table") {
+    const nestedTable = outerTable.rows[0]?.cells[1]?.children[0];
+    assert.equal(nestedTable?.type, "table");
+    if (nestedTable?.type === "table") {
+      const imageParagraph = nestedTable.rows[0]?.cells[0]?.children[0];
+      assert.equal(imageParagraph?.type, "paragraph");
+      const image = imageParagraph?.type === "paragraph" ? imageParagraph.children[0] : undefined;
+      assert.equal(image?.type, "image");
+      if (image?.type === "image") {
+        assert.equal(image.display, "floating");
+        assert.equal(image.floating?.wrap, "square");
+        assert.equal(image.floating?.horizontalPosition?.align, "right");
+        assert.equal(image.floating?.verticalPosition?.offset, 720);
+      }
+    }
+  }
+
+  const canonical = createCanonicalDocumentForSurface(normalized);
+  const surface = createEditorSurfaceSnapshot(canonical, {
+    anchor: 0,
+    head: 0,
+    isCollapsed: true,
+    activeRange: { kind: "range", range: { from: 0, to: 0 }, assoc: { start: -1, end: 1 } },
+  });
+  assert.equal(surface.blocks[0]?.kind, "sdt_block");
+  assert.equal(surface.blocks[1]?.kind, "opaque_block");
+  assert.equal(surface.blocks[2]?.kind, "opaque_block");
+
+  const pm = createPMStateFromSnapshot(surface, {
+    anchor: 0,
+    head: 0,
+    isCollapsed: true,
+    activeRange: { kind: "range", from: 0, to: 0, assoc: { start: -1, end: 1 } },
+  }, []);
+  assert.equal(pm.state.doc.firstChild?.type.name, "sdt_block");
+  assert.ok(pm.state.doc.textContent.includes("Controlled paragraph"));
+
+  const serialized = serializeMainDocument(
+    normalized.content,
+    normalized.preservation,
+    RELATIONSHIPS,
+    { media: normalized.media },
+  );
+  assert.match(serialized.documentXml, /<w:sdt>/);
+  assert.match(serialized.documentXml, /<w:customXml w:uri="urn:contract" w:element="party">/);
+  assert.match(serialized.documentXml, /<w:altChunk r:id="rIdChunk1"\/>/);
+  assert.match(serialized.documentXml, /<wp:anchor\b/);
+  assert.ok(
+    serialized.relationships.some((relationship) => relationship.id === "rIdChunk1"),
+    "Expected altChunk relationship to survive export.",
+  );
+});
+
+function createCanonicalDocumentForSurface(
+  normalized: ReturnType<typeof normalizeParsedTextDocument>,
+): CanonicalDocument {
+  return {
+    schemaVersion: CDS_SCHEMA_VERSION,
+    docId: "49d3576d-a0e3-4ce5-97c1-dc42f6200c1e",
+    createdAt: "2026-04-06T00:00:00.000Z",
+    updatedAt: "2026-04-06T00:00:00.000Z",
+    metadata: { customProperties: {} },
+    styles: { paragraphs: {}, characters: {}, tables: {} },
+    numbering: { abstractDefinitions: {}, instances: {} },
+    media: normalized.media,
+    content: normalized.content,
+    review: { comments: {}, revisions: {} },
+    preservation: normalized.preservation,
+    diagnostics: normalized.diagnostics,
+  };
+}