@beyondwork/docx-react-component 1.0.0

package/test/model/canonical-document.test.ts

@@ -0,0 +1,285 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  CDS_SCHEMA_VERSION,
+  PERSISTED_EDITOR_SNAPSHOT_VERSION,
+} from "../../src/model/cds-1.0.0.ts";
+import {
+  assertCanonicalDocument,
+  parseCanonicalDocument,
+  serializeCanonicalDocument,
+} from "../../src/model/canonical-document.ts";
+import {
+  assertPersistedEditorSnapshot,
+  createPersistedEditorSnapshot,
+  parsePersistedEditorSnapshot,
+  projectAnchorToSnapshot,
+  serializePersistedEditorSnapshot,
+} from "../../src/model/snapshot.ts";
+
+function createCanonicalDocument() {
+  return {
+    schemaVersion: CDS_SCHEMA_VERSION,
+    docId: "2d6e1c2e-7d15-45a4-8b7a-5f422f18bb3b",
+    createdAt: "2026-03-26T00:00:00.000Z",
+    updatedAt: "2026-03-26T00:05:00.000Z",
+    metadata: {
+      title: "Draft agreement",
+      customProperties: {
+        matterId: "MAT-001",
+      },
+    },
+    styles: {
+      paragraphs: {
+        Normal: {
+          styleId: "Normal",
+          displayName: "Normal",
+          kind: "paragraph",
+          isDefault: true,
+        },
+      },
+      characters: {},
+      tables: {},
+    },
+    numbering: {
+      abstractDefinitions: {
+        "abstract-num:main": {
+          abstractNumberingId: "abstract-num:main",
+          levels: [],
+        },
+      },
+      instances: {
+        "num:main": {
+          numberingInstanceId: "num:main",
+          abstractNumberingId: "abstract-num:main",
+          overrides: [],
+        },
+      },
+    },
+    media: {
+      items: {
+        "media:logo": {
+          mediaId: "media:logo",
+          contentType: "image/png",
+          filename: "logo.png",
+          packagePartName: "/word/media/logo.png",
+          relationshipId: "rId1",
+        },
+      },
+    },
+    content: {
+      type: "doc",
+      children: [
+        {
+          type: "paragraph",
+          children: [
+            {
+              type: "text",
+              text: "Hello world",
+            },
+          ],
+        },
+      ],
+    },
+    review: {
+      comments: {
+        "comment:thread-1": {
+          commentId: "comment:thread-1",
+          status: "open",
+          anchor: {
+            kind: "range",
+            range: { from: 1, to: 6 },
+            assoc: { start: 1, end: -1 },
+          },
+          createdAt: "2026-03-26T00:02:00.000Z",
+          createdBy: "author-1",
+          body: "Check this clause.",
+          entries: [
+            {
+              entryId: "comment:thread-1-entry-1",
+              authorId: "author-1",
+              createdAt: "2026-03-26T00:02:00.000Z",
+              body: "Check this clause.",
+            },
+          ],
+          warningIds: ["warning:anchor-1"],
+          isResolved: false,
+          metadata: {
+            source: "runtime",
+          },
+        },
+      },
+      revisions: {
+        "revision:ins-1": {
+          changeId: "revision:ins-1",
+          status: "open",
+          kind: "insertion",
+          anchor: {
+            kind: "node",
+            at: 3,
+            assoc: 1,
+          },
+          authorId: "author-1",
+          createdAt: "2026-03-26T00:03:00.000Z",
+          warningIds: [],
+          metadata: {
+            source: "runtime",
+          },
+        },
+      },
+    },
+    preservation: {
+      opaqueFragments: {
+        "fragment:alt-1": {
+          fragmentId: "fragment:alt-1",
+          payloadKind: "xml-subtree",
+          payloadReference: "fragment-ref",
+          featureClass: "preserve-only",
+          lastKnownRange: { from: 7, to: 9 },
+          warningId: "warning:anchor-1",
+          packagePartName: "/word/document.xml",
+          relationshipId: "rId2",
+        },
+      },
+      packageParts: {
+        "/customXml/item1.xml": {
+          packagePartName: "/customXml/item1.xml",
+          contentType: "application/xml",
+          relationshipIds: ["rId3"],
+        },
+      },
+    },
+    diagnostics: {
+      warnings: [
+        {
+          diagnosticId: "diagnostic:warning-1",
+          warningId: "warning:anchor-1",
+          source: "review",
+          message: "Anchor was remapped conservatively.",
+        },
+      ],
+      errors: [],
+    },
+  };
+}
+
+test("canonical document serialization is deterministic across object insertion order", () => {
+  const first = createCanonicalDocument();
+  const second = createCanonicalDocument();
+
+  second.metadata = {
+    customProperties: second.metadata.customProperties,
+    title: second.metadata.title,
+  };
+  second.styles = {
+    tables: second.styles.tables,
+    paragraphs: second.styles.paragraphs,
+    characters: second.styles.characters,
+  };
+
+  assertCanonicalDocument(first);
+  assertCanonicalDocument(second);
+
+  const serializedFirst = serializeCanonicalDocument(first);
+  const serializedSecond = serializeCanonicalDocument(second);
+
+  assert.equal(serializedFirst, serializedSecond);
+  assert.equal(parseCanonicalDocument(serializedFirst).schemaVersion, CDS_SCHEMA_VERSION);
+});
+
+test("canonical document validation rejects schema drift and identifier mismatches", () => {
+  const invalidSchema = createCanonicalDocument();
+  invalidSchema.schemaVersion = "cds/9.9.9";
+
+  assert.throws(() => assertCanonicalDocument(invalidSchema), (error: any) => {
+    return error?.name === "ModelValidationError" &&
+      error.issues?.some((issue: { path: string }) => issue.path === "$.schemaVersion");
+  });
+
+  const invalidMedia = createCanonicalDocument();
+  invalidMedia.media.items["media:logo"].mediaId = "media:other";
+
+  assert.throws(() => assertCanonicalDocument(invalidMedia), (error: any) => {
+    return error?.name === "ModelValidationError" &&
+      error.issues?.some(
+        (issue: { path: string; message: string }) =>
+          issue.path === "$.media.items.media:logo.mediaId" &&
+          issue.message.includes("match the map key"),
+      );
+  });
+
+  const invalidReviewId = createCanonicalDocument();
+  invalidReviewId.review.comments["comment:thread-1"].commentId = "comment:other";
+
+  assert.throws(() => assertCanonicalDocument(invalidReviewId), (error: any) => {
+    return error?.name === "ModelValidationError" &&
+      error.issues?.some(
+        (issue: { path: string; message: string }) =>
+          issue.path === "$.review.comments.comment:thread-1.commentId" &&
+          issue.message.includes("match the map key"),
+      );
+  });
+});
+
+test("persisted snapshot serialization enforces frozen keys and schema linkage", () => {
+  const canonicalDocument = createCanonicalDocument();
+  const snapshot = createPersistedEditorSnapshot({
+    documentId: "document-1",
+    savedAt: "2026-03-26T00:06:00.000Z",
+    editorBuild: "wave-2-test",
+    canonicalDocument,
+    compatibility: {
+      reportVersion: "compatibility-report/1",
+      generatedAt: "2026-03-26T00:06:00.000Z",
+      blockExport: false,
+      featureEntries: [
+        {
+          featureEntryId: "feature-1",
+          featureKey: "paragraphs",
+          featureClass: "supported-roundtrip",
+          message: "Paragraphs are supported.",
+          affectedAnchor: projectAnchorToSnapshot(
+            canonicalDocument.review.comments["comment:thread-1"].anchor,
+          ),
+        },
+      ],
+      warnings: [
+        {
+          warningId: "warning-1",
+          code: "unsupported_ooxml_preserved",
+          severity: "info",
+          message: "Opaque content is preserved.",
+          source: "preservation",
+        },
+      ],
+      errors: [],
+    },
+    warningLog: [
+      {
+        warningId: "warning-1",
+        code: "unsupported_ooxml_preserved",
+        severity: "info",
+        message: "Opaque content is preserved.",
+        source: "preservation",
+      },
+    ],
+  });
+
+  assert.equal(snapshot.snapshotVersion, PERSISTED_EDITOR_SNAPSHOT_VERSION);
+
+  const serialized = serializePersistedEditorSnapshot(snapshot);
+  const parsed = parsePersistedEditorSnapshot(serialized);
+
+  assertPersistedEditorSnapshot(parsed);
+  assert.equal(parsed.schemaVersion, CDS_SCHEMA_VERSION);
+  assert.equal(parsed.docId, parsed.canonicalDocument.docId);
+
+  const invalidSnapshot = structuredClone(snapshot);
+  invalidSnapshot.schemaVersion = "cds/9.9.9";
+
+  assert.throws(() => assertPersistedEditorSnapshot(invalidSnapshot), (error: any) => {
+    return error?.name === "ModelValidationError" &&
+      error.issues?.some((issue: { path: string }) => issue.path === "$.schemaVersion");
+  });
+});

package/test/preservation/opaque-fragment-store.test.ts

@@ -0,0 +1,121 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  createOpaqueFragmentDeletionIntent,
+  getLockedOpaqueFragment,
+  listLockedOpaqueFragments,
+  listLockedOpaqueFragmentsIntersectingRange,
+} from "../../src/preservation/opaque-fragment-store.ts";
+import {
+  findPreservedPartsReferencingRelationship,
+  getPreservedPartManifestEntry,
+  listPreservedPartManifestEntries,
+} from "../../src/preservation/preserved-part-manifest.ts";
+
+const preservationStore = {
+  opaqueFragments: {
+    "fragment:section-1": {
+      fragmentId: "fragment:section-1",
+      payloadKind: "xml-subtree",
+      payloadReference: "<w:sectPr/>",
+      featureClass: "preserve-only" as const,
+      lastKnownRange: { from: 4, to: 5 },
+      warningId: "warning:section-1",
+      packagePartName: "/word/document.xml",
+    },
+    "fragment:custom-xml-1": {
+      fragmentId: "fragment:custom-xml-1",
+      payloadKind: "xml-subtree",
+      payloadReference: "<w:customXml><w:r/></w:customXml>",
+      featureClass: "preserve-only" as const,
+      lastKnownRange: { from: 12, to: 13 },
+      warningId: "warning:custom-xml-1",
+      packagePartName: "/word/document.xml",
+      relationshipId: "rId55",
+    },
+  },
+  packageParts: {
+    "/customXml/item1.xml": {
+      packagePartName: "/customXml/item1.xml",
+      contentType: "application/xml",
+      relationshipIds: ["rId55"],
+    },
+    "/word/header1.xml": {
+      packagePartName: "/word/header1.xml",
+      contentType:
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml",
+      relationshipIds: ["rId12", "rId13"],
+    },
+  },
+};
+
+test("opaque fragment store exposes locked fragments with explicit deletion intent", () => {
+  const fragments = listLockedOpaqueFragments(preservationStore);
+  assert.equal(fragments.length, 2);
+  assert.deepEqual(
+    fragments.map((fragment) => fragment.fragmentId),
+    ["fragment:section-1", "fragment:custom-xml-1"],
+  );
+
+  const fragment = getLockedOpaqueFragment(
+    preservationStore,
+    "fragment:custom-xml-1",
+  );
+  assert.equal(fragment?.label, "Custom XML wrapper");
+  assert.match(fragment?.detail ?? "", /word\/document\.xml/);
+
+  const deletionIntent = createOpaqueFragmentDeletionIntent(
+    preservationStore,
+    "fragment:custom-xml-1",
+  );
+  assert.equal(deletionIntent?.destructive, true);
+  assert.equal(deletionIntent?.confirmationLabel, "Delete preserved content");
+  assert.match(
+    deletionIntent?.confirmationDetail ?? "",
+    /atomic region/i,
+  );
+});
+
+test("opaque fragment range queries stay whole-unit and tolerate missing fragments", () => {
+  const intersecting = listLockedOpaqueFragmentsIntersectingRange(
+    preservationStore,
+    { from: 3, to: 6 },
+  );
+  assert.deepEqual(
+    intersecting.map((fragment) => fragment.fragmentId),
+    ["fragment:section-1"],
+  );
+  assert.equal(
+    createOpaqueFragmentDeletionIntent(
+      preservationStore,
+      "fragment:missing",
+    ),
+    undefined,
+  );
+});
+
+test("preserved part manifest exposes stable entries and relationship coverage", () => {
+  const entries = listPreservedPartManifestEntries(preservationStore);
+  assert.deepEqual(
+    entries.map((entry) => entry.packagePartName),
+    ["/customXml/item1.xml", "/word/header1.xml"],
+  );
+  assert.match(entries[1]?.detail ?? "", /2 preserved relationships/i);
+
+  const part = getPreservedPartManifestEntry(
+    preservationStore,
+    "/customXml/item1.xml",
+  );
+  assert.equal(part?.relationshipIds[0], "rId55");
+  assert.match(part?.label ?? "", /Preserved package part/);
+
+  const related = findPreservedPartsReferencingRelationship(
+    preservationStore,
+    "rId55",
+  );
+  assert.deepEqual(
+    related.map((entry) => entry.packagePartName),
+    ["/customXml/item1.xml"],
+  );
+});