@svgrid/grid 3.0.2 → 3.0.4

package/src/history.test.ts

@@ -0,0 +1,196 @@
+import { describe, expect, it, vi } from 'vitest'
+import {
+  undoHistory,
+  redoHistory,
+  pushHistory,
+  runHistoryGroup,
+  nextGroupId,
+  type HistoryStep,
+} from './history'
+
+function step(n: number, over: Partial<HistoryStep> = {}): HistoryStep {
+  return { rowId: `r${n}`, columnId: 'c', field: 'c', before: n, after: n * 10, ...over }
+}
+
+function makeCtx(history: HistoryStep[] = [], limit = 200) {
+  const applied: Array<{ rowId: string; direction: string }> = []
+  const ctx = {
+    history,
+    historyPtr: history.length - 1,
+    historyVersion: 0,
+    historyGroupId: undefined as string | undefined,
+    UNDO_LIMIT: limit,
+    applyHistoryStep: vi.fn((s: HistoryStep, direction: 'undo' | 'redo') => {
+      applied.push({ rowId: s.rowId, direction })
+    }),
+  }
+  return { ctx, applied }
+}
+
+describe('undo / redo without groups', () => {
+  it('walks one step per call', () => {
+    const { ctx, applied } = makeCtx([step(1), step(2)])
+    expect(undoHistory(ctx)).toBe(true)
+    expect(applied).toEqual([{ rowId: 'r2', direction: 'undo' }])
+    expect(ctx.historyPtr).toBe(0)
+  })
+
+  it('returns false at the bottom and the top', () => {
+    const { ctx } = makeCtx([])
+    expect(undoHistory(ctx)).toBe(false)
+    expect(redoHistory(ctx)).toBe(false)
+  })
+
+  it('round-trips undo then redo', () => {
+    const { ctx, applied } = makeCtx([step(1)])
+    undoHistory(ctx)
+    expect(ctx.historyPtr).toBe(-1)
+    redoHistory(ctx)
+    expect(ctx.historyPtr).toBe(0)
+    expect(applied.map((a) => a.direction)).toEqual(['undo', 'redo'])
+  })
+})
+
+describe('undo / redo with groups', () => {
+  it('undoes a whole group in one call', () => {
+    const g = 'g1'
+    const { ctx, applied } = makeCtx([
+      step(1),
+      step(2, { groupId: g }), step(3, { groupId: g }), step(4, { groupId: g }),
+    ])
+    expect(undoHistory(ctx)).toBe(true)
+    expect(applied.map((a) => a.rowId)).toEqual(['r4', 'r3', 'r2'])
+    // The pointer lands before the group, so the next undo takes the lone step.
+    expect(ctx.historyPtr).toBe(0)
+  })
+
+  it('undoes a group newest-first so repeated writes to one cell unwind right', () => {
+    // Both steps touch r1. Applying oldest-first would leave the cell holding
+    // the intermediate value instead of the original.
+    const g = 'g1'
+    const { ctx, applied } = makeCtx([
+      { rowId: 'r1', columnId: 'c', field: 'c', before: 'orig', after: 'mid', groupId: g },
+      { rowId: 'r1', columnId: 'c', field: 'c', before: 'mid', after: 'final', groupId: g },
+    ])
+    undoHistory(ctx)
+    expect(applied).toEqual([
+      { rowId: 'r1', direction: 'undo' },
+      { rowId: 'r1', direction: 'undo' },
+    ])
+    expect(ctx.applyHistoryStep.mock.calls[0]![0].before).toBe('mid')
+    expect(ctx.applyHistoryStep.mock.calls[1]![0].before).toBe('orig')
+  })
+
+  it('redoes a whole group in order', () => {
+    const g = 'g1'
+    const { ctx, applied } = makeCtx([
+      step(1, { groupId: g }), step(2, { groupId: g }), step(3, { groupId: g }),
+    ])
+    ctx.historyPtr = -1
+    expect(redoHistory(ctx)).toBe(true)
+    expect(applied.map((a) => a.rowId)).toEqual(['r1', 'r2', 'r3'])
+    expect(ctx.historyPtr).toBe(2)
+  })
+
+  it('keeps two adjacent groups separate', () => {
+    const { ctx, applied } = makeCtx([
+      step(1, { groupId: 'g1' }), step(2, { groupId: 'g1' }),
+      step(3, { groupId: 'g2' }), step(4, { groupId: 'g2' }),
+    ])
+    undoHistory(ctx)
+    expect(applied.map((a) => a.rowId)).toEqual(['r4', 'r3'])
+    expect(ctx.historyPtr).toBe(1)
+    undoHistory(ctx)
+    expect(applied.map((a) => a.rowId)).toEqual(['r4', 'r3', 'r2', 'r1'])
+    expect(ctx.historyPtr).toBe(-1)
+  })
+})
+
+describe('pushHistory', () => {
+  it('truncates forward history so an edit invalidates redo', () => {
+    const { ctx } = makeCtx([step(1), step(2), step(3)])
+    ctx.historyPtr = 0
+    pushHistory(ctx, [step(9)])
+    expect(ctx.history.map((s) => s.rowId)).toEqual(['r1', 'r9'])
+    expect(ctx.historyPtr).toBe(1)
+  })
+
+  it('drops the OLDEST entries when the buffer is full', () => {
+    const { ctx } = makeCtx([step(1), step(2), step(3)], 3)
+    pushHistory(ctx, [step(4)])
+    expect(ctx.history.map((s) => s.rowId)).toEqual(['r2', 'r3', 'r4'])
+    expect(ctx.historyPtr).toBe(2)
+  })
+
+  it('does not tag a group of one', () => {
+    const { ctx } = makeCtx()
+    pushHistory(ctx, [step(1)], nextGroupId())
+    expect(ctx.history[0]!.groupId).toBeUndefined()
+  })
+
+  it('tags every step when several are pushed together', () => {
+    const { ctx } = makeCtx()
+    pushHistory(ctx, [step(1), step(2)], nextGroupId())
+    const ids = ctx.history.map((s) => s.groupId)
+    expect(ids[0]).toBeDefined()
+    expect(new Set(ids).size).toBe(1)
+  })
+
+  it('ignores an empty push', () => {
+    const { ctx } = makeCtx()
+    pushHistory(ctx, [])
+    expect(ctx.history).toHaveLength(0)
+    expect(ctx.historyVersion).toBe(0)
+  })
+})
+
+describe('runHistoryGroup', () => {
+  it('joins separate pushes into one undoable action', () => {
+    const { ctx, applied } = makeCtx()
+    runHistoryGroup(ctx, () => {
+      pushHistory(ctx, [step(1)])
+      pushHistory(ctx, [step(2)])
+      pushHistory(ctx, [step(3)])
+    })
+    expect(new Set(ctx.history.map((s) => s.groupId)).size).toBe(1)
+    undoHistory(ctx)
+    expect(applied.map((a) => a.rowId)).toEqual(['r3', 'r2', 'r1'])
+    expect(ctx.historyPtr).toBe(-1)
+  })
+
+  it('survives the buffer overflowing mid-group', () => {
+    // This is why the group id is ambient rather than stamped afterwards: the
+    // cap drops entries from the front, so any index captured before the call
+    // would point at the wrong steps by the end of it.
+    const { ctx } = makeCtx([step(0)], 3)
+    runHistoryGroup(ctx, () => {
+      pushHistory(ctx, [step(1)])
+      pushHistory(ctx, [step(2)])
+      pushHistory(ctx, [step(3)])
+    })
+    expect(ctx.history.map((s) => s.rowId)).toEqual(['r1', 'r2', 'r3'])
+    expect(new Set(ctx.history.map((s) => s.groupId)).size).toBe(1)
+  })
+
+  it('nests into the outer group so one action is one undo', () => {
+    const { ctx } = makeCtx()
+    runHistoryGroup(ctx, () => {
+      pushHistory(ctx, [step(1)])
+      runHistoryGroup(ctx, () => pushHistory(ctx, [step(2)]))
+    })
+    expect(new Set(ctx.history.map((s) => s.groupId)).size).toBe(1)
+  })
+
+  it('clears the ambient id when the body throws', () => {
+    const { ctx } = makeCtx()
+    expect(() => runHistoryGroup(ctx, () => { throw new Error('boom') })).toThrow('boom')
+    expect(ctx.historyGroupId).toBeUndefined()
+    pushHistory(ctx, [step(1)])
+    expect(ctx.history[0]!.groupId).toBeUndefined()
+  })
+
+  it('returns the body result', () => {
+    const { ctx } = makeCtx()
+    expect(runHistoryGroup(ctx, () => 42)).toBe(42)
+  })
+})

package/src/history.ts

@@ -0,0 +1,162 @@
+/**
+ * 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.
+ */
+
+export type HistoryStep = {
+  rowId: string
+  columnId: string
+  field: string
+  before: unknown
+  after: unknown
+  /** Set when this step is part of a multi-cell action. Steps sharing an id
+   *  are contiguous in the array and undo / redo as one. */
+  groupId?: string
+  /**
+   * A step that is not a cell write: something outside the grid's data that
+   * still belongs in the same Ctrl+Z stream, such as a cell format kept in a
+   * consumer's store. The cell fields are empty on such a step and the two
+   * functions do the work. Never serialised, since a closure cannot be.
+   */
+  custom?: { undo: () => void; redo: () => void }
+}
+
+/** Ctx surface these helpers touch. The controller satisfies it structurally. */
+type HistoryCtx = {
+  history: HistoryStep[]
+  historyPtr: number
+  historyVersion: number
+  UNDO_LIMIT: number
+  /** Set while a `runHistoryGroup` call is on the stack. Every step pushed
+   *  inside it joins that group, so a command does not have to thread a group
+   *  id down through the writers it calls. */
+  historyGroupId: string | undefined
+  applyHistoryStep(step: HistoryStep, direction: 'undo' | 'redo'): void
+}
+
+/** Index of the first step in the group that ends at `end`, or `end` itself
+ *  when that step is ungrouped. */
+function groupStart(history: ReadonlyArray<HistoryStep>, end: number): number {
+  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: ReadonlyArray<HistoryStep>, start: number): number {
+  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: HistoryCtx): boolean {
+  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: HistoryCtx): boolean {
+  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: HistoryCtx,
+  steps: ReadonlyArray<HistoryStep>,
+  groupId?: string,
+): void {
+  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(): string {
+  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<T>(ctx: HistoryCtx, fn: () => T): T {
+  const outer = ctx.historyGroupId
+  ctx.historyGroupId = outer ?? nextGroupId()
+  try {
+    return fn()
+  } finally {
+    ctx.historyGroupId = outer
+  }
+}

package/src/icon-seam.test.ts

@@ -38,8 +38,9 @@ function stripAllowedRegions(src: string): string {
 describe('icon seam', () => {
   it('leaves no inline <svg> outside the built-in catalogue', () => {
     // Data visualisation is not chrome: these draw values, not affordances, and
-    // there is nothing for a consumer's icon set to say about them.
-    const ALLOWED = ['sv-grid-sparkline']
+    // there is nothing for a consumer's icon set to say about them. Nor is a
+    // context-menu item's own path icon: that IS the consumer's drawing.
+    const ALLOWED = ['sv-grid-sparkline', 'sv-grid-menu-icon-own']
 
     const offenders: string[] = []
     for (const file of CHROME) {

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'
@@ -529,8 +530,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 +563,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 +646,9 @@ export {
   type ChartLine,
   type ChartLinePoint,
   type ChartPieSlice,
+  type ChartResponsiveRule,
+  type ChartStyle,
+  type ChartSeriesLabel,
   type ChartSelection,
   type ChartReferenceLine,
   type ChartRefLineGeo,
@@ -587,6 +670,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 +703,7 @@ export {
   downloadChartCsv,
   type ChartExportOptions,
 } from './chart-export'
+export { chartToPdfBlob, downloadChartPdf, printChart, buildChartPdf, type ChartPdfOptions } from './chart-export-pdf'
 export {
   buildSparkline,
   toSparklineValues,
@@ -705,7 +811,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 +855,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 +877,10 @@ export type {
   SvGridFilterOperator,
   SvGridViewState,
   SvGridWrapperProps,
+  SvGridSelectedRange,
+  SvGridCellCoords,
+  ChartTabSnapshot,
+  SavedChart,
 } from './svgrid-wrapper.types'
 export {
   parseEditorValue,