@kanunilabs/datagrid-react

@kanunilabs/datagrid-react / DataGridProps

Interface: DataGridProps<TRow>

Defined in: datagrid-react/src/types.ts:388

Extends

• Omit<DataGridCoreConfig<TRow>, "columns">

Type Parameters

TRow

TRow = GridRowData

Properties

alignedGrids?

optional alignedGrids?: string

Defined in: datagrid-react/src/types.ts:726

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.

announcements?

optional announcements?: boolean

Defined in: datagrid-react/src/types.ts:506

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

asyncTransactionWait?

optional asyncTransactionWait?: number

Defined in: datagrid-core/dist/index.d.ts:1162

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

Defined in: datagrid-react/src/types.ts:401

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.

autoSizeStrategy?

optional autoSizeStrategy?: "none" | "fitGrid" | "fitCells"

Defined in: datagrid-react/src/types.ts:667

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.

cellMenu?

optional cellMenu?: boolean | CellMenuOptions

Defined in: datagrid-react/src/types.ts:530

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

Defined in: datagrid-react/src/types.ts:412

columnReorder?

optional columnReorder?: boolean

Defined in: datagrid-react/src/types.ts:494

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

columnResize?

optional columnResize?: boolean

Defined in: datagrid-react/src/types.ts:496

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

columns?

optional columns?: ReactGridColumnDef<TRow>[]

Defined in: datagrid-react/src/types.ts:395

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

Defined in: datagrid-react/src/types.ts:415

Applies the packaged dark palette.

dataSource

dataSource: TRow[] | DataSource<TRow>

Defined in: datagrid-core/dist/index.d.ts:1097

Inherited from

Omit.dataSource

debugMode?

optional debugMode?: boolean

Defined in: datagrid-core/dist/index.d.ts:1153

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

Inherited from

DataGridCoreConfig.debugMode

defaultColumnDef?

optional defaultColumnDef?: Partial<GridColumnDef<TRow>>

Defined in: datagrid-core/dist/index.d.ts:1101

Inherited from

Omit.defaultColumnDef

density?

optional density?: GridDensity

Defined in: datagrid-react/src/types.ts:514

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.

emptyText?

optional emptyText?: string

Defined in: datagrid-react/src/types.ts:445

Shown when the pipeline yields no rows.

enterpriseEdition?

optional enterpriseEdition?: boolean

Defined in: datagrid-react/src/types.ts:778

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, summaries (footer column totals), column spanRows, notes, Excel and PDF export. 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, CSV export, themes, 12 locales and the whole event/imperative API. Boundary set with the user on 2026-08-14 against AG Grid's own line.

filterDebounce?

optional filterDebounce?: number

Defined in: datagrid-react/src/types.ts:465

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"

Defined in: datagrid-react/src/types.ts:492

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"

Defined in: datagrid-react/src/types.ts:476

A bar under the footer stating the active filter in words, with a checkbox that suspends it and an × that removes it — the DevExpress cxGrid 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

Defined in: datagrid-react/src/types.ts:478

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

filterRow?

optional filterRow?: boolean

Defined in: datagrid-react/src/types.ts:449

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

focusedRow?

optional focusedRow?: boolean

Defined in: datagrid-react/src/types.ts:548

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

Defined in: datagrid-react/src/types.ts:550

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

footer?

optional footer?: boolean

Defined in: datagrid-react/src/types.ts:574

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

Defined in: datagrid-react/src/types.ts:580

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"

Defined in: datagrid-react/src/types.ts:649

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

Defined in: datagrid-react/src/types.ts:749

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

Parameters

ctx

CellSlotContext<TRow>

Returns

string | undefined

getRowHeight?

optional getRowHeight?: (node, index) => number | undefined

Defined in: datagrid-core/dist/index.d.ts:1118

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

Defined in: datagrid-core/dist/index.d.ts:1096

Inherited from

DataGridCoreConfig.gridId

grouping?

optional grouping?: GroupingConfig

Defined in: datagrid-core/dist/index.d.ts:1124

Inherited from

DataGridCoreConfig.grouping

groupPanel?

optional groupPanel?: boolean

Defined in: datagrid-react/src/types.ts:508

Drop area above the grid for grouping by a column.

headerFilter?

optional headerFilter?: boolean

Defined in: datagrid-react/src/types.ts:486

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

headerMenu?

optional headerMenu?: boolean | ((context, defaults) => GridMenuItem<HeaderMenuContext>[])

Defined in: datagrid-react/src/types.ts:537

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

Defined in: datagrid-react/src/types.ts:676

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

Defined in: datagrid-react/src/types.ts:502

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

Defined in: datagrid-core/dist/index.d.ts:1144

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

Defined in: datagrid-core/dist/index.d.ts:1132

Expandable detail panels under rows. Enterprise (P9).

Inherited from

DataGridCoreConfig.masterDetail

messages?

optional messages?: Partial<GridDictionary>

Defined in: datagrid-core/dist/index.d.ts:1151

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>

Defined in: datagrid-react/src/types.ts:732

Cell notes (gap analysis P3.3) — user-written prose attached to a cell, marked with a corner triangle and revealed on hover. See GridNotesConfig.

onCellDoubleClick?

optional onCellDoubleClick?: (ctx) => void

Defined in: datagrid-react/src/types.ts:755

Parameters

ctx

CellSlotContext<TRow>

Returns

void

onCellPointerDown?

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

Defined in: datagrid-react/src/types.ts:753

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

Defined in: datagrid-react/src/types.ts:754

Parameters

ctx

CellSlotContext<TRow>

event

MouseEvent

Returns

void

onFocusedRowChanged?

optional onFocusedRowChanged?: (event) => void

Defined in: datagrid-react/src/types.ts:552

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

Parameters

event

row?

TRow

rowKey

RowKey | null

Returns

void

onOpenFilterBuilder?

optional onOpenFilterBuilder?: () => void

Defined in: datagrid-react/src/types.ts:484

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.

Returns

void

onReady?

optional onReady?: (controller) => void

Defined in: datagrid-react/src/types.ts:739

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

Defined in: datagrid-react/src/types.ts:504

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

Parameters

node

RowNode<TRow>

Returns

void

onRowClick?

optional onRowClick?: (node) => void

Defined in: datagrid-react/src/types.ts:733

Parameters

node

RowNode<TRow>

Returns

void

pagination?

optional pagination?: PaginationConfig

Defined in: datagrid-core/dist/index.d.ts:1133

Inherited from

DataGridCoreConfig.pagination

palette?

optional palette?: GridPalette

Defined in: datagrid-react/src/types.ts:441

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: Balham's dense ruled grid in Nord's blues, or Material'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.

pinnedBottomRows?

optional pinnedBottomRows?: readonly TRow[]

Defined in: datagrid-react/src/types.ts:641

Rows fixed below the scrolling body. See pinnedTopRows.

pinnedTopRows?

optional pinnedTopRows?: readonly TRow[]

Defined in: datagrid-react/src/types.ts:639

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.

printLayout?

optional printLayout?: boolean | PrintLayoutOptions

Defined in: datagrid-react/src/types.ts:710

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

Defined in: datagrid-core/dist/index.d.ts:1122

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

Inherited from

DataGridCoreConfig.remote

renderCellContent?

optional renderCellContent?: (ctx) => ReactNode

Defined in: datagrid-react/src/types.ts:747

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

Defined in: datagrid-react/src/types.ts:783

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

Defined in: datagrid-react/src/types.ts:789

Body of the in-grid edit form (mode: 'form'), rendered in the row flow under the record it edits. Set by EnterpriseDataGrid; the form's position and height come from controller.setEditFormRow.

Parameters

rowKey

RowKey

row

TRow | undefined

Returns

ReactNode

renderOverlay?

optional renderOverlay?: () => ReactNode

Defined in: datagrid-react/src/types.ts:751

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

Returns

ReactNode

renderRow?

optional renderRow?: (ctx) => ReactNode

Defined in: datagrid-react/src/types.ts:615

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

rowDrag?

optional rowDrag?: RowDragConfig<TRow>

Defined in: datagrid-react/src/types.ts:411

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

Defined in: datagrid-core/dist/index.d.ts:1104

The STANDARD row height in px. Default 28.

Inherited from

DataGridCoreConfig.rowHeight

rowKey

rowKey: RowKeyResolver<TRow>

Defined in: datagrid-core/dist/index.d.ts:1099

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>>[])

Defined in: datagrid-react/src/types.ts:520

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

Defined in: datagrid-react/src/types.ts:690

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.

scrolling?

optional scrolling?: ScrollingConfig

Defined in: datagrid-core/dist/index.d.ts:1135

Virtual (default) or infinite scrolling.

Inherited from

DataGridCoreConfig.scrolling

selection?

optional selection?: SelectionConfig

Defined in: datagrid-core/dist/index.d.ts:1123

Inherited from

DataGridCoreConfig.selection

showRowCount?

optional showRowCount?: boolean

Defined in: datagrid-react/src/types.ts:568

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

Defined in: datagrid-react/src/types.ts:447

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

sorting?

optional sorting?: SortingConfig

Defined in: datagrid-core/dist/index.d.ts:1102

Inherited from

DataGridCoreConfig.sorting

stateStoring?

optional stateStoring?: StateStoringConfig

Defined in: datagrid-react/src/types.ts:621

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

Defined in: datagrid-react/src/types.ts:443

Alternating row background.

style?

optional style?: CSSProperties

Defined in: datagrid-react/src/types.ts:413

summaries?

optional summaries?: SummaryDef<TRow>[]

Defined in: datagrid-core/dist/index.d.ts:1137

Footer totals over the filtered rows.

Inherited from

Omit.summaries

theme?

optional theme?: GridTheme

Defined in: datagrid-react/src/types.ts:430

A packaged look — 'quartz', 'balham', 'material', 'alpine', '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 — override the same properties yourself under your own class to go further.

toolbar?

optional toolbar?: boolean

Defined in: datagrid-react/src/types.ts:582

Toolbar with search, column chooser and export.

toolbarColumnChooser?

optional toolbarColumnChooser?: boolean

Defined in: datagrid-react/src/types.ts:589

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

Defined in: datagrid-react/src/types.ts:591

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

toolbarItemsAfter?

optional toolbarItemsAfter?: ReactNode

Defined in: datagrid-react/src/types.ts:603

toolbarItemsBefore?

optional toolbarItemsBefore?: ReactNode

Defined in: datagrid-react/src/types.ts:602

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

toolbarPdf?

optional toolbarPdf?: boolean

Defined in: datagrid-react/src/types.ts:600

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

Defined in: datagrid-react/src/types.ts:628

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>

Defined in: datagrid-core/dist/index.d.ts:1130

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

virtualization?

optional virtualization?: VirtualizationConfig

Defined in: datagrid-core/dist/index.d.ts:1119

Inherited from

DataGridCoreConfig.virtualization

worker?

optional worker?: WorkerConfig

Defined in: datagrid-core/dist/index.d.ts:1120

Inherited from

DataGridCoreConfig.worker