@svgrid/grid 3.0.2 → 3.0.4

package/dist/history.js

@@ -0,0 +1,133 @@
+/**
+ * Undo / redo over the grid's history array, group-aware.
+ *
+ * The history is one ordered array of per-cell steps plus a pointer to the
+ * last applied step (the model lives in SvGrid.controller.svelte.ts). A step
+ * describes ONE cell, which is right for a single edit and wrong for anything
+ * that writes many cells at once: `applyMoveRange` in clipboard.ts pushes one
+ * step per moved cell, so undoing a 15x20 range move takes 300 presses of
+ * Ctrl+Z, and with UNDO_LIMIT at 200 the same move evicts the entire history
+ * behind it.
+ *
+ * `groupId` fixes that without changing the storage model. Steps written
+ * inside one logical action share an id; undo and redo walk the whole run of
+ * steps carrying that id and apply them together, so a paste, a fill-down or
+ * a range move is one press, the way it is in a spreadsheet. Steps with no
+ * groupId behave exactly as before, one step per press.
+ *
+ * Undo applies a group in REVERSE order. Two steps that touched the same cell
+ * inside one action have to be unwound newest-first or the older `before`
+ * value is overwritten by the newer one and the cell lands on the wrong value.
+ */
+/** Index of the first step in the group that ends at `end`, or `end` itself
+ *  when that step is ungrouped. */
+function groupStart(history, end) {
+    const id = history[end]?.groupId;
+    if (!id)
+        return end;
+    let i = end;
+    while (i > 0 && history[i - 1]?.groupId === id)
+        i -= 1;
+    return i;
+}
+/** Index of the last step in the group that begins at `start`, or `start`
+ *  itself when that step is ungrouped. */
+function groupEnd(history, start) {
+    const id = history[start]?.groupId;
+    if (!id)
+        return start;
+    let i = start;
+    while (i < history.length - 1 && history[i + 1]?.groupId === id)
+        i += 1;
+    return i;
+}
+/** Undo one action. Returns false when there is nothing left to undo. */
+export function undoHistory(ctx) {
+    if (ctx.historyPtr < 0)
+        return false;
+    const end = ctx.historyPtr;
+    if (!ctx.history[end])
+        return false;
+    const start = groupStart(ctx.history, end);
+    // Reverse order: see the note at the top of the file.
+    for (let i = end; i >= start; i -= 1) {
+        const step = ctx.history[i];
+        if (step)
+            ctx.applyHistoryStep(step, 'undo');
+    }
+    ctx.historyPtr = start - 1;
+    ctx.historyVersion += 1;
+    return true;
+}
+/** Redo one action. Returns false when there is nothing left to redo. */
+export function redoHistory(ctx) {
+    if (ctx.historyPtr >= ctx.history.length - 1)
+        return false;
+    const start = ctx.historyPtr + 1;
+    if (!ctx.history[start])
+        return false;
+    const end = groupEnd(ctx.history, start);
+    for (let i = start; i <= end; i += 1) {
+        const step = ctx.history[i];
+        if (step)
+            ctx.applyHistoryStep(step, 'redo');
+    }
+    ctx.historyPtr = end;
+    ctx.historyVersion += 1;
+    return true;
+}
+/**
+ * Append steps at the pointer, truncating any forward history (the standard
+ * "an edit invalidates redo" rule) and capping the buffer at UNDO_LIMIT by
+ * dropping the OLDEST entries.
+ *
+ * Every writer goes through here rather than open-coding the slice / push /
+ * cap dance, which editing.ts and clipboard.ts previously did three times
+ * with three slightly different shapes.
+ */
+export function pushHistory(ctx, steps, groupId) {
+    if (!steps.length)
+        return;
+    // An ambient group wins: inside runHistoryGroup even a single step has to be
+    // tagged, because a later push in the same action must join it.
+    //
+    // Outside one, a group of one is just a step. Tagging it would make undo do
+    // the same work through a slower path and would show up in serialized state.
+    const id = ctx.historyGroupId ?? (groupId && steps.length > 1 ? groupId : undefined);
+    let next = ctx.history.slice(0, ctx.historyPtr + 1);
+    for (const step of steps)
+        next.push(id ? { ...step, groupId: id } : step);
+    if (next.length > ctx.UNDO_LIMIT)
+        next = next.slice(next.length - ctx.UNDO_LIMIT);
+    ctx.history = next;
+    ctx.historyPtr = ctx.history.length - 1;
+    ctx.historyVersion += 1;
+}
+let groupCounter = 0;
+/** A fresh group id. Monotonic, not random: ids never leave the session and a
+ *  counter is comparable in a test snapshot. */
+export function nextGroupId() {
+    groupCounter += 1;
+    return `g${groupCounter}`;
+}
+/**
+ * Run `fn` with every history step it writes tagged as one undoable action.
+ *
+ * This is ambient rather than a wrapper that re-tags afterwards, because
+ * `pushHistory` can drop the oldest entries when the buffer hits UNDO_LIMIT.
+ * A re-tagging implementation would compute its slice bounds from a length
+ * that had shifted underneath it and stamp the wrong steps.
+ *
+ * Nested calls join the outer group: one user action is one undo, however many
+ * layers of helper it goes through.
+ */
+export function runHistoryGroup(ctx, fn) {
+    const outer = ctx.historyGroupId;
+    ctx.historyGroupId = outer ?? nextGroupId();
+    try {
+        return fn();
+    }
+    finally {
+        ctx.historyGroupId = outer;
+    }
+}

package/dist/index.d.ts

@@ -7,7 +7,7 @@ export { subscribeGrid, subscribeSvGrid } from './subscribe.js';
 export { default as SvGrid } from './SvGrid.svelte';
 export type { BoardConfig, BoardLane, BoardCardMoveEvent, BoardCardCommitEvent, BoardLayout, BoardSubtask, BoardComment, BoardMenuContext, BoardLaneMenuContext, BoardDrawerConfig } from './SvGrid.types.js';
 export { registerBoardView, getBoardView, hasBoardView } from './board-view.svelte.js';
-export type { SelectionBarAction, SelectionBarTarget, ContextMenuItem, ContextMenuTarget, } from './SvGrid.types.js';
+export type { SelectionBarAction, SelectionBarTarget, ContextMenuIcon, ContextMenuItem, ContextMenuTarget, } from './SvGrid.types.js';
 export * from './ai.js';
 export { registerExportProvider, getExportProvider, type GridExportProvider, type GridExportRunOptions, } from './export-provider.js';
 export type { SchedulerConfig, SchedulerDrawerConfig, SchedulerEventMoveEvent, SchedulerEventResizeEvent, SchedulerEventCommitEvent, SchedulerRangeSelection, SchedulerView, SchedulerResource, SchedulerCollisionMode, SchedulerException, SchedulerEditScope, SchedulerOccurrenceChangeEvent, } from './SvGrid.types.js';
@@ -190,11 +190,18 @@ export { renderComponent, renderSnippet } from './render-component.js';
 export { default as SvGridChart } from './SvGridChart.svelte';
 export { default as SvGridChartPanel } from './SvGridChartPanel.svelte';
 export { default as SvChart } from './SvGridChart.svelte';
+export type { SvChartProps, ChartRenderContext, ChartTooltipContext, ChartTooltipRow, ChartLegendItemContext, ChartLegendPosition, ChartZoomConfig, ChartAnimateConfig, ChartContextTarget, ChartHoverPoint, } from './SvGridChart.types.js';
+export { wheelWindow, panWindow, pinchWindow, presetWindow, nearestIndexByTime, type ChartRangePreset, } from './chart-zoom.js';
+export { interpolateGeometry } from './chart-motion.js';
+export { drillTree, pathTo } from './chart-hierarchy.js';
+export { syncGroupState, publishSyncHover, publishSyncZoom, type ChartSyncState } from './chart-sync.svelte.js';
 export { default as SvChartPanel } from './SvGridChartPanel.svelte';
-export type { ChartingConfig, ChartAggregateRequest, ChartAggregateBucket } from './SvGrid.types.js';
+export { default as SvChartPanes } from './SvChartPanes.svelte';
+export type { ChartingConfig, ChartAggregateRequest, ChartAggregateBucket, ChartPanelInfo } from './SvGrid.types.js';
 export type { GridLocalization } from './SvGrid.types.js';
-export { buildChart, formatChartValue, rowsToChartSpec, rowsToBoxSpec, rowsToDirectSpec, boxStats, sliceChartWindow, chartScales, ordinalDateTicks, niceScale, niceLogScale, linearTrend, simpleMovingAverage, exponentialMovingAverage, computeOverlay, buildLinePath, sampleGradient, pickContrastText, DEFAULT_PALETTE, type ChartType, type ChartSpec, type ChartSeries, type ChartGeometry, type ChartScales, type ChartBar, type ChartCandle, type ChartBox, type ChartErrorBar, type BoxStats, type OhlcBar, type ChartLine, type ChartLinePoint, type ChartPieSlice, type ChartSelection, type ChartReferenceLine, type ChartRefLineGeo, type ChartRefLineGeoV, type ChartScatterDot, type ScatterPoint, type NiceScale, type SeriesOverlay, type SeriesPattern, type ChartAnnotation, type ChartHeatmapCell, type ChartFunnelSegment, type ChartRadarSeries, type ChartRadarAxis, type ChartTreemapCell, type ChartCalendarCell, type ChartGaugeLayout, type ChartSankeyNode, type ChartSankeyLink, type ChartValueFormat, type TreeNode, } from './chart.js';
+export { buildChart, formatChartValue, 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, type ChartType, type ChartSpec, type ChartSeries, type ChartGeometry, type ChartScales, type ChartBar, type ChartCandle, type ChartBox, type ChartErrorBar, type BoxStats, type OhlcBar, type ChartLine, type ChartLinePoint, type ChartPieSlice, type ChartResponsiveRule, type ChartStyle, type ChartSeriesLabel, type ChartSelection, type ChartReferenceLine, type ChartRefLineGeo, type ChartRefLineGeoV, type ChartScatterDot, type ScatterPoint, type NiceScale, type SeriesOverlay, type SeriesPattern, type ChartAnnotation, type ChartHeatmapCell, type ChartFunnelSegment, type ChartRadarSeries, type ChartRadarAxis, type ChartTreemapCell, type ChartCalendarCell, type ChartGaugeLayout, type ChartSankeyNode, 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.js';
 export { chartToSvgString, downloadChartSvg, chartToPngBlob, downloadChartPng, chartCsvExportable, chartSpecToCsv, downloadChartCsv, type ChartExportOptions, } from './chart-export.js';
+export { chartToPdfBlob, downloadChartPdf, printChart, buildChartPdf, type ChartPdfOptions } from './chart-export-pdf.js';
 export { buildSparkline, toSparklineValues, type SparklineConfig, type SparklineType, type SparklineGeometry, } from './sparkline.js';
 export { spreadsheetLayout, spansToMerges, type SpanColumn, type SpreadsheetActionOptions, type MergeSpec, type CellBorderSpec, type BorderSpec, } from './spreadsheet.js';
 export { rowResize, type RowResizeOptions } from './row-resize.js';
@@ -210,15 +217,26 @@ export { default as SvGroupCell } from './SvGroupCell.svelte';
 export { default as SvRowGroupPanel } from './SvRowGroupPanel.svelte';
 export { createNamedViews, memoryViews, localStorageViews, attachAutoSavedView, type SavedView, type ViewStorage, type NamedViews, type AutoSavedViewOptions, } from './named-views.js';
 export { resolveCellFormat, computeColumnStat, lerpColor, rgba, contrastText, formatNeedsStats, formatsNeedingStats, type ConditionalFormat, type ConditionalFormatSpec, type ColorScaleFormat, type ColorScaleStop, type ScaleBounds, type DataBarFormat, type IconSetFormat, type RuleFormat, type ResolvedCellFormat, } from './conditional-formatting.js';
-export { defaultGridMessages, resolveGridMessages, type GridMessages, } from './grid-messages.js';
+export { defaultGridMessages, resolveGridMessages, type GridMessages, type GridChromeMessages, } from './grid-messages.js';
+export { defaultChartMessages, resolveChartMessages, chartMessage, type ChartMessages, } from './chart-messages.js';
+export { defaultChartPanelMessages, resolveChartPanelMessages, chartPanelMessage, type GridChartPanelMessages, } from './chart-panel-messages.js';
+export { validateChartSpec, warnChartSpec, nearestKey as nearestChartKey, CHART_TYPES, KNOWN_SPEC_KEYS, KNOWN_SERIES_KEYS, type ChartDiagnostic, } from './chart-validate.js';
+export { chartSummary, type ChartSummaryOptions } from './chart-summary.js';
+export { appendPoints, type ChartPoint, type AppendPointsOptions } from './chart-stream.js';
+export { pivotResultToChartSpec, pivotChartType, pivotFilterColumn, type PivotResultChartOptions, type PivotResultLike } from './chart-pivot.js';
+export { chartSpecToTable, type ChartTable, type ChartTableColumn } from './chart-table.js';
 export { GRID_ICON_GLYPHS, GRID_ICON_NAMES, type GridIconName, type GridIcons, } from './grid-icons.js';
 export { insertGroupFooters, buildAutoGroupColumns, paginateGroupedRows, type GroupDisplayType, type GroupFooterOptions, type AutoGroupColumnSpec, type AutoGroupResult, type GroupPaginationOptions, type GroupPaginationResult, } from './group-display.js';
-export { getKeyboardIntent, getNextActiveCell, type GridKeyboardIntent } from './keyboard.js';
+export { getKeyboardIntent, getNextActiveCell, getEntryStep, pastCollapsed, type GridKeyboardIntent, type EntryIntent, type EntryRect, type EntryStep, type Collapsed } from './keyboard.js';
+export { buildMergeIndex, mergeAt, isCovered, originOf, endOf, expandRectToMerges, stepPastMerge, mergeDrawAt, type MergedCell, type MergeIndex, type MergeRect, type MergeDraw } from './merges.js';
+export { buildFillPattern } from './fill-patterns.js';
+export { registerGridShortcuts, hasGridShortcuts, clearGridShortcuts, type GridShortcutHandler, type GridCommandContext, } from './shortcut-registry.js';
+export type { HistoryStep } from './history.js';
 export { createVirtualizer } from './virtualization/virtualizer.js';
 export { createSvelteVirtualizer } from './virtualization/svelte-virtualizer.svelte.js';
 export { createColumnVirtualizer } from './virtualization/column-virtualizer.js';
 export type { VirtualItem, VirtualizerOptions, VirtualizerState } from './virtualization/types.js';
-export type { SvGridApi, SvGridFilterOperator, SvGridViewState, SvGridWrapperProps, } from './svgrid-wrapper.types.js';
+export type { SvGridApi, SvGridFilterOperator, SvGridViewState, SvGridWrapperProps, SvGridSelectedRange, SvGridCellCoords, ChartTabSnapshot, SavedChart, } from './svgrid-wrapper.types.js';
 export { parseEditorValue, normalizeEditorOptions, type CellEditorType, type CellEditorOption, } from './editors/cell-editors.js';
 export { applyExcelFilter, compileExcelFilter, normalizeForFilter, splitInTokens, joinInTokens, trailingInToken, type CompiledExcelFilter, type ExcelFilter, type ExcelFilterOperator, type ExcelFilterOptions, } from './filtering/excel-filters.js';
 export { ALL_FILTER_OPERATORS, SET_OPERATOR_IDS, VALUELESS_OPERATOR_IDS, RANGE_OPERATOR_IDS, isSetOperator, isValuelessOperator, isRangeOperator, type FilterValueType, } from './filtering/filter-operator-catalogue.js';

package/dist/index.js

@@ -229,9 +229,15 @@ 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 { wheelWindow, panWindow, pinchWindow, presetWindow, nearestIndexByTime, } from './chart-zoom.js';
+export { interpolateGeometry } from './chart-motion.js';
+export { drillTree, pathTo } from './chart-hierarchy.js';
+export { syncGroupState, publishSyncHover, publishSyncZoom } from './chart-sync.svelte.js';
 export { default as SvChartPanel } from './SvGridChartPanel.svelte';
-export { buildChart, formatChartValue, rowsToChartSpec, rowsToBoxSpec, rowsToDirectSpec, boxStats, sliceChartWindow, chartScales, ordinalDateTicks, niceScale, niceLogScale, linearTrend, simpleMovingAverage, exponentialMovingAverage, computeOverlay, buildLinePath, sampleGradient, pickContrastText, DEFAULT_PALETTE, } from './chart.js';
+export { default as SvChartPanes } from './SvChartPanes.svelte';
+export { buildChart, formatChartValue, rowsToChartSpec, rowsToBoxSpec, rowsToDirectSpec, rowsToScatterSpec, rowsToGaugeSpec, rowsToHistogramSpec, rowsToRangeSpec, paretoSpec, specToTreemap, specToCalendar, specToSankey, binValues, heikinAshi, resampleOhlc, rowsToOhlcSpec, guessOhlcColumns, splitPanelIndicators, applyChartFormat, CHART_RESPONSIVE_PRESETS, bollingerBands, rsi, macd, vwap, atr, stochastic, wma, obv, indicatorPane, arcPath, streamBaseline, boxStats, sliceChartWindow, matchResponsiveRules, resolveResponsive, chartStyleVars, chartScales, ordinalDateTicks, niceScale, niceLogScale, linearTrend, linearFit, polynomialFit, exponentialFit, logarithmicFit, powerFit, rSquared, pearson, simpleMovingAverage, exponentialMovingAverage, computeOverlay, computeOverlayFit, regressionFit, overlayName, buildLinePath, layoutDataLabels, markerPath, decimateSpec, pickCategories, lttb, minMaxIndices, reduceValues, percentile, bucketStart, PER_CATEGORY_SERIES_KEYS, sampleGradient, pickContrastText, DEFAULT_PALETTE, } from './chart.js';
 export { chartToSvgString, downloadChartSvg, chartToPngBlob, downloadChartPng, chartCsvExportable, chartSpecToCsv, downloadChartCsv, } from './chart-export.js';
+export { chartToPdfBlob, downloadChartPdf, printChart, buildChartPdf } from './chart-export-pdf.js';
 export { buildSparkline, toSparklineValues, } from './sparkline.js';
 export { spreadsheetLayout, spansToMerges, } from './spreadsheet.js';
 // The two resize actions, exported as a matched pair. `<SvGrid>` drives both
@@ -253,9 +259,21 @@ export { default as SvRowGroupPanel } from './SvRowGroupPanel.svelte';
 export { createNamedViews, memoryViews, localStorageViews, attachAutoSavedView, } from './named-views.js';
 export { resolveCellFormat, computeColumnStat, lerpColor, rgba, contrastText, formatNeedsStats, formatsNeedingStats, } from './conditional-formatting.js';
 export { defaultGridMessages, resolveGridMessages, } from './grid-messages.js';
+export { defaultChartMessages, resolveChartMessages, chartMessage, } from './chart-messages.js';
+export { defaultChartPanelMessages, resolveChartPanelMessages, chartPanelMessage, } from './chart-panel-messages.js';
+export { validateChartSpec, warnChartSpec, nearestKey as nearestChartKey, CHART_TYPES, KNOWN_SPEC_KEYS, KNOWN_SERIES_KEYS, } from './chart-validate.js';
+export { chartSummary } from './chart-summary.js';
+export { appendPoints } from './chart-stream.js';
+export { pivotResultToChartSpec, pivotChartType, pivotFilterColumn } from './chart-pivot.js';
+export { chartSpecToTable } from './chart-table.js';
 export { GRID_ICON_GLYPHS, GRID_ICON_NAMES, } from './grid-icons.js';
 export { insertGroupFooters, buildAutoGroupColumns, paginateGroupedRows, } from './group-display.js';
-export { getKeyboardIntent, getNextActiveCell } from './keyboard.js';
+export { getKeyboardIntent, getNextActiveCell, getEntryStep, pastCollapsed } from './keyboard.js';
+export { buildMergeIndex, mergeAt, isCovered, originOf, endOf, expandRectToMerges, stepPastMerge, mergeDrawAt } from './merges.js';
+// 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.js';
+export { registerGridShortcuts, hasGridShortcuts, clearGridShortcuts, } from './shortcut-registry.js';
 export { createVirtualizer } from './virtualization/virtualizer.js';
 export { createSvelteVirtualizer } from './virtualization/svelte-virtualizer.svelte.js';
 export { createColumnVirtualizer } from './virtualization/column-virtualizer.js';

package/dist/keyboard-handlers.js

@@ -1,11 +1,27 @@
 import "./sv-grid-scrollbar.js";
-import { getKeyboardIntent, getNextActiveCell } from "./keyboard.js";
+import { getKeyboardIntent, getNextActiveCell, getEntryStep, pastCollapsed } from "./keyboard.js";
+import { stepPastMerge } from "./merges.js";
+import { hasGridShortcuts, runGridShortcuts } from "./shortcut-registry.js";
+import { undoHistory, redoHistory } from "./history.js";
+import { buildCommandContext } from "./command-context.js";
 export function createKeyboard(ctx) {
     function onGridKeyDown(event) {
         // 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) {
@@ -16,6 +32,14 @@ export function createKeyboard(ctx) {
                 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`.
@@ -34,26 +58,12 @@ export function createKeyboard(ctx) {
             // 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.
@@ -178,26 +188,73 @@ export function createKeyboard(ctx) {
             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 = event.shiftKey &&
+        };
+        // Collapsed rows and columns are stepped over, as a sheet's hidden ones.
+        const collapsed = {
+            isRowCollapsed: (i) => ctx.isRowCollapsed(i),
+            isColumnCollapsed: (i) => !!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)
+                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);
-        else
-            ctx.setSelection(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) {
         if (event.key === "Escape" && (ctx.columnMenuFor || ctx.operatorMenuFor)) {

package/dist/keyboard.d.ts

@@ -6,3 +6,58 @@ export declare function getNextActiveCell(current: ActiveCellState, intent: Grid
     maxCol: number;
     pageSize?: number;
 }): ActiveCellState;
+export type Collapsed = {
+    isRowCollapsed: (rowIndex: number) => boolean;
+    isColumnCollapsed: (colIndex: number) => boolean;
+};
+/**
+ * Where a move lands once collapsed rows and columns are stepped over.
+ *
+ * A sheet's arrow keys never rest on a hidden row or column: the cursor
+ * goes on in the direction of travel to the next one that shows, and when
+ * nothing shows in that direction it comes back to the nearest one before
+ * the landing, which for End on a sheet whose last columns are hidden is the
+ * last visible column. An axis the move did not touch is left alone, so a
+ * cursor sitting on a row the user has just hidden still moves sideways.
+ * With every cell in the direction of travel hidden the cursor stays put.
+ */
+export declare function pastCollapsed(from: ActiveCellState, next: ActiveCellState, bounds: {
+    maxRow: number;
+    maxCol: number;
+}, collapsed: Collapsed): ActiveCellState;
+export type EntryIntent = 'moveDown' | 'moveUp' | 'tabNext' | 'tabPrev';
+export type EntryRect = {
+    minRow: number;
+    maxRow: number;
+    minCol: number;
+    maxCol: number;
+};
+export type EntryStep = {
+    cell: ActiveCellState;
+    /** The move stayed inside a multi-cell selection, which is kept. */
+    withinRange: boolean;
+    /** The column a run of Tabs began in, for the Enter that ends it. */
+    tabOrigin: number | null;
+};
+/**
+ * Where Enter and Tab put the cursor, the way a sheet's data entry expects.
+ *
+ * Two rules on top of `getNextActiveCell`. A run of Tabs remembers the
+ * column it started in, and the Enter that ends the run goes down from
+ * THAT column, not from the last cell: type across A1, B1, C1 with Tab and
+ * Enter lands on A2, ready for the next record. Any other move clears the
+ * memory, which the callers do by resetting `tabOrigin` on every plain
+ * `setActiveCell`. And inside a selection of more than one cell the cursor
+ * stays inside it: Enter walks down a column and wraps to the top of the
+ * next, Tab walks along a row and wraps to the start of the next, both
+ * back to the first cell after the last, and the selection is left
+ * standing, so a block can be filled without ever reaching for the mouse.
+ * Arrow keys are not entry keys and never come here.
+ */
+export declare function getEntryStep(current: ActiveCellState, intent: EntryIntent, opts: {
+    maxRow: number;
+    maxCol: number;
+    tabOrigin: number | null;
+    range: EntryRect | null;
+    collapsed?: Collapsed;
+}): EntryStep;

package/dist/keyboard.js

@@ -4,6 +4,18 @@ export function getKeyboardIntent(event) {
         return 'gridStart';
     if (event.ctrlKey && event.key === 'End')
         return 'gridEnd';
+    // Ctrl/Cmd + arrow is Excel's "jump to the edge of the data region". The
+    // grid does not implement that itself - it is a paid command registered
+    // through `registerGridShortcuts`, which runs before this function is ever
+    // called. If we get here the key was NOT claimed, and the right answer is to
+    // do nothing: moving one cell is a silently wrong response to a shortcut
+    // every spreadsheet user presses. Alt is excluded so a browser or OS
+    // combination still falls through untouched.
+    if ((event.ctrlKey || event.metaKey) && !event.altKey) {
+        if (event.key === 'ArrowLeft' || event.key === 'ArrowRight' ||
+            event.key === 'ArrowUp' || event.key === 'ArrowDown')
+            return 'noop';
+    }
     if (event.key === 'ArrowLeft')
         return 'moveLeft';
     if (event.key === 'ArrowRight')
@@ -89,3 +101,123 @@ export function getNextActiveCell(current, intent, bounds) {
         cellId: current.cellId,
     };
 }
+/**
+ * Where a move lands once collapsed rows and columns are stepped over.
+ *
+ * A sheet's arrow keys never rest on a hidden row or column: the cursor
+ * goes on in the direction of travel to the next one that shows, and when
+ * nothing shows in that direction it comes back to the nearest one before
+ * the landing, which for End on a sheet whose last columns are hidden is the
+ * last visible column. An axis the move did not touch is left alone, so a
+ * cursor sitting on a row the user has just hidden still moves sideways.
+ * With every cell in the direction of travel hidden the cursor stays put.
+ */
+export function pastCollapsed(from, next, bounds, collapsed) {
+    const axis = (fromIdx, nextIdx, max, isCollapsed) => {
+        if (nextIdx === fromIdx)
+            return nextIdx;
+        const dir = nextIdx > fromIdx ? 1 : -1;
+        let i = nextIdx;
+        while (i >= 0 && i <= max && isCollapsed(i))
+            i += dir;
+        if (i >= 0 && i <= max)
+            return i;
+        i = nextIdx - dir;
+        while (i !== fromIdx && isCollapsed(i))
+            i -= dir;
+        return i;
+    };
+    const rowIndex = axis(from.rowIndex, next.rowIndex, bounds.maxRow, collapsed.isRowCollapsed);
+    const colIndex = axis(from.colIndex, next.colIndex, bounds.maxCol, collapsed.isColumnCollapsed);
+    return rowIndex === next.rowIndex && colIndex === next.colIndex ? next : { rowIndex, colIndex, cellId: next.cellId };
+}
+/**
+ * Where Enter and Tab put the cursor, the way a sheet's data entry expects.
+ *
+ * Two rules on top of `getNextActiveCell`. A run of Tabs remembers the
+ * column it started in, and the Enter that ends the run goes down from
+ * THAT column, not from the last cell: type across A1, B1, C1 with Tab and
+ * Enter lands on A2, ready for the next record. Any other move clears the
+ * memory, which the callers do by resetting `tabOrigin` on every plain
+ * `setActiveCell`. And inside a selection of more than one cell the cursor
+ * stays inside it: Enter walks down a column and wraps to the top of the
+ * next, Tab walks along a row and wraps to the start of the next, both
+ * back to the first cell after the last, and the selection is left
+ * standing, so a block can be filled without ever reaching for the mouse.
+ * Arrow keys are not entry keys and never come here.
+ */
+export function getEntryStep(current, intent, opts) {
+    const step = entryStep(current, intent, opts);
+    const collapsed = opts.collapsed;
+    if (!collapsed)
+        return step;
+    const hidden = (c) => collapsed.isRowCollapsed(c.rowIndex) || collapsed.isColumnCollapsed(c.colIndex);
+    if (!hidden(step.cell))
+        return step;
+    if (!step.withinRange)
+        return { ...step, cell: pastCollapsed(current, step.cell, opts, collapsed) };
+    // Walking a block: the same step again from the hidden cell, until one
+    // shows. A block with nothing showing leaves the cursor where it is.
+    let cell = step.cell;
+    for (let guard = (opts.range.maxRow - opts.range.minRow + 1) * (opts.range.maxCol - opts.range.minCol + 1); guard > 0 && hidden(cell); guard -= 1) {
+        cell = entryStep(cell, intent, opts).cell;
+    }
+    return { ...step, cell: hidden(cell) ? current : cell };
+}
+function entryStep(current, intent, opts) {
+    const range = opts.range;
+    const inRange = range !== null &&
+        (range.maxRow > range.minRow || range.maxCol > range.minCol) &&
+        current.rowIndex >= range.minRow && current.rowIndex <= range.maxRow &&
+        current.colIndex >= range.minCol && current.colIndex <= range.maxCol;
+    if (inRange) {
+        let { rowIndex, colIndex } = current;
+        if (intent === 'moveDown') {
+            rowIndex += 1;
+            if (rowIndex > range.maxRow) {
+                rowIndex = range.minRow;
+                colIndex += 1;
+            }
+            if (colIndex > range.maxCol)
+                colIndex = range.minCol;
+        }
+        else if (intent === 'moveUp') {
+            rowIndex -= 1;
+            if (rowIndex < range.minRow) {
+                rowIndex = range.maxRow;
+                colIndex -= 1;
+            }
+            if (colIndex < range.minCol)
+                colIndex = range.maxCol;
+        }
+        else if (intent === 'tabNext') {
+            colIndex += 1;
+            if (colIndex > range.maxCol) {
+                colIndex = range.minCol;
+                rowIndex += 1;
+            }
+            if (rowIndex > range.maxRow)
+                rowIndex = range.minRow;
+        }
+        else {
+            colIndex -= 1;
+            if (colIndex < range.minCol) {
+                colIndex = range.maxCol;
+                rowIndex -= 1;
+            }
+            if (rowIndex < range.minRow)
+                rowIndex = range.maxRow;
+        }
+        return { cell: { rowIndex, colIndex, cellId: current.cellId }, withinRange: true, tabOrigin: null };
+    }
+    const bounds = { maxRow: opts.maxRow, maxCol: opts.maxCol };
+    if (intent === 'tabNext' || intent === 'tabPrev') {
+        return {
+            cell: getNextActiveCell(current, intent, bounds),
+            withinRange: false,
+            tabOrigin: opts.tabOrigin ?? current.colIndex,
+        };
+    }
+    const from = opts.tabOrigin === null ? current : { ...current, colIndex: opts.tabOrigin };
+    return { cell: getNextActiveCell(from, intent, bounds), withinRange: false, tabOrigin: null };
+}

package/dist/menus.d.ts

@@ -1,6 +1,7 @@
 import { type RowData, type TableFeatures } from "./index.js";
 import "./sv-grid-scrollbar.js";
-import type { FilterOperator } from "./SvGrid.types.js";
+import type { ContextMenuIcon, FilterOperator } from "./SvGrid.types.js";
+import type { GridIconName } from "./grid-icons.js";
 export declare function createMenus<TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData>(ctx: any): {
     updateFilterRow: (columnId: string, value: string) => void;
     updateFilterOperator: (columnId: string, operator: FilterOperator) => void;
@@ -37,6 +38,7 @@ export declare function createMenus<TFeatures extends TableFeatures = TableFeatu
     contextMenuItems: () => {
         key: string;
         label: string;
+        icon?: GridIconName | ContextMenuIcon;
         separator?: boolean;
         disabled?: boolean;
         run?: () => void;

package/dist/menus.js

@@ -487,11 +487,16 @@ export function createMenus(ctx) {
             }
             if (entry.hidden?.(target))
                 continue;
+            // An object on a built-in's key with no action of its own is that
+            // built-in with an icon (or a label) of the consumer's choosing.
+            const b = builtins[entry.key];
+            const builtinLabel = b ? ((b.msg && messages?.[b.msg]) || b.label) : entry.key;
             out.push({
                 key: entry.key,
-                label: entry.label,
+                label: entry.label ?? builtinLabel,
+                icon: entry.icon,
                 disabled: entry.disabled?.(target) ?? false,
-                run: () => entry.action(target),
+                run: entry.action ? () => entry.action(target) : b ? () => b.run(target) : undefined,
             });
         }
         // Drop leading/trailing/double separators.