@lotics/xlsx 0.1.0

package/src/csv_parser.ts

@@ -0,0 +1,172 @@
+import type {
+  ParsedSpreadsheet,
+  ParsedSheet,
+  ParsedRow,
+  ParsedCell,
+  ParsedColumn,
+} from "./types";
+
+const MAX_ROWS = 10_000;
+
+export async function parseCsvFile(url: string, signal?: AbortSignal): Promise<ParsedSpreadsheet> {
+  const response = await fetch(url, { signal });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch file: ${response.status} ${response.statusText}`);
+  }
+
+  const text = await response.text();
+  const sheet = parseCsvText(text);
+
+  return { sheets: [sheet], activeSheetIndex: 0 };
+}
+
+export function parseCsvText(text: string): ParsedSheet {
+  if (!text.trim()) {
+    return {
+      name: "Sheet1",
+      columns: [],
+      rows: [],
+      mergedCells: [],
+      totalRowCount: 0,
+      truncated: false,
+      defaultRowHeight: 20,
+      defaultColWidth: 8,
+      showGridLines: true,
+      conditionalFormats: [],
+      images: [],
+      rowOutlineLevels: new Map(),
+      colOutlineLevels: new Map(),
+    };
+  }
+
+  const delimiter = detectDelimiter(text);
+  const rawRows = parseRows(text, delimiter);
+
+  const totalRowCount = rawRows.length;
+  const truncated = totalRowCount > MAX_ROWS;
+  const visibleRows = truncated ? rawRows.slice(0, MAX_ROWS) : rawRows;
+
+  // Determine column count from widest row
+  let colCount = 0;
+  for (const row of visibleRows) {
+    if (row.length > colCount) colCount = row.length;
+  }
+
+  // Track max content width per column for auto-sizing
+  const maxContentWidth = Array.from<number>({ length: colCount }).fill(0);
+
+  const rows: ParsedRow[] = visibleRows.map((rawRow, i) => {
+    const cells: ParsedCell[] = [];
+    for (let c = 0; c < colCount; c++) {
+      const value = rawRow[c] ?? "";
+      cells.push({
+        column: c + 1,
+        value,
+        content: { type: "plain", text: value },
+        style: {},
+      });
+
+      // Sample first 200 rows for width computation
+      if (i < 200 && value.length > maxContentWidth[c]) {
+        maxContentWidth[c] = value.length;
+      }
+    }
+    return { index: i + 1, height: 20, cells, hidden: false };
+  });
+
+  const columns: ParsedColumn[] = [];
+  for (let c = 0; c < colCount; c++) {
+    const width = Math.max(8, Math.min(maxContentWidth[c] + 2, 40));
+    columns.push({ index: c + 1, width, hidden: false });
+  }
+
+  return {
+    name: "Sheet1",
+    columns,
+    rows,
+    mergedCells: [],
+    totalRowCount,
+    truncated,
+    defaultRowHeight: 20,
+    defaultColWidth: 8,
+    showGridLines: true,
+    conditionalFormats: [],
+    images: [],
+    rowOutlineLevels: new Map(),
+    colOutlineLevels: new Map(),
+  };
+}
+
+function detectDelimiter(text: string): string {
+  // Check first few lines for tab vs comma prevalence
+  const sample = text.slice(0, 2000);
+  const tabs = (sample.match(/\t/g) ?? []).length;
+  const commas = (sample.match(/,/g) ?? []).length;
+  return tabs > commas ? "\t" : ",";
+}
+
+/**
+ * Parse CSV text into rows of string arrays.
+ * Handles quoted fields (RFC 4180), mixed line endings.
+ */
+function parseRows(text: string, delimiter: string): string[][] {
+  const rows: string[][] = [];
+  let currentRow: string[] = [];
+  let currentField = "";
+  let inQuotes = false;
+  let i = 0;
+
+  while (i < text.length) {
+    const char = text[i];
+
+    if (inQuotes) {
+      if (char === '"') {
+        // Check for escaped quote ("")
+        if (i + 1 < text.length && text[i + 1] === '"') {
+          currentField += '"';
+          i += 2;
+        } else {
+          inQuotes = false;
+          i++;
+        }
+      } else {
+        currentField += char;
+        i++;
+      }
+    } else {
+      if (char === '"') {
+        inQuotes = true;
+        i++;
+      } else if (char === delimiter) {
+        currentRow.push(currentField);
+        currentField = "";
+        i++;
+      } else if (char === "\r") {
+        // Handle \r\n and \r
+        currentRow.push(currentField);
+        currentField = "";
+        rows.push(currentRow);
+        currentRow = [];
+        i++;
+        if (i < text.length && text[i] === "\n") i++;
+      } else if (char === "\n") {
+        currentRow.push(currentField);
+        currentField = "";
+        rows.push(currentRow);
+        currentRow = [];
+        i++;
+      } else {
+        currentField += char;
+        i++;
+      }
+    }
+  }
+
+  // Push last field and row
+  if (currentField || currentRow.length > 0) {
+    currentRow.push(currentField);
+    rows.push(currentRow);
+  }
+
+  return rows;
+}

package/src/data_validation.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect } from "vitest";
+import { findValidationForCell, validateCellValue } from "./data_validation";
+import type { ParsedDataValidation } from "./ooxml_chart_types";
+
+function makeDv(overrides: Partial<ParsedDataValidation> & { ref: string; type: ParsedDataValidation["type"] }): ParsedDataValidation {
+  return {
+    showDropdown: true,
+    ...overrides,
+  };
+}
+
+describe("findValidationForCell", () => {
+  it("matches single cell ref", () => {
+    const dv = makeDv({ ref: "B2", type: "list", formula1: "A,B" });
+    expect(findValidationForCell([dv], 2, 2)).toBe(dv);
+    expect(findValidationForCell([dv], 1, 1)).toBeUndefined();
+  });
+
+  it("matches range ref", () => {
+    const dv = makeDv({ ref: "A1:C5", type: "whole", operator: "greaterThan", formula1: "0" });
+    expect(findValidationForCell([dv], 3, 2)).toBe(dv);
+    expect(findValidationForCell([dv], 6, 1)).toBeUndefined();
+  });
+
+  it("handles multi-range refs", () => {
+    const dv = makeDv({ ref: "A1:A5 C1:C5", type: "list", formula1: "X,Y" });
+    expect(findValidationForCell([dv], 3, 1)).toBe(dv);
+    expect(findValidationForCell([dv], 3, 3)).toBe(dv);
+    expect(findValidationForCell([dv], 3, 2)).toBeUndefined();
+  });
+});
+
+describe("validateCellValue", () => {
+  it("validates list membership", () => {
+    const dv = makeDv({ ref: "A1", type: "list", formula1: "Red,Green,Blue" });
+    expect(validateCellValue("Red", dv)).toBe(true);
+    expect(validateCellValue("Yellow", dv)).toBe(false);
+  });
+
+  it("validates whole number range (between)", () => {
+    const dv = makeDv({ ref: "A1", type: "whole", operator: "between", formula1: "1", formula2: "10" });
+    expect(validateCellValue("5", dv)).toBe(true);
+    expect(validateCellValue("0", dv)).toBe(false);
+    expect(validateCellValue("11", dv)).toBe(false);
+    expect(validateCellValue("3.5", dv)).toBe(false); // not integer
+  });
+
+  it("validates decimal greaterThan", () => {
+    const dv = makeDv({ ref: "A1", type: "decimal", operator: "greaterThan", formula1: "5.5" });
+    expect(validateCellValue("6.0", dv)).toBe(true);
+    expect(validateCellValue("5.5", dv)).toBe(false);
+    expect(validateCellValue("abc", dv)).toBe(false);
+  });
+
+  it("validates text length", () => {
+    const dv = makeDv({ ref: "A1", type: "textLength", operator: "lessThanOrEqual", formula1: "5" });
+    expect(validateCellValue("hi", dv)).toBe(true);
+    expect(validateCellValue("toolong", dv)).toBe(false);
+  });
+
+  it("accepts empty values", () => {
+    const dv = makeDv({ ref: "A1", type: "whole", operator: "greaterThan", formula1: "0" });
+    expect(validateCellValue("", dv)).toBe(true);
+  });
+
+  it("passes for missing operator (defaults to between)", () => {
+    const dv = makeDv({ ref: "A1", type: "whole", formula1: "1", formula2: "10" });
+    expect(validateCellValue("5", dv)).toBe(true);
+    expect(validateCellValue("15", dv)).toBe(false);
+  });
+
+  it("validates notBetween", () => {
+    const dv = makeDv({ ref: "A1", type: "decimal", operator: "notBetween", formula1: "1", formula2: "10" });
+    expect(validateCellValue("0.5", dv)).toBe(true);
+    expect(validateCellValue("5", dv)).toBe(false);
+  });
+
+  it("validates equal / notEqual", () => {
+    const dv1 = makeDv({ ref: "A1", type: "whole", operator: "equal", formula1: "42" });
+    expect(validateCellValue("42", dv1)).toBe(true);
+    expect(validateCellValue("43", dv1)).toBe(false);
+
+    const dv2 = makeDv({ ref: "A1", type: "whole", operator: "notEqual", formula1: "42" });
+    expect(validateCellValue("43", dv2)).toBe(true);
+    expect(validateCellValue("42", dv2)).toBe(false);
+  });
+
+  it("returns true for date/time/custom types", () => {
+    const dv1 = makeDv({ ref: "A1", type: "date" });
+    expect(validateCellValue("anything", dv1)).toBe(true);
+
+    const dv2 = makeDv({ ref: "A1", type: "custom" });
+    expect(validateCellValue("anything", dv2)).toBe(true);
+  });
+});

package/src/data_validation.ts

@@ -0,0 +1,114 @@
+// =============================================================================
+// Data Validation — Cell value validation logic
+// =============================================================================
+
+import type { ParsedDataValidation } from "./ooxml_chart_types";
+import { colLettersToNum } from "./excel_utils";
+
+// =============================================================================
+// Find validation rule for a cell
+// =============================================================================
+
+/** Find the first data validation rule that applies to the given cell. */
+export function findValidationForCell(
+  validations: ParsedDataValidation[],
+  row: number,
+  col: number,
+): ParsedDataValidation | undefined {
+  for (const dv of validations) {
+    const ranges = dv.ref.split(/\s+/);
+    for (const range of ranges) {
+      // Single cell: "A1"
+      const singleMatch = range.match(/^([A-Z]+)(\d+)$/);
+      if (singleMatch) {
+        const c = colLettersToNum(singleMatch[1]);
+        const r = parseInt(singleMatch[2], 10);
+        if (r === row && c === col) return dv;
+        continue;
+      }
+      // Range: "A1:C10"
+      const rangeMatch = range.match(/^([A-Z]+)(\d+):([A-Z]+)(\d+)$/);
+      if (rangeMatch) {
+        const sc = colLettersToNum(rangeMatch[1]);
+        const sr = parseInt(rangeMatch[2], 10);
+        const ec = colLettersToNum(rangeMatch[3]);
+        const er = parseInt(rangeMatch[4], 10);
+        if (row >= sr && row <= er && col >= sc && col <= ec) return dv;
+      }
+    }
+  }
+  return undefined;
+}
+
+// =============================================================================
+// Validate a cell value against a rule
+// =============================================================================
+
+/** Check whether a string value passes the validation rule. Returns true if valid. */
+export function validateCellValue(
+  value: string,
+  dv: ParsedDataValidation,
+): boolean {
+  if (dv.type === "none") return true;
+  if (!value && dv.type !== "textLength") return true; // empty values pass (Excel behavior)
+
+  switch (dv.type) {
+    case "list": {
+      if (!dv.formula1) return true;
+      const items = dv.formula1.split(",").map((v) => v.trim().replace(/^"|"$/g, ""));
+      return items.includes(value);
+    }
+    case "whole": {
+      const num = Number(value);
+      if (!Number.isInteger(num)) return false;
+      return checkNumericOperator(num, dv);
+    }
+    case "decimal": {
+      const num = Number(value);
+      if (isNaN(num)) return false;
+      return checkNumericOperator(num, dv);
+    }
+    case "textLength": {
+      const len = value.length;
+      return checkNumericOperator(len, dv);
+    }
+    // date, time, custom — accept for now (would need formula engine)
+    case "date":
+    case "time":
+    case "custom":
+      return true;
+    default:
+      return true;
+  }
+}
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+function checkNumericOperator(value: number, dv: ParsedDataValidation): boolean {
+  const f1 = dv.formula1 !== undefined ? Number(dv.formula1) : NaN;
+  const f2 = dv.formula2 !== undefined ? Number(dv.formula2) : NaN;
+  const op = dv.operator ?? "between";
+
+  switch (op) {
+    case "between":
+      return !isNaN(f1) && !isNaN(f2) && value >= f1 && value <= f2;
+    case "notBetween":
+      return !isNaN(f1) && !isNaN(f2) && (value < f1 || value > f2);
+    case "equal":
+      return !isNaN(f1) && value === f1;
+    case "notEqual":
+      return !isNaN(f1) && value !== f1;
+    case "greaterThan":
+      return !isNaN(f1) && value > f1;
+    case "lessThan":
+      return !isNaN(f1) && value < f1;
+    case "greaterThanOrEqual":
+      return !isNaN(f1) && value >= f1;
+    case "lessThanOrEqual":
+      return !isNaN(f1) && value <= f1;
+    default:
+      return true;
+  }
+}

package/src/editing_layer.test.ts

@@ -0,0 +1,309 @@
+import { SelectionModel, normalizeRange } from "./selection_model";
+import { CommandHistory } from "./command_history";
+import type { Command } from "./command_history";
+import type { SelectionEvent } from "./selection_model";
+
+// =============================================================================
+// SelectionModel
+// =============================================================================
+
+describe("SelectionModel", () => {
+  test("starts at A1", () => {
+    const sm = new SelectionModel(100, 26);
+    expect(sm.getActiveCellRef()).toBe("A1");
+    expect(sm.getState().activeCell).toEqual({ row: 1, col: 1 });
+  });
+
+  test("click sets active cell", () => {
+    const sm = new SelectionModel(100, 26);
+    sm.click(5, 3);
+    expect(sm.getState().activeCell).toEqual({ row: 5, col: 3 });
+    expect(sm.getActiveCellRef()).toBe("C5");
+  });
+
+  test("click clamps to bounds", () => {
+    const sm = new SelectionModel(10, 5);
+    sm.click(15, 8);
+    expect(sm.getState().activeCell).toEqual({ row: 10, col: 5 });
+  });
+
+  test("shift+click extends selection", () => {
+    const sm = new SelectionModel(100, 26);
+    sm.click(2, 2);
+    sm.click(5, 5, true);
+    const range = sm.getState().ranges[0];
+    expect(range.start).toEqual({ row: 2, col: 2 });
+    expect(range.end).toEqual({ row: 5, col: 5 });
+    expect(sm.getSelectionRef()).toBe("B2:E5");
+  });
+
+  test("ctrl+click adds range", () => {
+    const sm = new SelectionModel(100, 26);
+    sm.click(1, 1);
+    sm.click(3, 3, false, true);
+    expect(sm.getState().ranges).toHaveLength(2);
+  });
+
+  test("move navigates active cell", () => {
+    const sm = new SelectionModel(100, 26);
+    sm.move(1, 0); // down
+    expect(sm.getState().activeCell).toEqual({ row: 2, col: 1 });
+    sm.move(0, 1); // right
+    expect(sm.getState().activeCell).toEqual({ row: 2, col: 2 });
+    sm.move(-1, 0); // up
+    expect(sm.getState().activeCell).toEqual({ row: 1, col: 2 });
+  });
+
+  test("move clamps at boundaries", () => {
+    const sm = new SelectionModel(10, 5);
+    sm.move(-1, 0); // try up from row 1
+    expect(sm.getState().activeCell.row).toBe(1);
+    sm.move(0, -1); // try left from col 1
+    expect(sm.getState().activeCell.col).toBe(1);
+  });
+
+  test("shift+move extends selection", () => {
+    const sm = new SelectionModel(100, 26);
+    sm.click(3, 3);
+    sm.move(2, 2, true);
+    const range = sm.getState().ranges[0];
+    expect(range.start).toEqual({ row: 3, col: 3 });
+    expect(range.end).toEqual({ row: 5, col: 5 });
+  });
+
+  test("goTo moves to specific cell", () => {
+    const sm = new SelectionModel(100, 26);
+    sm.goTo(10, 5);
+    expect(sm.getState().activeCell).toEqual({ row: 10, col: 5 });
+    expect(sm.getSelectionRef()).toBe("E10");
+  });
+
+  test("drag selection", () => {
+    const sm = new SelectionModel(100, 26);
+    sm.dragStart(2, 2);
+    expect(sm.getState().dragging).toBe(true);
+    sm.dragMove(5, 5);
+    const range = sm.getState().ranges[0];
+    expect(range.end).toEqual({ row: 5, col: 5 });
+    sm.dragEnd();
+    expect(sm.getState().dragging).toBe(false);
+  });
+
+  test("edit mode", () => {
+    const sm = new SelectionModel(100, 26);
+    const events: SelectionEvent[] = [];
+    sm.onChange = (e) => events.push(e);
+
+    sm.startEdit("Hello");
+    expect(sm.getState().editing).toBe(true);
+    expect(sm.getState().editText).toBe("Hello");
+
+    sm.updateEditText("Hello World");
+    expect(sm.getState().editText).toBe("Hello World");
+
+    sm.commitEdit();
+    expect(sm.getState().editing).toBe(false);
+    expect(events.find((e) => e.type === "edit_end")).toBeDefined();
+  });
+
+  test("escape cancels edit", () => {
+    const sm = new SelectionModel(100, 26);
+    const events: SelectionEvent[] = [];
+    sm.onChange = (e) => events.push(e);
+
+    sm.startEdit("Hello");
+    sm.cancelEdit();
+
+    expect(sm.getState().editing).toBe(false);
+    const endEvent = events.find((e) => e.type === "edit_end");
+    expect(endEvent).toBeDefined();
+    if (endEvent?.type === "edit_end") {
+      expect(endEvent.commit).toBe(false);
+    }
+  });
+
+  test("click during edit commits the edit", () => {
+    const sm = new SelectionModel(100, 26);
+    const events: SelectionEvent[] = [];
+    sm.onChange = (e) => events.push(e);
+
+    sm.startEdit("Test");
+    sm.click(5, 5);
+
+    const endEvent = events.find((e) => e.type === "edit_end");
+    expect(endEvent).toBeDefined();
+    expect(sm.getState().activeCell).toEqual({ row: 5, col: 5 });
+  });
+
+  test("fires events on changes", () => {
+    const sm = new SelectionModel(100, 26);
+    const events: SelectionEvent[] = [];
+    sm.onChange = (e) => events.push(e);
+
+    sm.click(3, 3);
+    expect(events.some((e) => e.type === "active_cell_changed")).toBe(true);
+    expect(events.some((e) => e.type === "selection_changed")).toBe(true);
+  });
+
+  test("selectRange sets multi-cell selection", () => {
+    const sm = new SelectionModel(100, 26);
+    sm.selectRange(2, 2, 5, 4);
+    expect(sm.getState().activeCell).toEqual({ row: 2, col: 2 });
+    const range = sm.getState().ranges[0];
+    expect(range.start).toEqual({ row: 2, col: 2 });
+    expect(range.end).toEqual({ row: 5, col: 4 });
+    expect(sm.getSelectionRef()).toBe("B2:D5");
+  });
+
+  test("selectRange clamps to bounds", () => {
+    const sm = new SelectionModel(10, 5);
+    sm.selectRange(1, 1, 20, 10);
+    expect(sm.getState().activeCell).toEqual({ row: 1, col: 1 });
+    const range = sm.getState().ranges[0];
+    expect(range.end).toEqual({ row: 10, col: 5 });
+  });
+
+  test("selectRange commits editing first", () => {
+    const sm = new SelectionModel(100, 26);
+    const events: SelectionEvent[] = [];
+    sm.onChange = (e) => events.push(e);
+    sm.startEdit("test");
+    sm.selectRange(2, 2, 5, 4);
+    expect(sm.getState().editing).toBe(false);
+    expect(events.some((e) => e.type === "edit_end")).toBe(true);
+  });
+
+  test("selectRange fires both events", () => {
+    const sm = new SelectionModel(100, 26);
+    const events: SelectionEvent[] = [];
+    sm.onChange = (e) => events.push(e);
+    sm.selectRange(2, 2, 5, 4);
+    expect(events.some((e) => e.type === "active_cell_changed")).toBe(true);
+    expect(events.some((e) => e.type === "selection_changed")).toBe(true);
+  });
+});
+
+describe("normalizeRange", () => {
+  test("normalizes reversed range", () => {
+    const range = normalizeRange({
+      start: { row: 5, col: 5 },
+      end: { row: 1, col: 1 },
+    });
+    expect(range.start).toEqual({ row: 1, col: 1 });
+    expect(range.end).toEqual({ row: 5, col: 5 });
+  });
+
+  test("keeps already-normalized range", () => {
+    const range = normalizeRange({
+      start: { row: 1, col: 1 },
+      end: { row: 5, col: 5 },
+    });
+    expect(range.start).toEqual({ row: 1, col: 1 });
+    expect(range.end).toEqual({ row: 5, col: 5 });
+  });
+});
+
+// =============================================================================
+// CommandHistory
+// =============================================================================
+
+describe("CommandHistory", () => {
+  function makeCommand(
+    desc: string,
+    onExecute: () => void,
+    onUndo: () => void,
+  ): Command {
+    return { description: desc, execute: onExecute, undo: onUndo };
+  }
+
+  test("execute adds to undo stack", () => {
+    const h = new CommandHistory();
+    let value = 0;
+    h.execute(makeCommand("set 1", () => { value = 1; }, () => { value = 0; }));
+    expect(value).toBe(1);
+    expect(h.canUndo).toBe(true);
+    expect(h.canRedo).toBe(false);
+  });
+
+  test("undo reverses command", () => {
+    const h = new CommandHistory();
+    let value = 0;
+    h.execute(makeCommand("set 1", () => { value = 1; }, () => { value = 0; }));
+    h.undo();
+    expect(value).toBe(0);
+    expect(h.canUndo).toBe(false);
+    expect(h.canRedo).toBe(true);
+  });
+
+  test("redo re-applies command", () => {
+    const h = new CommandHistory();
+    let value = 0;
+    h.execute(makeCommand("set 1", () => { value = 1; }, () => { value = 0; }));
+    h.undo();
+    h.redo();
+    expect(value).toBe(1);
+    expect(h.canUndo).toBe(true);
+    expect(h.canRedo).toBe(false);
+  });
+
+  test("new command clears redo stack", () => {
+    const h = new CommandHistory();
+    let value = 0;
+    h.execute(makeCommand("set 1", () => { value = 1; }, () => { value = 0; }));
+    h.undo();
+    h.execute(makeCommand("set 2", () => { value = 2; }, () => { value = 0; }));
+    expect(h.canRedo).toBe(false);
+    expect(value).toBe(2);
+  });
+
+  test("multiple undo/redo", () => {
+    const h = new CommandHistory();
+    const log: number[] = [];
+    h.execute(makeCommand("push 1", () => log.push(1), () => log.pop()));
+    h.execute(makeCommand("push 2", () => log.push(2), () => log.pop()));
+    h.execute(makeCommand("push 3", () => log.push(3), () => log.pop()));
+    expect(log).toEqual([1, 2, 3]);
+
+    h.undo();
+    expect(log).toEqual([1, 2]);
+    h.undo();
+    expect(log).toEqual([1]);
+    h.redo();
+    expect(log).toEqual([1, 2]);
+  });
+
+  test("max size trims oldest entries", () => {
+    const h = new CommandHistory(3);
+    for (let i = 0; i < 5; i++) {
+      h.execute(makeCommand(`cmd ${i}`, () => {}, () => {}));
+    }
+    expect(h.undoSize).toBe(3);
+  });
+
+  test("undo/redo return descriptions", () => {
+    const h = new CommandHistory();
+    h.execute(makeCommand("Set value", () => {}, () => {}));
+    expect(h.undoDescription).toBe("Set value");
+    const desc = h.undo();
+    expect(desc).toBe("Set value");
+    expect(h.redoDescription).toBe("Set value");
+  });
+
+  test("clear empties stacks", () => {
+    const h = new CommandHistory();
+    h.execute(makeCommand("cmd", () => {}, () => {}));
+    h.clear();
+    expect(h.canUndo).toBe(false);
+    expect(h.canRedo).toBe(false);
+  });
+
+  test("undo on empty returns undefined", () => {
+    const h = new CommandHistory();
+    expect(h.undo()).toBeUndefined();
+  });
+
+  test("redo on empty returns undefined", () => {
+    const h = new CommandHistory();
+    expect(h.redo()).toBeUndefined();
+  });
+});