@beyondwork/docx-react-component 1.0.0 → 1.0.2

package/test/runtime/table-schema.test.ts

@@ -1,221 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { Fragment, Schema } from "prosemirror-model";
-import {
-  getTableNodeSpecs,
-  tableCellNodeSpec,
-  tableHeaderCellNodeSpec,
-  tableNodeSpec,
-  tableRowNodeSpec,
-} from "../../src/runtime/table-schema.ts";
-
-// ---------------------------------------------------------------------------
-// Test schema built from the table specs
-// ---------------------------------------------------------------------------
-
-function buildTestSchema(): Schema {
-  return new Schema({
-    nodes: {
-      doc: { content: "block+" },
-      paragraph: {
-        content: "text*",
-        group: "block",
-        toDOM() {
-          return ["p", 0];
-        },
-      },
-      text: { group: "inline" },
-      ...getTableNodeSpecs(),
-    },
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Spec shape tests
-// ---------------------------------------------------------------------------
-
-test("getTableNodeSpecs returns all four node specs", () => {
-  const specs = getTableNodeSpecs();
-  assert.ok("table" in specs, "has table");
-  assert.ok("table_row" in specs, "has table_row");
-  assert.ok("table_cell" in specs, "has table_cell");
-  assert.ok("table_header_cell" in specs, "has table_header_cell");
-  assert.equal(Object.keys(specs).length, 4);
-});
-
-test("tableNodeSpec has correct tableRole, group, and content", () => {
-  const spec = tableNodeSpec as Record<string, unknown>;
-  assert.equal(spec.tableRole, "table");
-  assert.equal(spec.group, "block");
-  assert.equal(spec.content, "table_row+");
-  assert.equal(spec.isolating, true);
-});
-
-test("tableRowNodeSpec has correct tableRole and content", () => {
-  const spec = tableRowNodeSpec as Record<string, unknown>;
-  assert.equal(spec.tableRole, "row");
-  assert.equal(spec.content, "(table_cell | table_header_cell)+");
-});
-
-test("tableCellNodeSpec has correct tableRole, content, and attrs", () => {
-  const spec = tableCellNodeSpec as Record<string, unknown>;
-  assert.equal(spec.tableRole, "cell");
-  assert.equal(spec.content, "paragraph+");
-  assert.equal(spec.isolating, true);
-
-  const attrs = spec.attrs as Record<string, { default: unknown }>;
-  assert.ok("colspan" in attrs, "has colspan attr");
-  assert.ok("rowspan" in attrs, "has rowspan attr");
-  assert.ok("gridSpan" in attrs, "has gridSpan attr");
-  assert.ok("verticalMerge" in attrs, "has verticalMerge attr");
-  assert.equal(attrs.colspan?.default, 1);
-  assert.equal(attrs.rowspan?.default, 1);
-});
-
-test("tableHeaderCellNodeSpec has correct tableRole and attrs", () => {
-  const spec = tableHeaderCellNodeSpec as Record<string, unknown>;
-  assert.equal(spec.tableRole, "header_cell");
-  assert.equal(spec.content, "paragraph+");
-  assert.equal(spec.isolating, true);
-
-  const attrs = spec.attrs as Record<string, { default: unknown }>;
-  assert.ok("colspan" in attrs, "has colspan attr");
-  assert.ok("rowspan" in attrs, "has rowspan attr");
-  assert.equal(attrs.colspan?.default, 1);
-  assert.equal(attrs.rowspan?.default, 1);
-});
-
-// ---------------------------------------------------------------------------
-// Schema creation tests
-// ---------------------------------------------------------------------------
-
-test("Schema can be built with the table node specs", () => {
-  // Should not throw
-  const schema = buildTestSchema();
-  assert.ok(schema.nodes.table, "schema has table node type");
-  assert.ok(schema.nodes.table_row, "schema has table_row node type");
-  assert.ok(schema.nodes.table_cell, "schema has table_cell node type");
-  assert.ok(schema.nodes.table_header_cell, "schema has table_header_cell node type");
-});
-
-test("table node type has correct tableRole spec", () => {
-  const schema = buildTestSchema();
-  const spec = schema.nodes.table.spec as Record<string, unknown>;
-  assert.equal(spec.tableRole, "table");
-});
-
-test("table_cell node type has correct tableRole spec", () => {
-  const schema = buildTestSchema();
-  const spec = schema.nodes.table_cell.spec as Record<string, unknown>;
-  assert.equal(spec.tableRole, "cell");
-});
-
-test("table_header_cell node type has correct tableRole spec", () => {
-  const schema = buildTestSchema();
-  const spec = schema.nodes.table_header_cell.spec as Record<string, unknown>;
-  assert.equal(spec.tableRole, "header_cell");
-});
-
-// ---------------------------------------------------------------------------
-// Node creation tests
-// ---------------------------------------------------------------------------
-
-test("can create a table_cell node with default attrs", () => {
-  const schema = buildTestSchema();
-  const para = schema.nodes.paragraph.create();
-  const cell = schema.nodes.table_cell.create(null, Fragment.from(para));
-
-  assert.equal(cell.type.name, "table_cell");
-  assert.equal(cell.attrs.colspan, 1);
-  assert.equal(cell.attrs.rowspan, 1);
-  assert.equal(cell.attrs.gridSpan, 1);
-  assert.equal(cell.attrs.verticalMerge, null);
-  assert.equal(cell.childCount, 1);
-});
-
-test("can create a table_cell with colspan and rowspan", () => {
-  const schema = buildTestSchema();
-  const para = schema.nodes.paragraph.create();
-  const cell = schema.nodes.table_cell.create(
-    { colspan: 3, rowspan: 2 },
-    Fragment.from(para),
-  );
-
-  assert.equal(cell.attrs.colspan, 3);
-  assert.equal(cell.attrs.rowspan, 2);
-});
-
-test("can create a table_header_cell node", () => {
-  const schema = buildTestSchema();
-  const para = schema.nodes.paragraph.create();
-  const cell = schema.nodes.table_header_cell.create(null, Fragment.from(para));
-
-  assert.equal(cell.type.name, "table_header_cell");
-  assert.equal(cell.attrs.colspan, 1);
-  assert.equal(cell.attrs.rowspan, 1);
-});
-
-test("can create a table_row with both cell types", () => {
-  const schema = buildTestSchema();
-  const para = schema.nodes.paragraph.create();
-  const headerCell = schema.nodes.table_header_cell.create(null, Fragment.from(para));
-  const dataCell = schema.nodes.table_cell.create(null, Fragment.from(para));
-
-  const row = schema.nodes.table_row.create(
-    null,
-    Fragment.from([headerCell, dataCell]),
-  );
-
-  assert.equal(row.type.name, "table_row");
-  assert.equal(row.childCount, 2);
-  assert.equal(row.child(0).type.name, "table_header_cell");
-  assert.equal(row.child(1).type.name, "table_cell");
-});
-
-test("can create a complete table structure with 2 rows and 2 cells per row", () => {
-  const schema = buildTestSchema();
-
-  const makeCell = () =>
-    schema.nodes.table_cell.create(
-      null,
-      Fragment.from(schema.nodes.paragraph.create()),
-    );
-  const makeRow = () =>
-    schema.nodes.table_row.create(null, Fragment.from([makeCell(), makeCell()]));
-
-  const table = schema.nodes.table.create(
-    null,
-    Fragment.from([makeRow(), makeRow()]),
-  );
-
-  assert.equal(table.type.name, "table");
-  assert.equal(table.childCount, 2, "has 2 rows");
-  assert.equal(table.child(0).childCount, 2, "row 0 has 2 cells");
-  assert.equal(table.child(1).childCount, 2, "row 1 has 2 cells");
-});
-
-test("table node has expected nodeSize for a 1x1 table with empty paragraph", () => {
-  const schema = buildTestSchema();
-  const para = schema.nodes.paragraph.create();
-  const cell = schema.nodes.table_cell.create(null, Fragment.from(para));
-  const row = schema.nodes.table_row.create(null, Fragment.from(cell));
-  const table = schema.nodes.table.create(null, Fragment.from(row));
-
-  // para: 2, cell: 4, row: 6, table: 8
-  assert.equal(para.nodeSize, 2, "empty para nodeSize = 2");
-  assert.equal(cell.nodeSize, 4, "cell nodeSize = 4");
-  assert.equal(row.nodeSize, 6, "row nodeSize = 6");
-  assert.equal(table.nodeSize, 8, "table nodeSize = 8");
-});
-
-test("table_cell with verticalMerge attr set to restart", () => {
-  const schema = buildTestSchema();
-  const para = schema.nodes.paragraph.create();
-  const cell = schema.nodes.table_cell.create(
-    { verticalMerge: "restart", gridSpan: 2 },
-    Fragment.from(para),
-  );
-  assert.equal(cell.attrs.verticalMerge, "restart");
-  assert.equal(cell.attrs.gridSpan, 2);
-});

package/test/runtime/tracked-changes-toggle.test.ts

@@ -1,107 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import {
-  createRevisionDecorationModel,
-  getRevisionHighlightClass,
-  getRevisionRangeState,
-  shouldHideInCleanMode,
-} from "../../src/ui/headless/revision-decoration-model";
-import type { TrackedChangesSnapshot } from "../../src/api/public-types";
-
-function createTrackedChangesWithDeletion(): TrackedChangesSnapshot {
-  return {
-    pendingChangeIds: ["rev-del-1"],
-    acceptedChangeIds: [],
-    rejectedChangeIds: [],
-    detachedChangeIds: [],
-    actionableChangeIds: ["rev-del-1"],
-    preserveOnlyChangeIds: [],
-    totalCount: 1,
-    revisions: [
-      {
-        revisionId: "rev-del-1",
-        kind: "deletion",
-        label: "Delete Beta",
-        status: "active",
-        actionability: "actionable",
-        anchor: { kind: "range", from: 5, to: 9, assoc: { start: -1, end: 1 } },
-        anchorLabel: "Range 5-9",
-        createdAt: "2026-01-01T00:00:00.000Z",
-        authorId: "author-1",
-        warningCount: 0,
-        canAccept: true,
-        canReject: true,
-      },
-    ],
-  };
-}
-
-test("showTrackedChanges=false suppresses visual styling but model always exists", () => {
-  // The revision model is ALWAYS created. When showTrackedChanges is false,
-  // the PM decoration builder skips visual styling but still hides deletions.
-  // This test verifies that the headless model still works correctly even
-  // when the UI toggle is off.
-  const trackedChanges = createTrackedChangesWithDeletion();
-  const model = createRevisionDecorationModel(trackedChanges);
-  assert.ok(model);
-
-  // Model detects changes
-  const state = getRevisionRangeState(model, 5, 9);
-  assert.equal(state.hasChanges, true);
-  assert.equal(state.hasDeletions, true);
-
-  // shouldHideInCleanMode works regardless of toggle
-  const shouldHide = shouldHideInCleanMode(model, 5, 9);
-  assert.equal(shouldHide, true);
-});
-
-test("showTrackedChanges=true produces decoration model with active revision highlights", () => {
-  const trackedChanges = createTrackedChangesWithDeletion();
-  const model = createRevisionDecorationModel(trackedChanges);
-  assert.ok(model);
-
-  const state = getRevisionRangeState(model, 5, 9);
-  assert.equal(state.hasChanges, true);
-  assert.equal(state.hasDeletions, true);
-  assert.equal(state.count, 1);
-
-  // In "all" mode, deletion gets colored styling
-  const allClass = getRevisionHighlightClass(model, 5, 9, "all");
-  assert.match(allClass, /text-danger/);
-  assert.match(allClass, /line-through/);
-
-  // In "simple" mode, deletion gets subtle styling
-  const simpleClass = getRevisionHighlightClass(model, 5, 9, "simple");
-  assert.match(simpleClass, /line-through/);
-
-  // In "clean" mode, no decoration but deletion should be hidden
-  const cleanClass = getRevisionHighlightClass(model, 5, 9, "clean");
-  assert.equal(cleanClass, "");
-
-  const shouldHide = shouldHideInCleanMode(model, 5, 9);
-  assert.equal(shouldHide, true);
-});
-
-test("clean mode always hides deletions regardless of showTrackedChanges toggle", () => {
-  // The revision model is ALWAYS created (needed for deletion hiding).
-  // The showTrackedChanges toggle only controls whether visual styling
-  // (underlines, colored text) is applied — it never controls whether
-  // deletions are hidden in clean mode.
-  //
-  // This is critical for legal review: "hide tracked changes" must show
-  // the document as final text, not show deleted content as if it's kept.
-
-  const trackedChanges = createTrackedChangesWithDeletion();
-  const model = createRevisionDecorationModel(trackedChanges);
-
-  // Model always exists, deletions always detected
-  assert.ok(model);
-  assert.equal(shouldHideInCleanMode(model, 5, 9), true);
-
-  // Even if the UI toggle is "off", the model still exists and
-  // shouldHideInCleanMode still returns true. The PM surface uses
-  // the showTrackedChanges flag only to suppress visual styling,
-  // not to suppress the model itself.
-  assert.equal(shouldHideInCleanMode(model, 5, 9), true);
-});

package/test/ui/comment-review-surface.test.tsx

@@ -1,114 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import type { CommentSidebarSnapshot } from "../../src/api/public-types";
-import {
-  createCommentDecorationModel,
-  getCommentRangeState,
-  getCommentHighlightClass,
-} from "../../src/ui/headless/comment-decoration-model";
-
-function createSnapshot(): CommentSidebarSnapshot {
-  return {
-    activeCommentId: "comment-open",
-    openCommentIds: ["comment-open"],
-    resolvedCommentIds: ["comment-resolved"],
-    detachedCommentIds: ["comment-detached"],
-    totalCount: 3,
-    threads: [
-      {
-        commentId: "comment-open",
-        status: "open",
-        anchor: { kind: "range", from: 4, to: 12, assoc: { start: -1, end: 1 } },
-        excerpt: "Check the defined term capitalization in this clause.",
-        entryCount: 1,
-        entries: [
-          { entryId: "comment-open-entry-1", authorId: "Taylor Shaw", body: "Check the defined term capitalization in this clause.", createdAt: "2026-03-26T00:00:00.000Z" },
-        ],
-        createdAt: "2026-03-26T00:00:00.000Z",
-        createdBy: "Taylor Shaw",
-        warningCount: 0,
-        anchorLabel: "Range 4-12",
-        isActive: true,
-      },
-      {
-        commentId: "comment-resolved",
-        status: "resolved",
-        anchor: { kind: "range", from: 18, to: 24, assoc: { start: -1, end: 1 } },
-        excerpt: "This phrasing was approved in the last pass.",
-        entryCount: 1,
-        entries: [
-          { entryId: "comment-resolved-entry-1", authorId: "Dana Cross", body: "This phrasing was approved in the last pass.", createdAt: "2026-03-26T00:01:00.000Z" },
-        ],
-        createdAt: "2026-03-26T00:01:00.000Z",
-        createdBy: "Dana Cross",
-        warningCount: 0,
-        anchorLabel: "Range 18-24",
-        isActive: false,
-        resolvedAt: "2026-03-26T00:02:00.000Z",
-        resolvedBy: "Dana Cross",
-      },
-      {
-        commentId: "comment-detached",
-        status: "detached",
-        anchor: { kind: "detached", lastKnownRange: { from: 30, to: 33 }, reason: "deleted" },
-        excerpt: "Anchor detached after deletion.",
-        entryCount: 1,
-        entries: [
-          { entryId: "comment-detached-entry-1", authorId: "Morgan Lee", body: "Anchor detached after deletion.", createdAt: "2026-03-26T00:03:00.000Z" },
-        ],
-        createdAt: "2026-03-26T00:03:00.000Z",
-        createdBy: "Morgan Lee",
-        warningCount: 1,
-        anchorLabel: "Detached 30-33",
-        isActive: false,
-      },
-    ],
-  };
-}
-
-test("comment decoration model filters detached anchors and maps range positions", () => {
-  const model = createCommentDecorationModel(createSnapshot());
-  assert.ok(model);
-  assert.equal(model.threads.length, 2);
-  assert.equal(model.threads[0].commentId, "comment-open");
-  assert.equal(model.threads[0].from, 4);
-  assert.equal(model.threads[0].to, 12);
-  assert.equal(model.threads[1].commentId, "comment-resolved");
-});
-
-test("comment range state detects active and resolved anchors at correct positions", () => {
-  const model = createCommentDecorationModel(createSnapshot());
-  const activeState = getCommentRangeState(model, 5, 6);
-  const resolvedState = getCommentRangeState(model, 19, 20);
-  const noneState = getCommentRangeState(model, 40, 41);
-
-  assert.ok(activeState.hasComments);
-  assert.ok(activeState.hasActive);
-  assert.ok(activeState.hasOpen);
-  assert.equal(activeState.count, 1);
-
-  assert.ok(resolvedState.hasComments);
-  assert.ok(resolvedState.hasResolved);
-  assert.ok(!resolvedState.hasActive);
-
-  assert.ok(!noneState.hasComments);
-  assert.equal(noneState.count, 0);
-});
-
-test("comment highlight class varies by markup display mode", () => {
-  const model = createCommentDecorationModel(createSnapshot());
-
-  const cleanActive = getCommentHighlightClass(model, 5, 6, "clean");
-  assert.match(cleanActive, /bg-comment-soft/);
-
-  const simpleActive = getCommentHighlightClass(model, 5, 6, "simple");
-  assert.match(simpleActive, /underline/);
-  assert.match(simpleActive, /decoration-comment/);
-
-  const allActive = getCommentHighlightClass(model, 5, 6, "all");
-  assert.match(allActive, /bg-comment-strong/);
-
-  const noneClass = getCommentHighlightClass(model, 40, 41, "all");
-  assert.equal(noneClass, "");
-});

package/test/ui/reduced-motion-toggle.test.tsx

@@ -1,137 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import React from "react";
-import { act } from "react";
-import { createRoot } from "react-dom/client";
-import { JSDOM } from "jsdom";
-
-import { ReducedMotionToggle } from "../../services/react-word-editor/components/reduced-motion-toggle";
-
-const REDUCED_MOTION_STORAGE_KEY = "docx-react-review-workspace-reduced-motion";
-
-test("reduced-motion toggle honors persisted preference and updates document state", async () => {
-  const dom = installDom(false);
-  const host = dom.window.document.getElementById("root");
-  assert.ok(host);
-  const root = createRoot(host);
-
-  dom.window.localStorage.setItem(REDUCED_MOTION_STORAGE_KEY, "true");
-
-  await act(async () => {
-    root.render(<ReducedMotionToggle />);
-  });
-  await flushEffects();
-
-  let button = host.querySelector("button");
-  assert.ok(button instanceof dom.window.HTMLButtonElement);
-  assert.equal(button.getAttribute("aria-pressed"), "true");
-  assert.equal(dom.window.document.documentElement.dataset.reducedMotion, "true");
-
-  await act(async () => {
-    button.dispatchEvent(
-      new dom.window.MouseEvent("click", {
-        bubbles: true,
-        cancelable: true,
-      }),
-    );
-  });
-  await flushEffects();
-
-  button = host.querySelector("button");
-  assert.ok(button instanceof dom.window.HTMLButtonElement);
-  assert.equal(button.getAttribute("aria-pressed"), "false");
-  assert.equal(
-    dom.window.localStorage.getItem(REDUCED_MOTION_STORAGE_KEY),
-    "false",
-  );
-  assert.equal(dom.window.document.documentElement.dataset.reducedMotion, "false");
-
-  await act(async () => {
-    root.unmount();
-  });
-  restoreDom(dom);
-});
-
-test("reduced-motion toggle falls back to prefers-reduced-motion when no override exists", async () => {
-  const dom = installDom(true);
-  const host = dom.window.document.getElementById("root");
-  assert.ok(host);
-  const root = createRoot(host);
-
-  await act(async () => {
-    root.render(<ReducedMotionToggle />);
-  });
-  await flushEffects();
-
-  const button = host.querySelector("button");
-  assert.ok(button instanceof dom.window.HTMLButtonElement);
-  assert.equal(button.getAttribute("aria-pressed"), "true");
-  assert.equal(dom.window.document.documentElement.dataset.reducedMotion, "true");
-
-  await act(async () => {
-    root.unmount();
-  });
-  restoreDom(dom);
-});
-
-function installDom(prefersReducedMotion: boolean): JSDOM {
-  const dom = new JSDOM(
-    "<!doctype html><html><body><div id=\"root\"></div></body></html>",
-    {
-      pretendToBeVisual: true,
-      url: "http://localhost",
-    },
-  );
-
-  Object.defineProperty(dom.window, "matchMedia", {
-    configurable: true,
-    value: () => ({
-      matches: prefersReducedMotion,
-      media: "(prefers-reduced-motion: reduce)",
-      onchange: null,
-      addEventListener: () => undefined,
-      removeEventListener: () => undefined,
-      addListener: () => undefined,
-      removeListener: () => undefined,
-      dispatchEvent: () => false,
-    }),
-  });
-
-  defineDomGlobal("window", dom.window);
-  defineDomGlobal("document", dom.window.document);
-  defineDomGlobal("navigator", dom.window.navigator);
-  defineDomGlobal("HTMLElement", dom.window.HTMLElement);
-  defineDomGlobal("HTMLButtonElement", dom.window.HTMLButtonElement);
-  defineDomGlobal("MouseEvent", dom.window.MouseEvent);
-  defineDomGlobal("localStorage", dom.window.localStorage);
-  defineDomGlobal("IS_REACT_ACT_ENVIRONMENT", true);
-
-  return dom;
-}
-
-function restoreDom(dom: JSDOM): void {
-  dom.window.close();
-  delete (globalThis as Record<string, unknown>).window;
-  delete (globalThis as Record<string, unknown>).document;
-  delete (globalThis as Record<string, unknown>).navigator;
-  delete (globalThis as Record<string, unknown>).HTMLElement;
-  delete (globalThis as Record<string, unknown>).HTMLButtonElement;
-  delete (globalThis as Record<string, unknown>).MouseEvent;
-  delete (globalThis as Record<string, unknown>).localStorage;
-  delete (globalThis as Record<string, unknown>).IS_REACT_ACT_ENVIRONMENT;
-}
-
-async function flushEffects(): Promise<void> {
-  await act(async () => {
-    await Promise.resolve();
-    await Promise.resolve();
-  });
-}
-
-function defineDomGlobal(name: string, value: unknown): void {
-  Object.defineProperty(globalThis, name, {
-    configurable: true,
-    writable: true,
-    value,
-  });
-}