@beyondwork/docx-react-component 1.0.0

package/test/ui-tailwind/search-plugin.test.ts

@@ -0,0 +1,286 @@
+/**
+ * Tests for search-plugin.ts
+ *
+ * Verifies:
+ * - performSearch returns correct from/to positions for literal matches
+ * - Case-sensitivity option
+ * - Regex option (valid and invalid patterns)
+ * - Multiple matches in a single text node
+ * - Matches spanning across multiple text nodes
+ * - createSearchPlugin initializes with empty state
+ * - Plugin state is updated by setMeta dispatch
+ * - clearSearch resets plugin state
+ *
+ * These tests operate on pure ProseMirror state (no DOM/EditorView needed).
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { EditorState } from "prosemirror-state";
+import { editorSchema } from "../../src/ui-tailwind/editor-surface/pm-schema.ts";
+import {
+  createSearchPlugin,
+  performSearch,
+  clearSearch,
+  searchPluginKey,
+  type SearchResult,
+} from "../../src/ui-tailwind/editor-surface/search-plugin.ts";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Build an EditorState with a single paragraph containing `text`.
+ * The search plugin is always included.
+ */
+function stateWithText(text: string): EditorState {
+  const paragraph = editorSchema.nodes.paragraph.create(null, editorSchema.text(text));
+  const doc = editorSchema.nodes.doc.create(null, [paragraph]);
+  return EditorState.create({ doc, schema: editorSchema, plugins: [createSearchPlugin()] });
+}
+
+/**
+ * Build an EditorState with multiple paragraphs.
+ */
+function stateWithParagraphs(texts: string[]): EditorState {
+  const paragraphs = texts.map((t) =>
+    t.length > 0
+      ? editorSchema.nodes.paragraph.create(null, editorSchema.text(t))
+      : editorSchema.nodes.paragraph.create(),
+  );
+  const doc = editorSchema.nodes.doc.create(null, paragraphs);
+  return EditorState.create({ doc, schema: editorSchema, plugins: [createSearchPlugin()] });
+}
+
+/**
+ * Dispatch search results into the plugin and return the next state.
+ */
+function applySearchResults(
+  state: EditorState,
+  results: SearchResult[],
+  highlightColor: string,
+): EditorState {
+  const tr = state.tr.setMeta(searchPluginKey, { results, highlightColor });
+  return state.apply(tr);
+}
+
+// ---------------------------------------------------------------------------
+// performSearch — literal matches
+// ---------------------------------------------------------------------------
+
+test("performSearch returns empty array for empty query", () => {
+  const state = stateWithText("Hello World");
+  const results = performSearch(state, "");
+  assert.deepEqual(results, []);
+});
+
+test("performSearch finds a single literal match at the correct position", () => {
+  const state = stateWithText("Hello World");
+  const results = performSearch(state, "World");
+
+  assert.equal(results.length, 1);
+  assert.equal(results[0]?.text, "World");
+  // paragraph opens at pos 0 with token 1, text starts at pos 1
+  assert.ok(results[0]!.from >= 1, "match starts inside the paragraph");
+  assert.equal(results[0]!.to - results[0]!.from, 5, "match length equals query length");
+});
+
+test("performSearch returns all occurrences of a repeated pattern", () => {
+  const state = stateWithText("abc abc abc");
+  const results = performSearch(state, "abc");
+  assert.equal(results.length, 3, "should find 3 occurrences");
+  // Indices should be sequential
+  assert.equal(results[0]?.index, 0);
+  assert.equal(results[1]?.index, 1);
+  assert.equal(results[2]?.index, 2);
+});
+
+test("performSearch positions do not overlap for adjacent matches", () => {
+  const state = stateWithText("aaa");
+  const results = performSearch(state, "a");
+  assert.equal(results.length, 3);
+  assert.equal(results[0]!.to, results[1]!.from, "first match ends where second begins");
+  assert.equal(results[1]!.to, results[2]!.from, "second match ends where third begins");
+});
+
+test("performSearch returns nothing when query is not in the document", () => {
+  const state = stateWithText("Hello World");
+  const results = performSearch(state, "xyz");
+  assert.equal(results.length, 0);
+});
+
+// ---------------------------------------------------------------------------
+// Case sensitivity
+// ---------------------------------------------------------------------------
+
+test("performSearch is case-insensitive by default", () => {
+  const state = stateWithText("Hello HELLO hello");
+  const results = performSearch(state, "hello");
+  assert.equal(results.length, 3, "should match all three case variants");
+});
+
+test("performSearch respects caseSensitive option", () => {
+  const state = stateWithText("Hello HELLO hello");
+  const results = performSearch(state, "hello", { caseSensitive: true });
+  assert.equal(results.length, 1, "only the lowercase 'hello' should match");
+  assert.equal(results[0]?.text, "hello");
+});
+
+test("performSearch caseSensitive=false matches mixed-case query", () => {
+  const state = stateWithText("The Quick Brown Fox");
+  const results = performSearch(state, "quick", { caseSensitive: false });
+  assert.equal(results.length, 1);
+  assert.equal(results[0]?.text, "Quick");
+});
+
+// ---------------------------------------------------------------------------
+// Regex option
+// ---------------------------------------------------------------------------
+
+test("performSearch supports regex patterns", () => {
+  const state = stateWithText("cat bat mat sat");
+  const results = performSearch(state, "[cbm]at", { regex: true });
+  assert.equal(results.length, 3, "should match cat, bat, mat but not sat");
+  const texts = results.map((r) => r.text);
+  assert.ok(texts.includes("cat"));
+  assert.ok(texts.includes("bat"));
+  assert.ok(texts.includes("mat"));
+  assert.ok(!texts.includes("sat"));
+});
+
+test("performSearch with regex respects caseSensitive option", () => {
+  const state = stateWithText("Apple apple APPLE");
+  const results = performSearch(state, "apple", { regex: true, caseSensitive: true });
+  assert.equal(results.length, 1);
+  assert.equal(results[0]?.text, "apple");
+});
+
+test("performSearch returns empty array for an invalid regex pattern", () => {
+  const state = stateWithText("some text");
+  // Intentionally invalid regex
+  const results = performSearch(state, "[invalid", { regex: true });
+  assert.deepEqual(results, []);
+});
+
+test("performSearch escapes special regex characters in literal mode", () => {
+  const state = stateWithText("cost is $10.00");
+  // Without escaping, $ and . would be regex metacharacters
+  const results = performSearch(state, "$10.00", { regex: false });
+  assert.equal(results.length, 1);
+  assert.equal(results[0]?.text, "$10.00");
+});
+
+// ---------------------------------------------------------------------------
+// Multi-paragraph search
+// ---------------------------------------------------------------------------
+
+test("performSearch finds matches across multiple paragraphs", () => {
+  const state = stateWithParagraphs(["First paragraph", "Second paragraph", "Third paragraph"]);
+  const results = performSearch(state, "paragraph");
+  assert.equal(results.length, 3, "should find 'paragraph' in each of the three paragraphs");
+});
+
+test("performSearch returns matches in document order", () => {
+  const state = stateWithParagraphs(["Zebra", "Apple", "Mango"]);
+  const results = performSearch(state, "a", { caseSensitive: false });
+  // Positions should be in ascending order
+  for (let i = 1; i < results.length; i++) {
+    assert.ok(results[i]!.from > results[i - 1]!.from, "results must be in ascending position order");
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Plugin state management
+// ---------------------------------------------------------------------------
+
+test("createSearchPlugin initializes with empty results and no highlight color", () => {
+  const state = stateWithText("Hello");
+  const pluginState = searchPluginKey.getState(state);
+  assert.ok(pluginState, "plugin state must be present");
+  assert.deepEqual(pluginState!.results, []);
+  assert.equal(pluginState!.highlightColor, null);
+});
+
+test("plugin state updates when search results are dispatched via setMeta", () => {
+  const state = stateWithText("Hello World");
+  const results = performSearch(state, "Hello");
+  const nextState = applySearchResults(state, results, "#ffff00");
+
+  const pluginState = searchPluginKey.getState(nextState);
+  assert.ok(pluginState, "plugin state must be present after dispatch");
+  assert.equal(pluginState!.results.length, 1);
+  assert.equal(pluginState!.highlightColor, "#ffff00");
+  assert.equal(pluginState!.results[0]?.text, "Hello");
+});
+
+test("plugin state preserves across non-meta transactions", () => {
+  const state = stateWithText("Hello World");
+  const results = performSearch(state, "World");
+  const withResults = applySearchResults(state, results, "yellow");
+
+  // Apply a non-meta transaction (selection change)
+  const nonMetaTr = withResults.tr; // no doc change, no meta
+  const afterNonMeta = withResults.apply(nonMetaTr);
+
+  const pluginState = searchPluginKey.getState(afterNonMeta);
+  assert.equal(pluginState!.results.length, 1, "results should be preserved");
+  assert.equal(pluginState!.highlightColor, "yellow", "highlight color should be preserved");
+});
+
+// ---------------------------------------------------------------------------
+// clearSearch
+// ---------------------------------------------------------------------------
+
+test("clearSearch dispatches a transaction that resets plugin state", () => {
+  const state = stateWithText("Hello World");
+  const results = performSearch(state, "Hello");
+  const withResults = applySearchResults(state, results, "#ff0000");
+
+  // Verify results are present
+  assert.equal(searchPluginKey.getState(withResults)!.results.length, 1);
+
+  // Apply clearSearch
+  let cleared: EditorState | undefined;
+  const dispatched = clearSearch(withResults, (tr) => {
+    cleared = withResults.apply(tr);
+  });
+
+  assert.ok(dispatched, "clearSearch should return true");
+  assert.ok(cleared, "dispatch should have been called");
+  const clearedState = searchPluginKey.getState(cleared!);
+  assert.deepEqual(clearedState!.results, [], "results should be empty after clear");
+  assert.equal(clearedState!.highlightColor, null, "highlightColor should be null after clear");
+});
+
+test("clearSearch returns true without dispatching when dispatch is omitted", () => {
+  const state = stateWithText("Hello");
+  const result = clearSearch(state);
+  assert.ok(result, "clearSearch should return true even without dispatch");
+});
+
+test("clearSearch is idempotent on already-empty state", () => {
+  const state = stateWithText("Nothing to clear");
+
+  let cleared: EditorState | undefined;
+  clearSearch(state, (tr) => {
+    cleared = state.apply(tr);
+  });
+
+  const pluginState = searchPluginKey.getState(cleared!);
+  assert.deepEqual(pluginState!.results, []);
+  assert.equal(pluginState!.highlightColor, null);
+});
+
+// ---------------------------------------------------------------------------
+// SearchResult index field
+// ---------------------------------------------------------------------------
+
+test("each SearchResult has a sequential zero-based index", () => {
+  const state = stateWithText("a b c a b c");
+  const results = performSearch(state, "a");
+  results.forEach((r, i) => {
+    assert.equal(r.index, i, `result at position ${i} should have index ${i}`);
+  });
+});

package/test/validation/compatibility-engine.test.ts

@@ -0,0 +1,336 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { buildCompatibilityReport } from "../../src/validation/compatibility-engine.ts";
+
+test("compatibility engine derives supported and preserve-only features from runtime state", () => {
+  const report = buildCompatibilityReport({
+    generatedAt: "2026-03-26T12:00:00.000Z",
+    document: {
+      schemaVersion: "cds/1.0.0",
+      docId: "doc-compat-1",
+      createdAt: "2026-03-26T12:00:00.000Z",
+      updatedAt: "2026-03-26T12:00:00.000Z",
+      metadata: {},
+      styles: {},
+      numbering: {},
+      media: {
+        items: {},
+      },
+      content: {
+        type: "doc",
+        children: [
+          {
+            type: "paragraph",
+            styleId: "Heading1",
+            children: [
+              { type: "text", text: "Title" },
+              { type: "tab" },
+              {
+                type: "hyperlink",
+                href: "https://example.com",
+                children: [{ type: "text", text: "Link" }],
+              },
+            ],
+          },
+          {
+            type: "opaque_block",
+            fragmentId: "fragment:section-1",
+            warningId: "warning:section-1",
+          },
+        ],
+      },
+      review: {
+        comments: {
+          "comment-1": {
+            commentId: "comment-1",
+            body: "Check defined term",
+            anchor: {
+              kind: "range",
+              range: { from: 0, to: 5 },
+              assoc: { start: -1, end: 1 },
+            },
+            createdAt: "2026-03-26T12:00:00.000Z",
+            status: "open",
+            warningIds: [],
+            isResolved: false,
+          },
+        },
+        revisions: {},
+      },
+      preservation: {
+        opaqueFragments: {
+          "fragment:section-1": {
+            fragmentId: "fragment:section-1",
+            payloadKind: "xml-subtree",
+            payloadReference: "<w:sectPr/>",
+            featureClass: "preserve-only",
+            lastKnownRange: { from: 10, to: 11 },
+            warningId: "warning:section-1",
+          },
+        },
+        packageParts: {
+          "/custom/item1.xml": {
+            packagePartName: "/custom/item1.xml",
+            contentType: "application/xml",
+            relationshipIds: ["rId55"],
+          },
+        },
+      },
+      diagnostics: {
+        warnings: [
+          {
+            diagnosticId: "diagnostic:warning-1",
+            warningId: "warning:section-1",
+            source: "preservation",
+            message: "Section properties are preserved as a locked opaque block.",
+          },
+        ],
+        errors: [],
+      },
+    },
+    warnings: [],
+  });
+
+  assert.equal(report.blockExport, false);
+  assert.ok(report.featureEntries.some((entry) => entry.featureKey === "paragraphs"));
+  assert.ok(report.featureEntries.some((entry) => entry.featureKey === "headings"));
+  assert.ok(report.featureEntries.some((entry) => entry.featureKey === "hyperlinks"));
+  assert.ok(
+    report.featureEntries.some(
+      (entry) => entry.featureKey === "comments-single-paragraph",
+    ),
+  );
+  assert.ok(report.featureEntries.some((entry) => entry.featureKey === "sections"));
+  assert.ok(
+    report.featureEntries.some((entry) => entry.featureKey === "unknown-package-parts"),
+  );
+  assert.equal(report.warnings.length, 1);
+});
+
+test("compatibility engine blocks export when runtime or validation raises a fatal error", () => {
+  const report = buildCompatibilityReport({
+    generatedAt: "2026-03-26T12:00:00.000Z",
+    document: {
+      schemaVersion: "cds/1.0.0",
+      docId: "doc-compat-2",
+      createdAt: "2026-03-26T12:00:00.000Z",
+      updatedAt: "2026-03-26T12:00:00.000Z",
+      metadata: {},
+      styles: {},
+      numbering: {},
+      media: {},
+      content: {
+        type: "doc",
+        children: [{ type: "paragraph", children: [] }],
+      },
+      review: {
+        comments: {},
+        revisions: {},
+      },
+      preservation: {
+        opaqueFragments: {},
+        packageParts: {},
+      },
+      diagnostics: {
+        warnings: [],
+        errors: [],
+      },
+    },
+    fatalError: {
+      errorId: "error-1",
+      code: "validation_failed",
+      message: "Open XML validation failed.",
+      isFatal: true,
+      source: "validation",
+    },
+  });
+
+  assert.equal(report.blockExport, true);
+  assert.equal(report.errors.length, 1);
+});
+
+test("compatibility engine does not claim supported comments for detached preserve-only imports", () => {
+  const report = buildCompatibilityReport({
+    generatedAt: "2026-03-27T03:00:00.000Z",
+    document: {
+      schemaVersion: "cds/1.0.0",
+      docId: "doc-compat-detached-comments",
+      createdAt: "2026-03-27T03:00:00.000Z",
+      updatedAt: "2026-03-27T03:00:00.000Z",
+      metadata: {},
+      styles: {},
+      numbering: {},
+      media: { items: {} },
+      content: {
+        type: "doc",
+        children: [{ type: "paragraph", children: [{ type: "text", text: "Alpha" }] }],
+      },
+      review: {
+        comments: {
+          "comment-import-1": {
+            commentId: "comment-import-1",
+            body: "Detached imported comment.",
+            anchor: {
+              kind: "detached",
+              lastKnownRange: { from: 0, to: 5 },
+              reason: "importAmbiguity",
+            },
+            createdAt: "2026-03-27T03:00:00.000Z",
+            status: "detached",
+            warningIds: ["warning:comment-import-1"],
+            isResolved: false,
+            metadata: {
+              source: "import",
+            },
+          },
+        },
+        revisions: {},
+      },
+      preservation: {
+        opaqueFragments: {},
+        packageParts: {},
+      },
+      diagnostics: {
+        warnings: [
+          {
+            diagnosticId: "diagnostic:comment-import-1",
+            warningId: "warning:comment-import-1",
+            source: "review",
+            message: "Detached imported comment remains preserve-only.",
+          },
+        ],
+        errors: [],
+      },
+    },
+  });
+
+  assert.equal(
+    report.featureEntries.some((entry) => entry.featureKey === "comments-single-paragraph"),
+    false,
+  );
+  assert.equal(report.warnings[0]?.code, "import_normalized");
+});
+
+test("compatibility engine reports supported comments when a live thread remains alongside preserve-only imports", () => {
+  const report = buildCompatibilityReport({
+    generatedAt: "2026-03-27T04:00:00.000Z",
+    document: {
+      schemaVersion: "cds/1.0.0",
+      docId: "doc-compat-mixed-comments",
+      createdAt: "2026-03-27T04:00:00.000Z",
+      updatedAt: "2026-03-27T04:00:00.000Z",
+      metadata: {},
+      styles: {},
+      numbering: {},
+      media: { items: {} },
+      content: {
+        type: "doc",
+        children: [{ type: "paragraph", children: [{ type: "text", text: "Alpha Beta" }] }],
+      },
+      review: {
+        comments: {
+          "comment-live-1": {
+            commentId: "comment-live-1",
+            body: "Live comment.",
+            anchor: {
+              kind: "range",
+              range: { from: 0, to: 5 },
+              assoc: { start: -1, end: 1 },
+            },
+            createdAt: "2026-03-27T04:00:00.000Z",
+            status: "open",
+            warningIds: [],
+            isResolved: false,
+          },
+          "comment-import-2": {
+            commentId: "comment-import-2",
+            body: "Detached imported comment.",
+            anchor: {
+              kind: "detached",
+              lastKnownRange: { from: 6, to: 10 },
+              reason: "importAmbiguity",
+            },
+            createdAt: "2026-03-27T04:01:00.000Z",
+            status: "detached",
+            warningIds: ["warning:comment-import-2"],
+            isResolved: false,
+            metadata: {
+              source: "import",
+            },
+          },
+        },
+        revisions: {},
+      },
+      preservation: {
+        opaqueFragments: {},
+        packageParts: {},
+      },
+      diagnostics: {
+        warnings: [],
+        errors: [],
+      },
+    },
+  });
+
+  assert.equal(
+    report.featureEntries.some((entry) => entry.featureKey === "comments-single-paragraph"),
+    true,
+  );
+});
+
+test("compatibility engine reports preserved tables as preserve-only instead of supported-roundtrip", () => {
+  const report = buildCompatibilityReport({
+    generatedAt: "2026-03-27T02:00:00.000Z",
+    document: {
+      schemaVersion: "cds/1.0.0",
+      docId: "doc-compat-table",
+      createdAt: "2026-03-27T02:00:00.000Z",
+      updatedAt: "2026-03-27T02:00:00.000Z",
+      metadata: {},
+      styles: {},
+      numbering: {},
+      media: { items: {} },
+      content: {
+        type: "doc",
+        children: [
+          {
+            type: "paragraph",
+            children: [{ type: "text", text: "Lead paragraph" }],
+          },
+          {
+            type: "opaque_block",
+            fragmentId: "fragment:table-1",
+            warningId: "warning:table-1",
+          },
+        ],
+      },
+      review: {
+        comments: {},
+        revisions: {},
+      },
+      preservation: {
+        opaqueFragments: {
+          "fragment:table-1": {
+            fragmentId: "fragment:table-1",
+            payloadKind: "xml-subtree",
+            payloadReference: "<w:tbl><w:tblGrid/></w:tbl>",
+            featureClass: "preserve-only",
+            lastKnownRange: { from: 15, to: 16 },
+            warningId: "warning:table-1",
+          },
+        },
+        packageParts: {},
+      },
+      diagnostics: {
+        warnings: [],
+        errors: [],
+      },
+    },
+  });
+
+  const tableEntry = report.featureEntries.find((entry) => entry.featureKey === "tables");
+  assert.ok(tableEntry);
+  assert.equal(tableEntry?.featureClass, "preserve-only");
+  assert.equal(report.blockExport, false);
+});