Excel keyboard shortcuts

The muscle memory a spreadsheet user arrives with, on any <SvGrid> with cell selection on. One call turns it on:

import { setLicenseKey, enableSheet } from '@svgrid/enterprise'

setLicenseKey('YOUR-KEY')
enableSheet()

<SvGrid {data} {columns} enableCellSelection enableInlineEditing />

enableSheet() is idempotent, so call it from every component that wants it or once at app start. installEnterprise() calls it for you.

If you only want the shortcuts, import from the /sheet subpath so the rest of the pack (export, pivot, the scheduler, the board) stays out of your bundle:

import { enableSheet } from '@svgrid/enterprise/sheet'

The keymap

Navigation

The mouse follows Excel's rules too: a click on a column letter or a row number selects the whole line and puts the active cell on its first VISIBLE row or column, a drag along the letters or the numbers selects a run, Shift+click extends the run from the active cell's line, Ctrl+click adds a line beside the selection, and the corner selects everything without moving the active cell. The keyboard stays on the sheet afterwards: an arrow collapses to the active cell, Shift+Arrow grows a run of whole lines, and typing lands in the active cell. Shift+Arrow and the extending keys scroll along their own axis only, so a whole-column selection does not jump to the bottom of the sheet when it grows sideways.

Fill and entry

Formatting

These write through the store you attach with setFormatTarget. Until you attach one they decline, so the key falls through rather than looking broken. See number formats.

Structure, search and paste

These open your own chrome rather than any this layer ships, through setFindReplaceHandler, setPasteSpecialHandler and setFormatDialogHandler. See paste, find and structure.

The last seven raise the same actions as the ribbon buttons that name them; on a plain grid, setRibbonActionHandler decides what answers.

A command that needs the clipboard calls cmd.copy(), cmd.cut() or cmd.paste() on its GridCommandContext: the selection copy, cut and paste that Ctrl+C, Ctrl+X and Ctrl+V run, cell by cell through processCellForClipboard. A collapsed row is left out of a copy and a fill unless the grid's includeCollapsedRows says otherwise for it, which is how a spreadsheet copies a row hidden by hand and skips one a filter folded, and fills the same way. The api's copyToClipboard is something else, the export of the displayed rows with their headers.

Workbook

These need a workbook attached with setWorkbook; without one they decline, so a single-sheet grid leaves Ctrl+PageDown to the browser. See workbooks.

What Ctrl+Arrow actually does

It is not "move a long way". It is a run-boundary search, and the rule depends on what you are standing on:

• On a filled cell whose neighbour is also filled: run to the last filled cell before the next blank. This is how you get from the top of a column to its bottom in one press.
• On a filled cell whose neighbour is blank: skip the gap and land on the next filled cell. This is how you hop between blocks.
• On a blank cell: skip to the next filled cell.
• Nothing filled ahead: land on the last cell of the sheet in that direction.

A cell holding null, undefined or '' counts as blank. A 0, a false and a whitespace-only string are content, so a column of zeroes does not trap the cursor.

Fill has two behaviours, like Excel

Ctrl+D with a range selected copies the top row of that range into every row below it. With a single cell selected it pulls from the cell directly above instead, which is what makes it useful while typing down a column. Ctrl+R mirrors both, across instead of down.

Both run as one undoable action: filling thirty rows takes one Ctrl+Z, not thirty.

Fill is reference-aware: =A1*2 filled one row down becomes =A2*2, while =$A$1*B1 keeps its anchor and becomes =$A$1*B2. See spreadsheet formulas.

Ctrl+' is deliberately not a fill. It copies the cell above verbatim, so you get an unshifted copy of the formula to edit rather than one that has already moved.

Dates land as ISO, not as display text

Ctrl+; writes 2026-09-13, not 13/09/2026. The value goes into your data and a column's own format decides how it reads; stamping a localised string would put display text in the model.

What the grid still owns

enableSheet() does not take every key. Copy, cut, plain paste, undo, redo and find stay with the grid, and the plain arrow keys still move one cell. A command only claims a key when it has something to do: Ctrl+D on the top row with nothing above it declines, and the key falls through to the grid.

While a cell editor is open, every shortcut here declines, so nothing swallows a keystroke you meant for the editor.

Escape closes what is open

Escape backs out of whatever is in front, the way Excel's does: the marching ants after a copy, an open right-click menu, or a dialog. A right-click menu closes on Escape as well as on a click away, so a keyboard user who opened it is never trapped under it. A dialog opens with focus on its first control - the active tab or the first field - never the header close button, so Enter runs the dialog's primary action rather than dismissing it the instant it opens; Escape closes it and hands focus back to the cells.

Binding your own

The registry the sheet keymap uses is public and free, in @svgrid/grid:

import { registerGridShortcuts } from '@svgrid/grid/shortcuts'

const off = registerGridShortcuts((event, cmd) => {
  if (!(event.ctrlKey && event.key === 'k')) return false
  const active = cmd.activeCell
  if (!active) return false
  cmd.batch(() => {
    for (const [minRow, minCol, maxRow, maxCol] of cmd.ranges) {
      for (let r = minRow; r <= maxRow; r += 1) {
        for (let c = minCol; c <= maxCol; c += 1) cmd.setCellValue(r, c, 0)
      }
    }
  })
  return true          // claim the key; the grid stops here
}, { id: 'my-app', priority: 10 })

Return true to consume the event, false to let it fall through. Higher priority runs first; the sheet keymap registers at 100. Reusing an id replaces that handler rather than stacking a second copy. The returned function unregisters.

Indices in cmd are display indices, matching the selection model, so they follow sort, filter and pagination. That is why cmd.getCellValue exists alongside api.getCellValue: the api pair indexes the underlying data array, and mixing the two gives you the wrong cell as soon as the grid is sorted.

Wrap any multi-cell write in cmd.batch() so it undoes in one press.

While editing

A binding marked editing: true runs only inside the cell editor, and the others only outside it, so Ctrl+D while typing stays a keystroke for the text. The editor's element reaches such a binding as cmd.editor, which is how F4 reads and rewrites the draft. Alt+Enter needs no binding: the grid's multiline text editor takes it as a line break itself.