@svgrid/grid 3.0.4 → 3.0.5

package/src/SvGrid.types.ts

@@ -1,6 +1,7 @@
 // Type definitions extracted from SvGrid.svelte. These are compile-time
 // only - moving them out keeps the component's <script> focused on logic.
 import type { Snippet } from "svelte";
+import type { GridRowModel } from "./row-model";
 import type {
   CellEditorType,
   ColumnDef,
@@ -1112,8 +1113,276 @@ export type SchedulerConfig<
   searchPlaceholder?: string;
 };
 
+/**
+ * The Gantt axis presets: which unit is a tick and which is the coarser row
+ * grouping them. `week` (day ticks under month majors) is the default.
+ */
+export type GanttZoom = "day" | "week" | "month" | "quarter" | "year";
+
+/**
+ * The four classic dependency kinds. `FS` (finish-to-start) is the default:
+ * the successor may not start before the predecessor finishes.
+ */
+export type GanttDependencyType = "FS" | "SS" | "FF" | "SF";
+
+/**
+ * A link from a predecessor task (`from`) to a successor (`to`). Both are row
+ * ids (the grid's `getRowId`). `lag` is in DAYS - negative for a lead, so
+ * `{ type: 'FS', lag: -1 }` lets the successor start a day before the
+ * predecessor finishes.
+ */
+export type GanttDependency = {
+  id: string;
+  from: string;
+  to: string;
+  type?: GanttDependencyType;
+  lag?: number;
+};
+
+/** Fired when a task bar is dragged to new dates. {@link GanttConfig.onTaskMove}. */
+export type GanttTaskMoveEvent<TData extends RowData = RowData> = {
+  row: TData;
+  start: Date;
+  end: Date;
+  /**
+   * The moved row's descendants, shifted by the same delta - present only when
+   * a summary (parent) bar was dragged. Cascaded successors are NOT here; they
+   * arrive through {@link GanttConfig.onDependenciesChange}.
+   */
+  subtree?: Array<{ row: TData; start: Date; end: Date }>;
+};
+
+/** Fired when a task bar's edge is dragged. {@link GanttConfig.onTaskResize}. */
+export type GanttTaskResizeEvent<TData extends RowData = RowData> = {
+  row: TData;
+  start: Date;
+  end: Date;
+  /** Which edge the user dragged. */
+  edge: "start" | "end";
+};
+
+/** Fired when a bar's progress grip is dragged. {@link GanttConfig.onProgressChange}. */
+export type GanttProgressChangeEvent<TData extends RowData = RowData> = {
+  row: TData;
+  /** 0-100, in whole percent. */
+  progress: number;
+};
+
+/** Fired when the Gantt's detail drawer is saved. {@link GanttConfig.onTaskCommit}. */
+export type GanttTaskCommitEvent<TData extends RowData = RowData> = {
+  row: TData;
+  values: Partial<TData>;
+};
+
+/**
+ * The Gantt's built-in task drawer. Same shape as the scheduler's - a field
+ * list, a title and a width - so one drawer config type covers both views.
+ */
+export type GanttDrawerConfig<TData extends RowData = RowData> =
+  SchedulerDrawerConfig<TData>;
+
+/**
+ * Turns the grid into a Gantt chart. Set `gantt` and the grid renders its rows
+ * as a task table beside a time chart: one bar per row positioned by start /
+ * end, nested into a work-breakdown tree by `parentField`, with dependency
+ * arrows between linked tasks.
+ *
+ * Like the Kanban board and the scheduler it is a pure *view of the grid*: it
+ * renders the grid's filtered + sorted rows and writes back only through
+ * callbacks, never mutating your data. Dragging a bar fires
+ * {@link GanttConfig.onTaskMove} where you reassign the dates on your own rows.
+ *
+ * Dates are local calendar days and `end` is EXCLUSIVE, except that a date-only
+ * string (`'2026-09-14'`, no time part) is read as the end OF that day - the
+ * inclusive convention planning tools use. So
+ * `{ start: '2026-09-14', end: '2026-09-16' }` draws a three-day bar.
+ */
+export type GanttConfig<
+  TFeatures extends TableFeatures = TableFeatures,
+  TData extends RowData = RowData,
+> = {
+  /** Field holding each task's start (`Date` | epoch-ms | ISO string). Required. */
+  startField: keyof TData & string;
+  /** Field holding the end. Omit to use `durationField`, else the task is a milestone. */
+  endField?: keyof TData & string;
+  /** Field holding the length in WORKING days, used when `endField` is absent. */
+  durationField?: keyof TData & string;
+  /** Field for the task name. Defaults to the first column's field. */
+  titleField?: keyof TData & string;
+  /** Field holding percent complete (0-100). Drives the bar's inner fill. */
+  progressField?: keyof TData & string;
+  /**
+   * Field holding each row's PARENT task id, nesting the flat rows into a
+   * work-breakdown tree. Parents render a rolled-up summary bar and a collapse
+   * chevron. Rows whose parent is missing become roots rather than vanishing.
+   *
+   * This is the Gantt's own tree - do NOT also set the grid's `treeData` prop.
+   * `treeData` hides collapsed children from the view entirely, which would
+   * drop them out of their phase's summary bar.
+   */
+  parentField?: keyof TData & string;
+  /**
+   * Boolean field marking a task as a milestone (a diamond, no length). A task
+   * whose end equals its start renders as one regardless.
+   */
+  milestoneField?: keyof TData & string;
+  /** Field holding a per-task accent color (any CSS color). Else `color`. */
+  colorField?: keyof TData & string;
+  /** Fallback accent color for every bar. */
+  color?: string;
+
+  // --- dependencies ---------------------------------------------------------
+  /**
+   * Predecessor -> successor links, drawn as arrows between bars. `from` / `to`
+   * are row ids (your `getRowId`). See {@link GanttDependency}.
+   */
+  dependencies?: ReadonlyArray<GanttDependency>;
+  /**
+   * Per-row field holding that row's links (as `GanttDependency[]` or a plain
+   * list of successor ids). An alternative to the flat `dependencies` array.
+   */
+  dependencyField?: keyof TData & string;
+  /**
+   * Cascade successors forward on move / resize so every link stays legal,
+   * preserving each task's duration. Defaults to `true` when any dependency is
+   * present. Cascading never pulls a task earlier.
+   */
+  autoReschedule?: boolean;
+  /**
+   * Schedule in working time (see `nonWorkingDays` / `holidays`): a moved
+   * or cascaded task lands on a working day and keeps its WORKING length, so
+   * a five-day task dragged over a weekend stays five days of work, and the
+   * critical path measures slack in working days. `false` schedules in
+   * calendar time. Default `true`.
+   */
+  respectWorkingTime?: boolean;
+  /** Fired with the cascaded shifts after a move / resize (never mutates rows). */
+  onDependenciesChange?: (
+    moves: Array<{ id: string; start: Date; end: Date }>,
+  ) => void;
+  /** Fired when the user draws a new link (drag from one bar's edge to another). */
+  onDependencyAdd?: (dep: GanttDependency) => void;
+  /** Fired when the user removes a link (arrow context menu). */
+  onDependencyRemove?: (id: string) => void;
+
+  // --- axis -----------------------------------------------------------------
+  /** The axis preset the chart opens on. Default `'week'`. */
+  zoom?: GanttZoom;
+  /**
+   * The presets the toolbar's zoom stepper offers. Default all five; a single
+   * entry hides the stepper.
+   */
+  zoomLevels?: ReadonlyArray<GanttZoom>;
+  /** Fired when the zoom preset changes (stepper or Ctrl+wheel). */
+  onZoomChange?: (zoom: GanttZoom) => void;
+  /** First day of the week, 0-6 (0 = Sunday). Default 0. */
+  weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+  /**
+   * Weekday numbers (0 = Sun ... 6 = Sat) that are non-working: shaded in the
+   * chart and skipped by duration + cascade arithmetic. Default `[0, 6]`.
+   */
+  nonWorkingDays?: ReadonlyArray<number>;
+  /** Specific dates that are non-working (holidays, closures). */
+  holidays?: ReadonlyArray<Date | number | string>;
+  /** Shade the non-working columns. Default `true`. */
+  showNonWorking?: boolean;
+  /** Draw the dashed "today" line across the chart. Default `true`. */
+  todayLine?: boolean;
+  /** Earliest date the axis shows and a drag may reach. */
+  minDate?: Date | number | string;
+  /** Latest date the axis shows and a drag may reach. */
+  maxDate?: Date | number | string;
+  /** Calendar days of slack around the first start / last end. Default 7. */
+  rangePaddingDays?: number;
+
+  // --- layout ---------------------------------------------------------------
+  /**
+   * Column ids shown in the task table, in order. Defaults to every leaf
+   * column. Two built-ins need no column definition: `'__duration'` (working
+   * days) and `'__progress'` (a small bar).
+   */
+  tableColumns?: ReadonlyArray<string>;
+  /** Width (px) of the task table pane. Default 360; a splitter resizes it. */
+  tableWidth?: number;
+  /** Height (px) of one task row. Default 32. */
+  rowHeight?: number;
+  /** Parents draw a rolled-up summary bar spanning their children. Default `true`. */
+  summaryBars?: boolean;
+  /**
+   * Where a bar's label sits: `'inside'` (default, falling back to the right
+   * when the bar is too narrow), always `'right'`, or `'none'`.
+   */
+  labelPosition?: "inside" | "right" | "none";
+
+  // --- work-breakdown collapse ------------------------------------------------
+  /**
+   * Controlled collapse: the ids of the parent rows whose children are hidden.
+   * Omit to let the Gantt own its own collapse state.
+   */
+  collapsed?: ReadonlyArray<string>;
+  /** Fired when a chevron (or Expand / Collapse all) changes the collapsed set. */
+  onCollapseChange?: (collapsed: string[]) => void;
+
+  // --- editing ----------------------------------------------------------------
+  /**
+   * Enable drag-to-move, edge resize, the progress grip and link drawing.
+   * Without it the chart is read-only.
+   */
+  editable?: boolean;
+  /**
+   * Enable undo / redo of move, resize and progress edits with `Ctrl/Cmd+Z` and
+   * `Ctrl/Cmd+Shift+Z` (or `Ctrl+Y`). The callbacks re-fire with the reversed
+   * values, so your data follows.
+   */
+  history?: boolean;
+  /** Fired when a bar is dragged to new dates. */
+  onTaskMove?: (event: GanttTaskMoveEvent<TData>) => void;
+  /** Fired when a bar's edge is dragged. */
+  onTaskResize?: (event: GanttTaskResizeEvent<TData>) => void;
+  /** Fired when the progress grip is dragged. */
+  onProgressChange?: (event: GanttProgressChangeEvent<TData>) => void;
+  /** Fired when empty chart space is double-clicked - create a task there. */
+  onTaskAdd?: (start: Date, end: Date, parentId?: string) => void;
+  /**
+   * Fired from the bar's Delete action. Setting this shows Delete in the
+   * drawer and the context menu. Remove the row from your data in the handler.
+   */
+  onTaskDelete?: (row: TData) => void;
+
+  // --- chrome -----------------------------------------------------------------
+  /**
+   * Custom body for a TASK bar. Receives the row. Omit for the built-in label.
+   * A phase's summary bar is a thin spine with no room for a body, so it keeps
+   * its plain label; a milestone has no body at all.
+   */
+  task?: Snippet<[TData]>;
+  /**
+   * Hover tooltip for a bar. A `Snippet<[TData]>` for custom content, or `true`
+   * for the built-in one (title, dates, duration, percent). Omit to disable.
+   */
+  tooltip?: boolean | Snippet<[TData]>;
+  /** Delay (ms) before the hover tooltip opens. Default 400. */
+  tooltipDelay?: number;
+  /** Built-in task drawer: `true` for all fields, or a config object. */
+  drawer?: boolean | GanttDrawerConfig<TData>;
+  /** Fired when the drawer is saved. */
+  onTaskCommit?: (event: GanttTaskCommitEvent<TData>) => void;
+  /** Right-click menu for a bar. Return items or `undefined` to suppress. */
+  taskMenu?: (row: TData) => MenuItem[] | undefined;
+
+  /** Show the search box (binds to the grid's global filter). Default `true`. */
+  searchable?: boolean;
+  searchPlaceholder?: string;
+};
+
 export type Props<TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData> = {
-  data: ReadonlyArray<TData>;
+  /**
+   * The rows to render.
+   *
+   * Optional only because `rowModel` can supply them instead; a grid with
+   * neither renders empty. When both are present `data` wins.
+   */
+  data?: ReadonlyArray<TData>;
   columns: Array<ColumnDef<TFeatures, TData>>;
   /**
    * Kanban board mode. When set, the grid renders its rows as cards in
@@ -1127,6 +1396,15 @@ export type Props<TFeatures extends TableFeatures = TableFeatures, TData extends
    * {@link SchedulerConfig}.
    */
   scheduler?: SchedulerConfig<TFeatures, TData>;
+  /**
+   * Gantt mode. When set, the grid renders its rows as a task table beside a
+   * time chart: one bar per row by start / end, a work-breakdown tree from
+   * `parentField`, and dependency arrows. See {@link GanttConfig}.
+   *
+   * A view of the grid like the board and scheduler; the renderer ships in
+   * `@svgrid/enterprise` (call `enableGanttView()`).
+   */
+  gantt?: GanttConfig<TFeatures, TData>;
   /**
    * Chart view. When set, the grid renders its FILTERED + SORTED rows as a chart
    * instead of a table (search / filters / sort flow through). Unlike board and
@@ -2099,6 +2377,99 @@ export type Props<TFeatures extends TableFeatures = TableFeatures, TData extends
     scrollHeight: number;
     clientHeight: number;
   }) => void;
+  /**
+   * Fires when the range of rows on screen changes, with the first and last
+   * row INDEX (not pixels). Coalesced to one call per frame, so it is cheap
+   * to wire to something that fetches.
+   *
+   * This is the hook a block-loading data source needs and
+   * `onScrollBottomReached` cannot give it: "the user is looking at rows
+   * 4,000-4,020" answers which block to fetch and which to keep, while
+   * "they hit the bottom" only ever means "append more". Both are free; use
+   * this one with `createServerDataSource({ mode: 'infinite' })`, or let
+   * `rowModel` wire it for you.
+   *
+   * Reports `0, data.length - 1` when virtualization is off, since every row
+   * really is rendered.
+   */
+  onVisibleRangeChange?: (range: {
+    startIndex: number;
+    endIndex: number;
+  }) => void;
+  /**
+   * Marks a row as one whose data has not arrived: `"loading"` draws a
+   * shimmer in every cell, `"failed"` draws a full-width "could not load"
+   * row with a Retry button, and `null` (the default for every row) renders
+   * normally.
+   *
+   * Placeholder rows are inert - not selectable, not editable, and skipped
+   * by cell navigation - because there is nothing there to act on yet.
+   *
+   * `createServerDataSource` in `infinite` mode fills the gaps with rows this
+   * recognises, so the usual wiring is `rowPlaceholder={rowPlaceholderState}`
+   * (or nothing at all, via `rowModel`).
+   */
+  rowPlaceholder?: (row: TData, rowIndex: number) => "loading" | "failed" | null;
+  /** Called by the Retry button on a `"failed"` placeholder row. */
+  onRetryRow?: (row: TData, rowIndex: number) => void;
+  /**
+   * Hand selection over to an external model.
+   *
+   * The grid normally tracks selection as a record of the row ids it has
+   * seen, which is right until the rows it has seen are a window onto a
+   * million on a server: "select all" then means 20 ticked checkboxes rather
+   * than a million, and the header checkbox cannot honestly say `all`. A
+   * model that stores the RULE ("everything except these three") can answer
+   * both, so when this is set the header checkbox, the row checkboxes and
+   * `api.selectAllRows()` all route through it instead.
+   *
+   * `@svgrid/enterprise` ships one for the server-side row model; this is the
+   * seam it plugs into.
+   */
+  /**
+   * Drive the grid from a row model instead of wiring a dozen props.
+   *
+   * `createServerDataSource` returns one, and so does the Enterprise
+   * server-side row model, so server-backed grids become:
+   *
+   * ```svelte
+   * <SvGrid rowModel={ctl} {columns} />
+   * ```
+   *
+   * The model supplies `data`, `loading`, `getRowId`, the external sort
+   * and filter wiring, the visible range, placeholder rows, group
+   * accessors, selection and paging - each one only if it implements that
+   * part. A prop written explicitly on the grid always wins, so you can
+   * adopt it and still override one piece.
+   */
+  rowModel?: GridRowModel<TData>;
+  /**
+   * Columns that REPLACE `columns` while set. The server-side row model
+   * supplies them in pivot mode - one column per pivoted value, grouped
+   * under a header per pivot key - and clears them when pivot mode ends,
+   * so `columns` stays the app's own list. Rarely set by hand.
+   */
+  pivotResultColumns?: Array<ColumnDef<TFeatures, TData>> | null;
+  rowSelectionModel?: {
+    isSelected: (rowId: string, row: TData) => boolean;
+    /** Whether the header checkbox shows empty, indeterminate, or ticked. */
+    headerState: () => "none" | "some" | "all";
+    toggle: (rowId: string, row: TData, next: boolean) => void;
+    /** The header checkbox: select or clear everything, loaded or not. */
+    toggleAll: (next: boolean) => void;
+    /**
+     * How many rows the rule selects, counting the ones the grid never
+     * loaded; `null` when it cannot say. The selection bar shows this
+     * instead of counting ticked rows on screen.
+     */
+    selectedCount?: () => number | null;
+    /**
+     * Apply one patch to every selected row, loaded or not. When present,
+     * the bulk-edit drawer sends its edits here instead of writing the
+     * loaded cells. Resolves with how many rows changed.
+     */
+    bulkUpdate?: (patch: Record<string, unknown>) => Promise<number>;
+  };
   /**
    * Marks a row as an expandable "detail row". When this returns true the
    * grid renders that row as a SINGLE full-width cell (colspan across every
@@ -2119,8 +2490,10 @@ export type Props<TFeatures extends TableFeatures = TableFeatures, TData extends
    * Server-side group / tree keyboard + accessibility, built into the grid. When
    * set, the grid uses the treegrid role and marks matching rows with
    * `aria-level` / `aria-expanded`, and ArrowRight / ArrowLeft expand / collapse
-   * the focused group row (no app-level key handling). Pair with `serverGroupRows`
-   * + `SvGroupCell` for the visual expander. Every accessor receives the row data.
+   * the focused group row (no app-level key handling). Pair with
+   * `serverGroupRows` + `SvGroupCell` from `@svgrid/enterprise` for the visual
+   * expander, or drive it from your own tree state. Every accessor receives the
+   * row data.
    */
   serverGroup?: {
     /** Whether a row is an expandable group / branch. */

package/src/build-api.ts

@@ -735,9 +735,10 @@ export function createGridApi<
         });
       },
       selectAllRows() {
-        const next: Record<string, boolean> = {};
-        for (const row of ctx.allRows) if (!isGroupRow(row)) next[row.id] = true;
-        ctx.grid.setRowSelection(() => next);
+        // One implementation of "select everything", shared with the header
+        // checkbox, so it knows about an external selection model and about
+        // rows whose data has not arrived.
+        ctx.setSelectAllRows(true);
       },
       toggleRowSelected(id) {
         ctx.toggleRowSelectionById(id);
@@ -745,7 +746,13 @@ export function createGridApi<
       // ---- Pagination
       getPageInfo() {
         const { pageIndex, pageSize } = ctx.paginationState;
-        const total = ctx.allRowsBeforePagination.length;
+        // Under external pagination the grid holds ONE page, so counting the
+        // rows in hand would report a 95-row table as a 20-row one. The
+        // consumer tells us the real total through rowCount, which is what
+        // the footer has always shown.
+        const total = ctx.externalPaginationEnabled
+          ? (ctx.props.rowCount ?? ctx.allRowsBeforePagination.length)
+          : ctx.allRowsBeforePagination.length;
         const pageCount = Math.max(1, Math.ceil(total / Math.max(1, pageSize)));
         return { pageIndex, pageSize, pageCount, total };
       },

package/src/core.rowmodel-cache.test.ts

@@ -119,3 +119,54 @@ describe('row-model cache: selection', () => {
     expect(target.getIsSelected()).toBe(false)
   })
 })
+
+describe('base rows: reuse across a data swap', () => {
+  // The core reads `options.data` and `options.columns` off the object it was
+  // given (the component hands it a reactive one), so a swap is a write there.
+  const grid = () => {
+    const options = {
+      _features: tableFeatures({ rowSelectionFeature }),
+      _rowModels: { coreRowModel: createCoreRowModel<Row>() },
+      columns: COLUMNS as unknown as Array<ColumnDef<ReturnType<typeof tableFeatures>, Row>>,
+      data: makeRows(50),
+      getRowId: (r: Row) => String(r.id),
+    }
+    return { g: createSvGridCore<ReturnType<typeof tableFeatures>, Row>(options), options }
+  }
+
+  it('keeps the row object for a data object that stayed at its index, and rebuilds the rest', () => {
+    const { g, options } = grid()
+    const before = g.getRowModel().rows
+    const data = options.data.slice()
+    // A block landing: forty of fifty entries are the same objects, ten are new.
+    for (let i = 20; i < 30; i += 1) data[i] = { ...data[i]!, name: 'fresh' }
+    options.data = data
+    const after = g.getRowModel().rows
+    expect(after).toHaveLength(50)
+    for (let i = 0; i < 50; i += 1) {
+      if (i >= 20 && i < 30) expect(after[i]).not.toBe(before[i])
+      else expect(after[i]).toBe(before[i])
+    }
+    expect(after[25]!.getCellValueByColumnId('name')).toBe('fresh')
+  })
+
+  it('does not serve a memoised value after the object was changed in place', () => {
+    const { g, options } = grid()
+    const rows = g.getRowModel().rows
+    expect(rows[3]!.getCellValueByColumnId('score')).toBe((3 * 31) % 1000)
+    options.data[3]!.score = 4242
+    options.data = options.data.slice()
+    const again = g.getRowModel().rows
+    expect(again[3]).toBe(rows[3])
+    expect(again[3]!.getCellValueByColumnId('score')).toBe(4242)
+  })
+
+  it('rebuilds every row when the columns change', () => {
+    const { g, options } = grid()
+    const before = g.getRowModel().rows
+    options.columns = [...COLUMNS, { field: 'extra' }] as unknown as typeof options.columns
+    const after = g.getRowModel().rows
+    expect(after[0]).not.toBe(before[0])
+    expect(after[0]!.getAllCells()).toHaveLength(4)
+  })
+})

package/src/core.ts

@@ -1545,6 +1545,7 @@ export function createSvGridCore<TFeatures extends TableFeatures, TData extends
   let cachedBaseRowsInput: ReadonlyArray<TData> | null = null
   let cachedBaseRowsColumns: Array<Column<TData>> | null = null
   let cachedBaseRows: Array<Row<TData>> = []
+  let cachedRowCtx: BaseRowCtx<TData> | null = null
   let cachedRowModel: RowModel<TData> | null = null
   let cachedRowModelBaseRows: Array<Row<TData>> | null = null
   let cachedPipeline = options._rowModels
@@ -1754,22 +1755,35 @@ export function createSvGridCore<TFeatures extends TableFeatures, TData extends
     getRowModel() {
       const columns = grid.getAllColumns()
       if (cachedBaseRowsInput !== options.data || cachedBaseRowsColumns !== columns) {
+        // Same columns as last time: the shared context still describes them,
+        // and a row whose data object sits at the same index can keep its
+        // row object. A row model that streams blocks hands the grid a new
+        // array of 60k entries per block where 100 changed; building 60k
+        // fresh row objects each time was most of the cost of a block
+        // landing. The reused row drops its memoised values and cells, since
+        // an app may have changed the object in place before passing a new
+        // array - that is the case the old rebuild covered by accident.
+        const previous = cachedBaseRowsColumns === columns && cachedRowCtx ? cachedBaseRows : null
         cachedBaseRowsInput = options.data
         cachedBaseRowsColumns = columns
         // O(1) column-id → index lookup so getCellValueByColumnId doesn't do
         // a linear `findIndex` on every cell read (was O(rows × cells × cols)).
-        const columnIndexById = new Map<string, number>()
-        for (let i = 0; i < columns.length; i++) columnIndexById.set(columns[i]!.id, i)
-        const columnCount = columns.length
-
-        // One shared context for every row in this table, so a row carries a
-        // pointer rather than a closure scope. See BASE_ROW_METHODS.
-        const rowCtx: BaseRowCtx<TData> = {
-          grid: grid as SvGrid<TData>,
-          store,
-          columns,
-          columnCount,
-          columnIndexById,
+        let rowCtx: BaseRowCtx<TData>
+        if (previous && cachedRowCtx) {
+          rowCtx = cachedRowCtx
+        } else {
+          const columnIndexById = new Map<string, number>()
+          for (let i = 0; i < columns.length; i++) columnIndexById.set(columns[i]!.id, i)
+          // One shared context for every row in this table, so a row carries a
+          // pointer rather than a closure scope. See BASE_ROW_METHODS.
+          rowCtx = {
+            grid: grid as SvGrid<TData>,
+            store,
+            columns,
+            columnCount: columns.length,
+            columnIndexById,
+          }
+          cachedRowCtx = rowCtx
         }
 
         cachedBaseRows = new Array(options.data.length)
@@ -1785,6 +1799,13 @@ export function createSvGridCore<TFeatures extends TableFeatures, TData extends
         }
         for (let index = 0; index < options.data.length; index++) {
           const original = options.data[index]!
+          const kept = previous?.[index] as BaseRowState<TData> | undefined
+          if (kept && kept.original === original) {
+            kept[ROW_VALUES] = null
+            kept[ROW_CELLS] = null
+            cachedBaseRows[index] = kept
+            continue
+          }
           // `_values` and `_cells` stay null until something reads them - a
           // 100k-row grid showing twenty rows must not materialise every row's
           // values or cell objects to paint.

package/src/editing.ts

@@ -47,6 +47,14 @@ export function createEditing<
   function isCellEditable(column: Column<TData>, row?: Row<TData>): boolean {
     const editable = column.columnDef.editable;
     if (editable === false) return false;
+    if (row) {
+      // A server-side group row is a key with aggregates under the leaf
+      // columns, and a placeholder row has no data yet: neither takes an
+      // edit, whatever the column says.
+      const serverGroup = ctx.props.serverGroup;
+      if (serverGroup && row.original !== undefined && serverGroup.isGroup(row.original)) return false;
+      if (ctx.placeholderStateOf?.(row)) return false;
+    }
     if (typeof editable !== "function") return true;
     if (!row) return true;
     const cellCtx: CellContext<TData> = {

package/src/gantt-stub.test.svelte

@@ -0,0 +1,38 @@
+<script lang="ts">
+  /**
+   * A stand-in for @svgrid/enterprise's SvGridGantt, for `svgrid.gantt-seam.test.ts`.
+   *
+   * The seam's contract is which props the grid hands the renderer, so this
+   * writes each of them into the DOM where a test can read them back. It is
+   * named `.test.svelte` so `tools/strip-dist-tests.mjs` keeps it out of the
+   * published tarball, and the grid's vitest only collects `*.test.ts`, so it
+   * is never mistaken for a suite of its own.
+   */
+  import type { ColumnDef, GanttConfig, RowData, TableFeatures } from './index'
+
+  let {
+    data = [],
+    columns = [],
+    gantt,
+    getRowId,
+  }: {
+    data: ReadonlyArray<RowData>
+    columns: Array<ColumnDef<TableFeatures, any>>
+    gantt: GanttConfig<TableFeatures, any>
+    getRowId?: (row: any, index: number) => string
+  } = $props()
+
+  const ids = $derived(
+    data.map((r, i) => (getRowId ? getRowId(r, i) : String(i))).join(','),
+  )
+</script>
+
+<div
+  class="gantt-stub"
+  data-ids={ids}
+  data-rows={data.length}
+  data-cols={columns.length}
+  data-start={gantt?.startField ?? ''}
+  data-parent={gantt?.parentField ?? ''}
+  data-has-get-row-id={typeof getRowId === 'function'}
+></div>

package/src/gantt-view.svelte.ts

@@ -0,0 +1,35 @@
+/**
+ * gantt-view registry - the injection seam for the *Gantt view of the grid*.
+ * Setting the `gantt` prop on `<SvGrid>` switches the table for a task table
+ * beside a time chart (bars by start / end, a work-breakdown tree, dependency
+ * arrows), but the renderer itself ships in `@svgrid/enterprise` (a paid
+ * feature). This tiny reactive holder lets enterprise register that renderer at
+ * import time; the grid looks it up and mounts it, or shows an upsell
+ * placeholder when it is absent. Mirrors the `scheduler-view` / `board-view`
+ * pattern.
+ *
+ * ```ts
+ * // in @svgrid/enterprise, at module load:
+ * import { registerGanttView } from '@svgrid/grid'
+ * import SvGridGantt from './gantt/SvGridGantt.svelte'
+ * registerGanttView(SvGridGantt)
+ * ```
+ */
+import type { Component } from 'svelte'
+
+let renderer = $state<Component<any> | null>(null)
+
+/** Register the component that renders `gantt` mode. Enterprise calls this. */
+export function registerGanttView(component: Component<any>): void {
+  renderer = component
+}
+
+/** The registered Gantt renderer, or null when enterprise is not installed. */
+export function getGanttView(): Component<any> | null {
+  return renderer
+}
+
+/** Whether a Gantt renderer has been registered. */
+export function hasGanttView(): boolean {
+  return renderer != null
+}

package/src/grid-icons.ts

@@ -97,8 +97,8 @@ export type GridIcons = Partial<Record<GridIconName, Snippet>>
 
 /**
  * Icons whose built-in form is a character rather than an SVG path. Kept as
- * data so `<SvGrid>`, its footer and the standalone `SvRowGroupPanel` render
- * the same defaults instead of three copies drifting apart.
+ * data so `<SvGrid>`, its footer and the row-group panel in @svgrid/enterprise
+ * render the same defaults instead of three copies drifting apart.
  *
  * Each is the exact character that shipped inline before, so a grid that sets
  * no `icons` renders byte-for-byte what it always did.