@svgrid/grid 3.0.3 → 3.0.5

package/src/grid-messages.ts

@@ -7,11 +7,24 @@
  *
  * This mirrors the editor kit's `resolveMessages` pattern (editor-contract.ts) so
  * chrome and editors share one localization idiom.
+ *
+ * The chart panel's strings are the other half of `GridMessages`
+ * (`GridChartPanelMessages` in chart-panel-messages.ts): same map, same
+ * `localization.text`, but their English defaults load with the panel, not
+ * with every grid.
  */
 import { resolveMessages } from './editor-contract'
+import type { GridChartPanelMessages } from './chart-panel-messages'
+
+/**
+ * Every string `localization.text` accepts: the grid chrome's own
+ * ({@link GridChromeMessages}) and the chart panel's
+ * ({@link GridChartPanelMessages}).
+ */
+export type GridMessages = GridChromeMessages & GridChartPanelMessages
 
 /** Every localizable chrome string, grouped by area in the comments. */
-export type GridMessages = {
+export type GridChromeMessages = {
   // Empty / loading state
   noRows: string
   loading: string
@@ -93,16 +106,23 @@ export type GridMessages = {
   bulkEditCancel: string
   bulkEditNoFields: string
   chartRange: string
+  // Rows whose data has not arrived (server-side / infinite loading)
+  rowLoadFailed: string
+  rowLoadRetry: string
   // Upsell notes (enterprise views not installed)
   pivotUpsellTitle: string
   pivotUpsellBody: string
+  ganttUpsellTitle: string
+  ganttUpsellBody: string
+  /** Placeholder in the Gantt view's search box. */
+  ganttSearchPlaceholder: string
   /** Shared licensing line under every Enterprise upsell note. */
   upsellLicense: string
   upsellLicenseLink: string
 }
 
 /** English defaults - the literal strings the grid shipped before localization. */
-export const defaultGridMessages: GridMessages = {
+export const defaultGridMessages: GridChromeMessages = {
   noRows: 'No rows to display.',
   loading: 'Loading grid data...',
   columns: 'Columns',
@@ -172,8 +192,13 @@ export const defaultGridMessages: GridMessages = {
   opBefore: 'Before',
   opAfter: 'After',
   chartRange: 'Chart selected range',
+  rowLoadFailed: 'Could not load these rows.',
+  rowLoadRetry: 'Retry',
   pivotUpsellTitle: 'Pivot mode',
   pivotUpsellBody: 'Pivot mode is an Enterprise feature. Install @svgrid/enterprise and call enablePivot() to use it.',
+  ganttUpsellTitle: 'Gantt view',
+  ganttUpsellBody: 'The Gantt view is an Enterprise feature. Install @svgrid/enterprise and call enableGanttView() to render it.',
+  ganttSearchPlaceholder: 'Search tasks...',
   upsellLicense:
     'A license key is required for production use. Without one the feature still works, but the grid renders an unlicensed watermark.',
   upsellLicenseLink: 'View licensing',
@@ -184,6 +209,6 @@ export const defaultGridMessages: GridMessages = {
  * values fall back to the default (via `resolveMessages`), so a partial map only
  * replaces the keys it sets.
  */
-export function resolveGridMessages(overrides?: Partial<GridMessages> | null): GridMessages {
+export function resolveGridMessages(overrides?: Partial<GridMessages> | null): GridChromeMessages {
   return resolveMessages(defaultGridMessages, overrides)
 }

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

@@ -20,26 +20,25 @@ const SRC = join(process.cwd(), 'src')
 const read = (f: string) => readFileSync(join(SRC, f), 'utf8')
 
 /** Files that render grid chrome and therefore must go through the seam. */
-const CHROME = ['SvGrid.svelte', 'GridMenus.svelte', 'GridFooter.svelte', 'SvRowGroupPanel.svelte']
+const CHROME = ['SvGrid.svelte', 'GridMenus.svelte', 'GridFooter.svelte']
 
 /**
  * Drop the regions allowed to contain raw icon markup: the `icon` snippet's own
- * body (which IS the built-in set), the `ic` snippet in SvRowGroupPanel, and
- * every `<script>` block.
+ * body (which IS the built-in set) and every `<script>` block.
  */
 function stripAllowedRegions(src: string): string {
   let out = src.replace(/<script[\s\S]*?<\/script>/g, '')
   // The built-in catalogue: from the snippet header to its closing tag.
   out = out.replace(/\{#snippet icon\(name: GridIconName\)\}[\s\S]*?\n\{\/snippet\}/g, '')
-  out = out.replace(/\{#snippet ic\(name: GridIconName\)\}[\s\S]*?\{\/snippet\}/g, '')
   return out
 }
 
 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) {