@svgrid/grid 3.0.3 → 3.0.5

package/src/index.ts

@@ -86,6 +86,7 @@ export { registerBoardView, getBoardView, hasBoardView } from './board-view.svel
 export type {
   SelectionBarAction,
   SelectionBarTarget,
+  ContextMenuIcon,
   ContextMenuItem,
   ContextMenuTarget,
 } from './SvGrid.types'
@@ -120,6 +121,23 @@ export type {
   SchedulerOccurrenceChangeEvent,
 } from './SvGrid.types'
 export { registerSchedulerView, getSchedulerView, hasSchedulerView } from './scheduler-view.svelte'
+// Gantt view. Same split as the scheduler: the `gantt` prop and its config
+// types live in the free grid, the RENDERER ships in @svgrid/enterprise and
+// registers itself through this seam (see gantt-view.svelte.ts). Unlike the
+// scheduler, the Gantt's layout model lives in enterprise too - only the
+// renderer reads it.
+export type {
+  GanttConfig,
+  GanttDrawerConfig,
+  GanttTaskMoveEvent,
+  GanttTaskResizeEvent,
+  GanttProgressChangeEvent,
+  GanttTaskCommitEvent,
+  GanttDependency,
+  GanttDependencyType,
+  GanttZoom,
+} from './SvGrid.types'
+export { registerGanttView, getGanttView, hasGanttView } from './gantt-view.svelte'
 // Bulk-action bar over the row selection. Prop + types free, renderer Pro.
 export { registerSelectionBarView, getSelectionBarView, hasSelectionBarView } from './selection-bar-view.svelte'
 // Chart view. The `chart` prop + its config live in the free grid AND so does the
@@ -529,8 +547,32 @@ export { default as SvGridChartPanel } from './SvGridChartPanel.svelte'
 // unprefixed siblings SvGauge / SvSparkline. The `SvGrid*` names remain exported
 // as aliases so existing imports keep working.
 export { default as SvChart } from './SvGridChart.svelte'
+export type {
+  SvChartProps,
+  ChartRenderContext,
+  ChartTooltipContext,
+  ChartTooltipRow,
+  ChartLegendItemContext,
+  ChartLegendPosition,
+  ChartZoomConfig,
+  ChartAnimateConfig,
+  ChartContextTarget,
+  ChartHoverPoint,
+} from './SvGridChart.types'
+export {
+  wheelWindow,
+  panWindow,
+  pinchWindow,
+  presetWindow,
+  nearestIndexByTime,
+  type ChartRangePreset,
+} from './chart-zoom'
+export { interpolateGeometry } from './chart-motion'
+export { drillTree, pathTo } from './chart-hierarchy'
+export { syncGroupState, publishSyncHover, publishSyncZoom, type ChartSyncState } from './chart-sync.svelte'
 export { default as SvChartPanel } from './SvGridChartPanel.svelte'
-export type { ChartingConfig, ChartAggregateRequest, ChartAggregateBucket } from './SvGrid.types'
+export { default as SvChartPanes } from './SvChartPanes.svelte'
+export type { ChartingConfig, ChartAggregateRequest, ChartAggregateBucket, ChartPanelInfo } from './SvGrid.types'
 export type { GridLocalization } from './SvGrid.types'
 export {
   buildChart,
@@ -538,17 +580,72 @@ export {
   rowsToChartSpec,
   rowsToBoxSpec,
   rowsToDirectSpec,
+  rowsToScatterSpec,
+  rowsToGaugeSpec,
+  rowsToHistogramSpec,
+  rowsToRangeSpec,
+  paretoSpec,
+  specToTreemap,
+  specToCalendar,
+  specToSankey,
+  binValues,
+  heikinAshi,
+  resampleOhlc,
+  rowsToOhlcSpec,
+  guessOhlcColumns,
+  splitPanelIndicators,
+  applyChartFormat,
+  CHART_RESPONSIVE_PRESETS,
+  type ChartFormatState,
+  type OhlcColumns,
+  type ChartPanelIndicator,
+  bollingerBands,
+  rsi,
+  macd,
+  vwap,
+  atr,
+  stochastic,
+  wma,
+  obv,
+  indicatorPane,
+  type ChartIndicatorSpec,
+  arcPath,
+  streamBaseline,
   boxStats,
   sliceChartWindow,
+  matchResponsiveRules,
+  resolveResponsive,
+  chartStyleVars,
   chartScales,
   ordinalDateTicks,
   niceScale,
   niceLogScale,
   linearTrend,
+  linearFit,
+  polynomialFit,
+  exponentialFit,
+  logarithmicFit,
+  powerFit,
+  rSquared,
+  pearson,
+  type RegressionFit,
   simpleMovingAverage,
   exponentialMovingAverage,
   computeOverlay,
+  computeOverlayFit,
+  regressionFit,
+  overlayName,
   buildLinePath,
+  layoutDataLabels,
+  markerPath,
+  decimateSpec,
+  pickCategories,
+  lttb,
+  minMaxIndices,
+  reduceValues,
+  percentile,
+  bucketStart,
+  PER_CATEGORY_SERIES_KEYS,
   sampleGradient,
   pickContrastText,
   DEFAULT_PALETTE,
@@ -566,6 +663,9 @@ export {
   type ChartLine,
   type ChartLinePoint,
   type ChartPieSlice,
+  type ChartResponsiveRule,
+  type ChartStyle,
+  type ChartSeriesLabel,
   type ChartSelection,
   type ChartReferenceLine,
   type ChartRefLineGeo,
@@ -587,6 +687,28 @@ export {
   type ChartSankeyLink,
   type ChartValueFormat,
   type TreeNode,
+  type ChartAxisConfig,
+  type ChartReferenceBand,
+  type ChartRefBandGeo,
+  type ChartMarker,
+  type ChartMarkerShape,
+  type ChartDataLabelConfig,
+  type ChartDataLabel,
+  type ChartDecimateConfig,
+  type ChartReducer,
+  type ChartTimeBucket,
+  type ChartFrame,
+  type ChartLineStyle,
+  type ChartBins,
+  type ChartStem,
+  type ChartArc,
+  type ChartChordRibbon,
+  type ChartBullet,
+  type ChartZoomWindow,
+  type ChartPointRef,
+  type ChartDrawing,
+  type ChartDrawingKind,
+  type ChartDrawingGeo,
 } from './chart'
 export {
   chartToSvgString,
@@ -598,6 +720,7 @@ export {
   downloadChartCsv,
   type ChartExportOptions,
 } from './chart-export'
+export { chartToPdfBlob, downloadChartPdf, printChart, buildChartPdf, type ChartPdfOptions } from './chart-export-pdf'
 export {
   buildSparkline,
   toSparklineValues,
@@ -648,9 +771,11 @@ export {
 export {
   createServerDataSource,
   type ServerDataSource,
+  type ServerSelectionRule,
   type ServerRequest,
   type ServerResult,
   type ServerController,
+  type ServerControllerOptions,
   type ServerState,
   type ServerSortModel,
   type ServerFilterModel,
@@ -660,19 +785,26 @@ export {
   type ServerMoreRow,
   type ServerFooterRow,
   type ServerSkeletonRow,
+  type ServerGrandTotalRow,
+  type ServerPlaceholderRow,
   type ServerDisplayRow,
 } from './server-data-source'
 export {
-  createServerGroupModel,
-  serverGroupRows,
-  serverGroupNav,
-  type ServerGroupController,
-  type ServerGroupControllerOptions,
-  type ServerGroupState,
-  type ServerGroupGridRow,
-} from './server-group-model'
-export { default as SvGroupCell } from './SvGroupCell.svelte'
-export { default as SvRowGroupPanel } from './SvRowGroupPanel.svelte'
+  createBlockCache,
+  createRowPlaceholder,
+  rowPlaceholderState,
+  type BlockCache,
+  type BlockCacheOptions,
+  type BlockCacheState,
+  type BlockFetchResult,
+  type BlockState,
+} from './server-block-cache'
+export {
+  toServerFilterColumns,
+  type GridRowModel,
+  type GridFilterState,
+  type GridRowModelSort,
+} from './row-model'
 export {
   createNamedViews,
   memoryViews,
@@ -705,7 +837,33 @@ export {
   defaultGridMessages,
   resolveGridMessages,
   type GridMessages,
+  type GridChromeMessages,
 } from './grid-messages'
+export {
+  defaultChartMessages,
+  resolveChartMessages,
+  chartMessage,
+  type ChartMessages,
+} from './chart-messages'
+export {
+  defaultChartPanelMessages,
+  resolveChartPanelMessages,
+  chartPanelMessage,
+  type GridChartPanelMessages,
+} from './chart-panel-messages'
+export {
+  validateChartSpec,
+  warnChartSpec,
+  nearestKey as nearestChartKey,
+  CHART_TYPES,
+  KNOWN_SPEC_KEYS,
+  KNOWN_SERIES_KEYS,
+  type ChartDiagnostic,
+} from './chart-validate'
+export { chartSummary, type ChartSummaryOptions } from './chart-summary'
+export { appendPoints, type ChartPoint, type AppendPointsOptions } from './chart-stream'
+export { pivotResultToChartSpec, pivotChartType, pivotFilterColumn, type PivotResultChartOptions, type PivotResultLike } from './chart-pivot'
+export { chartSpecToTable, type ChartTable, type ChartTableColumn } from './chart-table'
 export {
   GRID_ICON_GLYPHS,
   GRID_ICON_NAMES,
@@ -723,7 +881,19 @@ export {
   type GroupPaginationOptions,
   type GroupPaginationResult,
 } from './group-display'
-export { getKeyboardIntent, getNextActiveCell, type GridKeyboardIntent } from './keyboard'
+export { getKeyboardIntent, getNextActiveCell, getEntryStep, pastCollapsed, type GridKeyboardIntent, type EntryIntent, type EntryRect, type EntryStep, type Collapsed } from './keyboard'
+export { buildMergeIndex, mergeAt, isCovered, originOf, endOf, expandRectToMerges, stepPastMerge, mergeDrawAt, type MergedCell, type MergeIndex, type MergeRect, type MergeDraw } from './merges'
+// The fill handle's series (2, 4, 6; Jan, Feb; dates by the day), for a host
+// that wants to show what a fill will write before it lands.
+export { buildFillPattern } from './fill-patterns'
+export {
+  registerGridShortcuts,
+  hasGridShortcuts,
+  clearGridShortcuts,
+  type GridShortcutHandler,
+  type GridCommandContext,
+} from './shortcut-registry'
+export type { HistoryStep } from './history'
 export { createVirtualizer } from './virtualization/virtualizer'
 export { createSvelteVirtualizer } from './virtualization/svelte-virtualizer.svelte'
 export { createColumnVirtualizer } from './virtualization/column-virtualizer'
@@ -733,6 +903,10 @@ export type {
   SvGridFilterOperator,
   SvGridViewState,
   SvGridWrapperProps,
+  SvGridSelectedRange,
+  SvGridCellCoords,
+  ChartTabSnapshot,
+  SavedChart,
 } from './svgrid-wrapper.types'
 export {
   parseEditorValue,

package/src/keyboard-handlers.coverage.test.ts

@@ -54,6 +54,10 @@ function makeCtx(overrides: Partial<any> = {}) {
     extendSelection: vi.fn(),
     setSelection: vi.fn(),
     closeMenus: vi.fn(),
+    tabRunOrigin: null,
+    activeRangeRect: () => null,
+    isRowCollapsed: () => false,
+    collapsedColumns: {},
     ...overrides,
   }
   ctx._state = state
@@ -344,12 +348,32 @@ describe('onGridKeyDown / navigation', () => {
     expect(ctx.extendSelection).not.toHaveBeenCalled()
   })
 
-  it('Shift+ArrowRight extends the selection rectangle', () => {
-    const ctx = navCtx()
+  it('Shift+ArrowRight extends the selection rectangle and leaves the active cell', () => {
+    const ctx = navCtx({
+      selectionRange: { anchor: { rowIndex: 1, colIndex: 1 }, focus: { rowIndex: 1, colIndex: 1 } },
+    })
     const { onGridKeyDown } = createKeyboard(ctx)
     onGridKeyDown(rootKeyEvent({ key: 'ArrowRight', shiftKey: true }))
-    expect(ctx.setActiveCell).toHaveBeenCalledWith(1, 2)
+    expect(ctx.setActiveCell).not.toHaveBeenCalled()
     expect(ctx.extendSelection).toHaveBeenCalledWith(1, 2)
+    expect(ctx.scrollActiveCellIntoView).toHaveBeenCalledWith(1, 2)
+    expect(ctx.setSelection).not.toHaveBeenCalled()
+  })
+
+  it('Shift+Home, Shift+PageDown and Ctrl+Shift+Home grow the range to where the plain key goes', () => {
+    const ctx = navCtx({
+      selectionRange: { anchor: { rowIndex: 1, colIndex: 1 }, focus: { rowIndex: 3, colIndex: 2 } },
+    })
+    const { onGridKeyDown } = createKeyboard(ctx)
+    onGridKeyDown(rootKeyEvent({ key: 'Home', shiftKey: true }))
+    expect(ctx.extendSelection).toHaveBeenLastCalledWith(3, 0)
+    onGridKeyDown(rootKeyEvent({ key: 'Home', shiftKey: true, ctrlKey: true }))
+    expect(ctx.extendSelection).toHaveBeenLastCalledWith(0, 0)
+    onGridKeyDown(rootKeyEvent({ key: 'PageDown', shiftKey: true }))
+    const [row, col] = ctx.extendSelection.mock.lastCall
+    expect(col).toBe(2)
+    expect(row).toBeGreaterThan(3)
+    expect(ctx.setActiveCell).not.toHaveBeenCalled()
     expect(ctx.setSelection).not.toHaveBeenCalled()
   })
 
@@ -364,13 +388,109 @@ describe('onGridKeyDown / navigation', () => {
     expect(ctx.setSelection).toHaveBeenCalledWith(1, 0)
   })
 
-  it('Shift+Enter (moveUp) DOES extend the selection (arrow-family intent)', () => {
+  it('Shift+Arrow grows from the far corner of the range, not from the active cell', () => {
+    const ctx = navCtx({
+      selectionRange: { anchor: { rowIndex: 1, colIndex: 1 }, focus: { rowIndex: 3, colIndex: 2 } },
+    })
+    const { onGridKeyDown } = createKeyboard(ctx)
+    onGridKeyDown(rootKeyEvent({ key: 'ArrowDown', shiftKey: true }))
+    expect(ctx.extendSelection).toHaveBeenCalledWith(4, 2)
+    expect(ctx.setActiveCell).not.toHaveBeenCalled()
+  })
+
+  it('Shift+Arrow with nothing anchored anchors at the active cell first', () => {
+    const ctx = navCtx({ selectionRange: { anchor: null, focus: null } })
+    const { onGridKeyDown } = createKeyboard(ctx)
+    onGridKeyDown(rootKeyEvent({ key: 'ArrowDown', shiftKey: true }))
+    expect(ctx.setSelection).toHaveBeenCalledWith(1, 1)
+    expect(ctx.extendSelection).toHaveBeenCalledWith(2, 1)
+  })
+
+  it('Shift+Arrow moves the active cell when cell selection is off', () => {
+    const ctx = navCtx({ enableCellSelectionEffective: false })
+    const { onGridKeyDown } = createKeyboard(ctx)
+    onGridKeyDown(rootKeyEvent({ key: 'ArrowDown', shiftKey: true }))
+    expect(ctx.setActiveCell).toHaveBeenCalledWith(2, 1)
+    expect(ctx.extendSelection).not.toHaveBeenCalled()
+  })
+
+  it('Ctrl+V with onPasteClipboard leaves the key to the browser and arms the async fallback', () => {
+    const arm = vi.fn()
+    const ctx = navCtx({ props: { rowHeight: 30, onPasteClipboard: () => true }, armPasteFallback: arm, pasteFromClipboard: vi.fn() })
+    const { onGridKeyDown } = createKeyboard(ctx)
+    const ev = rootKeyEvent({ key: 'v', ctrlKey: true })
+    onGridKeyDown(ev)
+    expect(ev.defaultPrevented).toBe(false)
+    expect(arm).toHaveBeenCalledTimes(1)
+    expect(ctx.pasteFromClipboard).not.toHaveBeenCalled()
+  })
+
+  it('Shift+Enter moves up without extending the selection', () => {
+    // Shift+Enter shares the moveUp intent with Shift+ArrowUp, and used to
+    // grow the range like the arrow does. In Excel it only reverses Enter.
     const ctx = navCtx()
     const { onGridKeyDown } = createKeyboard(ctx)
     onGridKeyDown(rootKeyEvent({ key: 'Enter', shiftKey: true }))
-    // Enter+shift -> moveUp, which is in the extend set.
     expect(ctx.setActiveCell).toHaveBeenCalledWith(0, 1)
-    expect(ctx.extendSelection).toHaveBeenCalledWith(0, 1)
+    expect(ctx.setSelection).toHaveBeenCalledWith(0, 1)
+    expect(ctx.extendSelection).not.toHaveBeenCalled()
+  })
+
+  it('Enter after a run of Tabs goes down from the column the run began in', () => {
+    const ctx = navCtx({ state: { activeCell: { rowIndex: 0, colIndex: 0, cellId: null } } })
+    // The fake setActiveCell does what the real one does: forgets the run.
+    ctx.setActiveCell = vi.fn((r: number, c: number) => {
+      const prev = ctx._state.activeCell
+      if (!prev || prev.rowIndex !== r || prev.colIndex !== c) ctx.tabRunOrigin = null
+      ctx._state.activeCell = { rowIndex: r, colIndex: c, cellId: null }
+    })
+    const { onGridKeyDown } = createKeyboard(ctx)
+    onGridKeyDown(rootKeyEvent({ key: 'Tab' }))
+    onGridKeyDown(rootKeyEvent({ key: 'Tab' }))
+    expect(ctx._state.activeCell).toMatchObject({ rowIndex: 0, colIndex: 2 })
+    expect(ctx.tabRunOrigin).toBe(0)
+    onGridKeyDown(rootKeyEvent({ key: 'Enter' }))
+    expect(ctx._state.activeCell).toMatchObject({ rowIndex: 1, colIndex: 0 })
+    expect(ctx.tabRunOrigin).toBe(null)
+    expect(ctx.setSelection).toHaveBeenLastCalledWith(1, 0)
+  })
+
+  it('an arrow between the Tabs ends the run', () => {
+    const ctx = navCtx({ state: { activeCell: { rowIndex: 0, colIndex: 0, cellId: null } } })
+    ctx.setActiveCell = vi.fn((r: number, c: number) => {
+      const prev = ctx._state.activeCell
+      if (!prev || prev.rowIndex !== r || prev.colIndex !== c) ctx.tabRunOrigin = null
+      ctx._state.activeCell = { rowIndex: r, colIndex: c, cellId: null }
+    })
+    const { onGridKeyDown } = createKeyboard(ctx)
+    onGridKeyDown(rootKeyEvent({ key: 'Tab' }))
+    onGridKeyDown(rootKeyEvent({ key: 'ArrowRight' }))
+    expect(ctx.tabRunOrigin).toBe(null)
+    onGridKeyDown(rootKeyEvent({ key: 'Enter' }))
+    expect(ctx._state.activeCell).toMatchObject({ rowIndex: 1, colIndex: 2 })
+  })
+
+  it('Enter and Tab stay inside a selected block and keep the selection', () => {
+    const ctx = navCtx({
+      state: { activeCell: { rowIndex: 1, colIndex: 1, cellId: null } },
+      activeRangeRect: () => ({ minRow: 1, maxRow: 2, minCol: 1, maxCol: 2 }),
+    })
+    ctx.setActiveCell = vi.fn((r: number, c: number) => {
+      const prev = ctx._state.activeCell
+      if (!prev || prev.rowIndex !== r || prev.colIndex !== c) ctx.tabRunOrigin = null
+      ctx._state.activeCell = { rowIndex: r, colIndex: c, cellId: null }
+    })
+    const { onGridKeyDown } = createKeyboard(ctx)
+    onGridKeyDown(rootKeyEvent({ key: 'Enter' }))
+    expect(ctx._state.activeCell).toMatchObject({ rowIndex: 2, colIndex: 1 })
+    onGridKeyDown(rootKeyEvent({ key: 'Enter' }))
+    expect(ctx._state.activeCell).toMatchObject({ rowIndex: 1, colIndex: 2 })
+    onGridKeyDown(rootKeyEvent({ key: 'Tab' }))
+    expect(ctx._state.activeCell).toMatchObject({ rowIndex: 2, colIndex: 1 })
+    onGridKeyDown(rootKeyEvent({ key: 'Tab', shiftKey: true }))
+    expect(ctx._state.activeCell).toMatchObject({ rowIndex: 1, colIndex: 2 })
+    expect(ctx.setSelection).not.toHaveBeenCalled()
+    expect(ctx.extendSelection).not.toHaveBeenCalled()
   })
 
   it('Tab moves right and wraps using getNextActiveCell', () => {

package/src/keyboard-handlers.ts

@@ -7,7 +7,11 @@ import {
 } from "./index";
 import "./sv-grid-scrollbar";
 
-import { getKeyboardIntent, getNextActiveCell } from "./keyboard";
+import { getKeyboardIntent, getNextActiveCell, getEntryStep, pastCollapsed } from "./keyboard";
+import { stepPastMerge } from "./merges";
+import { hasGridShortcuts, runGridShortcuts } from "./shortcut-registry";
+import { undoHistory, redoHistory } from "./history";
+import { buildCommandContext } from "./command-context";
 
 export function createKeyboard<
   TFeatures extends TableFeatures = TableFeatures,
@@ -16,7 +20,21 @@ export function createKeyboard<
   function onGridKeyDown(event: KeyboardEvent) {
     // Only the grid root drives navigation - keys on header buttons, menus,
     // or the cell editor are handled by those controls themselves.
+    //
+    // The command chain runs AFTER this guard, not before. Running it first
+    // meant a key typed into a filter-row input reached the sheet commands,
+    // so Ctrl+A or Ctrl+D while filtering mutated grid cells. The editor has
+    // its own chain call in editing.ts, which is what Alt+Enter needs.
     if (event.target !== event.currentTarget) return;
+
+    // Registered commands get the key BEFORE the grid interprets it. That is
+    // how @svgrid/enterprise binds Ctrl+Arrow, Ctrl+D and the rest without
+    // widening the closed GridKeyboardIntent union, which is public API. A
+    // grid with nothing registered pays one array-length read.
+    if (hasGridShortcuts() && runGridShortcuts(event, buildCommandContext(ctx, false))) {
+      return;
+    }
+
     if (ctx.editingCell) return;
 
     if ((event.ctrlKey || event.metaKey) && !event.altKey) {
@@ -27,6 +45,14 @@ export function createKeyboard<
         return;
       }
       if (lower === "v") {
+        // A consumer taking the paste over wants the browser's own `paste`
+        // event, which carries the clipboard's HTML unsanitised; the key is
+        // left alone and the async API is armed as the fallback for a
+        // browser that never delivers the event to a non-editable element.
+        if (ctx.props.onPasteClipboard) {
+          ctx.armPasteFallback();
+          return;
+        }
         // Secure context: read via the async Clipboard API and swallow the
         // key. Insecure context (no navigator.clipboard): DON'T preventDefault
         // so the browser delivers a native `paste` event to `onGridPaste`.
@@ -45,26 +71,12 @@ export function createKeyboard<
       // and Ctrl+Y both redo. Mirrors VSCode / Sheets / Excel.
       if (lower === "z" && !event.shiftKey) {
         event.preventDefault()
-        if (ctx.historyPtr >= 0) {
-          const step = ctx.history[ctx.historyPtr]
-          if (step) {
-            ctx.applyHistoryStep(step, 'undo')
-            ctx.historyPtr -= 1
-            ctx.historyVersion += 1
-          }
-        }
+        undoHistory(ctx)
         return
       }
       if ((lower === "z" && event.shiftKey) || lower === "y") {
         event.preventDefault()
-        if (ctx.historyPtr < ctx.history.length - 1) {
-          const step = ctx.history[ctx.historyPtr + 1]
-          if (step) {
-            ctx.applyHistoryStep(step, 'redo')
-            ctx.historyPtr += 1
-            ctx.historyVersion += 1
-          }
-        }
+        redoHistory(ctx)
         return
       }
       // Ctrl+F opens the find overlay.
@@ -204,25 +216,74 @@ export function createKeyboard<
       const usable = Math.max(0, clientHeight - headerHeight)
       return Math.max(1, Math.floor(usable / Math.max(rowHeight, 1)) - 1)
     }
-    const next = getNextActiveCell(current, intent, {
+    const bounds = {
       maxRow: Math.max(ctx.allRows.length - 1, 0),
       maxCol: Math.max(ctx.allColumns.length - 1, 0),
-      pageSize: pageStep(),
-    });
-    ctx.setActiveCell(next.rowIndex, next.colIndex);
-    ctx.scrollActiveCellIntoView(next.rowIndex, next.colIndex);
-    // Shift extends the selection ONLY for arrow keys (Excel-style).
-    // Shift+Enter / Shift+Tab just change direction; they don't grow the
-    // range, otherwise hammering Shift+Tab to backspace through a row
-    // would paint a creeping rectangle behind the cursor.
-    const shouldExtend =
+    };
+    // Collapsed rows and columns are stepped over, as a sheet's hidden ones.
+    const collapsed = {
+      isRowCollapsed: (i: number) => ctx.isRowCollapsed(i) as boolean,
+      isColumnCollapsed: (i: number) => !!ctx.collapsedColumns[ctx.allColumns[i]?.id],
+    };
+    // Enter and Tab are entry keys: they remember a Tab run and stay inside
+    // a selected block (getEntryStep). ArrowDown shares the moveDown intent
+    // and is a plain move, hence the key check.
+    if (
+      (event.key === "Enter" || event.key === "Tab") &&
+      (intent === "moveDown" || intent === "moveUp" || intent === "tabNext" || intent === "tabPrev")
+    ) {
+      const step = getEntryStep(current, intent, {
+        ...bounds,
+        tabOrigin: ctx.tabRunOrigin,
+        range: ctx.activeRangeRect(),
+        collapsed,
+      });
+      const landed = stepPastMerge(ctx.mergeIndex, current, step.cell, bounds);
+      ctx.setActiveCell(landed.rowIndex, landed.colIndex);
+      ctx.tabRunOrigin = step.tabOrigin;
+      ctx.scrollActiveCellIntoView(landed.rowIndex, landed.colIndex);
+      if (!step.withinRange) ctx.setSelection(landed.rowIndex, landed.colIndex);
+      return;
+    }
+    // Shift+Arrow grows the range from its far corner, and the active cell
+    // stays where it is, as in Excel: it is the cell the formula bar shows
+    // and the one the next keystroke edits. Shift+Home, Shift+End,
+    // Shift+PageUp / PageDown and Ctrl+Shift+Home / End grow it the same
+    // way, to where the plain key would have moved. Shift+Enter and
+    // Shift+Tab never come this way (they are entry keys, above), so
+    // hammering Shift+Tab back through a row cannot paint a creeping
+    // rectangle. A grid without cell selection has no range to grow and
+    // moves the active cell instead.
+    const extending =
       event.shiftKey &&
+      ctx.enableCellSelectionEffective !== false &&
       (intent === "moveLeft" ||
         intent === "moveRight" ||
         intent === "moveUp" ||
-        intent === "moveDown");
-    if (shouldExtend) ctx.extendSelection(next.rowIndex, next.colIndex);
-    else ctx.setSelection(next.rowIndex, next.colIndex);
+        intent === "moveDown" ||
+        intent === "rowStart" ||
+        intent === "rowEnd" ||
+        intent === "pageUp" ||
+        intent === "pageDown" ||
+        intent === "gridStart" ||
+        intent === "gridEnd");
+    if (extending) {
+      const anchored = !!ctx.selectionRange?.anchor;
+      if (!anchored) ctx.setSelection(current.rowIndex, current.colIndex);
+      const from = anchored ? ctx.selectionRange.focus ?? current : current;
+      const next = stepPastMerge(ctx.mergeIndex, from, pastCollapsed(from, getNextActiveCell(from, intent, { ...bounds, pageSize: pageStep() }), bounds, collapsed), bounds);
+      ctx.extendSelection(next.rowIndex, next.colIndex);
+      // Scroll along the axis of the key only, as Excel does: Shift+Right
+      // brings the new column into view without moving the rows, so a
+      // whole-column selection (its far corner on the last row) stays put.
+      const sideways = intent === "moveLeft" || intent === "moveRight" || intent === "rowStart" || intent === "rowEnd";
+      ctx.scrollActiveCellIntoView(sideways ? current.rowIndex : next.rowIndex, sideways ? next.colIndex : current.colIndex);
+      return;
+    }
+    const next = stepPastMerge(ctx.mergeIndex, current, pastCollapsed(current, getNextActiveCell(current, intent, { ...bounds, pageSize: pageStep() }), bounds, collapsed), bounds);
+    ctx.setActiveCell(next.rowIndex, next.colIndex);
+    ctx.scrollActiveCellIntoView(next.rowIndex, next.colIndex);
+    ctx.setSelection(next.rowIndex, next.colIndex);
   }
 
   function onWindowKeydown(event: KeyboardEvent) {