@kanunilabs/datagrid-react / DataGridProps
Interface: DataGridProps<TRow>
Extends
Omit<DataGridCoreConfig<TRow>,"columns">
Type Parameters
TRow
TRow = GridRowData
Properties
alignedGrids?
optionalalignedGrids?:string
Keep this grid's COLUMN LAYOUT and horizontal scroll in step with every other grid given the same name (gap analysis P3.2).
For two grids that have to read as one table — a scrolling body with a fixed totals strip under it, or a master and a detail over the same columns. Resize, move, hide or pin a column in one and the others follow; scroll one sideways and the others keep pace.
Sort, filter, selection and VERTICAL scroll deliberately do not travel. Aligned grids share a shape, not a result — a summary strip that re-sorted itself because the grid above it did would be answering a different question. Columns the peer does not have are ignored, so a three-column strip can align under a twelve-column grid.
animateRows?
optionalanimateRows?:boolean
Rows glide to their new place when a sort, a filter, a grouping or a data change reorders them (G-CORE-04), instead of jumping. Rows that come into view fade in. Off by default; off as well whenever the system asks for reduced motion.
Inherited from
DataGridCoreConfig.animateRows
announcements?
optionalannouncements?:boolean
Announcements for screen readers (sort/filter/selection). Defaults on.
ariaLabel?
optionalariaLabel?:string
The grid's accessible name: what a screen reader says when focus enters
it ("Orders, grid"). Without it the grid is named by gridId, which is
an identifier rather than words — give every grid on a page its own,
in the page's language. Read by both renderers.
Inherited from
asyncTransactionWait?
optionalasyncTransactionWait?:number
Milliseconds applyTransactionAsync waits before applying a batch
(gap analysis P3.6). Default 50 — about three frames.
Raise it for a feed that ticks faster than the eye can follow; the grid then repaints less often and each pass carries more. Lower it only if the grid must visibly track something else on screen tick for tick.
Inherited from
DataGridCoreConfig.asyncTransactionWait
autoColumns?
optionalautoColumns?:boolean|InferColumnsOptions
Tunes the columns derived from the data when columns is omitted:
sampleSize, include, exclude, humanizeHeaders, defaults.
false turns the derivation off and leaves the grid with no columns.
autoHeaderHeight?
optionalautoHeaderHeight?:boolean
Let the header row grow to fit its tallest caption — the partner of a
column's wrapHeaderText. Default false: the header keeps the theme's
fixed height and a long caption ends in an ellipsis (or, wrapped, is
clipped).
Off by default because the height is MEASURED after layout: everything stuck under the header (the filter row, pinned rows, the totals row at the top, sticky group headers) has to move with it, and a grid that never wraps a caption should not pay for that. Only the columns on screen are measured, so scrolling sideways onto a longer caption can grow the header then.
autoSizeStrategy?
optionalautoSizeStrategy?:"none"|"fitGrid"|"fitCells"
What to do with the column widths once the grid knows how much room it has
(gap analysis P2.5). Default 'none' — the configured widths are used as
written, which is what every existing grid already does.
'fitGrid'spreads the columns across the width so they fill it exactly, proportionally to their configured widths, re-applied when the grid is resized. For a grid that should never show empty canvas or a horizontal scrollbar.'fitCells'measures the rendered content and sizes each column to it — the "best fit" the header menu offers, applied once to every column after the first rows paint. It can overflow the grid; that is the point.
A user resize is not undone by either: 'fitGrid' re-runs on a GRID resize
and takes the current widths as its proportions, so a column the user made
wider stays proportionally wider.
cardView?
optionalcardView?:boolean|DataGridCardViewOptions<TRow>
Rows as cards on a narrow grid — a phone, a side panel. Below
breakpoint pixels (default 600) each data row is drawn as a card: the
first field as its title, the rest as "Header value" lines, as wide as
the grid. The column headers give way to a sort control.
Sort, filter, search, selection, grouping, virtual scrolling and remote
data keep working. What needs a cell does not apply while cards are shown:
in-cell editing, range selection, the fill handle and column resizing.
A card shows each field's TEXT (formatters and lookups included); a
column's renderCell is not used on a card. While cards are shown they
replace renderRow.
columns picks the fields and their order (the first is the title);
default: the visible columns.
A card is a tap target (P-9): onCardPress hears it, renderCard draws
the card's content yourself, and on an editing grid edit: 'popup' opens
the row in the edit dialog. See DataGridCardViewOptions.
cellMenu?
optionalcellMenu?:boolean|CellMenuOptions
The grid's OWN cell-menu entries — clipboard and export — appended below
whatever rowMenu supplies. See CellMenuOptions.
On by default: a right-click that offers no way to copy the cell is the
gap this closes, and an app that wants the menu bare passes false.
rowMenu is untouched either way — an app's items keep the order it wrote
them in, and the built-ins read as an addition after a separator.
className?
optionalclassName?:string
columnReorder?
optionalcolumnReorder?:boolean
Drag a header onto another header to change the column order. Default on.
columnResize?
optionalcolumnResize?:boolean
Width drag handle on each header's trailing edge; double-click best-fits. Default on.
columns?
optionalcolumns?:ReactGridColumnDef<TRow>[]
Optional: with an ARRAY data source and no columns, one column per field
is derived from the data (see autoColumns). A remote DataSource must
declare them — there is nothing to sample before the first fetch.
dark?
optionaldark?:boolean
Applies the packaged dark palette.
dataSource
dataSource:
TRow[] |DataSource<TRow>
Inherited from
Omit.dataSource
debugMode?
optionaldebugMode?:boolean
Console diagnostics for integration mistakes (duplicate keys, unknown columns…).
Inherited from
defaultColumnDef?
optionaldefaultColumnDef?:Partial<GridColumnDef<TRow>>
Inherited from
Omit.defaultColumnDef
density?
optionaldensity?:GridDensity
Vertical rhythm preset. Resolves to a row height, header height, font size
and cell padding. An explicit rowHeight still wins — density is a
shorthand, not an override.
editing?
optionalediting?:DataGridEditingOptions<TRow>
Edit data in the grid — single cells free since 2026-10-12, batch, row, form and popup editing free since 2026-10-16 (owner decision).
Off unless this object is given (editing={{ onSave }}); enabled: false
turns it off again. In the default 'cell' mode double-click, F2 or
typing opens the editor on an editable column; Enter commits and moves
down, Tab moves to the next editable cell, Esc cancels. Each committed cell
is written to its row and passed to onSave — one call per edit — and
cellValueChanged fires. mode switches to collecting edits ('batch',
with a Save / Cancel strip above the grid) or to editing a whole row at a
time ('row', 'form', 'popup' — opened by double-click or "Edit row…"
in the row menu); see DataGridEditingOptions.mode.
A column with editable: false, a lookup or a renderEditor stays
read-only here, in every mode.
Validation rules, crud handlers, adding and deleting rows, per-row
permissions, lookup and custom editors, the command column, undo/redo,
range selection, fill and paste are EnterpriseDataGrid.
emptyText?
optionalemptyText?:string
Shown when the pipeline yields no rows.
enterpriseEdition?
optionalenterpriseEdition?:boolean
Unlocks the Enterprise edition. Set by EnterpriseDataGrid — an app
rendering DataGrid directly leaves it off.
The engine keeps every capability either way: the pipeline (filter → sort →
group → aggregate) is one piece, and an edition boundary cutting through it
would be a fork rather than a gate. What this flag decides is what the
COMPONENT agrees to switch on. See gateEdition for the removals and
DataGridController.setEnterpriseEdition for the imperative half.
Off, the following are declined (each says why under debugMode):
multi-level grouping (capped at one level), grouping.groupSummaries,
masterDetail, tree, column spanRows, notes, Excel and PDF export.
Footer column totals (summaries) are Community since 2026-08-25. A server-side DataSource
THROWS rather than being stripped — an empty grid sends the developer
hunting in their backend.
Community keeps: virtual scrolling at a million rows, worker offload, sorting, the column family, filtering, selection, pagination, single-level grouping, footer column totals, CSV export, themes, 12 locales and the whole event/imperative API. Boundary set with the user on 2026-08-14 to match how comparable grids draw this line.
filterDebounce?
optionalfilterDebounce?:number
Milliseconds to wait after the last keystroke before applying a filter-row
value. 0 applies on every keystroke.
Defaults to 0 for client data (filtering is local and instant — adding a
delay to something already immediate would be a regression in feel) and
200 for a remote DataSource, where each keystroke is a network round
trip: typing "Marmara" used to open seven queries, six of them already
superseded by the time they answered.
Set it explicitly on a very large CLIENT grid, where one pass is expensive enough that coalescing keystrokes is worth a short delay.
Enter, or moving focus out of the box, always applies immediately.
filterIconMode?
optionalfilterIconMode?:"hover"|"always"
When the funnel is visible. 'hover' (default) keeps the header clean and
reveals it on hover or keyboard focus; 'always' pins it. A column that is
actually filtered always shows its funnel, in either mode.
filterPanel?
optionalfilterPanel?:boolean|"always"
A bar under the footer stating the active filter in words, with a checkbox
that suspends it and an × that removes it — a filter panel.
true shows it only while something is filtered; 'always' keeps it in
place. It describes the FULL filter — the builder's conditions and every
column funnel and filter-row entry, combined — which is what makes it the
one place to read back why the grid is showing 12 of 100.000 rows.
filterPanelLabels?
optionalfilterPanelLabels?:DescribeFilterOptions
Wording for the filter panel's sentence — and / or / is / blank…
filterRow?
optionalfilterRow?:boolean
Text-input row under the header, one box per column.
focusedRow?
optionalfocusedRow?:boolean
Highlight the row holding focus. Distinct from selection: focus is where the keyboard is, selection is what an action applies to — a grid that conflates them cannot express "look at this row without selecting it".
focusedRowKey?
optionalfocusedRowKey?:RowKey|null
Focus this row on mount / when the prop changes (controlled focus).
footer?
optionalfooter?:boolean
Column-aligned totals row at the bottom of the grid. Defaults to on when
summaries is non-empty. Turning it on with no summaries shows an empty
row, which is how the user reaches the per-column aggregation menu.
footerMenu?
optionalfooterMenu?:boolean
Right-click (and click) on a footer cell opens the aggregation picker —
Count / Sum / Average / Min / Max, filtered to what the column's data type
supports. false makes the footer read-only.
footerPosition?
optionalfooterPosition?:"top"|"bottom"
Which edge the grand total row sticks to (P2.8). Default 'bottom'.
Same row either way — the column-aligned totals over the filtered result,
with the same aggregation menu. 'top' is for a grid read top-down, where
the totals are the headline; the rows below are then the evidence for it.
getCellClassName?
optionalgetCellClassName?: (ctx) =>string|undefined
Extra class names per cell (dirty marker, range highlight, invalid).
Parameters
ctx
CellSlotContext<TRow>
Returns
string | undefined
getHeaderClassName?
optionalgetHeaderClassName?: (columnId) =>string|undefined
Extra class names per header cell. Must be a fresh function when the answer changes.
Parameters
columnId
string
Returns
string | undefined
getRowHeight?
optionalgetRowHeight?: (node,index) =>number|undefined
Per-row height, in px. Return undefined for the standard height.
OPT-IN, and deliberately so: supplying it means the grid asks about every
row in the view on every projection, which on a million rows is a million
calls per filter keystroke. Leave it off and row geometry stays one
multiplication — see RowHeightIndex. Detail panels and the edit form do
NOT need this; they carry their own height.
For heights that depend on how text wraps, prefer autoHeight on the
column: the adapter measures what it rendered instead of asking the app to
predict it.
Parameters
node
RowNode<TRow>
index
number
Returns
number | undefined
Inherited from
Omit.getRowHeight
gridId
gridId:
string
Inherited from
grouping?
optionalgrouping?:GroupingConfig
Inherited from
groupPanel?
optionalgroupPanel?:boolean
Drop area above the grid for grouping by a column.
headerFilter?
optionalheaderFilter?:boolean
Funnel button per header opening the distinct-value checklist popup.
headerMenu?
optionalheaderMenu?:boolean| ((context,defaults) =>GridMenuItem<HeaderMenuContext>[])
Right-click menu on COLUMN HEADERS: sort, group, footers, hide, field
chooser, best fit. true (default) uses the built-in list; a function
receives it and returns the list to show, so an app can drop items or
append its own. false turns it off and lets the browser menu through.
highlightSearch?
optionalhighlightSearch?:boolean
Mark the search term inside cell text (gap analysis P2.4). Default true.
The search already decides which rows survive; without the marks the user
is left scanning fifteen columns for the reason a row is on screen. Only
the grid's own rendering is marked up — a column with a renderCell owns
its output and is left alone.
loadingOverlay?
optionalloadingOverlay?:number|boolean
Overlay shown while the grid is busy, with a percentage where one exists. Default on. A number sets how many milliseconds of work must pass before it appears (default 300) — short operations finish without ever showing it.
locale?
optionallocale?:string
Locale for collation, date handling AND the interface language. Default
'en'. One of the twelve the grid ships (GRID_LOCALES); a regional tag
narrows to its base (de-AT → de), and anything unknown falls back to
English rather than failing to render.
Inherited from
masterDetail?
optionalmasterDetail?:MasterDetailConfig<TRow>
Expandable detail panels under rows. Enterprise (P9).
Inherited from
Omit.masterDetail
messages?
optionalmessages?:Partial<GridDictionary>
Override individual strings without replacing the language.
Merged over the resolved dictionary, so an app can rename "Actions" to its own wording in every language while leaving the other 250 alone.
Inherited from
notes?
optionalnotes?:GridNotesConfig<TRow>
Cell notes (gap analysis P3.3) — user-written prose attached to a cell, marked with a corner triangle and revealed on hover. See GridNotesConfig.
onCardViewChange?
optionalonCardViewChange?: (active) =>void
The grid switched between cards and the table (cardView), as its width
crossed the breakpoint. true while cards are shown.
Parameters
active
boolean
Returns
void
onCellDoubleClick?
optionalonCellDoubleClick?: (ctx) =>void
Parameters
ctx
CellSlotContext<TRow>
Returns
void
onCellPointerDown?
optionalonCellPointerDown?: (ctx,event) =>void
Pointer down on a cell, with the view coordinates the range engine needs.
Parameters
ctx
CellSlotContext<TRow>
event
MouseEvent
Returns
void
onCellPointerEnter?
optionalonCellPointerEnter?: (ctx,event) =>void
Parameters
ctx
CellSlotContext<TRow>
event
MouseEvent
Returns
void
onFocusedRowChanged?
optionalonFocusedRowChanged?: (event) =>void
Fired when the focused ROW changes — not on every cell move within it.
Parameters
event
FocusedRowChangedEvent<TRow>
Returns
void
onHeaderClick?
optionalonHeaderClick?: (columnId,event) =>boolean
A click on a column header, asked before it sorts; return true to take it (the header then does not sort). Column selection uses it (G-SEL-02).
Parameters
columnId
string
event
MouseEvent
Returns
boolean
onKeyDown?
optionalonKeyDown?:GridKeyHook
Called for EVERY key pressed inside the grid (P-7.2), in the capture phase
at the grid's root: before the grid's own handling and before an open
cell editor sees the key — so it also gets F2 while a cell is being typed
in. ctx says whether an editor is open, which cell the key is about,
whether that row is new, and can commit() the value being typed or
cancel() it. Return 'handled' and the grid does nothing with the key
(the browser's own default is not prevented; call event.preventDefault()
for that).
The grid also leaves alone any key whose defaultPrevented is already
true when it arrives (a page listener on window took it) and every Alt
combination except AltGr typing. Default: not called.
onOpenFilterBuilder?
optionalonOpenFilterBuilder?: (context?) =>void
Opens the app's filter builder from the panel's chevron. Without it the
chevron is not rendered, because a control that opens nothing is worse than
no control. EnterpriseDataGrid wires this to its own builder.
Parameters
context?
columnId?
string
Returns
void
onReady?
optionalonReady?: (controller) =>void
Imperative access to the controller (§5.3) — search, filters, layout, export. Called once per controller instance; keep the callback stable (useCallback) or it will fire on every render.
Parameters
controller
DataGridController<TRow>
Returns
void
onRowActivate?
optionalonRowActivate?: (node) =>void
Fired on Enter / double-click over the focused row.
Parameters
node
RowNode<TRow>
Returns
void
onRowClick?
optionalonRowClick?: (node) =>void
Parameters
node
RowNode<TRow>
Returns
void
onRowLeaving?
optionalonRowLeaving?: (from,to) =>boolean|Promise<boolean>
Asked before focus leaves a row for another row (or for none), by any
road: a click, the arrow keys, Tab, Enter, focusCell / focusRow /
moveFocus / clearFocus. Return false to stay on from — the move does
not happen and neither does the click's selection. Return a Promise to
decide later (a server check, a "Save changes?" dialog): focus stays on
from until it settles, true then makes the move, and other moves asked
for meanwhile are refused. Moving inside a row does not ask. A row that
leaves the view (filtered, deleted) is not asked about. Delphi's
BeforePost / OnCanFocusRecord.
Parameters
from
RowLeavingSide<TRow>
to
RowLeavingSide<TRow> | null
Returns
boolean | Promise<boolean>
Inherited from
Omit.onRowLeaving
openCardEditor?
optionalopenCardEditor?: (rowKey) =>boolean
Open a row in the edit dialog from a card (cardView.edit: 'popup', P-9).
Set by EnterpriseDataGrid, which owns its editing layer; the free grid
uses its own editing when this is left empty. False when nothing opened.
Parameters
rowKey
Returns
boolean
pagination?
optionalpagination?:PaginationConfig
Inherited from
palette?
optionalpalette?:GridPaletteName
A colour scheme, on top of whatever theme decides about structure —
'nord', 'dracula', 'solarized', 'gruvbox', 'catppuccin' or
'tokyo-night'.
Independent of theme, so the two multiply: Ledger's dense ruled grid in
Nord's blues, or Elevated's tall one in the same blues. Works with dark
(each palette ships both), and without a theme it recolours the packaged
default. Omit it and the theme's own colours apply.
Also one of the 36 packaged colour schemes (GRID_COLOR_SCHEMES —
'porcelain', 'graphite'…; each light OR dark, whatever dark says),
with its stylesheet @kanunilabs/datagrid-react/themes/<id>.css imported
after styles.css; or the name of your own scheme from the Theme Builder.
pinFooterToBottom?
optionalpinFooterToBottom?:boolean
Keep the bottom totals row on the grid's bottom edge when there are too few
rows to reach it (Tekax B.3), as a desktop data grid does. Default false:
the row follows the last data row and sticks to the edge only once the rows
scroll. Rows pinned to the bottom (pinnedBottomRows) move down with it.
No effect with footerPosition: 'top'.
pinnedBottomRows?
optionalpinnedBottomRows?: readonlyTRow[]
Rows fixed below the scrolling body. See pinnedTopRows.
pinnedTopRows?
optionalpinnedTopRows?: readonlyTRow[]
Rows fixed above the scrolling body (P2.3) — a target line, last year's figures, a row the user pinned for comparison.
They are NOT data: never sorted, filtered, paged, selected or counted, and
not included in an export. Everything visual is shared with a real row
(columns, widths, pinned offsets, renderCell), so the two stay aligned.
For totals over the grid's own rows, use summaries — that is what the
footer row is.
portalContainer?
optionalportalContainer?:PortalContainer
Where the grid draws its popups (header filter, menus, date and lookup
lists, dialogs): an element, or a function returning one. Default
document.body.
Set it when the grid sits in a modal (Radix Dialog and the like): the
modal makes the rest of the page ignore the pointer, so a popup on <body>
cannot be clicked. Pass the modal's content element (one without
overflow: hidden). Popups stay in place even when the modal is moved
with a CSS transform. Every popup carries data-kanuni-portal.
printLayout?
optionalprintLayout?:boolean|PrintLayoutOptions
Print the whole grid instead of the screenful that happened to be visible (gap analysis P3.4). Off by default.
Virtualization is what makes a printed grid useless: the browser gets the
twenty rows inside a clipped, fixed-height box and paginates those. With
this on, beforeprint switches the grid to a mode that renders every row
and lets the box grow, and afterprint puts it back — the user's scroll
position and selection survive, because only the rendering changed.
{ always: true } stays in that mode permanently, for rendering a grid
into a report page where there is no print dialog to react to.
{ maxRows } (default 5.000) is where it refuses. Print layout puts every
row in the DOM; at a hundred thousand that is a frozen tab, which is worse
than a short printout. Past the cap the grid prints what it always did and
says so under debugMode — exportPdf() is the tool at that size, and it
streams.
remote?
optionalremote?:RemoteConfig
Tuning for a remote DataSource (ignored for array data).
Inherited from
renderCellContent?
optionalrenderCellContent?: (ctx) =>ReactNode
Replace a cell's content (e.g. with an editor). Return undefined for default.
Parameters
ctx
CellSlotContext<TRow>
Returns
ReactNode
renderDetail?
optionalrenderDetail?: (row) =>ReactNode
Body of a row's detail panel. Required for the expander column to appear —
together with masterDetail on the config.
Parameters
row
TRow
Returns
ReactNode
renderEditForm?
optionalrenderEditForm?: (rowKey,row) =>ReactNode
Body of the in-grid edit form (mode: 'form'), rendered in the row flow
under the record it edits. Set by EnterpriseDataGrid; the free grid's own
editing.mode: 'form' fills it when this is left empty. The form's
position and height come from controller.setEditFormRow.
Parameters
rowKey
row
TRow | undefined
Returns
ReactNode
renderHeaderLabel?
optionalrenderHeaderLabel?: (columnId) =>ReactNode
Replace a header's label (a rename box). Undefined = the label. Fresh when the answer changes.
Parameters
columnId
string
Returns
ReactNode
renderOverlay?
optionalrenderOverlay?: () =>ReactNode
Absolutely-positioned layer over the viewport (fill handle, watermark).
Returns
ReactNode
renderRow?
optionalrenderRow?: (ctx) =>ReactNode
Replace each DATA row's content. Group headers and detail panels keep their own rendering — a template that had to handle those too would be a template of the whole grid.
The row ELEMENT stays: it carries the height, the aria indices and the
click handlers the virtualizer and selection depend on. What the template
replaces are the cells — so in-cell editing, range selection and the fill
handle have nothing to attach to while it is on. For per-cell
customization that keeps the column layout, use a column's renderCell.
Parameters
ctx
RowTemplateContext<TRow>
Returns
ReactNode
rowClassName?
optionalrowClassName?: (ctx) =>string|undefined
A class name for a whole data row (P-8), from the row itself: one rule
for every column instead of a cellClassName per column ("a return line
reads red"). Added to the row element beside the grid's own classes
(rowStatus, selection, odd/even); return undefined or '' for none.
Asked for every rendered row on every render, so it follows edits (with
pending values — row is what the row shows), refreshCells() and
scrolling without being told. Keep it cheap. Data rows only: group,
detail and message rows are not asked. Card view: the class lands on the
card's row element too.
Parameters
ctx
RowClassNameContext<TRow>
Returns
string | undefined
rowDrag?
optionalrowDrag?:RowDragConfig<TRow>
Drag rows to reorder them, and — with a shared group — between two
grids. A grip appears at the start of each row on hover.
Reordering the grid's own array only works on an UNSORTED view: with a
sort active the sort decides the order and the drop would be invisible.
Handle onReorder yourself (updating an order field, or the server) to
support a sorted grid.
rowHeight?
optionalrowHeight?:number
The STANDARD row height in px. Default 28.
Inherited from
rowKey
rowKey:
RowKeyResolver<TRow>
REQUIRED: stable row identity — selection, editing and live updates hang off it.
Inherited from
Omit.rowKey
rowMenu?
optionalrowMenu?:GridMenuItem<RowMenuContext<TRow>>[] | ((context) =>GridMenuItem<RowMenuContext<TRow>>[])
Right-click (and Shift+F10 / ContextMenu key) menu for data rows. A function receives the row that was clicked, so the items can depend on it. Returning an empty list suppresses the menu for that row.
rowNumbers?
optionalrowNumbers?:boolean
A leading column numbering the rows (gap analysis P3.5). Default false.
The number is the row's position in WHAT IS SHOWN — it renumbers after a sort or a filter rather than carrying a record's identity around. A stable per-record number is a column of your data; this is a reading aid, the one users mean when they say "the third row".
With pagination on it continues across pages: page 2 of 50 starts at 51, because a second page starting at 1 again says nothing about position. Group headers and detail panels get an empty cell — a number on a group header would claim it is a record.
rowPinning?
optionalrowPinning?:boolean|RowPinningOptions<TRow>
Let the user pin rows from the row menu (G-CORE-05). true offers "Pin row
to top" / "Pin row to bottom" on every data row; isRowPinnable narrows
that. See pinRow() for what a pinned row is.
Inherited from
Omit.rowPinning
rowStatus?
optionalrowStatus?:boolean|RowStatusOptions<TRow>
Show each row's save state: a thin bar at the row's leading edge — amber
while it has unsaved changes, blue while its save is in flight, green for
a moment once saved, red when the save was refused — and, with tint, a
light wash over the whole row. Free (Community) in both renderers.
Screen readers hear it too (aria-description; aria-busy while saving,
aria-invalid after a refusal).
The grid's own status follows editing (every mode, onSave and
crud); get lets an app that saves elsewhere supply it instead, and
works without editing. Colours: --dg-row-status-changed, -saving,
-saved, -error; width --dg-row-status-width. Off unless passed.
Inherited from
Omit.rowStatus
rowStatusSource?
optionalrowStatusSource?:RowStatusSource|null
Where rowStatus reads each row's save state — EnterpriseDataGrid's
editing engine. With this grid's own editing on, its engine answers and
this is not asked.
scrolling?
optionalscrolling?:ScrollingConfig
Virtual (default) or infinite scrolling.
Inherited from
searchFold?
optionalsearchFold?:LookupMatchFold
How the quick search (the toolbar box, setSearchText) and the find bar
fold text before comparing — and mark it — in the lookup editors'
matchFold modes. Default 'case': case, and İ I ı i are one
letter. 'tr-loose' also drops the marks of ç ş ğ ö ü â î û, so
"siparis" finds "Sipariş". Client data only: a server grid receives the
search text as typed and folds it itself. Change it later with
controller.setSearchFold.
Inherited from
selection?
optionalselection?:SelectionConfig<TRow>
Inherited from
Omit.selection
showRowCount?
optionalshowRowCount?:boolean
Deprecated
Retired 2026-08-15 and now a no-op; the prop is kept so existing call sites do not break, and will be dropped in a later major.
It rendered a strip under the grid whose only remaining content was the row count. That strip once carried the per-column totals too, but punch item #18 moved those into the column-aligned footer ROW, where each number sits under the column it belongs to — leaving a whole bar to say one number. With the Enterprise status bar switched on, that number was then printed twice, one line above itself.
Where the count lives now: the status bar (statusBar, Enterprise —
it reports total, filtered and selected), or the pager, which shows the
total whenever pagination is on.
sortable?
optionalsortable?:boolean
Header click sorting (multi-sort follows sorting.multi + Shift).
sorting?
optionalsorting?:SortingConfig<TRow>
Inherited from
Omit.sorting
stateStoring?
optionalstateStoring?:StateStoringConfig
Remember the user's columns, sort, filters and grouping between visits. Off by default: persisting a layout the app never asked to persist is a surprise, and the storage key is shared ground the app may own.
striped?
optionalstriped?:boolean
Alternating row background.
style?
optionalstyle?:CSSProperties
summaries?
optionalsummaries?:SummaryDef<TRow>[]
Footer totals over the filtered rows.
Inherited from
Omit.summaries
theme?
optionaltheme?:GridThemeName
A packaged look — 'minimal', 'ledger', 'elevated', 'framed',
'kanuni' or 'kanuni-midnight'. Omit for the default palette, which is
unchanged and always will be.
Switchable at runtime: it resolves to one class on the grid root, so
changing it repaints without rebuilding anything. Combines with dark
(each theme ships both palettes) and with density. 'kanuni-midnight'
is already dark and ignores the flag.
Every colour, metric and border the stylesheet draws with is a --dg-*
custom property, so a theme is a token override and nothing more.
YOUR OWN theme is a name here too: theme="acme" puts the class
kanuni-datagrid-theme-acme on every surface a packaged theme reaches —
the grid, the Enterprise wrapper and every popup and dialog — so tokens
declared under .kanuni-datagrid-theme-acme restyle all of them. A custom
theme has no row-height preset: set rowHeight (or density) with it.
(className is not the channel for this: it lands on the grid root only.)
toolbar?
optionaltoolbar?:boolean|ToolbarOptions
Toolbar with search, column chooser and export. true shows all of it;
an object picks the parts and sets the search box up:
toolbar={{ export: false, columns: false, search: { maxLength: 100, debounce: 300, validate } }}
Your own buttons: toolbarItemsBefore (start) and toolbarItemsAfter
(end), e.g. <GridToolbarButton>.
toolbarColumnChooser?
optionaltoolbarColumnChooser?:boolean
The toolbar's Columns button — the popup listing HIDDEN columns. Default true. The Enterprise wrapper turns it off when the side bar's Columns panel is showing: two surfaces answering "where did my column go" is one more than anyone needs, and the panel is the fuller of the two.
toolbarExcel?
optionaltoolbarExcel?:boolean
Add an Excel entry to the toolbar's export menu (needs the optional exceljs peer).
toolbarItemsAfter?
optionaltoolbarItemsAfter?:ReactNode
toolbarItemsBefore?
optionaltoolbarItemsBefore?:ReactNode
Extra toolbar controls, before / after the built-in ones.
toolbarPdf?
optionaltoolbarPdf?:boolean
Add a PDF entry to the toolbar's export menu (needs the optional jspdf
and jspdf-autotable peers).
Off by default for the same reason as Excel: an entry that is always there would fail on a grid that never installed the libraries, and a menu item that throws is worse than one that is absent.
tooltip?
optionaltooltip?:GridTooltipConfig
Cell and header tooltips (P2.1). On by default — with no configuration at
all, a cell whose text is clipped shows it in full on hover, which is the
complaint this exists to answer. Pass { enabled: false } to opt out, or
see a column's tooltip / tooltipField to say something else.
tree?
optionaltree?:TreeDataConfig<TRow>
Hierarchical rows (Enterprise, P1.4): each row points at its parent, the
grid renders the tree. Mutually exclusive with grouping — tree wins and
grouping is ignored (reported under debugMode). Client row model only.
Inherited from
Omit.tree
viewportDatasource?
optionalviewportDatasource?:ViewportDatasource<TRow>
A server that PUSHES the rows on screen (G-ROW-02, Enterprise): the grid
says which rows are visible, the source sends them — and every change to
them — whenever it likes, the way a price feed works. Takes the place of
dataSource (pass [] there). The source owns the order: the grid's sort,
filter and search reach it through setQuery. Rows cannot be grouped, and
an export holds the rows on screen. See ViewportDatasource.
Inherited from
Omit.viewportDatasource
virtualization?
optionalvirtualization?:VirtualizationConfig
Inherited from
DataGridCoreConfig.virtualization
worker?
optionalworker?:WorkerConfig