Dash component props

Every prop of the dash_tensor_grid.TensorGrid component. Props marked * are required. Start typing to filter.

Name	Type	Default	Description
client_side_aggregation Aggregation	boolean	false	When True, the grid aggregates in the FRONTEND: pass flat (un-aggregated) row_data and the grid groups by group_by and aggregates each measure column itself (using its aggregationFn), instead of consuming a pre-aggregated backend tree. Default False (the backend computes aggregates).
enable_grouping_panel Aggregation	boolean	true	Show the interactive "Group by" panel in client-side aggregation mode (default True).
footer Aggregation	dict	None	Explicit footer values keyed by column id (e.g. backend grand totals). When omitted and show_footer is set, footer aggregates are computed client-side from each measure column's aggregationFn.
group_by Aggregation	list of strings	None	Column ids to group by when client_side_aggregation is True (the row hierarchy). Measure columns aggregate within each group via their aggregationFn ('sum' | 'mean' | 'min' | 'max' | 'count' | 'median' | 'uniqueCount').
range_aggregation Aggregation	dict | string	None	Input: a server-computed aggregation of the selected range, rendered in the status bar. Feed it the result of engine.aggregate_cells(range_selection['cells']) -- {fields, overall} (the overall stats are shown) -- or a pre-formatted string. The ENGINE does the math; the grid only displays it. Optional formatStr on the object formats the numbers.
show_footer Aggregation	boolean	false	Render a footer row with per-column aggregates (default False).
action_triggered Callback-state	dict	None	Set when an action button is clicked. Row action: {row_id, action, n, row, path}; column / header action: {scope: 'column', column, action, n}. path is the decoded group-key path (e.g. ["AMER", "US"]) -- hand it straight to engine.drill_through. Action items are {id, label, icon, title}.
cell_clicked Callback-state	dict	None	Output: set when a data cell is clicked (with enable_cell_click): {row_id, column, value, row, n, path}. path is the decoded group-key path (e.g. ["AMER", "US"], or None for flat rows) -- pass it to engine.drill_through to fetch the underlying source rows. Use as a Dash callback Input.
command Callback-state	dict	None	Imperative command (write-only): set {action, args?, n} from a callback to drive the grid. action is one of expandAll, collapseAll, expandToDepth (args.depth), clearSelection, selectRows (args.ids), scrollToRow (args.index or args.id), export (args.mode), print, autoSizeColumns (args.columns). Bump n (a nonce) each time so the same action can fire again.
context_menu_action Callback-state	dict	None	Output: the chosen menu item, pushed as {item, row_id, column_id, value, row, n} (n is a nonce so the same item can fire twice). Use as a callback Input.
detail_request Callback-state	dict	None	Output: set when a detail panel opens with no local data -- {row_id, row, path, n}. Use as a callback Input to fetch and return detail_data[row_id].
enable_cell_click Callback-state	boolean	false	Fire cell_clicked when a data cell / row is clicked (default False).
error Callback-state	dict	None	Output: set if the grid hits a render error -- {message, stack}. The grid degrades to an inline message (it never white-screens the host page) and auto-recovers when new row_data / column_defs arrive. Use as a callback Input to surface or log failures.
grid_event Callback-state	dict	None	Output: lifecycle / interaction events {type, payload, n} (n is a nonce). type is one of ready, firstDataRendered, sortChanged, filterChanged, columnResized, columnVisibilityChanged, paginationChanged. Use as a callback Input to observe grid lifecycle.
row_counts Callback-state	dict	None	Output: row counts pushed whenever they change -- {total, filtered, visible, selected}. Use as a callback Input for a "showing X of Y" label or counters.
row_moved Callback-state	dict	None	Output: fired when a row is dropped in a new position, as {id, old_index, new_index, n} (absolute indices into the flat data; n is a nonce). Use as a callback Input to persist the new order server-side.
setProps Callback-state	func	Dash-assigned	Dash-assigned callback used to report prop changes back to the server.
view_state Callback-state	dict	None	Output: a snapshot of the table view state, pushed whenever it changes: {sorting, column_filters, global_filter, grouping, column_order, column_sizing, column_visibility, collapsed_groups, expanded, row_selection}. Use as a Dash callback Input to react to any interaction.
context_menu_items Chrome	list	None	Context-menu items [{id, label, icon?, iconSvg?, divider?}]. Omit for the defaults (Copy cell, Copy row, Export CSV, plus Expand/Collapse on group rows). Built-in ids copyCell / copyRow / export / toggleExpand run locally; any other id only fires context_menu_action.
debounce Chrome	number	250	Debounce (ms, default 250; 0 disables). Applies to the outgoing view_state prop so rapid changes coalesce into one callback round-trip, AND to the global search box so a large client grid is not re-filtered on every keystroke -- the search input stays instant while the filter it drives is committed on the trailing edge.
enable_column_menu Chrome	boolean	false	Show a per-column header menu (kebab) consolidating sort asc/desc/clear, pin left/right/unpin, hide column, and (with client_side_aggregation) group-by -- each respecting the column's enable flags. Default False.
enable_column_panel Chrome	boolean	false	Show a toolbar button that toggles a column tool-panel (a slide-in side panel, default False). The panel lists every real leaf column with a show/hide checkbox (sharing the column-visibility state with the header menu) and Up/Down reorder controls (sharing the column-order state), plus Show all / Hide all. View-state only -- the grid does no math.
enable_column_reorder Chrome	boolean	true	Allow drag-and-drop column reordering (default True).
enable_column_resize Chrome	boolean	true	Allow column resizing by dragging the header border (default True). Set per column with enableResizing: false in column_defs to fix a single column's width while others stay resizable.
enable_column_visibility Chrome	boolean	false	Show a toolbar "Columns" menu to hide / show columns (default False).
enable_context_menu Chrome	boolean	false	Enable the right-click context menu on cells/rows.
enable_expand_all Chrome	boolean	true	Show "expand all" / "collapse all" buttons in the toolbar for the row-group hierarchy (default True). Hidden when there is nothing to expand or in lazy mode (children are fetched on demand there).
enable_fullscreen Chrome	boolean	false	Show a toolbar fullscreen toggle (default False). Uses the native Fullscreen API on the grid root, falling back to a fixed-position maximized overlay.
enable_keyboard_nav Chrome	boolean	false	Enable keyboard navigation (ARIA treegrid, roving tabindex): Arrow keys move the active cell, Home/End and PageUp/PageDown jump, Left/Right collapse / expand a group row, Space toggles row selection, Enter / F2 (or typing) edit an editable cell. Opt-in (default False) so existing tab order is unchanged.
enable_pagination Chrome	boolean	false	Paginate rows with a footer pager (default False). Best for flat data.
enable_shortcut_help Chrome	boolean	false	Show a toolbar "?" button that opens a keyboard-shortcut help dialog (default False). The dialog (role=dialog, aria-modal) lists only the shortcuts whose feature is enabled -- keyboard navigation (arrows / Page / Home-End / Space / Enter), and range selection (drag / Ctrl-Cmd-C / Esc). Press "?" to toggle it, Esc / backdrop / close to dismiss.
enable_status_bar Chrome	boolean	false	Show a footer status bar (default False) with Total / Filtered / Selected row counts and, when rows are selected, Sum / Avg / Min / Max / Count of a numeric field over the selection (presentation of loaded values, not grid aggregation).
height Chrome	string	None	Fixed height of the scroll area (any CSS length); overrides min/max sizing.
id Chrome	string	—	The Dash component id, applied to the root DOM element.
loading Chrome	boolean	None (follows Dash loading_state)	Show a loading overlay + spinner. True/False forces it; when null (default) the grid follows Dash's own loading_state.is_loading (so a pending callback that targets the grid shows the overlay automatically).
loading_message Chrome	string	None	Optional text shown beneath the spinner in the loading overlay.
loading_state Chrome	dict (shape: {is_loading: bool, prop_name: string, component_name: string})	None	Dash-injected loading state {is_loading, prop_name, component_name}.
locale_text Chrome	dict	None	Translate the grid's chrome strings: an object overriding any of the built-in English defaults per key. Keys: search, filter, filterMin, filterMax, filterAll, rowsPerPage, all, pageInfo (template with {start}/{end}/{total}), firstPage, prevPage, nextPage, lastPage, noRows, columns, exportLabel, exportRaw, exportNested, exportSelected, copyCell, copyRow, exportCsv, expand, collapse, showDetail, hideDetail, loading, errorTitle, searchValues, selectAll, clear, selected, and, or, value, operators (a sub-map of operator labels, deep-merged), and status-bar labels statusTotal / statusFiltered / statusSelected / statusSum / statusAvg / statusMin / statusMax / statusCount / enterFullscreen / exitFullscreen. (Number / date formatting is separate -- see locale.)
max_height Chrome	string	None	Max height of the scroll area (any CSS length, e.g. '600px'); header sticks.
min_height Chrome	string	None	Min height of the scroll area (any CSS length).
no_rows_message Chrome	string	None (renders 'No rows')	Message shown when there are no rows (default 'No rows').
page_size Chrome	number	50	Initial rows per page (default 50). 0 means show all.
page_size_options Chrome	list of numbers	[20, 50, 100, 0]	Page-size choices in the pager dropdown (default [20, 50, 100, 0]); 0 renders as "All". Pass your own list to customise.
persisted_props Chrome	list of strings	['view_state']	Which props to persist (default ['view_state']).
persistence Chrome	boolean | string | number	—	Dash persistence: when truthy, the grid's view_state (sort / filter / order / sizing / visibility / pinning / expansion / selection) is saved and restored across reloads. A string/number scopes the stored value.
persistence_type Chrome	enum: 'local' | 'session' | 'memory'	'local'	Where persisted data is stored: 'local' | 'session' | 'memory'.
show_row_numbers Chrome	boolean	false	Show a pinned-left, display-only row-number column with the 1-based ABSOLUTE ordinal of each row (correct under pagination / virtualization / infinite). Default False. Sits right of the selection column. Header localized (rowNumber).
status_bar_field Chrome	string	None (first visible numeric column)	Column id whose values the status bar aggregates over the selection. Defaults to the first visible numeric column.
auto_group_column_def Data	dict	None	Auto-group column (default None). When set to an object, the grid prepends one dedicated leading column (id __group__) that owns the hierarchy -- the indent, the expand/collapse toggle, and a group label -- and suppresses the toggle/indent on the first data cell, so the other columns stay tidy. Keys: header (default "Group"), width, field (row key to show as the label; defaults to the client-side grouping value, else the first data column's value). Use it with a tree (backend full-tree row_data with subRows, or client-side aggregation). The grid does no math -- it renders labels already present on the row.
column_defs Data	list	[]	Column descriptors. A leaf is { accessorKey/field, header, type, formatStr, align, filterType, filterOptions, headerActions }; a group is { header, columns: [...] }; an action column is { type: 'action', header, actions: [{id, label, icon, title}] }. headerActions: [{id, icon, label, title}] adds clickable buttons to a column header (fires action_triggered with scope: 'column'). formatStr grammar: kind[:arg][:flag…][;modifier…] -- kind is number/currency/percentage/date; numeric flags/modifiers: compact (1.2K/3.4M), accounting (negatives in parens), sign (+/-), unit=<suffix>. e.g. 'currency:USD:compact', 'number:2;accounting', 'number:0;unit=kg'. filterType is 'text' | 'range' | 'select' | 'set' | 'conditions' | 'date' (omit to derive; a date-typed column gets a from/to date-picker range). Per-column toggles (industry-standard, default True): enableGrouping, enableSorting, enableFilter, enableHiding, enableResizing. Icons accept a built-in name (e.g. 'edit', 'delete', 'view', 'search', 'download', 'info', 'filter', 'more', 'plus', 'check', 'refresh', 'star') or a raw iconSvg string. Sizing: width/minWidth/maxWidth. Display: wrapText, enableTooltip (+tooltipField), headerTooltip. A calculated column carries an id and a formula string (same syntax as the Python DSL) evaluated client-side from the row's other measure values -- e.g. {id: 'margin', formula: '(rev-cost)/rev'}. A column whose value is an array of numbers can render an in-cell mini chart with cellRenderer: 'sparkline' (line) or 'bar', plus optional cellRendererParams: {width, height, color, colorUp, colorDown, fill}. Other (display-only) cellRenderer values: badge / chip (colorMap), progressBar, link, rating (stars; params {max}), boolean / checkbox, email / url / phone (scheme-safe links), tags (array or separator-split string -> chips). pinned: 'left' | 'right' freezes a column on horizontal scroll (the select column auto-pins left when anything is pinned). Conditional formatting: cellStyle (a static style object) and styleRules: [{if, style, className}] where if is a formula tested per row against {value, ...other columns} (e.g. {if: "value < 0", style: {color: "#e03131"}}). editable: true makes the column's cells inline-editable when the grid's enable_editing is set. conditionalFormat applies a value-driven visual: {type: 'dataBar', color?, negativeColor?, origin?, min?, max?} (in-cell bar; origin makes it diverge left/right of that value), {type: 'colorScale', colors?, min?, mid?, max?} (interpolated background) or {type: 'iconSet', set?, thresholds?, colors?, reverse?} (icon by threshold; colors overrides the per-level red/amber/green, reverse flips it so a LOW value is "good"). Bounds default to the column's faceted min/max.
default_column_def Data	dict	None	Base column definition shallow-merged under every leaf column (per-column keys win; meta deep-merges). Use for shared defaults like {minWidth: 80, enableTooltip: true}.
detail_data Data	dict	None	Detail content keyed by row_id (for lazy master/detail): supply it from a callback in response to detail_request. Takes precedence over detail_field.
detail_field Data	string	None	Row field whose value fills the detail panel (an array of records renders as a small table; an object as a key/value list; anything else as text).
enable_master_detail Data	boolean	false	Enable master/detail sub-panels. Leaf rows (or rows flagged _detail: true; opt out with _detail: false) get an expander that reveals a full-width panel below the row.
enable_row_drag Data	boolean	false	Enable row drag-reorder (default False): prepend a drag-handle column and let the user drag a row (by its grip) to a new position. The display reorders optimistically and a row_moved output fires so the backend can persist the order. Restricted to the FLAT client model -- with grouping, a backend tree, or the infinite/server model it is a no-op. The frontend does no math -- it reorders the display + reports.
expanded_state Data	boolean | dict	None	Expansion state: true (all expanded) or { node_id: boolean }. Owned by the frontend and pushed out on every expand/collapse. In lazy mode this is the canonical signal: a callback Input on expanded_state re-materialises the expanded nodes' children (see examples/lazy_app.py).
initial_state Data	dict	None	Initial table state, applied once on mount: any of grouping (array of column ids), sorting ([{id, desc}]), expanded (true | object), columnOrder (array of ids), columnSizing ({id: width}), columnVisibility ({id: bool}), columnFilters, globalFilter. If omitted the grid starts flat (no grouping), showing every row line by line.
pinned_bottom_rows Data	list	None	Rows pinned to the bottom (sticky band above the pager/status bar).
pinned_top_rows Data	list	None	Rows pinned to the top of the grid (array of row objects, same shape as row_data). Rendered as a sticky band just below the header; they do not scroll / sort / filter / select. Use for caller-computed totals or header rows (the engine does the math; the grid just displays them).
row_data Data	list	[]	The tree of rows (each node may carry a stable `id` and a `subRows` array).
row_id_field Data	string	None (effective 'id')	The row field used as the stable id for getRowId, transactions, selection and editing. Default id.
transaction Data	dict	None	Apply a row delta WITHOUT resending row_data (write-only; bump n each time): {add: [...rows], update: [...rows], remove: [...ids|rows], n}. Rows match by the row_id_field (default id). Changed cells briefly flash (green up / red down for numbers). A new row_data replaces the local copy wholesale. The grid does no math -- the caller supplies fully-formed rows. Best for flat/leaf rows.
cell_edited Editing	dict	None	Output: set when a cell is edited: {row_id, column, old_value, new_value, row, path, n}. Use as a callback Input to persist the change and feed back updated row_data (the edit is optimistically shown until then). path is the decoded group-key path.
detail_editable Editing	boolean	false	With enable_master_detail: SOURCE cells in a records-array detail panel are click-to-edit (an input swap; Enter/blur commits, Escape cancels; numeric cells coerce and invalid input cancels). A commit emits source_cell_edited; the panel shows the committed value once the callback returns refreshed detail_data. Grid cells stay read-only aggregates -- source rows are the write surface.
enable_editing Editing	boolean	false	Enable inline cell editing (pair with a per-column editable: true). Double-click an editable cell to edit it; commit on Enter / blur, cancel on Escape. The frontend does ZERO math -- it only reports the edit.
source_cell_edited Editing	dict	None	Output: a SOURCE-row edit committed in an editable detail panel -- {row_id, path, row_index, column, old_value, new_value, n} (the wire SourceCellEdit shape plus Dash conventions). DISTINCT from cell_edited, which reports a grid-level edit of an AGGREGATED cell. path + row_index address the row_index-th source row matching the group-key path in drill-through order, and old_value is the raw wire value the editor saw -- it composes directly with the engine's wire-terms stale guard: pass the event to GridDataEngine.apply_edit(dims, event) and return refreshed row_data + detail_data[row_id].
source_edit_rejected Editing	dict	None	Output (callback-set): the engine's verdict when a source_cell_edited edit is REJECTED -- {row_id, column, code, message, n} (the RejectedEdit wire shape plus Dash conventions). DISTINCT from source_cell_edited (the edit request). A commit callback that catches EditValidationError (or any apply_edit ValueError) sets this prop instead of updating row_data, so the app can show the reason / flash the invalid cell. code is validation.<rule> / validation.config / a stale/dtype code; message is the engine's human text.
clipboard_copy Export	dict	None	Output: fired when the user copies the active range with Ctrl/Cmd-C, as {rows, cols, text_len, n} (block dimensions + copied-text length; n is a nonce so each copy registers). The TSV itself goes to the OS clipboard, not the wire. Requires enable_range_selection.
download_request Export	dict	None	Trigger an export from a callback (write-only nonce): set {mode, n} where mode is 'leaf' (raw rows), 'tree' (nested groups, pivot-shaped CSV) or 'selected' (only selected). Bump n each time.
enable_clipboard Export	boolean	true	Allow Ctrl/Cmd-C to copy the selected rows as TSV when the grid has focus (default True; requires enable_row_selection).
enable_export Export	boolean	false	Show a toolbar "Export CSV" button (downloads selected rows, else all).
enable_print Export	boolean	false	Show a toolbar Print action (default False). Clicking it expands all groups and opens the browser print dialog (Save as PDF). An @media print stylesheet hides the chrome and lays the full table out for paper; client virtualization is suspended during the print so every row is on the page. The command prop action print triggers the same flow from a callback.
enable_clear_filters Filtering	boolean	false	Show a toolbar button that clears ALL filters at once (default False) -- the per-column filters (header menus + the floating filter row) and the global search, which share state. The button is disabled when no filter is active.
enable_column_filters Filtering	boolean	true	Show per-column filter inputs (default True).
enable_floating_filters Filtering	boolean	false	Show an always-visible floating filter row directly beneath the column header (default False). Each visible leaf column gets a type-aware inline filter (text contains / number min-max / select), wired to the SAME column-filter state as the header filter menus -- set one and the other reflects it. Columns with filtering disabled (and the select / row-number / action pseudo columns) show no input. The row sticks just under the header on vertical scroll.
enable_global_filter Filtering	boolean	true	Show the global search box (default True).
filter_state Filtering	list	None	Initial column filters: [{id, value}].
global_filter Filtering	string	None	Initial global search string (frontend owns it at runtime).
highlight_matches Filtering	boolean	false	Highlight global-search matches in the cells (default False). When on and the global filter is a non-empty string, matching substrings of plain-text cell content are wrapped in <mark class="tg-mark"> (case-insensitive). Widget / action / pseudo cells are left as-is. XSS-safe: matches render as React text nodes, never raw HTML.
allow_html Formatting	boolean	false	Opt into rendering RAW HTML (trusted): when True, custom iconSvg is injected unsanitized and link hrefs skip the scheme allowlist. Default False (safe): iconSvg is sanitized (script / event-handler / javascript: stripped) and link cells only follow http/https/mailto/tel/relative URLs. Set True only for fully trusted, developer-controlled content.
date_format Formatting	string | dict	None	Default date formatting: an Intl.DateTimeFormat options object (e.g. {dateStyle: 'medium'} or {year: 'numeric', month: 'short'}), or a style shorthand string 'short' | 'medium' | 'long' | 'full'. A column's own formatStr such as 'date:short' overrides this. Uses locale.
locale Formatting	string	None (browser locale)	BCP-47 locale / region tag for number & date display, e.g. 'de-DE', 'fr-FR', 'en-IN'. Controls grouping order and default separators. When omitted, the browser's locale is used. Affects display only -- raw numerics stay on the wire so sorting and aggregation are unaffected.
number_format Formatting	dict	None	Number-formatting overrides applied to every numeric / currency / percentage column: {decimal: ',', thousands: '.', grouping: true, currency: 'EUR'}. decimal / thousands override the locale's separators (any string); grouping toggles thousands grouping; currency is the default currency code for currency columns (a column's own formatStr like 'currency:JPY' wins).
overflow_tooltip Formatting	boolean	false	Show a native tooltip with the full text on plain-text cells that are truncated (ellipsised) by their column width (default False). The title is set lazily on hover and only when the text actually overflows -- a fully-visible cell gets no tooltip. An explicit per-column enableTooltip / tooltipField still wins. Ignored for wrapping cells and widget / action / pseudo cells.
wrap_text Formatting	boolean	false	Wrap long cell text instead of clipping it (default False). Per-column wrapText: true enables it for a single column.
enable_group_collapse Pivot	boolean	true	Allow collapsing / expanding pivot column groups (default True). A collapsed group hides its deeper child columns but keeps its own subtotal columns.
enable_pivot_ui Pivot	boolean	false	Show the interactive pivot configurator (drag fields between Rows / Columns / Values). Emits pivot_state; a callback feeds it to engine.pivot.
pivot_fields Pivot	dict	None	Fields the pivot configurator offers: {dimensions: [...], values: [...], labels?: {field: label}}. Dimensions go in Rows/Columns; values (measures) go in Values.
pivot_state Pivot	dict	None	Pivot configuration {rows, columns, values} (lists of field names). Two-way: seed the initial layout via this prop, and the interactive pivot configurator (enable_pivot_ui) writes it back on every change. Use it as a Dash callback Input to recompute row_data / column_defs with engine.pivot(...).
enable_range_selection Selection	boolean	false	Enable cell RANGE / marquee selection (spreadsheet block; default False). Click a cell to anchor, then shift-click or click-drag to extend a rectangular block; Escape or a plain single click clears it. Selection state only -- the grid computes nothing.
enable_row_selection Selection	boolean	false	Add a checkbox column for selecting rows / groups (default False).
range_selection Selection	dict	None	Output: the current selected block as {start: {row, col}, end: {row, col}, cells: [{row, col, field, value}], n} (or start/end null + empty cells when cleared). row is the absolute data index (pagination/virtualization aware); col is the visible-leaf column index; coordinates are normalised so start <= end on both axes. n is a nonce.
select_mode Selection	enum: 'multi' | 'single'	'multi'	'multi' (default) or 'single' row selection.
select_on_row_click Selection	boolean	false	Select a row by clicking anywhere on it (not just the checkbox). Shift-click extends a range, Ctrl/Cmd-click toggles, plain click replaces (default False).
selected_ids Selection	list of strings	None	Controlled selection input: an array of row ids to select (e.g. set it from a callback to programmatically select / clear). The frontend still owns selection between updates; selected_rows remains the output.
selected_rows Selection	list	None	Output: the selected rows, as [{id, depth, grouped, data}] (read-only from Python — use it as a callback Input to react to / export the selection). Selecting a group also selects its descendant rows.
block_size Server-Lazy	number	100	Infinite mode: how many rows to request per block (default 100).
column_facets Server-Lazy	dict	None	Server / infinite mode input: engine-supplied per-column facets, keyed by accessorKey — {[col]: {type: 'set', values: [{value, count}], total, truncated} | {type: 'range', min, max, count}} from engine.facet_counts. Feeds the set / range filter UI (value list + counts, range bound hints) when present; absent (null) keeps the client-derived facets. The frontend does zero math over these.
data_mode Server-Lazy	enum: 'full' | 'lazy'	'full'	'full' (client-side expand) or 'lazy' (server fetches children per node).
expand_request Server-Lazy	dict	None	Lazy-mode convenience output: {node_ids: [...]} listing only the nodes just opened (the delta). Optional -- the canonical lazy trigger is expanded_state (the full map). Useful if you prefer to fetch only the new ids.
row_count Server-Lazy	number	None	Infinite mode: total filtered row count (sizes the scrollbar).
row_model Server-Lazy	enum: 'client' | 'infinite'	'client'	Row model. 'client' (default): all rows are in row_data and the browser sorts / filters / paginates. 'infinite': a virtualized, server-side model for huge flat tables -- the grid renders only a window and requests blocks via rows_request as you scroll; sorting and filtering are applied by the engine (get_rows_window) over the whole dataset, never in the client.
rows_request Server-Lazy	dict	None	Infinite mode output: a block request {start_row, end_row, sort, filters, global_filter, n}. Wire a callback that returns rows_response from engine.get_rows_window(start_row, end_row, sort=sort, filters=filters).
rows_response Server-Lazy	dict	None	Infinite mode input: a served block {start_row, rows, row_count}.
enable_sorting Sorting	boolean	true	Enable click-to-sort on column headers (default True).
sort_state Sorting	list	None	Initial sort state: [{id, desc}].
class_name Theming	string	'' (empty string)	Extra CSS class(es) on the grid root, for custom styling.
density Theming	enum: 'compact' | 'standard' | 'comfortable'	'standard'	Row density: 'compact' | 'standard' | 'comfortable' (default 'standard').
dir Theming	enum: 'ltr' | 'rtl' | 'auto'	'ltr'	Text direction: 'ltr' | 'rtl' | 'auto' (default 'ltr'). RTL mirrors the layout via logical CSS.
enable_density_toggle Theming	boolean	false	Show a toolbar button that cycles the row density (comfortable -> standard -> compact, default False). Seeds from the density prop and drives the same data-density CSS; the density prop still works when set by the host.
striped Theming	boolean	true	Zebra-stripe rows (default True).
style Theming	dict (object)	None	Inline style on the grid root; merges over theme_overrides (CSS variables).
theme Theming	enum: 'light' | 'dark' | 'high-contrast'	'light'	Colour theme: 'light', 'dark', or 'high-contrast' (WCAG-AAA-ish preset).
theme_overrides Theming	dict	None	Override any CSS variable to adapt colours / spacing, e.g. {'--tg-accent': '#e64980', '--tg-radius': '12px'}. Applied inline on the root.
enable_column_virtualization Virtualization	boolean	false	Virtualize columns horizontally for very wide grids (default False): render only the horizontally-visible slice of leaf columns plus left/right spacer cells (so the total width and scrollbar stay correct). Pinned columns always render. Restricted to flat headers -- with column groups (or pivot) the flag is a no-op and every column renders, to keep the multi-row header aligned.
enable_virtualization Virtualization	boolean	false	Virtualize rows: render only the visible window of a large client-side tree (DOM windowing with top/bottom spacers), instead of every row. Assumes a fixed row height (row_height); detail panels keep their natural height. Works with pagination (windows within the page). Not used in row_model='infinite' (which has its own server window). Default False (renders all rows).
row_height Virtualization	number	36	Infinite mode: fixed row height in px for virtualization (default 36).