@lotics/xlsx 0.1.0

package/src/formula_suggest.ts

@@ -0,0 +1,100 @@
+// =============================================================================
+// Formula Function-name Autocomplete
+// =============================================================================
+//
+// Given a formula string and cursor position, return matching Excel function
+// names that should be offered as completions. The active token is the
+// alphabetic identifier ending at the cursor; the user is "in formula mode"
+// when the text starts with `=`.
+// =============================================================================
+
+const FUNCTION_NAMES = [
+  // Math & trig
+  "ABS","ACOS","ACOSH","ASIN","ASINH","ATAN","ATAN2","ATANH","CEILING","COS","COSH","DEGREES","EVEN","EXP","FACT","FACTDOUBLE","FLOOR","GCD","INT","LCM","LN","LOG","LOG10","MOD","MROUND","ODD","PI","POWER","PRODUCT","QUOTIENT","RADIANS","RAND","RANDBETWEEN","ROUND","ROUNDDOWN","ROUNDUP","SEC","SECH","SIGN","SIN","SINH","SQRT","SUBTOTAL","SUM","SUMIF","SUMIFS","SUMPRODUCT","SUMSQ","TAN","TANH","TRUNC",
+  // Statistical
+  "AVERAGE","AVERAGEA","AVERAGEIF","AVERAGEIFS","COUNT","COUNTA","COUNTBLANK","COUNTIF","COUNTIFS","LARGE","MAX","MAXA","MAXIFS","MEDIAN","MIN","MINA","MINIFS","MODE","PERCENTILE","QUARTILE","RANK","SLOPE","SMALL","STDEV","STDEVA","STDEVP","VAR","VARA","VARP",
+  // Logical
+  "AND","FALSE","IF","IFERROR","IFNA","IFS","NOT","OR","SWITCH","TRUE","XOR",
+  // Lookup & reference
+  "ADDRESS","CHOOSE","COLUMN","COLUMNS","HLOOKUP","HYPERLINK","INDEX","INDIRECT","LOOKUP","MATCH","OFFSET","ROW","ROWS","TRANSPOSE","VLOOKUP","XLOOKUP","XMATCH",
+  // Text
+  "CHAR","CLEAN","CODE","CONCAT","CONCATENATE","DOLLAR","EXACT","FIND","FIXED","LEFT","LEN","LOWER","MID","PROPER","REPLACE","REPT","RIGHT","SEARCH","SUBSTITUTE","T","TEXT","TEXTJOIN","TRIM","UNICHAR","UNICODE","UPPER","VALUE",
+  // Date & time
+  "DATE","DATEDIF","DATEVALUE","DAY","DAYS","DAYS360","EDATE","EOMONTH","HOUR","ISOWEEKNUM","MINUTE","MONTH","NETWORKDAYS","NOW","SECOND","TIME","TIMEVALUE","TODAY","WEEKDAY","WEEKNUM","WORKDAY","YEAR","YEARFRAC",
+  // Information
+  "CELL","ERROR.TYPE","INFO","ISBLANK","ISERR","ISERROR","ISEVEN","ISFORMULA","ISLOGICAL","ISNA","ISNONTEXT","ISNUMBER","ISODD","ISREF","ISTEXT","N","NA","TYPE",
+  // Financial (most common)
+  "FV","IRR","NPER","NPV","PMT","PPMT","PV","RATE","XIRR","XNPV",
+  // Engineering (common)
+  "BIN2DEC","DEC2BIN","DEC2HEX","HEX2DEC",
+  // Database
+  "DAVERAGE","DCOUNT","DCOUNTA","DGET","DMAX","DMIN","DPRODUCT","DSTDEV","DSUM","DVAR",
+];
+
+export interface FormulaSuggestion {
+  /** The full function name (e.g. "VLOOKUP"). */
+  name: string;
+  /** Substring of `name` that matched the user's input. */
+  matchStart: number;
+  matchEnd: number;
+}
+
+export interface FormulaSuggestResult {
+  suggestions: FormulaSuggestion[];
+  /** Start index in the input where the active token begins. The caller uses
+   *  this when accepting a suggestion to splice in the function name. */
+  tokenStart: number;
+  /** Cursor position (== end of token). */
+  tokenEnd: number;
+}
+
+/**
+ * Compute function-name suggestions based on a partial token at the cursor.
+ * Returns an empty list when the text isn't a formula (`=` prefix) or when
+ * the cursor is not on an alphabetic identifier.
+ */
+export function getFormulaSuggestions(
+  text: string,
+  cursor: number,
+  limit = 8,
+): FormulaSuggestResult {
+  const empty: FormulaSuggestResult = { suggestions: [], tokenStart: cursor, tokenEnd: cursor };
+  if (!text.startsWith("=")) return empty;
+
+  // Walk backwards from the cursor while we see alphabetic chars or '.'
+  // (Excel function names like ERROR.TYPE include dot).
+  let start = cursor;
+  while (start > 0) {
+    const c = text[start - 1];
+    if (!/[A-Za-z.]/.test(c)) break;
+    start--;
+  }
+  if (start === cursor) return empty;
+
+  const token = text.slice(start, cursor).toUpperCase();
+  if (token.length === 0) return empty;
+
+  const suggestions: FormulaSuggestion[] = [];
+  for (const name of FUNCTION_NAMES) {
+    if (name.startsWith(token) && name !== token) {
+      suggestions.push({ name, matchStart: 0, matchEnd: token.length });
+      if (suggestions.length >= limit) break;
+    }
+  }
+  return { suggestions, tokenStart: start, tokenEnd: cursor };
+}
+
+/**
+ * Apply a chosen suggestion to the text + cursor, returning the new pair.
+ * Inserts an opening parenthesis after the function name and positions the
+ * cursor inside it — Excel's behavior on autocomplete acceptance.
+ */
+export function applyFormulaSuggestion(
+  text: string,
+  suggestion: FormulaSuggestion,
+  range: { start: number; end: number },
+): { text: string; cursor: number } {
+  const inserted = `${suggestion.name}(`;
+  const newText = text.slice(0, range.start) + inserted + text.slice(range.end);
+  return { text: newText, cursor: range.start + inserted.length };
+}

package/src/hidden_sheets.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect } from "vitest";
+import { parseExcelFromZip } from "./excel_parser";
+
+const enc = (s: string) => new TextEncoder().encode(s);
+
+// Minimal two-sheet workbook: one visible, one hidden.
+const WORKBOOK = `<?xml version="1.0"?>
+<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+  <sheets>
+    <sheet name="Visible" sheetId="1" r:id="rId1"/>
+    <sheet name="Secret" sheetId="2" state="hidden" r:id="rId2"/>
+  </sheets>
+</workbook>`;
+
+const RELS = `<?xml version="1.0"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet1.xml"/>
+  <Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet2.xml"/>
+</Relationships>`;
+
+const sheetXml = (cell: string) => `<?xml version="1.0"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <sheetData><row r="1"><c r="A1" t="inlineStr"><is><t>${cell}</t></is></c></row></sheetData>
+</worksheet>`;
+
+describe("parseExcelFromZip — hidden sheets", () => {
+  const wb = parseExcelFromZip({
+    "xl/workbook.xml": enc(WORKBOOK),
+    "xl/_rels/workbook.xml.rels": enc(RELS),
+    "xl/worksheets/sheet1.xml": enc(sheetXml("public")),
+    "xl/worksheets/sheet2.xml": enc(sheetXml("classified")),
+  });
+
+  it("includes hidden sheets instead of dropping them", () => {
+    expect(wb.sheets.map((s) => s.name)).toEqual(["Visible", "Secret"]);
+  });
+
+  it("tags only the hidden sheet via the `hidden` flag", () => {
+    const visible = wb.sheets.find((s) => s.name === "Visible")!;
+    const secret = wb.sheets.find((s) => s.name === "Secret")!;
+    expect(visible.hidden).toBeFalsy();
+    expect(secret.hidden).toBe(true);
+  });
+
+  it("parses the hidden sheet's cell data", () => {
+    const secret = wb.sheets.find((s) => s.name === "Secret")!;
+    expect(secret.rows[0]?.cells[0]?.value).toBe("classified");
+  });
+});

package/src/index.ts

@@ -0,0 +1,149 @@
+// =============================================================================
+// @lotics/xlsx — public barrel
+// =============================================================================
+//
+// The curated public surface of the package. New code should import from
+// this barrel; existing subpath imports continue to work for backward
+// compatibility but are considered legacy.
+//
+// Internals NOT re-exported here (canvas renderer, OOXML parser internals,
+// formula engine internals) remain reachable via subpath imports for
+// embedders that explicitly need them, but they are not part of the
+// stability contract.
+
+// -----------------------------------------------------------------------------
+// Types
+// -----------------------------------------------------------------------------
+
+export type {
+  ParsedSpreadsheet,
+  ParsedSheet,
+  ParsedCell,
+  ParsedColumn,
+  ParsedRow,
+  ParsedImage,
+  CellStyle,
+  BorderStyle,
+  CellContent,
+  RichTextPart,
+  RichTextFont,
+  GradientData,
+  MergedCellRange,
+  FreezePane,
+  PageSetup,
+  PrintTitles,
+  HeaderFooter,
+} from "./types";
+
+export { PasswordProtectedError } from "./types";
+
+// -----------------------------------------------------------------------------
+// Workbook model & cell storage
+// -----------------------------------------------------------------------------
+
+export {
+  WorkbookModel,
+  SheetModel,
+  StyleRegistry,
+  CellMap,
+  loadWorkbookFromSnapshot,
+  materializeDisplayValue,
+} from "./workbook_model";
+
+export type { CellModel, CellValue, ChangeEvent } from "./workbook_model";
+
+// -----------------------------------------------------------------------------
+// Color utilities — canonical `#RRGGBB` everywhere
+// -----------------------------------------------------------------------------
+
+export {
+  normalizeColor,
+  hexToArgb,
+  hexToOoxmlRgb,
+  prefixHex,
+  applyTint,
+} from "./ooxml_color";
+
+// -----------------------------------------------------------------------------
+// Cell reference / coordinate utilities
+// -----------------------------------------------------------------------------
+
+export {
+  refToRowCol,
+  rowColToRef,
+  colLettersToNum,
+  colNumToLetters,
+  parseNameBoxInput,
+  buildNamedRangeExpr,
+  packRef,
+  unpackRef,
+  packRowCol,
+  unpackRowCol,
+} from "./excel_utils";
+
+export type { ParsedInput } from "./excel_utils";
+
+// -----------------------------------------------------------------------------
+// Style helpers
+// -----------------------------------------------------------------------------
+
+export { allBorders, bottomBorder, topBorder } from "./style_helpers";
+
+// -----------------------------------------------------------------------------
+// I/O — parse from .xlsx, export to .xlsx
+// -----------------------------------------------------------------------------
+
+export {
+  parseExcelBuffer,
+  parseExcelFromZip,
+} from "./excel_parser";
+
+export { exportWorkbook } from "./xlsx_writer";
+
+export { unzipXlsx } from "./ooxml_zip";
+
+// -----------------------------------------------------------------------------
+// Spreadsheet commands (mutations with undo/redo support)
+// -----------------------------------------------------------------------------
+
+export {
+  setCellValueCommand,
+  setCellStyleCommand,
+  setRangeStyleCommand,
+  setRangeNumFmtCommand,
+  deleteCellCommand,
+  clearRangeCommand,
+  mergeCellsCommand,
+  unmergeCellsCommand,
+  insertRowsCommand,
+  deleteRowsCommand,
+  insertColsCommand,
+  deleteColsCommand,
+  setColWidthCommand,
+  setRowHeightCommand,
+  setNamedRangeCommand,
+  addSheetCommand,
+  deleteSheetCommand,
+  renameSheetCommand,
+  batchCommand,
+  setHiddenRowsCommand,
+  setHiddenColsCommand,
+  sortColumnCommand,
+  multiSortCommand,
+  setFreezePanesCommand,
+  setZoomCommand,
+  addConditionalFormatCommand,
+  deleteConditionalFormatCommand,
+  reorderSheetsCommand,
+  insertCellsShiftDownCommand,
+  // Merge-range and formula-range adjusters used by the placeholder engine.
+  // Public so external template engines can call them; the row/col commands
+  // call them internally too.
+  adjustMergedCellsForRowInsert,
+  adjustMergedCellsForRowDelete,
+  adjustMergedCellsForColInsert,
+  adjustMergedCellsForColDelete,
+  expandFormulaRangesForRowInsert,
+} from "./spreadsheet_commands";
+
+export type { SortSpec } from "./spreadsheet_commands";

package/src/keyboard_nav.test.ts

@@ -0,0 +1,394 @@
+import { SelectionModel } from "./selection_model";
+import { CommandHistory } from "./command_history";
+import { WorkbookModel, SheetModel, StyleRegistry } from "./workbook_model";
+import { handleKeyDown, type KeyboardNavContext } from "./keyboard_nav";
+import type { ClipboardData } from "./clipboard";
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+function makeWorkbook(): WorkbookModel {
+  const styles = new StyleRegistry();
+  const sheet = new SheetModel("Sheet1");
+  // Add some test data
+  sheet.set("A1", "Hello");
+  sheet.set("B1", 42);
+  sheet.set("A2", "World");
+  sheet.set("C3", 100);
+  return new WorkbookModel({
+    sheets: [sheet],
+    activeSheetIndex: 0,
+    styles,
+  });
+}
+
+function makeContext(overrides?: Partial<KeyboardNavContext>): KeyboardNavContext {
+  const workbook = overrides?.workbook ?? makeWorkbook();
+  const selection = overrides?.selection ?? new SelectionModel(100, 26);
+  return {
+    selection,
+    workbook,
+    sheetIndex: 0,
+    history: new CommandHistory(),
+    engine: undefined,
+    clipboardData: undefined,
+    setClipboardData: () => {},
+    onStartEdit: () => {},
+    onRedraw: () => {},
+    pageSize: 20,
+    ...overrides,
+  };
+}
+
+function makeKey(key: string, opts?: {
+  ctrlKey?: boolean;
+  metaKey?: boolean;
+  shiftKey?: boolean;
+  altKey?: boolean;
+}): KeyboardEvent {
+  // Use a plain object — no DOM KeyboardEvent constructor in Node
+  return {
+    key,
+    ctrlKey: opts?.ctrlKey ?? false,
+    metaKey: opts?.metaKey ?? false,
+    shiftKey: opts?.shiftKey ?? false,
+    altKey: opts?.altKey ?? false,
+  } as unknown as KeyboardEvent;
+}
+
+// =============================================================================
+// Tests
+// =============================================================================
+
+describe("handleKeyDown", () => {
+  describe("arrow key navigation", () => {
+    test("ArrowDown moves active cell down", () => {
+      const ctx = makeContext();
+      const handled = handleKeyDown(makeKey("ArrowDown"), ctx);
+      expect(handled).toBe(true);
+      expect(ctx.selection.getState().activeCell).toEqual({ row: 2, col: 1 });
+    });
+
+    test("ArrowUp moves active cell up", () => {
+      const ctx = makeContext();
+      ctx.selection.click(3, 3);
+      const handled = handleKeyDown(makeKey("ArrowUp"), ctx);
+      expect(handled).toBe(true);
+      expect(ctx.selection.getState().activeCell).toEqual({ row: 2, col: 3 });
+    });
+
+    test("ArrowRight moves active cell right", () => {
+      const ctx = makeContext();
+      const handled = handleKeyDown(makeKey("ArrowRight"), ctx);
+      expect(handled).toBe(true);
+      expect(ctx.selection.getState().activeCell).toEqual({ row: 1, col: 2 });
+    });
+
+    test("ArrowLeft moves active cell left", () => {
+      const ctx = makeContext();
+      ctx.selection.click(1, 3);
+      const handled = handleKeyDown(makeKey("ArrowLeft"), ctx);
+      expect(handled).toBe(true);
+      expect(ctx.selection.getState().activeCell).toEqual({ row: 1, col: 2 });
+    });
+
+    test("Shift+Arrow extends selection", () => {
+      const ctx = makeContext();
+      ctx.selection.click(3, 3);
+      handleKeyDown(makeKey("ArrowDown", { shiftKey: true }), ctx);
+      const range = ctx.selection.getState().ranges[0];
+      expect(range.start).toEqual({ row: 3, col: 3 });
+      expect(range.end).toEqual({ row: 4, col: 3 });
+    });
+  });
+
+  describe("Tab and Enter", () => {
+    test("Tab moves right", () => {
+      const ctx = makeContext();
+      const handled = handleKeyDown(makeKey("Tab"), ctx);
+      expect(handled).toBe(true);
+      expect(ctx.selection.getState().activeCell).toEqual({ row: 1, col: 2 });
+    });
+
+    test("Shift+Tab moves left", () => {
+      const ctx = makeContext();
+      ctx.selection.click(1, 3);
+      handleKeyDown(makeKey("Tab", { shiftKey: true }), ctx);
+      expect(ctx.selection.getState().activeCell).toEqual({ row: 1, col: 2 });
+    });
+
+    test("Enter moves down", () => {
+      const ctx = makeContext();
+      const handled = handleKeyDown(makeKey("Enter"), ctx);
+      expect(handled).toBe(true);
+      expect(ctx.selection.getState().activeCell).toEqual({ row: 2, col: 1 });
+    });
+
+    test("Shift+Enter moves up", () => {
+      const ctx = makeContext();
+      ctx.selection.click(3, 1);
+      handleKeyDown(makeKey("Enter", { shiftKey: true }), ctx);
+      expect(ctx.selection.getState().activeCell).toEqual({ row: 2, col: 1 });
+    });
+  });
+
+  describe("Home key", () => {
+    test("Home moves to column 1", () => {
+      const ctx = makeContext();
+      ctx.selection.click(5, 10);
+      handleKeyDown(makeKey("Home"), ctx);
+      expect(ctx.selection.getState().activeCell).toEqual({ row: 5, col: 1 });
+    });
+
+    test("Ctrl+Home moves to A1", () => {
+      const ctx = makeContext();
+      ctx.selection.click(5, 10);
+      handleKeyDown(makeKey("Home", { ctrlKey: true }), ctx);
+      expect(ctx.selection.getState().activeCell).toEqual({ row: 1, col: 1 });
+    });
+  });
+
+  describe("Page Up/Down", () => {
+    test("PageDown moves by pageSize rows", () => {
+      const ctx = makeContext({ pageSize: 10 });
+      const handled = handleKeyDown(makeKey("PageDown"), ctx);
+      expect(handled).toBe(true);
+      expect(ctx.selection.getState().activeCell.row).toBe(11);
+    });
+
+    test("PageUp moves up by pageSize rows", () => {
+      const ctx = makeContext({ pageSize: 10 });
+      ctx.selection.click(20, 1);
+      handleKeyDown(makeKey("PageUp"), ctx);
+      expect(ctx.selection.getState().activeCell.row).toBe(10);
+    });
+  });
+
+  describe("Delete and Backspace", () => {
+    test("Delete clears cell value via command", () => {
+      const ctx = makeContext();
+      ctx.selection.click(1, 1); // A1 has "Hello"
+      handleKeyDown(makeKey("Delete"), ctx);
+      expect(ctx.workbook.sheets[0].getCell("A1")).toBeUndefined();
+    });
+
+    test("Backspace clears cell and starts edit", () => {
+      const editCalls: string[] = [];
+      const ctx = makeContext({
+        onStartEdit: (text) => editCalls.push(text ?? ""),
+      });
+      ctx.selection.click(1, 1);
+      handleKeyDown(makeKey("Backspace"), ctx);
+      expect(ctx.workbook.sheets[0].getCell("A1")).toBeUndefined();
+      expect(editCalls).toContain("");
+    });
+  });
+
+  describe("F2 — edit mode", () => {
+    test("F2 starts edit with existing cell value", () => {
+      const editCalls: string[] = [];
+      const ctx = makeContext({
+        onStartEdit: (text) => editCalls.push(text ?? ""),
+      });
+      ctx.selection.click(1, 1); // A1 = "Hello"
+      handleKeyDown(makeKey("F2"), ctx);
+      expect(editCalls).toContain("Hello");
+    });
+
+    test("F2 on formula cell shows = prefix", () => {
+      const workbook = makeWorkbook();
+      workbook.sheets[0].set("D1", null, undefined, undefined, "SUM(A1:B1)");
+      const editCalls: string[] = [];
+      const ctx = makeContext({
+        workbook,
+        onStartEdit: (text) => editCalls.push(text ?? ""),
+      });
+      ctx.selection.click(1, 4); // D1
+      handleKeyDown(makeKey("F2"), ctx);
+      expect(editCalls).toContain("=SUM(A1:B1)");
+    });
+  });
+
+  describe("printable character starts edit", () => {
+    test("typing a letter starts edit", () => {
+      const editCalls: string[] = [];
+      const ctx = makeContext({
+        onStartEdit: (text) => editCalls.push(text ?? ""),
+      });
+      handleKeyDown(makeKey("a"), ctx);
+      expect(editCalls).toContain("a");
+    });
+
+    test("typing a digit starts edit", () => {
+      const editCalls: string[] = [];
+      const ctx = makeContext({
+        onStartEdit: (text) => editCalls.push(text ?? ""),
+      });
+      handleKeyDown(makeKey("5"), ctx);
+      expect(editCalls).toContain("5");
+    });
+
+    test("ctrl+key is not printable", () => {
+      const editCalls: string[] = [];
+      const ctx = makeContext({
+        onStartEdit: (text) => editCalls.push(text ?? ""),
+      });
+      handleKeyDown(makeKey("a", { ctrlKey: true }), ctx);
+      // Ctrl+A is select all, not printable edit
+      expect(editCalls).toHaveLength(0);
+    });
+  });
+
+  describe("Ctrl+Z/Y — undo/redo", () => {
+    test("Ctrl+Z undoes last command", () => {
+      const ctx = makeContext();
+      ctx.selection.click(1, 1);
+      // Delete cell via command
+      handleKeyDown(makeKey("Delete"), ctx);
+      expect(ctx.workbook.sheets[0].getCell("A1")).toBeUndefined();
+      // Undo
+      handleKeyDown(makeKey("z", { ctrlKey: true }), ctx);
+      expect(ctx.workbook.sheets[0].getCell("A1")).toBeDefined();
+    });
+
+    test("Ctrl+Y redoes undone command", () => {
+      const ctx = makeContext();
+      ctx.selection.click(1, 1);
+      handleKeyDown(makeKey("Delete"), ctx);
+      handleKeyDown(makeKey("z", { ctrlKey: true }), ctx);
+      expect(ctx.workbook.sheets[0].getCell("A1")).toBeDefined();
+      handleKeyDown(makeKey("y", { ctrlKey: true }), ctx);
+      expect(ctx.workbook.sheets[0].getCell("A1")).toBeUndefined();
+    });
+
+    test("Ctrl+Shift+Z redoes", () => {
+      const ctx = makeContext();
+      ctx.selection.click(1, 1);
+      handleKeyDown(makeKey("Delete"), ctx);
+      handleKeyDown(makeKey("z", { ctrlKey: true }), ctx);
+      handleKeyDown(makeKey("z", { ctrlKey: true, shiftKey: true }), ctx);
+      expect(ctx.workbook.sheets[0].getCell("A1")).toBeUndefined();
+    });
+  });
+
+  describe("Ctrl+C/X/V — clipboard", () => {
+    test("Ctrl+C copies selection to clipboard buffer", () => {
+      let storedClipboard: ClipboardData | undefined;
+      const ctx = makeContext({
+        setClipboardData: (d) => { storedClipboard = d; },
+      });
+      ctx.selection.click(1, 1);
+      handleKeyDown(makeKey("c", { ctrlKey: true }), ctx);
+      expect(storedClipboard).toBeDefined();
+      expect(storedClipboard!.cells[0][0]?.displayValue).toBe("Hello");
+      expect(storedClipboard!.isCut).toBe(false);
+    });
+
+    test("Ctrl+X sets isCut flag", () => {
+      let storedClipboard: ClipboardData | undefined;
+      const ctx = makeContext({
+        setClipboardData: (d) => { storedClipboard = d; },
+      });
+      ctx.selection.click(1, 1);
+      handleKeyDown(makeKey("x", { ctrlKey: true }), ctx);
+      expect(storedClipboard!.isCut).toBe(true);
+    });
+  });
+
+  describe("Ctrl+B/I/U — style toggling", () => {
+    test("Ctrl+B toggles bold", () => {
+      const ctx = makeContext();
+      ctx.selection.click(1, 1);
+      handleKeyDown(makeKey("b", { ctrlKey: true }), ctx);
+      const cell = ctx.workbook.sheets[0].getCell("A1");
+      expect(cell).toBeDefined();
+      const style = ctx.workbook.styles.get(cell!.styleIndex);
+      expect(style.fontBold).toBe(true);
+    });
+
+    test("Ctrl+I toggles italic", () => {
+      const ctx = makeContext();
+      ctx.selection.click(1, 1);
+      handleKeyDown(makeKey("i", { ctrlKey: true }), ctx);
+      const cell = ctx.workbook.sheets[0].getCell("A1");
+      const style = ctx.workbook.styles.get(cell!.styleIndex);
+      expect(style.fontItalic).toBe(true);
+    });
+  });
+
+  describe("Ctrl+A — select all", () => {
+    test("selects used range", () => {
+      const ctx = makeContext();
+      handleKeyDown(makeKey("a", { ctrlKey: true }), ctx);
+      const range = ctx.selection.getState().ranges[0];
+      // Used range is A1:C3 based on test data
+      expect(range.start).toEqual({ row: 1, col: 1 });
+      expect(range.end).toEqual({ row: 3, col: 3 });
+    });
+  });
+
+  describe("editing mode keys", () => {
+    test("Enter during edit commits and moves down", () => {
+      const ctx = makeContext();
+      ctx.selection.startEdit("test");
+      expect(ctx.selection.getState().editing).toBe(true);
+      handleKeyDown(makeKey("Enter"), ctx);
+      expect(ctx.selection.getState().editing).toBe(false);
+      expect(ctx.selection.getState().activeCell).toEqual({ row: 2, col: 1 });
+    });
+
+    test("Tab during edit commits and moves right", () => {
+      const ctx = makeContext();
+      ctx.selection.startEdit("test");
+      handleKeyDown(makeKey("Tab"), ctx);
+      expect(ctx.selection.getState().editing).toBe(false);
+      expect(ctx.selection.getState().activeCell).toEqual({ row: 1, col: 2 });
+    });
+
+    test("Escape during edit cancels", () => {
+      const ctx = makeContext();
+      ctx.selection.startEdit("test");
+      handleKeyDown(makeKey("Escape"), ctx);
+      expect(ctx.selection.getState().editing).toBe(false);
+    });
+
+    test("regular key during edit returns false (input handles it)", () => {
+      const ctx = makeContext();
+      ctx.selection.startEdit("test");
+      const handled = handleKeyDown(makeKey("a"), ctx);
+      expect(handled).toBe(false);
+    });
+  });
+
+  describe("Ctrl+Arrow — jump to data edge", () => {
+    test("Ctrl+ArrowDown jumps to last data cell in column", () => {
+      const ctx = makeContext();
+      ctx.selection.click(1, 1); // A1 has data
+      handleKeyDown(makeKey("ArrowDown", { ctrlKey: true }), ctx);
+      // A1="Hello", A2="World", A3 is empty → should jump to A2
+      expect(ctx.selection.getState().activeCell.row).toBe(2);
+    });
+
+    test("Ctrl+ArrowRight jumps to last data cell in row", () => {
+      const ctx = makeContext();
+      ctx.selection.click(1, 1); // Row 1: A1, B1 have data
+      handleKeyDown(makeKey("ArrowRight", { ctrlKey: true }), ctx);
+      expect(ctx.selection.getState().activeCell.col).toBe(2); // B1
+    });
+  });
+
+  describe("unhandled keys", () => {
+    test("Alt key returns false", () => {
+      const ctx = makeContext();
+      const handled = handleKeyDown(makeKey("a", { altKey: true }), ctx);
+      expect(handled).toBe(false);
+    });
+
+    test("Escape outside editing returns false", () => {
+      const ctx = makeContext();
+      const handled = handleKeyDown(makeKey("Escape"), ctx);
+      expect(handled).toBe(false);
+    });
+  });
+});