Documentation

@kanunilabs/datagrid-react


@kanunilabs/datagrid-react / DataGridProps

Interface: DataGridProps<TRow>

Extends

Type Parameters

TRow

TRow = GridRowData

Properties

alignedGrids?

optional alignedGrids?: 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?

optional animateRows?: 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?

optional announcements?: boolean

Announcements for screen readers (sort/filter/selection). Defaults on.


ariaLabel?

optional ariaLabel?: 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

DataGridCoreConfig.ariaLabel


asyncTransactionWait?

optional asyncTransactionWait?: 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?

optional autoColumns?: 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?

optional autoHeaderHeight?: 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?

optional autoSizeStrategy?: "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?

optional cardView?: 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?

optional cellMenu?: 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?

optional className?: string


columnReorder?

optional columnReorder?: boolean

Drag a header onto another header to change the column order. Default on.


columnResize?

optional columnResize?: boolean

Width drag handle on each header's trailing edge; double-click best-fits. Default on.


columns?

optional columns?: 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?

optional dark?: boolean

Applies the packaged dark palette.


dataSource

dataSource: TRow[] | DataSource<TRow>

Inherited from

Omit.dataSource


debugMode?

optional debugMode?: boolean

Console diagnostics for integration mistakes (duplicate keys, unknown columns…).

Inherited from

DataGridCoreConfig.debugMode


defaultColumnDef?

optional defaultColumnDef?: Partial<GridColumnDef<TRow>>

Inherited from

Omit.defaultColumnDef


density?

optional density?: 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?

optional editing?: 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?

optional emptyText?: string

Shown when the pipeline yields no rows.


enterpriseEdition?

optional enterpriseEdition?: 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?

optional filterDebounce?: 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?

optional filterIconMode?: "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?

optional filterPanel?: 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?

optional filterPanelLabels?: DescribeFilterOptions

Wording for the filter panel's sentence — and / or / is / blank…


filterRow?

optional filterRow?: boolean

Text-input row under the header, one box per column.


focusedRow?

optional focusedRow?: 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?

optional focusedRowKey?: RowKey | null

Focus this row on mount / when the prop changes (controlled focus).


optional footer?: 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?

optional footerMenu?: 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?

optional footerPosition?: "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?

optional getCellClassName?: (ctx) => string | undefined

Extra class names per cell (dirty marker, range highlight, invalid).

Parameters

ctx

CellSlotContext<TRow>

Returns

string | undefined


getHeaderClassName?

optional getHeaderClassName?: (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?

optional getRowHeight?: (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

DataGridCoreConfig.gridId


grouping?

optional grouping?: GroupingConfig

Inherited from

DataGridCoreConfig.grouping


groupPanel?

optional groupPanel?: boolean

Drop area above the grid for grouping by a column.


headerFilter?

optional headerFilter?: boolean

Funnel button per header opening the distinct-value checklist popup.


headerMenu?

optional headerMenu?: 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?

optional highlightSearch?: 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?

optional loadingOverlay?: 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?

optional locale?: 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

DataGridCoreConfig.locale


masterDetail?

optional masterDetail?: MasterDetailConfig<TRow>

Expandable detail panels under rows. Enterprise (P9).

Inherited from

Omit.masterDetail


messages?

optional messages?: 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

DataGridCoreConfig.messages


notes?

optional notes?: 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?

optional onCardViewChange?: (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?

optional onCellDoubleClick?: (ctx) => void

Parameters

ctx

CellSlotContext<TRow>

Returns

void


onCellPointerDown?

optional onCellPointerDown?: (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?

optional onCellPointerEnter?: (ctx, event) => void

Parameters

ctx

CellSlotContext<TRow>

event

MouseEvent

Returns

void


onFocusedRowChanged?

optional onFocusedRowChanged?: (event) => void

Fired when the focused ROW changes — not on every cell move within it.

Parameters

event

FocusedRowChangedEvent<TRow>

Returns

void


onHeaderClick?

optional onHeaderClick?: (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?

optional onKeyDown?: 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?

optional onOpenFilterBuilder?: (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?

optional onReady?: (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?

optional onRowActivate?: (node) => void

Fired on Enter / double-click over the focused row.

Parameters

node

RowNode<TRow>

Returns

void


onRowClick?

optional onRowClick?: (node) => void

Parameters

node

RowNode<TRow>

Returns

void


onRowLeaving?

optional onRowLeaving?: (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?

optional openCardEditor?: (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

RowKey

Returns

boolean


pagination?

optional pagination?: PaginationConfig

Inherited from

DataGridCoreConfig.pagination


palette?

optional palette?: 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?

optional pinFooterToBottom?: 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?

optional pinnedBottomRows?: readonly TRow[]

Rows fixed below the scrolling body. See pinnedTopRows.


pinnedTopRows?

optional pinnedTopRows?: readonly TRow[]

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?

optional portalContainer?: 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?

optional printLayout?: 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?

optional remote?: RemoteConfig

Tuning for a remote DataSource (ignored for array data).

Inherited from

DataGridCoreConfig.remote


renderCellContent?

optional renderCellContent?: (ctx) => ReactNode

Replace a cell's content (e.g. with an editor). Return undefined for default.

Parameters

ctx

CellSlotContext<TRow>

Returns

ReactNode


renderDetail?

optional renderDetail?: (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?

optional renderEditForm?: (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

RowKey

row

TRow | undefined

Returns

ReactNode


renderHeaderLabel?

optional renderHeaderLabel?: (columnId) => ReactNode

Replace a header's label (a rename box). Undefined = the label. Fresh when the answer changes.

Parameters

columnId

string

Returns

ReactNode


renderOverlay?

optional renderOverlay?: () => ReactNode

Absolutely-positioned layer over the viewport (fill handle, watermark).

Returns

ReactNode


renderRow?

optional renderRow?: (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?

optional rowClassName?: (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?

optional rowDrag?: 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?

optional rowHeight?: number

The STANDARD row height in px. Default 28.

Inherited from

DataGridCoreConfig.rowHeight


rowKey

rowKey: RowKeyResolver<TRow>

REQUIRED: stable row identity — selection, editing and live updates hang off it.

Inherited from

Omit.rowKey


rowMenu?

optional rowMenu?: 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?

optional rowNumbers?: 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?

optional rowPinning?: 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?

optional rowStatus?: 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?

optional rowStatusSource?: 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?

optional scrolling?: ScrollingConfig

Virtual (default) or infinite scrolling.

Inherited from

DataGridCoreConfig.scrolling


searchFold?

optional searchFold?: 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

DataGridCoreConfig.searchFold


selection?

optional selection?: SelectionConfig<TRow>

Inherited from

Omit.selection


showRowCount?

optional showRowCount?: 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?

optional sortable?: boolean

Header click sorting (multi-sort follows sorting.multi + Shift).


sorting?

optional sorting?: SortingConfig<TRow>

Inherited from

Omit.sorting


stateStoring?

optional stateStoring?: 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?

optional striped?: boolean

Alternating row background.


style?

optional style?: CSSProperties


summaries?

optional summaries?: SummaryDef<TRow>[]

Footer totals over the filtered rows.

Inherited from

Omit.summaries


theme?

optional theme?: 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?

optional toolbar?: 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?

optional toolbarColumnChooser?: 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?

optional toolbarExcel?: boolean

Add an Excel entry to the toolbar's export menu (needs the optional exceljs peer).


toolbarItemsAfter?

optional toolbarItemsAfter?: ReactNode


toolbarItemsBefore?

optional toolbarItemsBefore?: ReactNode

Extra toolbar controls, before / after the built-in ones.


toolbarPdf?

optional toolbarPdf?: 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?

optional tooltip?: 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?

optional tree?: 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?

optional viewportDatasource?: 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?

optional virtualization?: VirtualizationConfig

Inherited from

DataGridCoreConfig.virtualization


worker?

optional worker?: WorkerConfig

Inherited from

DataGridCoreConfig.worker