@lotics/xlsx 0.1.0

package/src/spreadsheet_commands.test.ts

@@ -0,0 +1,772 @@
+import {
+  setCellValueCommand,
+  setCellStyleCommand,
+  setRangeStyleCommand,
+  deleteCellCommand,
+  clearRangeCommand,
+  mergeCellsCommand,
+  unmergeCellsCommand,
+  setNamedRangeCommand,
+  setRangeNumFmtCommand,
+  addSheetCommand,
+  deleteSheetCommand,
+  renameSheetCommand,
+  setHiddenRowsCommand,
+  setHiddenColsCommand,
+  sortColumnCommand,
+  multiSortCommand,
+  setFreezePanesCommand,
+  setZoomCommand,
+  addConditionalFormatCommand,
+  deleteConditionalFormatCommand,
+  reorderSheetsCommand,
+  insertCellsShiftDownCommand,
+  insertCellsShiftRightCommand,
+  deleteCellsShiftUpCommand,
+  deleteCellsShiftLeftCommand,
+  setShowGridLinesCommand,
+  setShowHeadersCommand,
+  setHyperlinkCommand,
+} from "./spreadsheet_commands";
+import { CommandHistory } from "./command_history";
+import { WorkbookModel, SheetModel, StyleRegistry } from "./workbook_model";
+import type { ChangeEvent } from "./workbook_model";
+
+function makeWorkbook(): WorkbookModel {
+  const styles = new StyleRegistry();
+  const sheet = new SheetModel("Sheet1");
+  return new WorkbookModel({ sheets: [sheet], activeSheetIndex: 0, styles });
+}
+
+describe("setCellValueCommand", () => {
+  test("sets cell value", () => {
+    const wb = makeWorkbook();
+    const cmd = setCellValueCommand(wb, undefined, 0, 1, 1, "Hello");
+    cmd.execute();
+    expect(wb.sheets[0].getCell("A1")?.value).toBe("Hello");
+  });
+
+  test("sets numeric value", () => {
+    const wb = makeWorkbook();
+    const cmd = setCellValueCommand(wb, undefined, 0, 1, 1, "42");
+    cmd.execute();
+    expect(wb.sheets[0].getCell("A1")?.value).toBe(42);
+  });
+
+  test("sets boolean value", () => {
+    const wb = makeWorkbook();
+    const cmd = setCellValueCommand(wb, undefined, 0, 1, 1, "TRUE");
+    cmd.execute();
+    expect(wb.sheets[0].getCell("A1")?.value).toBe(true);
+  });
+
+  test("sets formula", () => {
+    const wb = makeWorkbook();
+    const cmd = setCellValueCommand(wb, undefined, 0, 1, 1, "=SUM(A2:A5)");
+    cmd.execute();
+    expect(wb.sheets[0].getCell("A1")?.formula).toBe("SUM(A2:A5)");
+  });
+
+  test("undo restores previous value", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", "Old");
+    const cmd = setCellValueCommand(wb, undefined, 0, 1, 1, "New");
+    cmd.execute();
+    expect(wb.sheets[0].getCell("A1")?.value).toBe("New");
+    cmd.undo();
+    expect(wb.sheets[0].getCell("A1")?.value).toBe("Old");
+  });
+
+  test("undo deletes cell if it was empty", () => {
+    const wb = makeWorkbook();
+    const cmd = setCellValueCommand(wb, undefined, 0, 1, 1, "Value");
+    cmd.execute();
+    cmd.undo();
+    expect(wb.sheets[0].getCell("A1")).toBeUndefined();
+  });
+
+  test("fires change events", () => {
+    const wb = makeWorkbook();
+    const events: ChangeEvent[] = [];
+    wb.onChange = (e) => events.push(e);
+    const cmd = setCellValueCommand(wb, undefined, 0, 1, 1, "Test");
+    cmd.execute();
+    expect(events).toHaveLength(1);
+    expect(events[0].type).toBe("cell_value");
+  });
+
+  test("integrates with CommandHistory for undo/redo", () => {
+    const wb = makeWorkbook();
+    const history = new CommandHistory();
+    history.execute(setCellValueCommand(wb, undefined, 0, 1, 1, "First"));
+    history.execute(setCellValueCommand(wb, undefined, 0, 1, 1, "Second"));
+    expect(wb.sheets[0].getCell("A1")?.value).toBe("Second");
+    history.undo();
+    expect(wb.sheets[0].getCell("A1")?.value).toBe("First");
+    history.redo();
+    expect(wb.sheets[0].getCell("A1")?.value).toBe("Second");
+  });
+});
+
+describe("setCellStyleCommand", () => {
+  test("applies style override", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", "Hello");
+    const cmd = setCellStyleCommand(wb, 0, 1, 1, { fontBold: true });
+    cmd.execute();
+    const styleIdx = wb.sheets[0].getCell("A1")!.styleIndex;
+    expect(wb.styles.get(styleIdx).fontBold).toBe(true);
+  });
+
+  test("undo reverts style", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", "Hello");
+    const cmd = setCellStyleCommand(wb, 0, 1, 1, { fontBold: true });
+    cmd.execute();
+    cmd.undo();
+    const styleIdx = wb.sheets[0].getCell("A1")!.styleIndex;
+    expect(wb.styles.get(styleIdx)).toEqual({});
+  });
+});
+
+describe("setRangeStyleCommand", () => {
+  test("applies style to all cells in range", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", "1");
+    wb.sheets[0].set("B1", "2");
+    wb.sheets[0].set("A2", "3");
+    wb.sheets[0].set("B2", "4");
+
+    const cmd = setRangeStyleCommand(wb, 0, 1, 1, 2, 2, { fontBold: true });
+    cmd.execute();
+
+    for (const ref of ["A1", "B1", "A2", "B2"]) {
+      const styleIdx = wb.sheets[0].getCell(ref)!.styleIndex;
+      expect(wb.styles.get(styleIdx).fontBold).toBe(true);
+    }
+  });
+
+  test("undo reverts all cells", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", "1");
+    wb.sheets[0].set("B1", "2");
+
+    const cmd = setRangeStyleCommand(wb, 0, 1, 1, 1, 2, { fontBold: true });
+    cmd.execute();
+    cmd.undo();
+
+    for (const ref of ["A1", "B1"]) {
+      const styleIdx = wb.sheets[0].getCell(ref)!.styleIndex;
+      expect(wb.styles.get(styleIdx).fontBold).toBeUndefined();
+    }
+  });
+});
+
+describe("deleteCellCommand", () => {
+  test("deletes a cell", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", "Hello");
+    const cmd = deleteCellCommand(wb, undefined, 0, 1, 1);
+    cmd.execute();
+    expect(wb.sheets[0].getCell("A1")).toBeUndefined();
+  });
+
+  test("undo restores the cell", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", "Hello");
+    const cmd = deleteCellCommand(wb, undefined, 0, 1, 1);
+    cmd.execute();
+    cmd.undo();
+    expect(wb.sheets[0].getCell("A1")?.value).toBe("Hello");
+  });
+});
+
+describe("clearRangeCommand", () => {
+  test("clears all cells in range", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", "1");
+    wb.sheets[0].set("B1", "2");
+    wb.sheets[0].set("A2", "3");
+
+    const cmd = clearRangeCommand(wb, undefined, 0, 1, 1, 2, 2);
+    cmd.execute();
+
+    expect(wb.sheets[0].getCell("A1")).toBeUndefined();
+    expect(wb.sheets[0].getCell("B1")).toBeUndefined();
+    expect(wb.sheets[0].getCell("A2")).toBeUndefined();
+  });
+
+  test("undo restores all cells", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", "1");
+    wb.sheets[0].set("B1", "2");
+
+    const cmd = clearRangeCommand(wb, undefined, 0, 1, 1, 1, 2);
+    cmd.execute();
+    cmd.undo();
+
+    expect(wb.sheets[0].getCell("A1")?.displayValue).toBe("1");
+    expect(wb.sheets[0].getCell("B1")?.displayValue).toBe("2");
+  });
+});
+
+describe("mergeCellsCommand", () => {
+  test("adds merge range", () => {
+    const wb = makeWorkbook();
+    const cmd = mergeCellsCommand(wb, 0, 1, 1, 1, 3);
+    cmd.execute();
+    expect(wb.sheets[0].mergedCells).toContain("A1:C1");
+  });
+
+  test("undo removes merge range", () => {
+    const wb = makeWorkbook();
+    const cmd = mergeCellsCommand(wb, 0, 1, 1, 1, 3);
+    cmd.execute();
+    cmd.undo();
+    expect(wb.sheets[0].mergedCells).not.toContain("A1:C1");
+  });
+});
+
+describe("unmergeCellsCommand", () => {
+  test("removes merge range", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].mergedCells.push("A1:C1");
+    const cmd = unmergeCellsCommand(wb, 0, "A1:C1");
+    cmd.execute();
+    expect(wb.sheets[0].mergedCells).not.toContain("A1:C1");
+  });
+
+  test("undo re-adds merge range", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].mergedCells.push("A1:C1");
+    const cmd = unmergeCellsCommand(wb, 0, "A1:C1");
+    cmd.execute();
+    cmd.undo();
+    expect(wb.sheets[0].mergedCells).toContain("A1:C1");
+  });
+});
+
+describe("setNamedRangeCommand", () => {
+  test("creates a named range", () => {
+    const wb = makeWorkbook();
+    const cmd = setNamedRangeCommand(wb, "TotalRevenue", "Sheet1!$C$11");
+    cmd.execute();
+    expect(wb.namedRanges.get("TotalRevenue")).toBe("Sheet1!$C$11");
+  });
+
+  test("undo removes a newly created named range", () => {
+    const wb = makeWorkbook();
+    const cmd = setNamedRangeCommand(wb, "MyRange", "Sheet1!$A$1:$C$10");
+    cmd.execute();
+    cmd.undo();
+    expect(wb.namedRanges.has("MyRange")).toBe(false);
+  });
+
+  test("undo restores previous value when overwriting", () => {
+    const wb = makeWorkbook();
+    wb.namedRanges.set("MyRange", "Sheet1!$A$1");
+    const cmd = setNamedRangeCommand(wb, "MyRange", "Sheet1!$B$2:$D$5");
+    cmd.execute();
+    expect(wb.namedRanges.get("MyRange")).toBe("Sheet1!$B$2:$D$5");
+    cmd.undo();
+    expect(wb.namedRanges.get("MyRange")).toBe("Sheet1!$A$1");
+  });
+
+  test("redo re-applies the named range", () => {
+    const wb = makeWorkbook();
+    const history = new CommandHistory();
+    history.execute(setNamedRangeCommand(wb, "Test", "Sheet1!$A$1"));
+    history.undo();
+    expect(wb.namedRanges.has("Test")).toBe(false);
+    history.redo();
+    expect(wb.namedRanges.get("Test")).toBe("Sheet1!$A$1");
+  });
+});
+
+describe("setRangeNumFmtCommand", () => {
+  test("changes number format for a cell", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", 42);
+    const cmd = setRangeNumFmtCommand(wb, 0, 1, 1, 1, 1, "0.00");
+    cmd.execute();
+    expect(wb.sheets[0].getCell("A1")?.numFmtCode).toBe("0.00");
+  });
+
+  test("applies to a range", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", 1);
+    wb.sheets[0].set("B1", 2);
+    wb.sheets[0].set("A2", 3);
+    const cmd = setRangeNumFmtCommand(wb, 0, 1, 1, 2, 2, "$#,##0.00");
+    cmd.execute();
+    expect(wb.sheets[0].getCell("A1")?.numFmtCode).toBe("$#,##0.00");
+    expect(wb.sheets[0].getCell("B1")?.numFmtCode).toBe("$#,##0.00");
+    expect(wb.sheets[0].getCell("A2")?.numFmtCode).toBe("$#,##0.00");
+  });
+
+  test("undo restores previous format", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", 42);
+    const cmd = setRangeNumFmtCommand(wb, 0, 1, 1, 1, 1, "0.00%");
+    cmd.execute();
+    cmd.undo();
+    expect(wb.sheets[0].getCell("A1")?.numFmtCode).toBe("General");
+  });
+
+  test("creates empty cell with format if cell was empty", () => {
+    const wb = makeWorkbook();
+    const cmd = setRangeNumFmtCommand(wb, 0, 1, 1, 1, 1, "0.00");
+    cmd.execute();
+    expect(wb.sheets[0].getCell("A1")?.numFmtCode).toBe("0.00");
+  });
+
+  test("undo removes cell if it was empty before", () => {
+    const wb = makeWorkbook();
+    const cmd = setRangeNumFmtCommand(wb, 0, 1, 1, 1, 1, "0.00");
+    cmd.execute();
+    cmd.undo();
+    expect(wb.sheets[0].getCell("A1")).toBeUndefined();
+  });
+});
+
+describe("addSheetCommand", () => {
+  test("adds a new sheet", () => {
+    const wb = makeWorkbook();
+    const cmd = addSheetCommand(wb, "Sheet2");
+    cmd.execute();
+    expect(wb.sheets).toHaveLength(2);
+    expect(wb.sheets[1].name).toBe("Sheet2");
+  });
+
+  test("undo removes the added sheet", () => {
+    const wb = makeWorkbook();
+    const cmd = addSheetCommand(wb, "Sheet2");
+    cmd.execute();
+    cmd.undo();
+    expect(wb.sheets).toHaveLength(1);
+  });
+});
+
+describe("deleteSheetCommand", () => {
+  test("deletes a sheet", () => {
+    const wb = makeWorkbook();
+    wb.sheets.push(new (wb.sheets[0].constructor as new (name: string) => typeof wb.sheets[0])("Sheet2"));
+    const cmd = deleteSheetCommand(wb, 1);
+    cmd.execute();
+    expect(wb.sheets).toHaveLength(1);
+  });
+
+  test("undo restores the deleted sheet", () => {
+    const wb = makeWorkbook();
+    const originalSheet = wb.sheets[0];
+    originalSheet.set("A1", "Keep");
+    const cmd = deleteSheetCommand(wb, 0);
+    cmd.execute();
+    expect(wb.sheets).toHaveLength(0);
+    cmd.undo();
+    expect(wb.sheets).toHaveLength(1);
+    expect(wb.sheets[0].getCell("A1")?.value).toBe("Keep");
+  });
+});
+
+describe("renameSheetCommand", () => {
+  test("renames a sheet", () => {
+    const wb = makeWorkbook();
+    const cmd = renameSheetCommand(wb, 0, "Renamed");
+    cmd.execute();
+    expect(wb.sheets[0].name).toBe("Renamed");
+  });
+
+  test("undo restores original name", () => {
+    const wb = makeWorkbook();
+    const cmd = renameSheetCommand(wb, 0, "Renamed");
+    cmd.execute();
+    cmd.undo();
+    expect(wb.sheets[0].name).toBe("Sheet1");
+  });
+});
+
+// =============================================================================
+// New commands
+// =============================================================================
+
+describe("setHiddenRowsCommand", () => {
+  test("sets hidden rows", () => {
+    const wb = makeWorkbook();
+    const cmd = setHiddenRowsCommand(wb, 0, new Set([2, 3]));
+    cmd.execute();
+    expect(wb.sheets[0].hiddenRows).toEqual(new Set([2, 3]));
+  });
+
+  test("undo restores previous hidden rows", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].hiddenRows = new Set([5]);
+    const cmd = setHiddenRowsCommand(wb, 0, new Set([2, 3]));
+    cmd.execute();
+    cmd.undo();
+    expect(wb.sheets[0].hiddenRows).toEqual(new Set([5]));
+  });
+
+  test("redo re-applies", () => {
+    const wb = makeWorkbook();
+    const history = new CommandHistory();
+    history.execute(setHiddenRowsCommand(wb, 0, new Set([1, 2])));
+    history.undo();
+    expect(wb.sheets[0].hiddenRows.size).toBe(0);
+    history.redo();
+    expect(wb.sheets[0].hiddenRows).toEqual(new Set([1, 2]));
+  });
+});
+
+describe("setHiddenColsCommand", () => {
+  test("sets hidden cols", () => {
+    const wb = makeWorkbook();
+    const cmd = setHiddenColsCommand(wb, 0, new Set([1, 4]));
+    cmd.execute();
+    expect(wb.sheets[0].hiddenCols).toEqual(new Set([1, 4]));
+  });
+
+  test("undo restores previous hidden cols", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].hiddenCols = new Set([3]);
+    const cmd = setHiddenColsCommand(wb, 0, new Set([1]));
+    cmd.execute();
+    cmd.undo();
+    expect(wb.sheets[0].hiddenCols).toEqual(new Set([3]));
+  });
+});
+
+describe("sortColumnCommand", () => {
+  test("sorts rows ascending", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", 3);
+    wb.sheets[0].set("A2", 1);
+    wb.sheets[0].set("A3", 2);
+    const cmd = sortColumnCommand(wb, 0, 1, true);
+    cmd.execute();
+    expect(wb.sheets[0].getCell("A1")?.value).toBe(1);
+    expect(wb.sheets[0].getCell("A2")?.value).toBe(2);
+    expect(wb.sheets[0].getCell("A3")?.value).toBe(3);
+  });
+
+  test("undo restores original order", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", 3);
+    wb.sheets[0].set("A2", 1);
+    const cmd = sortColumnCommand(wb, 0, 1, true);
+    cmd.execute();
+    cmd.undo();
+    expect(wb.sheets[0].getCell("A1")?.value).toBe(3);
+    expect(wb.sheets[0].getCell("A2")?.value).toBe(1);
+  });
+});
+
+describe("multiSortCommand", () => {
+  test("sorts by 2 keys (primary asc, secondary desc)", () => {
+    const wb = makeWorkbook();
+    // Col A = category, Col B = value
+    wb.sheets[0].set("A1", "B");
+    wb.sheets[0].set("B1", 3);
+    wb.sheets[0].set("A2", "A");
+    wb.sheets[0].set("B2", 1);
+    wb.sheets[0].set("A3", "A");
+    wb.sheets[0].set("B3", 2);
+    wb.sheets[0].set("A4", "B");
+    wb.sheets[0].set("B4", 1);
+
+    const cmd = multiSortCommand(wb, 0, [
+      { col: 1, ascending: true },   // Sort by col A asc
+      { col: 2, ascending: false },  // Then by col B desc
+    ], false);
+    cmd.execute();
+
+    // A asc: A,A,B,B — within A: B desc: 2,1 — within B: B desc: 3,1
+    expect(wb.sheets[0].getCell("A1")?.value).toBe("A");
+    expect(wb.sheets[0].getCell("B1")?.value).toBe(2);
+    expect(wb.sheets[0].getCell("A2")?.value).toBe("A");
+    expect(wb.sheets[0].getCell("B2")?.value).toBe(1);
+    expect(wb.sheets[0].getCell("A3")?.value).toBe("B");
+    expect(wb.sheets[0].getCell("B3")?.value).toBe(3);
+    expect(wb.sheets[0].getCell("A4")?.value).toBe("B");
+    expect(wb.sheets[0].getCell("B4")?.value).toBe(1);
+  });
+
+  test("undo restores original order", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", 3);
+    wb.sheets[0].set("A2", 1);
+    wb.sheets[0].set("A3", 2);
+
+    const cmd = multiSortCommand(wb, 0, [{ col: 1, ascending: true }], false);
+    cmd.execute();
+    expect(wb.sheets[0].getCell("A1")?.value).toBe(1);
+    cmd.undo();
+    expect(wb.sheets[0].getCell("A1")?.value).toBe(3);
+    expect(wb.sheets[0].getCell("A2")?.value).toBe(1);
+    expect(wb.sheets[0].getCell("A3")?.value).toBe(2);
+  });
+
+  test("hasHeader skips first row", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", "Header");
+    wb.sheets[0].set("A2", 3);
+    wb.sheets[0].set("A3", 1);
+    wb.sheets[0].set("A4", 2);
+
+    const cmd = multiSortCommand(wb, 0, [{ col: 1, ascending: true }], true);
+    cmd.execute();
+
+    // Header stays at row 1, data rows 2-4 get sorted
+    expect(wb.sheets[0].getCell("A1")?.value).toBe("Header");
+    expect(wb.sheets[0].getCell("A2")?.value).toBe(1);
+    expect(wb.sheets[0].getCell("A3")?.value).toBe(2);
+    expect(wb.sheets[0].getCell("A4")?.value).toBe(3);
+  });
+});
+
+describe("setFreezePanesCommand", () => {
+  test("sets freeze panes", () => {
+    const wb = makeWorkbook();
+    const cmd = setFreezePanesCommand(wb, 0, { row: 2, col: 1 });
+    cmd.execute();
+    expect(wb.sheets[0].freeze).toEqual({ row: 2, col: 1 });
+  });
+
+  test("clears freeze panes", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].freeze = { row: 3, col: 2 };
+    const cmd = setFreezePanesCommand(wb, 0, undefined);
+    cmd.execute();
+    expect(wb.sheets[0].freeze).toBeUndefined();
+  });
+
+  test("undo restores previous freeze", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].freeze = { row: 1, col: 1 };
+    const cmd = setFreezePanesCommand(wb, 0, { row: 3, col: 3 });
+    cmd.execute();
+    cmd.undo();
+    expect(wb.sheets[0].freeze).toEqual({ row: 1, col: 1 });
+  });
+});
+
+describe("setZoomCommand", () => {
+  test("sets zoom level", () => {
+    const wb = makeWorkbook();
+    const cmd = setZoomCommand(wb, 0, 150);
+    cmd.execute();
+    expect(wb.sheets[0].view.zoomScale).toBe(150);
+  });
+
+  test("undo restores previous zoom", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].view.zoomScale = 80;
+    const cmd = setZoomCommand(wb, 0, 120);
+    cmd.execute();
+    cmd.undo();
+    expect(wb.sheets[0].view.zoomScale).toBe(80);
+  });
+});
+
+describe("addConditionalFormatCommand", () => {
+  test("adds a CF rule", () => {
+    const wb = makeWorkbook();
+    const cf = { ref: "A1:B5", rules: [{ ruleType: "colorScale" as const, priority: 1, colors: ["#F00", "#0F0", "#00F"] }] };
+    const cmd = addConditionalFormatCommand(wb, 0, cf);
+    cmd.execute();
+    expect(wb.sheets[0].conditionalFormats).toHaveLength(1);
+    expect(wb.sheets[0].conditionalFormats[0].ref).toBe("A1:B5");
+  });
+
+  test("undo removes the added rule", () => {
+    const wb = makeWorkbook();
+    const cf = { ref: "A1:B5", rules: [{ ruleType: "colorScale" as const, priority: 1, colors: ["#F00", "#0F0", "#00F"] }] };
+    const cmd = addConditionalFormatCommand(wb, 0, cf);
+    cmd.execute();
+    cmd.undo();
+    expect(wb.sheets[0].conditionalFormats).toHaveLength(0);
+  });
+});
+
+describe("deleteConditionalFormatCommand", () => {
+  test("deletes a CF rule", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].conditionalFormats.push({ ref: "A1:A10", rules: [{ ruleType: "colorScale", priority: 1, colors: ["#F00", "#0F0", "#00F"] }] });
+    const cmd = deleteConditionalFormatCommand(wb, 0, 0);
+    cmd.execute();
+    expect(wb.sheets[0].conditionalFormats).toHaveLength(0);
+  });
+
+  test("undo restores deleted rule", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].conditionalFormats.push({ ref: "A1:A10", rules: [{ ruleType: "colorScale", priority: 1, colors: ["#F00", "#0F0", "#00F"] }] });
+    const cmd = deleteConditionalFormatCommand(wb, 0, 0);
+    cmd.execute();
+    cmd.undo();
+    expect(wb.sheets[0].conditionalFormats).toHaveLength(1);
+    expect(wb.sheets[0].conditionalFormats[0].ref).toBe("A1:A10");
+  });
+});
+
+describe("reorderSheetsCommand", () => {
+  test("moves a sheet", () => {
+    const wb = makeWorkbook();
+    wb.sheets.push(new SheetModel("Sheet2"));
+    wb.sheets.push(new SheetModel("Sheet3"));
+    const cmd = reorderSheetsCommand(wb, 0, 2);
+    cmd.execute();
+    expect(wb.sheets.map((s) => s.name)).toEqual(["Sheet2", "Sheet3", "Sheet1"]);
+  });
+
+  test("undo reverses the move", () => {
+    const wb = makeWorkbook();
+    wb.sheets.push(new SheetModel("Sheet2"));
+    const cmd = reorderSheetsCommand(wb, 0, 1);
+    cmd.execute();
+    cmd.undo();
+    expect(wb.sheets.map((s) => s.name)).toEqual(["Sheet1", "Sheet2"]);
+  });
+});
+
+describe("insertCellsShiftDownCommand", () => {
+  test("shifts cells down", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", "Top");
+    wb.sheets[0].set("A2", "Middle");
+    wb.sheets[0].set("A3", "Bottom");
+    const cmd = insertCellsShiftDownCommand(wb, 0, 2, 1, 2, 1);
+    cmd.execute();
+    expect(wb.sheets[0].getCell("A1")?.value).toBe("Top");
+    expect(wb.sheets[0].getCell("A2")).toBeUndefined();
+    expect(wb.sheets[0].getCell("A3")?.value).toBe("Middle");
+    expect(wb.sheets[0].getCell("A4")?.value).toBe("Bottom");
+  });
+
+  test("undo restores cells", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", "Top");
+    wb.sheets[0].set("A2", "Middle");
+    const cmd = insertCellsShiftDownCommand(wb, 0, 1, 1, 1, 1);
+    cmd.execute();
+    cmd.undo();
+    expect(wb.sheets[0].getCell("A1")?.value).toBe("Top");
+    expect(wb.sheets[0].getCell("A2")?.value).toBe("Middle");
+  });
+});
+
+describe("insertCellsShiftRightCommand", () => {
+  test("shifts cells right", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", "Left");
+    wb.sheets[0].set("B1", "Right");
+    const cmd = insertCellsShiftRightCommand(wb, 0, 1, 1, 1, 1);
+    cmd.execute();
+    expect(wb.sheets[0].getCell("A1")).toBeUndefined();
+    expect(wb.sheets[0].getCell("B1")?.value).toBe("Left");
+    expect(wb.sheets[0].getCell("C1")?.value).toBe("Right");
+  });
+});
+
+describe("deleteCellsShiftUpCommand", () => {
+  test("deletes cells and shifts up", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", "One");
+    wb.sheets[0].set("A2", "Two");
+    wb.sheets[0].set("A3", "Three");
+    const cmd = deleteCellsShiftUpCommand(wb, 0, 1, 1, 1, 1);
+    cmd.execute();
+    expect(wb.sheets[0].getCell("A1")?.value).toBe("Two");
+    expect(wb.sheets[0].getCell("A2")?.value).toBe("Three");
+    expect(wb.sheets[0].getCell("A3")).toBeUndefined();
+  });
+
+  test("undo restores deleted cells and shifts back", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", "One");
+    wb.sheets[0].set("A2", "Two");
+    const cmd = deleteCellsShiftUpCommand(wb, 0, 1, 1, 1, 1);
+    cmd.execute();
+    cmd.undo();
+    expect(wb.sheets[0].getCell("A1")?.value).toBe("One");
+    expect(wb.sheets[0].getCell("A2")?.value).toBe("Two");
+  });
+});
+
+describe("deleteCellsShiftLeftCommand", () => {
+  test("deletes cells and shifts left", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", "Left");
+    wb.sheets[0].set("B1", "Mid");
+    wb.sheets[0].set("C1", "Right");
+    const cmd = deleteCellsShiftLeftCommand(wb, 0, 1, 1, 1, 1);
+    cmd.execute();
+    expect(wb.sheets[0].getCell("A1")?.value).toBe("Mid");
+    expect(wb.sheets[0].getCell("B1")?.value).toBe("Right");
+    expect(wb.sheets[0].getCell("C1")).toBeUndefined();
+  });
+});
+
+describe("setShowGridLinesCommand", () => {
+  test("toggles grid lines off", () => {
+    const wb = makeWorkbook();
+    expect(wb.sheets[0].view.showGridLines).toBe(true);
+    const cmd = setShowGridLinesCommand(wb, 0, false);
+    cmd.execute();
+    expect(wb.sheets[0].view.showGridLines).toBe(false);
+  });
+
+  test("undo restores grid lines", () => {
+    const wb = makeWorkbook();
+    const cmd = setShowGridLinesCommand(wb, 0, false);
+    cmd.execute();
+    cmd.undo();
+    expect(wb.sheets[0].view.showGridLines).toBe(true);
+  });
+});
+
+describe("setShowHeadersCommand", () => {
+  test("toggles headers off", () => {
+    const wb = makeWorkbook();
+    expect(wb.sheets[0].view.showHeaders).toBe(true);
+    const cmd = setShowHeadersCommand(wb, 0, false);
+    cmd.execute();
+    expect(wb.sheets[0].view.showHeaders).toBe(false);
+  });
+
+  test("undo restores headers", () => {
+    const wb = makeWorkbook();
+    const cmd = setShowHeadersCommand(wb, 0, false);
+    cmd.execute();
+    cmd.undo();
+    expect(wb.sheets[0].view.showHeaders).toBe(true);
+  });
+});
+
+describe("setHyperlinkCommand", () => {
+  test("sets hyperlink on cell", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", "Click me");
+    const cmd = setHyperlinkCommand(wb, 0, "A1", "https://example.com");
+    cmd.execute();
+    expect(wb.sheets[0].hyperlinks.get("A1")).toBe("https://example.com");
+    expect(wb.sheets[0].getCell("A1")?.content.type).toBe("hyperlink");
+  });
+
+  test("removes hyperlink", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", "Click me");
+    wb.sheets[0].hyperlinks.set("A1", "https://example.com");
+    const cmd = setHyperlinkCommand(wb, 0, "A1", undefined);
+    cmd.execute();
+    expect(wb.sheets[0].hyperlinks.has("A1")).toBe(false);
+  });
+
+  test("undo restores previous hyperlink state", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", "Click me");
+    const cmd = setHyperlinkCommand(wb, 0, "A1", "https://example.com");
+    cmd.execute();
+    cmd.undo();
+    expect(wb.sheets[0].hyperlinks.has("A1")).toBe(false);
+  });
+});