@beyondwork/docx-react-component 1.0.0 → 1.0.2

package/test/runtime/session-capabilities.test.ts

@@ -1,260 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import type { RuntimeRenderSnapshot } from "../../src/api/public-types";
-import { deriveCapabilities } from "../../src/runtime/session-capabilities";
-
-function createBaseSnapshot(
-  overrides: Partial<RuntimeRenderSnapshot> = {},
-): RuntimeRenderSnapshot {
-  return {
-    documentId: "doc-1",
-    sessionId: "session-1",
-    revisionToken: "doc-1:1",
-    isReady: true,
-    isDirty: false,
-    readOnly: false,
-    selection: {
-      anchor: 0,
-      head: 0,
-      isCollapsed: true,
-      activeRange: { kind: "range", from: 0, to: 0, assoc: { start: -1, end: 1 } },
-    },
-    documentStats: { storyLength: 100, commentCount: 0, revisionCount: 0, opaqueFragmentCount: 0 },
-    comments: {
-      openCommentIds: [],
-      resolvedCommentIds: [],
-      detachedCommentIds: [],
-      totalCount: 0,
-      threads: [],
-    },
-    trackedChanges: {
-      pendingChangeIds: [],
-      acceptedChangeIds: [],
-      rejectedChangeIds: [],
-      detachedChangeIds: [],
-      actionableChangeIds: [],
-      preserveOnlyChangeIds: [],
-      totalCount: 0,
-      revisions: [],
-    },
-    compatibility: {
-      blockExport: false,
-      blockExportReasons: [],
-      warningCount: 0,
-      errorCount: 0,
-      featureEntries: [],
-    },
-    warnings: [],
-    commandState: { canUndo: false, canRedo: false, readOnly: false },
-    ...overrides,
-  };
-}
-
-test("loading snapshot produces loading phase with all capabilities disabled", () => {
-  const caps = deriveCapabilities(
-    createBaseSnapshot({ isReady: false }),
-    "review",
-  );
-  assert.equal(caps.phase, "loading");
-  assert.equal(caps.canEdit, false);
-  assert.equal(caps.canUndo, false);
-  assert.equal(caps.canRedo, false);
-  assert.equal(caps.canAddComment, false);
-  assert.equal(caps.canExport, false);
-  assert.equal(caps.canAcceptChange, false);
-  assert.equal(caps.canRejectChange, false);
-});
-
-test("ready editable snapshot enables editing capabilities", () => {
-  const caps = deriveCapabilities(createBaseSnapshot(), "review");
-  assert.equal(caps.phase, "ready");
-  assert.equal(caps.mode, "review");
-  assert.equal(caps.canEdit, true);
-  assert.equal(caps.isReady, true);
-});
-
-test("read-only snapshot disables editing capabilities", () => {
-  const caps = deriveCapabilities(
-    createBaseSnapshot({ readOnly: true }),
-    "editing",
-  );
-  assert.equal(caps.canEdit, false);
-  assert.equal(caps.canAddComment, false);
-  assert.equal(caps.canAcceptChange, false);
-  assert.equal(caps.mode, "editing");
-});
-
-test("fatal error produces diagnostics phase and read-only-diagnostics mode", () => {
-  const caps = deriveCapabilities(
-    createBaseSnapshot({
-      fatalError: {
-        errorId: "err-1",
-        code: "internal_invariant",
-        message: "Broken import",
-        isFatal: true,
-        source: "import",
-      },
-    }),
-    "review",
-  );
-  assert.equal(caps.phase, "diagnostics");
-  assert.equal(caps.mode, "read-only-diagnostics");
-  assert.equal(caps.canEdit, false);
-  assert.equal(caps.canExport, false);
-  assert.equal(caps.hasFatalError, true);
-});
-
-test("blocked export disables canExport", () => {
-  const caps = deriveCapabilities(
-    createBaseSnapshot({
-      compatibility: {
-        blockExport: true,
-        blockExportReasons: ["Unsupported content"],
-        warningCount: 0,
-        errorCount: 1,
-        featureEntries: [],
-      },
-    }),
-    "review",
-  );
-  assert.equal(caps.canExport, false);
-  assert.equal(caps.exportBlocked, true);
-});
-
-test("actionable revisions enable accept/reject capabilities", () => {
-  const caps = deriveCapabilities(
-    createBaseSnapshot({
-      trackedChanges: {
-        pendingChangeIds: ["rev-1"],
-        acceptedChangeIds: [],
-        rejectedChangeIds: [],
-        detachedChangeIds: [],
-        actionableChangeIds: ["rev-1"],
-        preserveOnlyChangeIds: [],
-        totalCount: 1,
-        revisions: [
-          {
-            revisionId: "rev-1",
-            kind: "insertion",
-            label: "Insert Alpha",
-            status: "active",
-            actionability: "actionable",
-            anchor: { kind: "range", from: 0, to: 5, assoc: { start: -1, end: 1 } },
-            anchorLabel: "Range 0-5",
-            createdAt: "2026-01-01T00:00:00.000Z",
-            authorId: "author-1",
-            warningCount: 0,
-            canAccept: true,
-            canReject: true,
-          },
-        ],
-      },
-    }),
-    "review",
-  );
-  assert.equal(caps.canAcceptChange, true);
-  assert.equal(caps.canRejectChange, true);
-  assert.equal(caps.canAcceptAll, true);
-  assert.equal(caps.trackChangesSupported, true);
-});
-
-test("no revisions disables accept/reject capabilities", () => {
-  const caps = deriveCapabilities(createBaseSnapshot(), "review");
-  assert.equal(caps.canAcceptChange, false);
-  assert.equal(caps.canRejectChange, false);
-  assert.equal(caps.canAcceptAll, false);
-  assert.equal(caps.trackChangesSupported, false);
-});
-
-test("reviewMode editing hides review rail when no trust concerns", () => {
-  const caps = deriveCapabilities(createBaseSnapshot(), "editing");
-  assert.equal(caps.reviewRailVisible, false);
-  assert.equal(caps.mode, "editing");
-});
-
-test("reviewMode editing shows review rail when trust concerns exist", () => {
-  const caps = deriveCapabilities(
-    createBaseSnapshot({
-      compatibility: {
-        blockExport: false,
-        blockExportReasons: [],
-        warningCount: 1,
-        errorCount: 0,
-        featureEntries: [
-          { featureEntryId: "f1", featureKey: "tables", featureClass: "preserve-only", message: "Tables" },
-        ],
-      },
-    }),
-    "editing",
-  );
-  assert.equal(caps.reviewRailVisible, true);
-  assert.equal(caps.mode, "editing");
-});
-
-test("reviewMode review shows review rail by default", () => {
-  const caps = deriveCapabilities(createBaseSnapshot(), "review");
-  assert.equal(caps.reviewRailVisible, true);
-  assert.equal(caps.mode, "review");
-});
-
-test("undo/redo driven by commandState and canEdit", () => {
-  const caps = deriveCapabilities(
-    createBaseSnapshot({
-      commandState: { canUndo: true, canRedo: true, readOnly: false },
-    }),
-    "review",
-  );
-  assert.equal(caps.canUndo, true);
-  assert.equal(caps.canRedo, true);
-
-  const readOnlyCaps = deriveCapabilities(
-    createBaseSnapshot({
-      readOnly: true,
-      commandState: { canUndo: true, canRedo: true, readOnly: true },
-    }),
-    "review",
-  );
-  assert.equal(readOnlyCaps.canUndo, false);
-  assert.equal(readOnlyCaps.canRedo, false);
-});
-
-test("canAddComment requires non-collapsed selection and canEdit", () => {
-  const collapsedCaps = deriveCapabilities(createBaseSnapshot(), "review");
-  assert.equal(collapsedCaps.canAddComment, false);
-
-  const selectedCaps = deriveCapabilities(
-    createBaseSnapshot({
-      selection: {
-        anchor: 0,
-        head: 5,
-        isCollapsed: false,
-        activeRange: { kind: "range", from: 0, to: 5, assoc: { start: -1, end: 1 } },
-      },
-    }),
-    "review",
-  );
-  assert.equal(selectedCaps.canAddComment, true);
-});
-
-test("preserve-only and unsupported-fatal counts computed from feature entries", () => {
-  const caps = deriveCapabilities(
-    createBaseSnapshot({
-      compatibility: {
-        blockExport: false,
-        blockExportReasons: [],
-        warningCount: 0,
-        errorCount: 0,
-        featureEntries: [
-          { featureEntryId: "f1", featureKey: "tables", featureClass: "preserve-only", message: "Tables" },
-          { featureEntryId: "f2", featureKey: "fields", featureClass: "preserve-only", message: "Fields" },
-          { featureEntryId: "f3", featureKey: "custom-xml", featureClass: "unsupported-fatal", message: "Custom XML" },
-          { featureEntryId: "f4", featureKey: "text", featureClass: "supported-roundtrip", message: "Text" },
-        ],
-      },
-    }),
-    "review",
-  );
-  assert.equal(caps.preserveOnlyCount, 2);
-  assert.equal(caps.unsupportedFatalCount, 1);
-});

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

@@ -1,356 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { Fragment, Schema } from "prosemirror-model";
-import { EditorState, TextSelection } from "prosemirror-state";
-
-import {
-  addColumnAfter,
-  addColumnBefore,
-  addRowAfter,
-  addRowBefore,
-  deleteColumn,
-  deleteRow,
-} from "../../src/runtime/table-commands.ts";
-import { getTableNodeSpecs } from "../../src/runtime/table-schema.ts";
-
-// ---------------------------------------------------------------------------
-// Test schema
-// ---------------------------------------------------------------------------
-
-const testSchema = new Schema({
-  nodes: {
-    doc: { content: "block+" },
-    paragraph: {
-      content: "text*",
-      group: "block",
-      toDOM() {
-        return ["p", 0];
-      },
-    },
-    text: { group: "inline" },
-    ...getTableNodeSpecs(),
-  },
-});
-
-// ---------------------------------------------------------------------------
-// Test document helpers
-// ---------------------------------------------------------------------------
-
-function makePara() {
-  return testSchema.nodes.paragraph.create();
-}
-
-function makeCell() {
-  return testSchema.nodes.table_cell.create(null, Fragment.from(makePara()));
-}
-
-function makeRow(cellCount = 2) {
-  const cells: ReturnType<typeof makeCell>[] = [];
-  for (let i = 0; i < cellCount; i++) cells.push(makeCell());
-  return testSchema.nodes.table_row.create(null, Fragment.from(cells));
-}
-
-function makeTable(rowCount = 2, colCount = 2) {
-  const rows: ReturnType<typeof makeRow>[] = [];
-  for (let i = 0; i < rowCount; i++) rows.push(makeRow(colCount));
-  return testSchema.nodes.table.create(null, Fragment.from(rows));
-}
-
-/**
- * Create an EditorState with the cursor inside the first cell of the given table.
- *
- * For a table at the start of the doc, the position inside the first cell's
- * paragraph is 4 (doc-start > table-open > row-open > cell-open > para-open).
- */
-function stateInsideFirstCell(table: ReturnType<typeof makeTable>) {
-  const doc = testSchema.nodes.doc.create(null, Fragment.from(table));
-  // Position 4 = inside the first cell's empty paragraph:
-  // 0: table open, 1: row open, 2: cell open, 3: para open, 4: inside empty para
-  const sel = TextSelection.create(doc, 4);
-  return EditorState.create({ doc, selection: sel });
-}
-
-/**
- * Create an EditorState with the cursor inside a standalone paragraph (no table).
- */
-function stateOutsideTable() {
-  const doc = testSchema.nodes.doc.create(null, Fragment.from(makePara()));
-  return EditorState.create({ doc, selection: TextSelection.create(doc, 1) });
-}
-
-// ---------------------------------------------------------------------------
-// Guard tests: commands return false outside a table
-// ---------------------------------------------------------------------------
-
-test("addRowBefore returns false outside a table", () => {
-  assert.equal(addRowBefore(stateOutsideTable()), false);
-});
-
-test("addRowAfter returns false outside a table", () => {
-  assert.equal(addRowAfter(stateOutsideTable()), false);
-});
-
-test("deleteRow returns false outside a table", () => {
-  assert.equal(deleteRow(stateOutsideTable()), false);
-});
-
-test("addColumnBefore returns false outside a table", () => {
-  assert.equal(addColumnBefore(stateOutsideTable()), false);
-});
-
-test("addColumnAfter returns false outside a table", () => {
-  assert.equal(addColumnAfter(stateOutsideTable()), false);
-});
-
-test("deleteColumn returns false outside a table", () => {
-  assert.equal(deleteColumn(stateOutsideTable()), false);
-});
-
-// ---------------------------------------------------------------------------
-// Guard tests: commands return true inside a table (no dispatch)
-// ---------------------------------------------------------------------------
-
-test("addRowBefore returns true inside a table (no dispatch)", () => {
-  const state = stateInsideFirstCell(makeTable(2, 2));
-  assert.equal(addRowBefore(state), true);
-});
-
-test("addRowAfter returns true inside a table (no dispatch)", () => {
-  const state = stateInsideFirstCell(makeTable(2, 2));
-  assert.equal(addRowAfter(state), true);
-});
-
-test("addColumnBefore returns true inside a table (no dispatch)", () => {
-  const state = stateInsideFirstCell(makeTable(2, 2));
-  assert.equal(addColumnBefore(state), true);
-});
-
-test("addColumnAfter returns true inside a table (no dispatch)", () => {
-  const state = stateInsideFirstCell(makeTable(2, 2));
-  assert.equal(addColumnAfter(state), true);
-});
-
-// ---------------------------------------------------------------------------
-// addRowBefore
-// ---------------------------------------------------------------------------
-
-test("addRowBefore inserts a row before the current row", () => {
-  const state = stateInsideFirstCell(makeTable(2, 2));
-  let newState: EditorState | null = null;
-
-  addRowBefore(state, (tr) => {
-    newState = state.apply(tr);
-  });
-
-  assert.ok(newState, "dispatch was called");
-  const table = (newState as EditorState).doc.firstChild!;
-  assert.equal(table.childCount, 3, "table now has 3 rows");
-  // New row is at index 0 (before the original first row)
-  assert.equal(table.child(0).childCount, 2, "new row has 2 cells");
-});
-
-test("addRowBefore new row cells have empty paragraphs", () => {
-  const state = stateInsideFirstCell(makeTable(1, 3));
-  let newState: EditorState | null = null;
-
-  addRowBefore(state, (tr) => {
-    newState = state.apply(tr);
-  });
-
-  const table = (newState as EditorState).doc.firstChild!;
-  assert.equal(table.childCount, 2, "now 2 rows");
-  const newRow = table.child(0);
-  assert.equal(newRow.childCount, 3, "new row has 3 cells matching original");
-  for (let i = 0; i < newRow.childCount; i++) {
-    const cell = newRow.child(i);
-    assert.equal(cell.type.name, "table_cell");
-    assert.equal(cell.childCount, 1, "cell has one paragraph");
-    assert.equal(cell.child(0).type.name, "paragraph");
-  }
-});
-
-// ---------------------------------------------------------------------------
-// addRowAfter
-// ---------------------------------------------------------------------------
-
-test("addRowAfter inserts a row after the current row", () => {
-  const state = stateInsideFirstCell(makeTable(2, 2));
-  let newState: EditorState | null = null;
-
-  addRowAfter(state, (tr) => {
-    newState = state.apply(tr);
-  });
-
-  assert.ok(newState, "dispatch was called");
-  const table = (newState as EditorState).doc.firstChild!;
-  assert.equal(table.childCount, 3, "table now has 3 rows");
-  // New row is at index 1 (after the original first row)
-  assert.equal(table.child(1).childCount, 2, "new row has 2 cells");
-});
-
-test("addRowAfter preserves original rows", () => {
-  const state = stateInsideFirstCell(makeTable(2, 2));
-  let newState: EditorState | null = null;
-
-  addRowAfter(state, (tr) => {
-    newState = state.apply(tr);
-  });
-
-  const table = (newState as EditorState).doc.firstChild!;
-  // Original row 0 is still at index 0
-  assert.equal(table.child(0).childCount, 2);
-  // Original row 1 is now at index 2
-  assert.equal(table.child(2).childCount, 2);
-});
-
-// ---------------------------------------------------------------------------
-// deleteRow
-// ---------------------------------------------------------------------------
-
-test("deleteRow removes the current row", () => {
-  const state = stateInsideFirstCell(makeTable(3, 2));
-  let newState: EditorState | null = null;
-
-  deleteRow(state, (tr) => {
-    newState = state.apply(tr);
-  });
-
-  assert.ok(newState, "dispatch was called");
-  const table = (newState as EditorState).doc.firstChild!;
-  assert.equal(table.childCount, 2, "table now has 2 rows (was 3)");
-});
-
-test("deleteRow returns false when table has only one row", () => {
-  const state = stateInsideFirstCell(makeTable(1, 2));
-  const result = deleteRow(state);
-  assert.equal(result, false, "cannot delete the only row");
-});
-
-test("deleteRow does not dispatch when table has one row", () => {
-  const state = stateInsideFirstCell(makeTable(1, 2));
-  let dispatched = false;
-  deleteRow(state, () => {
-    dispatched = true;
-  });
-  assert.equal(dispatched, false);
-});
-
-// ---------------------------------------------------------------------------
-// addColumnBefore
-// ---------------------------------------------------------------------------
-
-test("addColumnBefore inserts a cell before the current column in all rows", () => {
-  const state = stateInsideFirstCell(makeTable(2, 2));
-  let newState: EditorState | null = null;
-
-  addColumnBefore(state, (tr) => {
-    newState = state.apply(tr);
-  });
-
-  assert.ok(newState, "dispatch was called");
-  const table = (newState as EditorState).doc.firstChild!;
-  assert.equal(table.childCount, 2, "still 2 rows");
-  assert.equal(table.child(0).childCount, 3, "row 0 now has 3 cells");
-  assert.equal(table.child(1).childCount, 3, "row 1 now has 3 cells");
-});
-
-test("addColumnBefore new cells contain empty paragraphs", () => {
-  const state = stateInsideFirstCell(makeTable(2, 2));
-  let newState: EditorState | null = null;
-
-  addColumnBefore(state, (tr) => {
-    newState = state.apply(tr);
-  });
-
-  const row0 = (newState as EditorState).doc.firstChild!.child(0);
-  // New cell is at index 0 (before the original first cell)
-  const newCell = row0.child(0);
-  assert.equal(newCell.type.name, "table_cell");
-  assert.equal(newCell.childCount, 1);
-  assert.equal(newCell.child(0).type.name, "paragraph");
-});
-
-// ---------------------------------------------------------------------------
-// addColumnAfter
-// ---------------------------------------------------------------------------
-
-test("addColumnAfter inserts a cell after the current column in all rows", () => {
-  const state = stateInsideFirstCell(makeTable(2, 2));
-  let newState: EditorState | null = null;
-
-  addColumnAfter(state, (tr) => {
-    newState = state.apply(tr);
-  });
-
-  assert.ok(newState, "dispatch was called");
-  const table = (newState as EditorState).doc.firstChild!;
-  assert.equal(table.child(0).childCount, 3, "row 0 now has 3 cells");
-  assert.equal(table.child(1).childCount, 3, "row 1 now has 3 cells");
-});
-
-test("addColumnAfter new cell is after the current cell (index 1 of original 2)", () => {
-  const state = stateInsideFirstCell(makeTable(2, 2));
-  let newState: EditorState | null = null;
-
-  addColumnAfter(state, (tr) => {
-    newState = state.apply(tr);
-  });
-
-  const row0 = (newState as EditorState).doc.firstChild!.child(0);
-  // Row had cells [A, B]. After addColumnAfter at index 0: [A, NEW, B]
-  assert.equal(row0.childCount, 3);
-  // Cells at 0 and 2 are the original (original A and B)
-  // Cell at 1 is the new one
-  assert.equal(row0.child(1).type.name, "table_cell");
-  assert.equal(row0.child(1).childCount, 1);
-  assert.equal(row0.child(1).child(0).type.name, "paragraph");
-});
-
-// ---------------------------------------------------------------------------
-// deleteColumn
-// ---------------------------------------------------------------------------
-
-test("deleteColumn removes the current column from all rows", () => {
-  const state = stateInsideFirstCell(makeTable(2, 3));
-  let newState: EditorState | null = null;
-
-  deleteColumn(state, (tr) => {
-    newState = state.apply(tr);
-  });
-
-  assert.ok(newState, "dispatch was called");
-  const table = (newState as EditorState).doc.firstChild!;
-  assert.equal(table.child(0).childCount, 2, "row 0 now has 2 cells (was 3)");
-  assert.equal(table.child(1).childCount, 2, "row 1 now has 2 cells (was 3)");
-});
-
-test("deleteColumn returns false when row has only one cell", () => {
-  const state = stateInsideFirstCell(makeTable(2, 1));
-  const result = deleteColumn(state);
-  assert.equal(result, false, "cannot delete the only column");
-});
-
-test("deleteColumn does not dispatch when row has one cell", () => {
-  const state = stateInsideFirstCell(makeTable(2, 1));
-  let dispatched = false;
-  deleteColumn(state, () => {
-    dispatched = true;
-  });
-  assert.equal(dispatched, false);
-});
-
-test("deleteColumn preserves correct number of rows", () => {
-  const state = stateInsideFirstCell(makeTable(3, 2));
-  let newState: EditorState | null = null;
-
-  deleteColumn(state, (tr) => {
-    newState = state.apply(tr);
-  });
-
-  const table = (newState as EditorState).doc.firstChild!;
-  assert.equal(table.childCount, 3, "table still has 3 rows");
-  assert.equal(table.child(0).childCount, 1, "each row now has 1 cell");
-  assert.equal(table.child(1).childCount, 1);
-  assert.equal(table.child(2).childCount, 1);
-});