@beyondwork/docx-react-component 1.0.0 → 1.0.2

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

@@ -1,286 +0,0 @@
-/**
- * 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

@@ -1,336 +0,0 @@
-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);
-});