React Migration in Grid Component

This section explains how to migrate the Grid component from EJ2 React to React. It provides a detailed comparison of APIs, including props, methods, and events.

Properties

EJ2 ReactReactDescription

Props: aggregates

footerSum(props: any) : any { return(<span>Sum: {props.Sum}</span>) } <GridComponent dataSource={data}> <ColumnsDirective> <ColumnDirective field='OrderID' headerText='Order ID' textAlign='Right'/> <ColumnDirective field='Freight' headerText='Freight' textAlign='Right'/> </ColumnsDirective> <AggregatesDirective> <AggregateDirective> <AggregateColumnsDirective> <AggregateColumnDirective field='Freight' type='Sum' footerTemplate={footerSum}/> </AggregateColumnsDirective> </AggregateDirective> </AggregatesDirective> <Inject services={[Aggregate]}/> </GridComponent>

Props: aggregates

const footerSum = useCallback((props: AggregateData) => { return (<span>Sum: {props.Sum}</span>); }, []); <Grid dataSource={data} modules={AggregateModule}> <Columns> <Column field='OrderID' headerText='Order ID' textAlign='Right'/> <Column field='Freight' headerText='Freight' textAlign='Right'/> </Columns> <Aggregates> <AggregateRow> <AggregateColumn field='Freight' type='Sum' footerTemplate={footerSum}/> </AggregateRow> </Aggregates> </Grid>
Replace <AggregatesDirective> with <Aggregates>, <AggregateRow>, and <AggregateColumn>. Use modules={AggregateModule} instead of <Inject services={[Aggregate]}/>. Behavior unchanged.

Props: allowKeyboard

<GridComponent allowKeyboard={true}></GridComponent>

Props: allowKeyboard

<Grid allowKeyboard={true}></Grid>
Set allowKeyboard on <Grid>. No changes to name or behavior. Enables keyboard navigation.

Props: clipMode

<GridComponent clipMode={'EllipsisWithTooltip'}></GridComponent>

Props: clipMode

<Grid clipMode={ClipMode.EllipsisWithTooltip}></Grid>
Use ClipMode enum for values (Clip, Ellipsis, EllipsisWithTooltip). Set on <Grid>. No structural changes.

Props: columns

<GridComponent dataSource={data}> <ColumnsDirective> <ColumnDirective field='OrderID' headerText='Order ID' textAlign='Right'/> <ColumnDirective field='Freight' headerText='Freight' textAlign='Right'/> </ColumnsDirective> </GridComponent>

Props: columns

<Grid dataSource={data}> <Columns> <Column field='OrderID' headerText='Order ID' textAlign='Right'/> <Column field='Freight' headerText='Freight' textAlign='Right'/> </Columns> </Grid>
Replace <ColumnsDirective> with <Columns> and <ColumnDirective> with <Column>. Pass array of ColumnProps<T>. Behavior unchanged.

Props: dataSource

<GridComponent dataSource={data}></GridComponent>

Props: dataSource

<Grid dataSource={data}></Grid>
Set dataSource on <Grid>. Supports array, DataManager, or DataResult. No changes needed.

Props: editSettings

<GridComponent editSettings={{ allowEditing: true, allowAdding: true, allowDeleting: true }}> <Inject services={[Edit]}/> </GridComponent>

Props: editSettings

<Grid editSettings={{ allowEdit: true, allowAdd: true, allowDelete: true }} modules={EditModule}></Grid>
Update to camelCase (allowEdit, allowAdd, allowDelete). Use modules={EditModule} instead of <Inject services={[Edit]}/>. Set object on <Grid>. Behavior preserved.

Props: emptyRecordTemplate

const emptyRecordTemplate = ( <div className="empty-grid-message"> <h3>No employees found</h3> </div> ); <GridComponent emptyRecordTemplate={emptyRecordTemplate}></GridComponent>

Props: emptyRecordTemplate

const emptyRecordTemplate = ( <div className="empty-grid-message"> <h3>No employees found</h3> </div> ); <Grid emptyRecordTemplate={emptyRecordTemplate}></Grid>
Define template as string, ReactElement, or function. Set on <Grid>. No changes to behavior.

Props: enableAltRow

<GridComponent enableAltRow={true}></GridComponent>

Props: enableAltRow

<Grid enableAltRow={true}></Grid>
Set enableAltRow on <Grid>. Toggles sf-alt-row class. No changes to behavior.

Props: enableHover

<GridComponent enableHover={true}></GridComponent>

Props: enableHover

<Grid enableHover={true}></Grid>
Set enableHover on <Grid>. Enables row hover effects. No changes to behavior.

Props: enableHtmlSanitizer

<GridComponent enableHtmlSanitizer={true}></GridComponent>

Props: enableHtmlSanitizer

<Grid enableHtmlSanitizer={true}></Grid>
Set enableHtmlSanitizer on <Grid>. Sanitizes HTML to prevent XSS. No changes to behavior.

Props: enableStickyHeader

<GridComponent enableStickyHeader={true}></GridComponent>

Props: enableStickyHeader

<Grid enableStickyHeader={true}></Grid>
Set enableStickyHeader on <Grid>. Keeps headers fixed on scroll. No changes to behavior.

Props: allowFiltering

<GridComponent allowFiltering={true}> <Inject services={[Filter]}/> </GridComponent>

Props: filterSettings

<Grid filterSettings={{ enabled: true }} modules={FilterModule}></Grid>
Replace allowFiltering with filterSettings={{ enabled: true }}. Use modules={FilterModule} instead of <Inject services={[Filter]}/>. Configure filter UI via object.

Props: gridLines

<GridComponent gridLines={'Both'}></GridComponent>

Props: gridLines

<Grid gridLines={GridLine.Both}></Grid>
Use GridLine enum (Default, None, Both, Horizontal, Vertical). Set on <Grid>. No changes to behavior.

Props: height

<GridComponent height={'400'}></GridComponent>

Props: height

<Grid height={'400'}></Grid>
Set height on <Grid>. Accepts number, string (e.g., '400px'), or 'auto'. Behavior unchanged.

Props: id

<GridComponent id={'grid'}></GridComponent>

Props: id

<Grid id={'grid'}></Grid>
Set id on <Grid> for unique identification. No changes to name or behavior.

Props: loadingIndicator

<GridComponent loadingIndicator={{ indicatorType: 'Spinner' }} />

Props: loadingIndicatorSettings

<Grid loadingIndicatorSettings={{ indicatorType: LoadingIndicatorType.Spinner }} />
Replace loadingIndicator with loadingIndicatorSettings. Use LoadingIndicatorType enum instead of string values.

Props: allowPaging

<GridComponent allowPaging={true}> <Inject services={[Page]}/> </GridComponent>

Props: pageSettings

<Grid pageSettings={{ enabled: true }} modules={PagerModule}></Grid>
Replace allowPaging with pageSettings={{ enabled: true }}. Use modules={PagerModule} instead of <Inject services={[Page]}/>. Configure pagination via object.

Props: query

const query = new Query().sortBy('name', 'ascending'); <GridComponent query={query}></GridComponent>

Props: query

const query = new Query().sortBy('name', 'ascending'); <Grid query={query}></Grid>
Set query on <Grid>. Accepts Query instance for sorting, filtering, and other grid action. No changes to behavior.

Props: rowClass Not applicable

Props: rowClass

<Grid rowClass={'grid-row'}></Grid>
Set rowClass on <Grid> as string or function returning class name based on RowClassProps<T>.

Props: rowHeight

<GridComponent rowHeight={'40'}></GridComponent>

Props: rowHeight

<Grid rowHeight={'40'}></Grid>
Set rowHeight on <Grid> for fixed row height in pixels. No changes to behavior.

Props: rowTemplate

const rowTemplate = ( <div className="row-template"> <h3>Row Info</h3> </div> ); <GridComponent rowTemplate={rowTemplate}></GridComponent>

Props: rowTemplate

const rowTemplate = (<div className="row-template"> <h3>Row Info</h3> </div> ); <Grid rowTemplate={rowTemplate}></Grid>
Define rowTemplate as string, ReactElement, or function. Set on <Grid>. No changes to behavior.

Props: searchSettings

<GridComponent toolbar={['Search']} searchSettings={{ fields: ['OrderID'], key: 2 }}> <Inject services={[Search, Toolbar]}/> </GridComponent>

Props: searchSettings

<Grid toolbar={['Search']} searchSettings={{ enabled: true, fields: ['OrderID'], value: 2 }} modules={[SearchModule, ToolbarModule]}></Grid>
Replace key with value in searchSettings. Use modules={[SearchModule, ToolbarModule]} instead of <Inject services={[Search, Toolbar]}/>. Configure search via object on <Grid>.

Props: allowSelection

<GridComponent allowSelection={true}> <Inject services={[Selection]}/> </GridComponent>

Props: selectionSettings

<Grid selectionSettings={{ enabled: true }}></Grid>
Replace allowSelection with selectionSettings={{ enabled: true }}. Remove <Inject services={[Selection]}/>. Configure via object.

Props: allowSorting

<GridComponent allowSorting={true}> <Inject services={[Sort]}/> </GridComponent>

Props: sortSettings

<Grid sortSettings={{ enabled: true }} ></Grid>
Replace allowSorting with sortSettings={{ enabled: true }}. Remove <Inject services={[Sort]}/>. Configure via object.

Props: allowTextWrap

<GridComponent allowTextWrap={true}></GridComponent>

Props: textWrapSettings

<Grid textWrapSettings={{ enabled: true }}></Grid>
Replace allowTextWrap with textWrapSettings={{ enabled: true }}. Configure text wrapping via object on <Grid>.

Props: toolbar

<GridComponent toolbar={['Add', 'Edit', 'Delete']}> <Inject services={[Toolbar]}/> </GridComponent>

Props: toolbar

<Grid toolbar={['Add', 'Edit', 'Delete']} modules={ToolbarModule}></Grid>
Set toolbar array on <Grid>. Use modules={ToolbarModule} instead of <Inject services={[Toolbar]}/>. Same item keys supported.

Props: enableVirtualization

<GridComponent enableVirtualization={true}> <Inject services={[VirtualScroll]}/> </GridComponent>

Props: virtualizationSettings

<Grid virtualizationSettings={{ scrollMode: ScrollMode.Virtual, enabled: true, }} />
Replace enableVirtualization with virtualizationSettings. Use scrollMode: ScrollMode.Virtual and enabled: true. Remove <Inject services={[VirtualScroll]}/>. No changes to behavior.

Props: width

<GridComponent width={'800'}></GridComponent>

Props: width

<Grid width={'800'}></Grid>
Set width on <Grid>. Accepts number, string (e.g., '800px'), or 'auto'. No changes to behavior.

Props: enableInfiniteScrolling

<GridComponent enableInfiniteScrolling={true} pageSettings={{ pageSize: 50 }} > <Inject services={[InfiniteScroll]} /> </GridComponent>

Props: virtualizationSettings

<Grid virtualizationSettings={{ scrollMode: ScrollMode.Infinite, enabled: true }} pageSettings={{ pageSize: 50 }} />
Replace enableInfiniteScrolling with virtualizationSettings. Use scrollMode: ScrollMode.Infinite. Remove <Inject services={[InfiniteScroll]}/>. No changes to behavior.

Props: showColumnChooser, showInColumnChooser

<GridComponent showColumnChooser={true} toolbar={['ColumnChooser']}> <ColumnsDirective> <ColumnDirective field='ShipCity' showInColumnChooser={false}/> <ColumnDirective field='ShipCountry' showInColumnChooser={true}/> </ColumnsDirective> </GridComponent>

Props: showColumnChooser, showInColumnChooser

<Grid toolbar={['ColumnChooser']} showColumnChooser={true}> <Columns> <Column field='ShipCity' showInColumnChooser={false} /> <Column field='ShipCountry' showInColumnChooser={true}/> </Columns> </Grid>
Replace <ColumnsDirective> / <ColumnDirective> with <Columns> / <Column>. Use modules={[ColumnChooserModule, ToolbarModule]} instead of <Inject services={[ColumnChooser, Toolbar]}/>. No changes to behavior.

Props: columnChooserSettings

<GridComponent toolbar={['ColumnChooser']} showColumnChooser={true} columnChooserSettings={{ enableSearching: false, operator: 'contains' }} > <Inject services={[ColumnChooser, Toolbar]} /> </GridComponent>

Props: columnChooserSettings

<Grid toolbar={['ColumnChooser']} showColumnChooser={true} columnChooserSettings={{ enableSearch: false, operator: 'contains', }} modules={[ColumnChooserModule, ToolbarModule]} />
Replace enableSearching with enableSearch. Use columnChooserSettings for configuration (search, operator, accent handling, sorting, templates). Use modules={[ColumnChooserModule, ToolbarModule]} instead of <Inject services={[ColumnChooser, Toolbar]}/>. No changes to behavior.

Props: selectionSettings

<GridComponent selectionSettings={{ mode: 'Cell', cellSelectionMode: 'Box', type: 'Multiple' }} />

Props: selectionSettings

<Grid selectionSettings={{ type: SelectionType.Cell, mode: 'Multiple', cellSelectionType: 'Box' }} />
Allows using either string or enum (SelectionType, SelectionMode). Use enabled property to toggle selection. Behavior unchanged.

Props: contextMenuItems, showContextMenu

<GridComponent showContextMenu={true} contextMenuItems={['Edit', 'Delete', 'SortAscending', 'SortDescending']}> <Inject services={[Sort, ContextMenu, Edit]}/> </GridComponent>

Props: contextMenuSettings

<Grid contextMenuSettings={{ enabled: true, items: ['Edit', 'Delete', 'SortAscending', 'SortDescending']}} modules={ContextMenuModule} />
Replace showContextMenu and contextMenuItems with contextMenuSettings. Use modules={ContextMenuModule} instead of <Inject services={[ContextMenu]}/>. Configure via object.

Props: allowGrouping

<GridComponent allowGrouping={true}> <Inject services={[Group]}/> </GridComponent>

Props: groupSettings

<Grid groupSettings={{ enabled: true }} modules={GroupModule} />
Replace allowGrouping with groupSettings={{ enabled: true }}. Use modules={GroupModule} instead of <Inject services={[Group]}/> and configure grouping behavior via the groupSettings object.

Props: childGrid

const childGridOptions = { columns: [ { field: 'OrderID', headerText: 'Order ID', textAlign: 'Right', width: 120 }, ], dataSource: data, queryString: 'EmployeeID' }; return ( <GridComponent dataSource={employeeData} childGrid={childGridOptions} height={315}> <ColumnsDirective> <ColumnDirective field='EmployeeID' headerText='Employee ID' width='120' textAlign='Right'/> </ColumnsDirective> <Inject services={[DetailRow]} /> </GridComponent> );

Props: isMasterDetail, defaultExpandedRows

return ( <Grid dataSource={employees} columns={columns} isMasterDetail={true} modules={DetailGridModule} detailRowTemplate={(params) => ( <div> <h4>Order {params.rowIndex} Details</h4> <Grid dataSource={getDetailData(params.row.id)} columns={detailColumns} /> </div> )} /> );

Replace childGrid with master-detail props; Use isMasterDetail to enable expandable rows and detailRowTemplate to render child grid or custom content. Use modules={DetailGridModule} instead of <Inject services={[DetailRow]}/>.

Props: enableAutoFill

<GridComponent dataSource={data} enableAutoFill={true} selectionSettings={{ cellSelectionMode: 'Box', mode: 'Cell' }} > <Inject services={[Selection]} /> </GridComponent>

Props: autoFillSettings

<Grid modules={AutoFillModule} autoFillSettings={{ enabled: true, mode: 'Copy' }} selectionSettings={{ type: 'Cell', mode: 'Multiple' }} > </Grid>

Replace enableAutoFill with autoFillSettings object for configuration. Use modules={AutoFillModule} instead of <Inject services={[Selection]}/>. Behavior unchanged.

Props: clipboardSettings

Not applicable

Props: clipboardSettings

<Grid modules={ClipboardModule} clipboardSettings={{enabled: true}} selectionSettings={{ type: 'Cell', mode: 'Multiple' }}> </Grid>

Use clipboardSettings object with ClipboardModule for centralized configuration.

Props: allowFormula

<GridComponent dataSource={data} > <Columns> <Column field="Price" headerText="Price" width="120"/> <Column field="Total" headerText="Total" allowFormula={true} formula="=Price*Quantity"/> </Columns> <Inject services={[Formula]}/> </GridComponent>

Props: formulaSettings

<Grid modules={FormulaModule} formulaSettings={{ enabled: true }}> <Columns> <Column field="Price" headerText="Price" width={120}/> <Column field="Total" headerText="Total" allowFormula={true} /> </Columns> </Grid>

Replace allowFormula with formulaSettings. Use modules={FormulaModule} instead of <Inject services={[Formula]}/>. Enable formula columns are evaluated and updated.

Props: isTreeMode

Not applicable

Props: isTreeMode

<Grid isTreeMode={true} treeColumnIndex={0} treeDataChildrenField="children" modules={TreeDataModule}> </Grid>

Pure React simplifies with isTreeMode prop and treeDataChildrenField configuration. Requires TreeDataModule.

Props: pivotSettings

Not applicable

Props: pivotSettings

<Grid modules={PivotModule} pivotSettings={{ enabled: true, rows: ['Region'], columns: ['Year'], values: [{ name: 'Sales', aggregate: 'Sum' }] }} ></Grid>

Pure React Grid includes built-in pivot functionality via pivotSettings. Configure rows, columns, and aggregate values. Requires PivotModule.

Props: contextMenuItems

<GridComponent contextMenuItems={[ 'Bar', 'StackingBar', 'StackingBar100', 'Pie', 'Column', 'StackingColumn', 'StackingColumn100', 'Line', 'StackingLine', 'StackingLine100', 'Area', 'StackingArea', 'StackingArea100', 'Scatter' ]} > <Inject services={[ContextMenu]} /> </GridComponent>

Props: enableGridChart , contextMenuItems

<Grid enableGridChart={true} contextMenuItems={enabled:true, [ 'Bar', 'StackingBar', 'StackingBar100', 'Pie', 'Column', 'StackingColumn', 'StackingColumn100', 'Line', 'StackingLine', 'StackingLine100', 'Area', 'StackingArea', 'StackingArea100', 'Scatter' ]} modules={[ContextMenuModule]} > </Grid>
Replace <Inject services={[ContextMenu]} /> with modules={ContextMenuModule}. Configure enableGridChart and chart type options as array strings in contextMenuItems for grid context menu integration. Behavior unchanged.

Props: rowNumberSettings

Not applicable

Props: rowNumberSettings

<Grid rowNumberSettings={{ enabled: true}} ></Grid>

New property. Adds built-in rowNumberSettings for sequential row numbers.

Props: sideBar

Not applicable

Props: sideBar

<Grid sideBar={{ enabled: true }} modules={ColumnChooserModule, FilterModule, EditModule, FilterToolPanelModule, ColumnToolPanelModule, EditToolPanelModule}> </Grid>

New property. Define sideBar={{ enabled: true}} to enable tool panels with filter, column, edit and custom panels for quick action. Requires corresponding modules.

Props: allowResizing

<GridComponent allowResizing={true}> <Inject services={[Resize]}/> </GridComponent>

Props: resizeSettings

<Grid resizeSettings={{ enabled: true }} modules={ResizeModule}></Grid>
Replace allowResizing with resizeSettings={{ enabled: true }}. Use modules={ResizeModule} instead of <Inject services={[Resize]}/>. No changes to behavior.

Props: minWidth / maxWidth

<GridComponent allowResizing={true}> <ColumnsDirective> <ColumnDirective field='OrderID' headerText='Order ID' minWidth={100} maxWidth={200}/> </ColumnsDirective> <Inject services={[Resize]}/> </GridComponent>

Props: minWidth / maxWidth

<Grid resizeSettings={{ enabled: true }} modules={ResizeModule}> <Columns> <Column field='OrderID' headerText='Order ID' minWidth={100} maxWidth={200}/> </Columns> </Grid>
Column-level constraints (minWidth, maxWidth) remain the same. Apply directly on <Column>. Behavior unchanged.

Props: showColumnMenu

<GridComponent showColumnMenu={true}> <Inject services={[ColumnMenu]}/> </GridComponent>

Props: columnMenuSettings

<Grid columnMenuSettings={{ enabled: true }} modules={ColumnMenuModule}></Grid>
Replace showColumnMenu with columnMenuSettings={{ enabled: true }}. Use modules={ColumnMenuModule} instead of <Inject services={[ColumnMenu]}/>. Behavior unchanged.

Props: column.allowReordering

<GridComponent dataSource={data}> <ColumnsDirective> <ColumnDirective field='CustomerName' allowReordering={true} /> </ColumnsDirective> </GridComponent>

Props: column.allowReorder on Column level

<Grid reorderSettings={{ enabled: true }} modules={ReorderModule}> <Column field="OrderID" headerText="Order ID" allowReorder={false}/> <Column field="CustomerID" headerText="Customer ID"/> </Grid>
Use allowReordering prop directly on individual columns to enable or disable reordering per column. EJ2 required event handlers, Pure React allows declarative column-level control.

Props: editSettings.mode='Batch'

<GridComponent dataSource={data} editSettings={{ allowEditing: true, allowAdding: true, allowDeleting: true, mode: 'Batch' }}> <ColumnsDirective> <ColumnDirective field='OrderID' isPrimaryKey={true} /> </ColumnsDirective> <Inject services={[Edit]}/> </GridComponent>

Props: editSettings.allowBatchSave, editSettings.mode

<Grid dataSource={data} editSettings={{ allowEdit: true, allowAdd: true, allowDelete: true, allowBatchSave: true, mode: 'Cell' }} modules={EditModule}> <Columns> <Column field='OrderID' isPrimaryKey={true} /> </Columns> </Grid>

Replace mode: 'Batch' with allowBatchSave: true and mode as Cell or Normal for cell-level batch editing and also multiple cells in a row. Use modules={EditModule} instead of <Inject services={[Edit]}/>. Set isPrimaryKey on a unique column.

Props: editSettings.enableUndoRedo, editSettings.undoRedoLimit

<GridComponent dataSource={data} editSettings={{ allowEditing: true, allowAdding: true, allowDeleting: true, mode: 'Batch', enableUndoRedo: true, undoRedoLimit: 5 }} toolbar={['Add', 'Edit', 'Delete', 'Update', 'Cancel', 'Undo', 'Redo']}> <Inject services={[Edit, Toolbar]}/> </GridComponent>

Props: editSettings.allowUndoRedo, editSettings.undoRedoLimit

<Grid dataSource={data} editSettings={{ allowEdit: true, allowAdd: true, allowDelete: true, allowUndoRedo: true, undoRedoLimit: 5 }} toolbar={['Add', 'Edit', 'Delete', 'Update', 'Cancel', 'Undo', 'Redo']} modules={EditModule, ToolbarModule}></Grid>

Replace enableUndoRedo with allowUndoRedo in editSettings. Use modules={EditModule, ToolbarModule} instead of <Inject services={[Edit, Toolbar]}/>. Behavior unchanged.

Props: enableColumnSpan

<GridComponent enableColumnSpan={true}> </GridComponent>

Props: enableAutoSpan, colSpan

<Grid dataSource={data}> <Columns> <Column field="OrderID" colSpan={(args?: CellSpanArgs<DataItem>) => args?.data.OrderID === args?.data.CustomerID ? 2 : 1 } /> <Column field="Slot1" headerText="Slot 1" colSpan={true} /> </Columns> </Grid>

Replace enableColumnSpan with enableAutoSpan and use column.colSpan: true for auto-span, or a callback receiving CellSpanArgs<T> for conditional cell span logic.

Props: enableRowSpan

<GridComponent enableRowSpan={true}> </GridComponent>

Props: enableAutoSpan, rowSpan

<Grid enableAutoSpan={true}> <Columns> <Column field="CustomerName" rowSpan={(args?: CellSpanArgs<DataItem>) => args?.data.CustomerName === args?.previousData?.CustomerName ? 0 : 2 } /> <Column field="OrderDate" headerText="Order Date" rowSpan={true} /> </Columns> </Grid>

Replace enableRowSpan with enableAutoSpan and use column.rowSpan: true for auto-span, or a callback receiving CellSpanArgs<T> for conditional row span logic.

Props: frozenColumns

<GridComponent dataSource={data} frozenColumns={2}> <Columns> <Column field='OrderID' headerText='Order ID' width='120' textAlign='Right'/> </Columns> <Inject services={[Freeze]} /> </GridComponent>

Props: pinningSettings

<Grid dataSource={data} pinningSettings={{ enabled: true, type: PinScope.Column }} modules={PinningModule}> <Column field="OrderID" headerText="Order ID" width={120} pinDirection="left"/> <Column field="ShipCity" headerText="Ship City" width={150} pinDirection="right"/> <Column field="Freight" headerText="Freight" width={150}/> </Grid>

Replace frozenColumns with pinningSettings={{ enabled: true, type: PinScope.Column }}. Use pinDirection on each column (left, right, none) to configure pinning. Use modules={PinningModule} instead of <Inject services={[Freeze]} />.

Props: column.freeze: 'Left' | 'Right' | 'Fixed' | 'None'

<GridComponent dataSource={data}> <ColumnsDirective> <ColumnDirective field='OrderID' freeze='Left' /> </ColumnsDirective> </GridComponent>

Props: pinDirection

<Grid dataSource={data} pinningSettings={{ enabled: true, type: PinScope.Column }} modules={PinningModule}> <Column field="OrderID" headerText="Order ID" width={120} pinDirection="left"/> <Column field="ShipCity" headerText="Ship City" width={150} pinDirection="right"/> <Column field="Freight" headerText="Freight" width={150}/> </Grid>

Renamed freeze to pinDirection ('Left' | 'Right' | 'None'; 'Fixed' removed). Requires grid-level pinningSettings={{ enabled: true, type: PinScope.Column }} to activate. pinDirection also accepts a callback for conditional pinning, unlike EJ2's static freeze value.

Props: isRowPinned

const isRowPinned = (rowData: any): boolean => { return rowData.OrderID === 10248; }; <GridComponent isRowPinned={isRowPinned}> </GridComponent>

Props: pinningSettings.type='Row', allowTopPin, allowBottomPin

<Grid modules={PinningModule} pinningSettings={{ enabled: true, type: PinScope.Row, allowTopPin: true, allowBottomPin: true }}> </Grid>

Use pinningSettings with PinScope.Row or Both for dynamic top/bottom pinning instead of isRowPinned callback to fix rows at the top. Requires PinningModule.

Props: allowRowDragAndDrop

<GridComponent allowRowDragAndDrop={true}> <Inject services={[RowDD]}/> </GridComponent>

Props: dragAndDropSettings

<Grid dragAndDropSettings={{ enabled: true }} modules={ReorderModule}> </Grid>

Replace allowRowDragAndDrop and rowDropSettings. Use modules={ReorderModule} instead of <Inject services={[RowDD]}/>. Behavior unchanged.

Methods

EJ2 ReactReactDescription

Methods: addRecord(data?: Object, index?: number): void

let grid; return ( <div> <Button onClick={() => { grid.addRecord({OrderID: 1, Freight: 22}); }}></Button> <GridComponent ref={g => grid = g} editSettings={{ allowEditing: true, allowAdding: true, allowDeleting: true }}> <Inject services={[Edit]}/> </GridComponent> </div> );

Methods: addRecord(data?: T, index?: number): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.addRecord({OrderID: 1, Freight: 22}); }}></Button> <Grid<DataItem> ref={gridRef} editSettings={{ allowEdit: true, allowAdd: true, allowDelete: true }} modules={EditModule}></Grid> </div> );
Use useRef<GridRef<T>> for grid reference. Use modules={EditModule} instead of <Inject services={[Edit]}/>. Method signature unchanged; adds record at index or start.

Methods: closeEdit(): void

let grid; return ( <div> <Button onClick={() => { grid.closeEdit(); }}></Button> <GridComponent ref={g => grid = g} editSettings={{ allowEditing: true, allowAdding: true, allowDeleting: true }}> <Inject services={[Edit]}/> </GridComponent> </div> );

Methods: cancelDataChanges(): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.cancelDataChanges(); }}></Button> <Grid<DataItem> ref={gridRef} editSettings={{ allowEdit: true, allowAdd: true, allowDelete: true }} modules={EditModule}></Grid> </div> );
Replace closeEdit with cancelDataChanges. Use useRef<GridRef<T>>. Use modules={EditModule} instead of <Inject services={[Edit]}/>. Cancels CRUD operations.

Methods: clearFiltering(fields?: string[]): void

let grid; return ( <div> <Button onClick={() => { grid.clearFiltering(); }}></Button> <GridComponent ref={g => grid = g} allowFiltering={true}> <Inject services={[Filter]}/> </GridComponent> </div> );

Methods: clearFilter(fields?: string[]): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.clearFilter(); }}></Button> <Grid<DataItem> ref={gridRef} filterSettings={{ enabled: true }} modules={FilterModule}></Grid> </div> );
Replace clearFiltering with clearFilter. Use useRef<GridRef<T>>. Use modules={FilterModule} instead of <Inject services={[Filter]}/>. Clears filters for fields or all columns.

Methods: clearRowSelection(): void

let grid; return ( <div> <Button onClick={() => { grid.clearRowSelection(); }}></Button> <GridComponent ref={g => grid = g} allowSelection={true}> <Inject services={[Selection]}/> </GridComponent> </div> );

Methods: clearRowSelection(indexes: number[]): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.clearRowSelection([1]); }}></Button> <Grid<DataItem> ref={gridRef} selectionSettings={{ enabled: true }}></Grid> </div> );
The clearRowSelection method now supports deselecting specific row indexes.

Methods: clearSelection(): void

let grid; return ( <div> <Button onClick={() => { grid.clearSelection(); }}></Button> <GridComponent ref={g => grid = g} allowSelection={true}> <Inject services={[Selection]}/> </GridComponent> </div> );

Methods: clearSelection(): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.clearSelection(); }}></Button> <Grid<DataItem> ref={gridRef} selectionSettings={{ enabled: true }}</Grid> </div> );
Use useRef<GridRef<T>>. Remove <Inject services={[Selection]}/>. Method name and behavior unchanged; clears all row selections.

Methods: clearCellSelection(): void

let grid; const clearCellSelection = () => { grid.clearCellSelection(); } return ( <div> <Button onClick={clearCellSelection}></Button> <GridComponent ref={g => grid = g} selectionSettings={{ type: 'Cell' }}> <Inject services={[Selection]}/> </GridComponent> </div> );

Methods: clearCellSelection(cells?: RowCellInfo[]): void

const gridRef = useRef<GridRef<DataItem>>(null); const clearCellSelection = () => { gridRef.current?.clearCellSelection([ { rowKey: 10248, fieldNames: ['OrderID'] }, { rowKey: 10249, fieldNames: ['CustomerName'] } ]); } return ( <div> <Button onClick={clearCellSelection}></Button> <Grid<DataItem> ref={gridRef} selectionSettings={{ type: 'Cell' }}></Grid> </div> );
Use useRef<GridRef<T>>. Remove <Inject services={[Selection]}/>. Method name and behavior unchanged; clears all cell selections.

Methods: clearSorting(): void

let grid; return ( <div> <Button onClick={() => { grid.clearSorting(); }}></Button> <GridComponent ref={g => grid = g} allowSorting={true}> <Inject services={[Sort]}/> </GridComponent> </div> );

Methods: clearSort(fields?: string[]): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.clearSort(); }}></Button> <Grid<DataItem> ref={gridRef} sortSettings={{ enabled: true }} modules={SortModule}></Grid> </div> );
Replace clearSorting with clearSort. Use useRef<GridRef<T>>. Use modules={SortModule} instead of <Inject services={[Sort]}/>. Clears sorting for fields or all columns.

Methods: clearGrouping(): void

let grid; const clearGroup = () => { grid.clearGrouping(); } return ( <div> <Button onClick={clearGroup}></Button> <GridComponent ref={g => grid = g} allowGrouping={true} groupSettings={{ columns: ['CustomerID'] }}> <Inject services={[Group]}/> </GridComponent> </div> );

Methods: clearGrouping(): void

const gridRef = useRef<GridRef<DataItem>>(null); const clearGroup = () => { gridRef.current?.clearGrouping(); } return ( <div> <Button onClick={clearGroup}></Button> <Grid<DataItem> ref={gridRef} groupSettings={{ enabled:true, columns: ['CustomerID'] }} modules={GroupModule}></Grid> </div> );

Use useRef<GridRef<T>>. Use modules={GroupModule} instead of <Inject services={[Group]}/>.
No changes to name or behavior; clears all grouped columns.

Methods: deleteRecord(fieldName?: string, data?: Object): void

let grid; return ( <div> <Button onClick={() => { grid.deleteRecord('OrderID', {OrderID: 1}); }}></Button> <GridComponent ref={g => grid = g} editSettings={{ allowDeleting: true }}> <Inject services={[Edit]}/> </GridComponent> </div> );

Methods: deleteRecord(fieldName?: string, data?: T): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.deleteRecord('OrderID', {OrderID: 1}); }}></Button> <Grid<DataItem> ref={gridRef} editSettings={{ allowDelete: true }} modules={EditModule}></Grid> </div> );
Use useRef<GridRef<T>>. Use modules={EditModule} instead of <Inject services={[Edit]}/>. Method signature unchanged; deletes record by field or selected row.

Methods: startEdit(): void

let grid; return ( <div> <Button onClick={() => { grid.startEdit(); }}></Button> <GridComponent ref={g => grid = g} editSettings={{ allowEditing: true }}> <Inject services={[Edit]}/> </GridComponent> </div> );

Methods: editRecord(rowElement?: HTMLTableRowElement): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.editRecord(); }}></Button> <Grid<DataItem> ref={gridRef} editSettings={{ allowEdit: true }} modules={EditModule}></Grid> </div> );
Replace startEdit with editRecord. Use useRef<GridRef<T>>. Use modules={EditModule} instead of <Inject services={[Edit]}/>. Accepts optional row element; edits selected row if omitted.

Methods: filterByColumn(fieldName: string, filterOperator: string, filterValue: string | number | Date | boolean | number[] | string[] | Date[] | boolean[] | null, predicate?: string, matchCase?: boolean, ignoreAccent?: boolean, actualFilterValue?: string, actualOperator?: string): void

let grid; return ( <div> <Button onClick={() => { grid.filterByColumn('OrderID', 'equal', 1); }}></Button> <GridComponent ref={g => grid = g} allowFiltering={true}> <Inject services={[Filter]}/> </GridComponent> </div> );

Methods: filterByColumn(fieldName: string, filterOperator: string, filterValue: ValueType | ValueType[], predicate?: string, caseSensitive?: boolean, ignoreAccent?: boolean): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.filterByColumn('OrderID', 'equal', 1); }}></Button> <Grid<DataItem> ref={gridRef} filterSettings={{ enabled: true }} modules={FilterModule}></Grid> </div> );
Rename matchCase to caseSensitive. Remove actualFilterValue and actualOperator parameters. Use useRef<GridRef<T>> for grid reference. Use modules={FilterModule} instead of <Inject services={[Filter]}/>. Filters rows by column criteria with filterValue as ValueType | ValueType[].

Methods: getColumnByField(field: string): Column

let grid; return ( <div> <Button onClick={() => { console.log(grid.getColumnByField('OrderID')); }}></Button> <GridComponent ref={g => grid = g}></GridComponent> </div> );

Methods: getColumnByField(field: string): ColumnProps<T>

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { console.log(gridRef.current.getColumnByField('OrderID')); }}></Button> <Grid<DataItem> ref={gridRef}></Grid> </div> );
Use useRef<GridRef<T>>. Returns ColumnProps<T> instead of Column. Retrieves column config by field.

Methods: getColumns(isRefresh?: boolean): Column[]

let grid; return ( <div> <Button onClick={() => { console.log(grid.getColumns()); }}></Button> <GridComponent ref={g => grid = g}></GridComponent> </div> );

Methods: getColumns(): ColumnProps<T>[]

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { console.log(gridRef.current.getColumns()); }}></Button> <Grid<DataItem> ref={gridRef}></Grid> </div> );
Use useRef<GridRef<T>>. Returns ColumnProps<T>[] instead of Column[]. Retrieves all column configs.

Methods: getData(skipPage?: boolean, requiresCount?: boolean): T[] | Promise<Response | DataReturnType> Not applicable

Methods: getData(skipPage?: boolean, requiresCount?: boolean): T[] | Promise<Response | DataReturnType>

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { console.log(gridRef.current.getData()); }}></Button> <Grid<DataItem> ref={gridRef}></Grid> </div> );
Use useRef<GridRef<T>>. Retrieves grid data.

Methods: getHiddenColumns(): Column[]

let grid; return ( <div> <Button onClick={() => { console.log(grid.getHiddenColumns()); }}></Button> <GridComponent ref={g => grid = g}></GridComponent> </div> );

Methods: getHiddenColumns(): ColumnProps<T>[]

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { console.log(gridRef.current.getHiddenColumns()); }}></Button> <Grid<DataItem> ref={gridRef}></Grid> </div> );
Use useRef<GridRef<T>>. Returns ColumnProps<T>[] instead of Column[]. Retrieves hidden column configs.

Methods: getPrimaryKeyFieldNames(): string[]

let grid; return ( <div> <Button onClick={() => { console.log(grid.getPrimaryKeyFieldNames()); }}></Button> <GridComponent ref={g => grid = g}></GridComponent> </div> );

Methods: getPrimaryKeyFieldNames(): string[]

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { console.log(gridRef.current.getPrimaryKeyFieldNames()); }}></Button> <Grid<DataItem> ref={gridRef}></Grid> </div> );
Use useRef<GridRef<T>>. No changes to name or behavior; returns primary key field names.

Methods: getRowInfo(target: Element | EventTarget): RowInfo

let grid; return ( <div> <Button onClick={() => { console.log(grid.getRowInfo(document.querySelector('td'))); }}></Button> <GridComponent ref={g => grid = g}></GridComponent> </div> );

Methods: getRowInfo(target: Element): RowInfo

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { console.log(gridRef.current.getRowInfo(document.querySelector('td'))); }}></Button> <Grid<DataItem> ref={gridRef}></Grid> </div> );
Use useRef<GridRef<T>>. Retrieves row metadata.

Methods: getSelectedRecords(): Object[]

let grid; return ( <div> <Button onClick={() => { console.log(grid.getSelectedRecords()); }}></Button> <GridComponent ref={g => grid = g} allowSelection={true}> <Inject services={[Selection]}/> </GridComponent> </div> );

Methods: getSelectedRecords(): T[] | null

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { console.log(gridRef.current.getSelectedRecords()); }}></Button> <Grid<DataItem> ref={gridRef} selectionSettings={{ enabled: true }}></Grid> </div> );
Use useRef<GridRef<T>>. Returns T[] | null instead of Object[]. Remove <Inject services={[Selection]}/>. Retrieves selected row data.

Methods: getSelectedRowIndexes(): number[]

let grid; return ( <div> <Button onClick={() => { console.log(grid.getSelectedRowIndexes()); }}></Button> <GridComponent ref={g => grid = g} allowSelection={true}> <Inject services={[Selection]}/> </GridComponent> </div> );

Methods: getSelectedRowIndexes(): number[]

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { console.log(gridRef.current.getSelectedRowIndexes()); }}></Button> <Grid<DataItem> ref={gridRef} selectionSettings={{ enabled: true }} ></Grid> </div> );
Use useRef<GridRef<T>>. Remove <Inject services={[Selection]}/>. No changes to name or behavior; returns selected row indexes.

Methods: getVisibleColumns(): Column[]

let grid; return ( <div> <Button onClick={() => { console.log(grid.getVisibleColumns()); }}></Button> <GridComponent ref={g => grid = g}></GridComponent> </div> );

Methods: getVisibleColumns(): ColumnProps<T>[]

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { console.log(gridRef.current.getVisibleColumns()); }}></Button> <Grid<DataItem> ref={gridRef}></Grid> </div> );
Use useRef<GridRef<T>>. Returns ColumnProps<T>[] instead of Column[]. Retrieves visible column configs.

Methods: goToPage(pageNo: number): void

let grid; return ( <div> <Button onClick={() => { grid.goToPage(2); }}></Button> <GridComponent ref={g => grid = g} allowPaging={true}> <Inject services={[Page]}/> </GridComponent> </div> );

Methods: goToPage(pageNumber: number): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.goToPage(2); }}></Button> <Grid<DataItem> ref={gridRef} pageSettings={{ enabled: true }}></Grid> </div> );
Use useRef<GridRef<T>>. Use modules={PagerModule} instead of <Inject services={[Page]}/>. No changes to name or behavior; navigates to specified page.

Methods: hideSpinner(): void

let grid; return ( <div> <Button onClick={() => { grid.hideSpinner(); }}></Button> <GridComponent ref={g => grid = g}></GridComponent> </div> );

Methods: hideSpinner(): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.hideSpinner(); }}></Button> <Grid<DataItem> ref={gridRef}></Grid> </div> );
Use useRef<GridRef<T>>. No changes to name or behavior; hides loading spinner.

Methods: refresh(): void

let grid; return ( <div> <Button onClick={() => { grid.refresh(); }}></Button> <GridComponent ref={g => grid = g}></GridComponent> </div> );

Methods: refresh(): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.refresh(); }}></Button> <Grid<DataItem> ref={gridRef}></Grid> </div> );
Use useRef<GridRef<T>>. No changes to name or behavior; refreshes grid data and view.

Methods: removeSortColumn(columnName: string): void Not applicable

Methods: removeSortColumn(columnName: string): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.removeSortColumn('OrderID'); }}></Button> <Grid<DataItem> ref={gridRef} sortSettings={{ enabled: true }}></Grid> </div> );
Use useRef<GridRef<T>>. Clears sorting for specified column.

Methods: endEdit(): void

let grid; return ( <div> <Button onClick={() => { grid.endEdit(); }}></Button> <GridComponent ref={g => grid = g} editSettings={{ allowEditing: true }}> <Inject services={[Edit]}/> </GridComponent> </div> );

Methods: saveDataChanges(): Promise<boolean>

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.saveDataChanges(); }}></Button> <Grid<DataItem> ref={gridRef} editSettings={{ allowEdit: true }}></Grid> </div> );
Replace endEdit with saveDataChanges. Use useRef<GridRef<T>>. Use modules={EditModule} instead of <Inject services={[Edit]}/>. Returns Promise<boolean> for save validation.

Methods: search(searchString: string): void

let grid; return ( <div> <Button onClick={() => { grid.search('123'); }}></Button> <GridComponent ref={g => grid = g} toolbar={['Search']}> <Inject services={[Search, Toolbar]}/> </GridComponent> </div> );

Methods: search(searchString?: string): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.search('123'); }}></Button> <Grid<DataItem> ref={gridRef} toolbar={['Search']} searchSettings={{ enabled: true }}></Grid> </div> );
Use useRef<GridRef<T>>. Use modules={[SearchModule, ToolbarModule]} instead of <Inject services={[Search, Toolbar]}/>. No changes to name or behavior; applies search term.

Methods: selectRow(index: number, isToggle?: boolean): void

let grid; return ( <div> <Button onClick={() => { grid.selectRow(1); }}></Button> <GridComponent ref={g => grid = g} allowSelection={true}> <Inject services={[Selection]}/> </GridComponent> </div> );

Methods: selectRow(rowIndex: number, isToggle?: boolean): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.selectRow(1); }}></Button> <Grid<DataItem> ref={gridRef} selectionSettings={{ enabled: true }}></Grid> </div> );
Use useRef<GridRef<T>>. Remove <Inject services={[Selection]}/>. Rename index to rowIndex. Selects row by index.

Methods: selectRowsByRange(startIndex: number, endIndex?: number): void

let grid; return ( <div> <Button onClick={() => { grid.selectRowsByRange(1, 3); }}></Button> <GridComponent ref={g => grid = g} allowSelection={true}> <Inject services={[Selection]}/> </GridComponent> </div> );

Methods: selectRowByRange(startIndex: number, endIndex?: number): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.selectRowByRange(1, 3); }}></Button> <Grid<DataItem> ref={gridRef} selectionSettings={{ enabled: true }}></Grid> </div> );
Use useRef<GridRef<T>>. Remove <Inject services={[Selection]}/>. Rename selectRowsByRange to selectRowByRange. Selects row range.

Methods: selectRows(rowIndexes: number[]): void

let grid; return ( <div> <Button onClick={() => { grid.selectRows([1, 2]); }}></Button> <GridComponent ref={g => grid = g} allowSelection={true}> <Inject services={[Selection]}/> </GridComponent> </div> );

Methods: selectRows(rowIndexes: number[]): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.selectRows([1, 2]); }}></Button> <Grid<DataItem> ref={gridRef} selectionSettings={{ enabled: true }}></Grid> </div> );
Use useRef<GridRef<T>>. Remove <Inject services={[Selection]}/>. No changes to name or behavior; selects multiple rows by indexes.

Methods: selectCell(cellIndex: IIndex, isToggle?: boolean): void

let grid; return ( <div> <Button onClick={() => { grid.selectCell({ rowIndex: 1, cellIndex: 2 }); }}></Button> <GridComponent ref={g => grid = g} selectionSettings={{ type: 'Cell' }}> <Inject services={[Selection]}/> </GridComponent> </div> );

Methods: selectCell(rowKey: string | number, fieldName: string): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current?.selectCell(10248, 'OrderID'); }}>Select Cell</Button> <Grid<DataItem> ref={gridRef} selectionSettings={{ type: 'Cell' }}></Grid> </div> );

Use useRef<GridRef<T>>. Remove <Inject services={[Selection]}/>.
Rename cellIndex to rowKey and fieldName. EJ2 uses row/column index; React uses row primary key and field name.

Methods: selectCells(rowCellIndexes: ISelectedCell[]): void

let grid; return ( <div> <Button onClick={() => { grid.selectCells([{ rowIndex: 1, cellIndex: 2 }, { rowIndex: 2, cellIndex: 1 }]); }}></Button> <GridComponent ref={g => grid = g} selectionSettings={{ type: 'Cell' }}> <Inject services={[Selection]}/> </GridComponent> </div> );

Methods: selectCells(cells: RowCellInfo[]): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current?.selectCells([ { rowKey: 10248, fieldNames: ['OrderID', 'CustomerName'] }, { rowKey: 10249, fieldNames: ['Freight'] } ]); }}>Select Cells</Button> <Grid<DataItem> ref={gridRef} selectionSettings={{ type: 'Cell' }}></Grid> </div> );

Use useRef<GridRef<T>>. Remove <Inject services={[Selection]}/>.
Rename rowCellIndexes to cells. EJ2 uses row/column indexes; React uses row primary key and field names.

Methods: selectCellsByRange(startIndex: IIndex, endIndex?: IIndex): void

let grid; return ( <div> <Button onClick={() => { grid.selectCellsByRange({ rowIndex: 1, cellIndex: 1 }, { rowIndex: 3, cellIndex: 2 }); }}></Button> <GridComponent ref={g => grid = g} selectionSettings={{ type: 'Cell' }}> <Inject services={[Selection]}/> </GridComponent> </div> );

Methods: selectCellsByRange(start: CellIdentifier, end: CellIdentifier): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current?.selectCellsByRange( { rowKey: 10248, fieldName: 'OrderID' }, { rowKey: 10250, fieldName: 'Freight' } ); }}>Select Range</Button> <Grid<DataItem> ref={gridRef} selectionSettings={{ type: 'Cell' }}></Grid> </div> );

Use useRef<GridRef<T>>. Remove <Inject services={[Selection]}/>.
Rename startIndex/endIndex to start/end. EJ2 uses row/column indexes; React uses row primary key and field name.

Methods: setCellValue(key: string | number, field: string, value: string | number | boolean | Date | null): void

let grid; return ( <div> <Button onClick={() => { grid.setCellValue(1, 'OrderID', 100); }}></Button> <GridComponent ref={g => grid = g}> <ColumnsDirective> <ColumnDirective field='OrderID' isPrimaryKey={true}/> </ColumnsDirective> </GridComponent> </div> );

Methods: setCellValue(key: string | number, field: string, value: ValueType | null, isDataSourceChangeRequired?: boolean): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.setCellValue(1, 'OrderID', 100); }}></Button> <Grid<DataItem> ref={gridRef}> <Columns> <Column field='OrderID' isPrimaryKey={true}/> </Columns> </Grid> </div> );
Use useRef<GridRef<T>>. Use ValueType for value. No other changes; updates cell value by primary key.

Methods: updateExternalMessage(message: string): void

let grid; return ( <div> <Button onClick={() => { grid.updateExternalMessage('Loading...'); }}></Button> <GridComponent ref={g => grid = g}></GridComponent> </div> );

Methods: setPagerMessage(message?: string): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.setPagerMessage('Loading...'); }}></Button> <Grid<DataItem> ref={gridRef}></Grid> </div> );
Replace updateExternalMessage with setPagerMessage. Use useRef<GridRef<T>>. Message is optional; updates grid message.

Methods: setRowData(key: string | number, rowData?: Object): void

let grid; return ( <div> <Button onClick={() => { grid.setRowData(1, {OrderID: 1, Freight: 22}); }}></Button> <GridComponent ref={g => grid = g}> <ColumnsDirective> <ColumnDirective field='OrderID' isPrimaryKey={true}/> </ColumnsDirective> </GridComponent> </div> );

Methods: setRowData(key: string | number, data: T, isDataSourceChangeRequired?: boolean): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.setRowData(1, {OrderID: 1, Freight: 22}); }}></Button> <Grid<DataItem> ref={gridRef}> <Columns> <Column field='OrderID' isPrimaryKey={true}/> </Columns> </Grid> </div> );
Use useRef<GridRef<T>>. Use T for data. No other changes; updates row by primary key.

Methods: updateRowAsync(index: number, data: Object): Promise<Object>

let grid; return ( <div> <Button onClick={() => { grid.updateRowAsync(1, {OrderID: 1, Freight: 22}); }}></Button> <GridComponent ref={g => grid = g}> <ColumnsDirective> <ColumnDirective field='OrderID' isPrimaryKey={true}/> </ColumnsDirective> </GridComponent> </div> );

Methods: updateRecordAsync(key: string | number, data: T, isDataSourceChangeRequired?: boolean): Promise<T>

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.updateRecordAsync(1, {OrderID: 1, Freight: 22}); }}></Button> <Grid<DataItem> ref={gridRef}> <Columns> <Column field='OrderID' isPrimaryKey={true}/> </Columns> </Grid> </div> );
Replace updateRowAsync with updateRecordAsync. Use useRef<GridRef<T>>. Use T for data. No other changes; updates row by primary key.

Methods: showSpinner(): void

let grid; return ( <div> <Button onClick={() => { grid.showSpinner(); }}></Button> <GridComponent ref={g => grid = g}></GridComponent> </div> );

Methods: showSpinner(): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.showSpinner(); }}></Button> <Grid<DataItem> ref={gridRef}></Grid> </div> );
Use useRef<GridRef<T>>. No changes to name or behavior; shows loading spinner.

Methods: sortColumn(columnName: string, direction: SortDirection, isMultiSort?: boolean): void

let grid; return ( <div> <Button onClick={() => { grid.sortColumn('OrderID', 'Ascending'); }}></Button> <GridComponent ref={g => grid = g} allowSorting={true}> <Inject services={[Sort]}/> </GridComponent> </div> );

Methods: sortByColumn(columnName: string, sortDirection: SortDirection | string, isMultiSort?: boolean): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.sortByColumn('OrderID', 'Ascending'); }}></Button> <Grid<DataItem> ref={gridRef} sortSettings={{ enabled: true }}></Grid> </div> );
Replace sortColumn with sortByColumn. Use useRef<GridRef<T>>. Use modules={SortModule} instead of <Inject services={[Sort]}/>. Sorts column with direction.

Methods: updateRow(index: number, data: Object): void

let grid; return ( <div> <Button onClick={() => { grid.updateRow(1, {OrderID: 1, Freight: 22}); }}></Button> <GridComponent ref={g => grid = g} editSettings={{ allowEditing: true }}> <Inject services={[Edit]}/> </GridComponent> </div> );

Methods: updateRecord(index: number, data: T): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current.updateRecord(1, {OrderID: 1, Freight: 22}); }}></Button> <Grid<DataItem> ref={gridRef} editSettings={{ allowEdit: true }}></Grid> </div> );
Replace updateRow with updateRecord. Use useRef<GridRef<T>>. Use modules={EditModule} instead of <Inject services={[Edit]}/>. Updates row by index.

Methods: validateEditForm(): boolean Not applicable

Methods: validateEditForm(): boolean

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => console.log(gridRef.current?.validateEditForm())}></Button> <Grid<DataItem> ref={gridRef} editSettings={{ allowEdit: true, allowAdd: true }} ></Grid> </div> );
New method. Use useRef<GridRef<T>>. Validates all fields in edit/add form. Returns boolean.

Methods: validateField(field: string): boolean Not applicable

Methods: validateField(field: string): boolean

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => console.log(gridRef.current?.validateField('OrderID'))}></Button> <Grid<DataItem> ref={gridRef} editSettings={{ allowEdit: true, allowAdd: true, allowDelete: true }} > <Columns> <Column field='OrderID' isPrimaryKey={true} validationRules={{ required: true }}/> </Columns> </Grid> </div> );
New method. Use useRef<GridRef<T>>. Validates specific field against column rules. Returns boolean.

Methods: editCell(index: number, field: string): void

let grid; return ( <div> <Button onClick={() => { grid.editCell(2, 'Freight'); }}></Button> <GridComponent ref={g => grid = g} editSettings={{ mode: 'Batch' }}> <Inject services={[Edit]}/> </GridComponent> </div> );

Methods: editCell(primaryKeyValue: string | number, field: string): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current?.editCell(10248, 'Freight'); }}>Edit Cell</Button> <Grid<DataItem> ref={gridRef} editSettings={{ mode: 'Cell' }}></Grid> </div> );

Use useRef<GridRef<T>> for grid reference. Use modules={EditModule} instead of <Inject services={[Edit]}/>.
Ensure edit mode editSettings.mode='Cell'.

Methods: groupColumn(columnName: string): void

let grid; return ( <div> <Button onClick={() => { grid.groupColumn('CustomerName'); }}></Button> <GridComponent ref={g => grid = g} allowGrouping={true}> <Inject services={[Group]}/> </GridComponent> </div> );

Methods: groupColumn(fields: string[], isResetRequired?: boolean): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current?.groupColumn(['CustomerName']); }}>Group Column</Button> <Grid<DataItem> ref={gridRef} groupSettings={{ enabled:true }}></Grid> </div> );

Use useRef<GridRef<T>>. Use modules={GroupModule} instead of <Inject services={[Group]}/>. Rename columnName to fields (array). Behavior unchanged.

Methods: ungroupColumn(columnName: string): void

let grid; return ( <div> <Button onClick={() => { grid.ungroupColumn('CustomerID'); }}></Button> <GridComponent ref={g => grid = g} allowGrouping={true} groupSettings={{ columns: ['CustomerID'] }}> <Inject services={[Group]}/> </GridComponent> </div> );

Methods: ungroupColumn(fields: string[]): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current?.ungroupColumn(['CustomerID']); }}>Ungroup Column</Button> <Grid<DataItem> ref={gridRef} groupSettings={{ enabled:true, columns: ['CustomerID'] }}></Grid> </div> );

Use useRef<GridRef<T>>. Use modules={GroupModule} instead of <Inject services={[Group]}/>. Rename columnName to fields (array). Behavior unchanged.

Methods: onExpandStateChange(rowIndex: number, rowData?: T): void Not applicable

Methods: onExpandStateChange(rowIndex: number, rowData?: T): void

const gridRef = useRef<GridRef<DataItem>>(null); const toggleExpand = () => { gridRef.current?.onExpandStateChange(2, { OrderID: 10248, CustomerName: 'Nancy' }); } return ( <div> <Button onClick={toggleExpand}>Toggle Expand</Button> <Grid<DataItem> ref={gridRef} isMasterDetail={true}></Grid> </div> );

New method. Use useRef<GridRef<T>>. Use modules={DetailGridModule} instead of <Inject services={[DetailRow]}/>. Toggles expansion state for a master row by rowIndex and optional rowData.

Methods: openColumnChooser(x?: number, y?: number): void

let grid; return ( <div> <Button onClick={() => { grid.openColumnChooser(100, 40); }}></Button> <GridComponent ref={g => grid = g} showColumnChooser={true}> <Inject services={[ColumnChooser]}/> </GridComponent> </div> );

Methods: openColumnChooser(x?: number, y?: number): void

const gridRef = useRef<GridRef<DataItem>>(null); const handleOpen = () => { gridRef.current?.openColumnChooser(100, 40); } return ( <div> <Button onClick={handleOpen}></Button> <Grid<DataItem> ref={gridRef} showColumnChooser={true}></Grid> </div> );

Use useRef<GridRef<T>>. Use modules={ColumnChooserModule} instead of <Inject services={[ColumnChooser]}/>.
No changes to name or behavior.

Methods: applyFill(fillRange: AutoFillRange): Promise<void>

Not applicable

Methods: applyFill(fillRange: AutoFillRange): Promise<void>

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={async () => { await gridRef.current?.applyFill({ startCell: {rowIndex: 0, cellIndex: 0}, endCell: {rowIndex: 5, cellIndex: 2} }); }}></Button> <Grid<DataItem> ref={gridRef} autoFillSettings={{ enabled: true }}></Grid> </div> );

Executes cell fill from source to destination range. Generates fill values based on detected patterns. Requires autoFillSettings.enabled=true.

Methods: copy(withHeader?: boolean): void

let grid; return ( <div> <Button onClick={() => { grid.copy(); }}></Button> <GridComponent ref={g => grid = g}> </GridComponent> </div> );

Methods: copyToClipboard(withHeaders?: boolean): Promise<void>

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={async () => { await gridRef.current?.copyToClipboard(true); }}>Copy</Button> <Grid<DataItem> ref={gridRef} modules={{ ClipboardModule }}></Grid> </div> );

New method. Copies selected cells/rows to clipboard with optional headers. Requires ClipboardModule in modules.

Methods: cutToClipboard(): Promise<void>

Not applicable

Methods: cutToClipboard(): Promise<void>

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={async () => { await gridRef.current?.cutToClipboard(); }}>Cut</Button> <Grid<DataItem> ref={gridRef} modules={{ ClipboardModule }}></Grid> </div> );

New method. Cuts selected cells/rows to clipboard. Requires ClipboardModule in modules.

Methods: pasteFromClipboard(clipboardText: string): void

Not applicable

Methods: pasteFromClipboard(clipboardText: string): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current?.pasteFromClipboard('OrderID\tFreight\n10248\t32.38'); }}>Paste</Button> <Grid<DataItem> ref={gridRef} modules={{ ClipboardModule }}></Grid> </div> );

New method. Pastes clipboard text into grid starting from active cell. Requires ClipboardModule in modules.

Methods: saveBulkChanges(): void

Not applicable

Methods: saveBulkChanges(): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current?.saveBulkChanges(); }}>Save Bulk Changes</Button> <Grid<DataItem> ref={gridRef} editSettings={{ mode: 'Batch' }}></Grid> </div> );

Updates multiple fields across multiple records in bulk. Used with batch editing mode.

Methods: resizeColumn(): void Not applicable

Methods: resizeColumn(field: string, width: number): void

const gridRef = useRef<GridRef<DataItem>>(null); <Button onClick={() => { gridRef.current.resizeColumn('OrderID', 200); }}> Resize OrderID Column </Button> <Grid<DataItem> ref={gridRef} resizeSettings={{ enabled: true }} modules={ResizeModule}></Grid>
New method. Use useRef<GridRef<T>>. Programmatically resizes a column by field name to the specified width.

Methods: reorderColumns(fromIndex: number, toIndex: number): void

let grid; return ( <div> <Button onClick={() => { grid.reorderColumns(0,2); }}>Reorder Columns</Button> <GridComponent ref={g => grid = g} allowReordering={true}> <Inject services={[Reorder]}/> </GridComponent> </div> );

Methods: reorderColumns(fields: string | string[], toIndex: number): void

const gridRef = useRef<GridRef<DataItem>>(null); <Button onClick={() => { gridRef.current.reorderColumns('OrderID', 2); }}> Move OrderID to index 2 </Button> <Grid<DataItem> ref={gridRef} reorderSettings={{ enabled: true }} modules={ReorderModule}/>
Use field names with target index. instead of from and to index. Access via useRef<GridRef<T>>().

Methods: pinColumn(): void

Not applicable

Methods: pinColumn(fields: string[], direction: ColumnPinDirection): void, unpinColumn(fields: string[]): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current?.pinColumn(['CustomerID'], 'left'); }}>Pin Column</Button> <Button onClick={() => { gridRef.current?.unpinColumn(['CustomerID']); }}>Unpin Column</Button> <Grid<DataItem> ref={gridRef} pinningSettings={{ enabled: true }} modules={PinningModule}> <Column field="CustomerID" headerText="Customer ID" width={150}/> <Column field="ShipCity" headerText="Ship City" width={150}/> </Grid> </div> );

New method. Use useRef<GridRef<T>>. PinningModule module is required. Programmatically pin the specified column to left, right or none.

Methods: batchSave(): void

let grid; return ( <div> <Button onClick={() => { grid.editModule.batchSave(); }}>Save</Button> <GridComponent ref={g => grid = g} editSettings={{ allowEditing: true, mode: 'Batch' }}> <Inject services={[Edit]}/> </GridComponent> </div> );

Methods: saveBatchChanges(): Promise<boolean>

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={async () => { await gridRef.current?.saveBatchChanges(); }}>Save</Button> <Grid<DataItem> ref={gridRef} editSettings={{ allowEdit: true, allowBatchSave: true, mode: 'Cell' }} modules={EditModule}></Grid> </div> );

Replace batchSave with saveBatchChanges. Use useRef<GridRef<T>>. Use modules={EditModule} instead of <Inject services={[Edit]}/>. Also available through the useEdit hook in custom templates.

Methods: batchCancel(): void

let grid; return ( <div> <Button onClick={() => { grid.editModule.batchCancel(); }}>Cancel</Button> <GridComponent ref={g => grid = g} editSettings={{ allowEditing: true, mode: 'Batch' }}> <Inject services={[Edit]}/> </GridComponent> </div> );

Methods: cancelBatchChanges(): Promise<void>

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={async () => { await gridRef.current?.cancelBatchChanges(); }}>Cancel</Button> <Grid<DataItem> ref={gridRef} editSettings={{ allowEdit: true, allowBatchSave: true, mode: 'Cell' }} modules={EditModule}></Grid> </div> );

Replace batchCancel with cancelBatchChanges. Use useRef<GridRef<T>>. Use modules={EditModule} instead of <Inject services={[Edit]}/>. Discards all pending changes.

Methods: getBatchChanges(): Object

let grid; return ( <div> <Button onClick={() => { console.log(grid.getBatchChanges()); }}>Get Changes</Button> <GridComponent ref={g => grid = g} editSettings={{ allowEditing: true, mode: 'Batch' }}> <Inject services={[Edit]}/> </GridComponent> </div> );

Methods: getBatchQueue(): StagedRowData<T>[]

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { console.log(gridRef.current?.getBatchQueue()); }}>Get Changes</Button> <Grid<DataItem> ref={gridRef} editSettings={{ allowEdit: true, allowBatchSave: true, mode: 'Cell' }} modules={EditModule}></Grid> </div> );

Replace getBatchChanges with getBatchQueue. Use useRef<GridRef<T>>. Returns pending rows as StagedRowData<T>[] instead of Object. Use modules={EditModule} instead of <Inject services={[Edit]}/>.

Methods: getConfirmBatch()

Not applicable

Methods: getConfirmBatch(): Promise<boolean>

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={async () => { console.log(await gridRef.current?.getConfirmBatch()); }}>Check Confirmation</Button> <Grid<DataItem> ref={gridRef} editSettings={{ allowEdit: true, allowBatchSave: true, mode: 'Cell' }} modules={EditModule}></Grid> </div> );

New method. Use useRef<GridRef<T>>. Indicates whether pending batch changes require confirmation. Requires allowBatchSave and modules={EditModule}.

Methods: undoEdit(): void

let grid; return ( <div> <Button onClick={() => { grid.undoEdit(); }}>Undo</Button> <GridComponent ref={g => grid = g} editSettings={{ allowEditing: true, allowAdding: true, allowDeleting: true, mode: 'Batch', enableUndoRedo: true }}> <Inject services={[Edit]}/> </GridComponent> </div> );

Methods: undo(): Promise<void>

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={async () => { await gridRef.current?.undo(); }}>Undo</Button> <Grid<DataItem> ref={gridRef} editSettings={{ allowEdit: true, allowAdd: true, allowDelete: true, allowUndoRedo: true }} modules={EditModule}></Grid> </div> );

Replace undoEdit with undo. Use useRef<GridRef<T>>. Returns Promise<void> instead of void. Use modules={EditModule} instead of <Inject services={[Edit]}/>. Requires editSettings.allowUndoRedo.

Methods: redoEdit(): void

let grid; return ( <div> <Button onClick={() => { grid.redoEdit(); }}>Redo</Button> <GridComponent ref={g => grid = g} editSettings={{ allowEditing: true, allowAdding: true, allowDeleting: true, mode: 'Batch', enableUndoRedo: true }}> <Inject services={[Edit]}/> </GridComponent> </div> );

Methods: redo(): Promise<void>

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={async () => { await gridRef.current?.redo(); }}>Redo</Button> <Grid<DataItem> ref={gridRef} editSettings={{ allowEdit: true, allowAdd: true, allowDelete: true, allowUndoRedo: true }} modules={EditModule}></Grid> </div> );

Replace redoEdit with redo. Use useRef<GridRef<T>>. Returns Promise<void> instead of void. Use modules={EditModule} instead of <Inject services={[Edit]}/>. Requires editSettings.allowUndoRedo.

Methods: getUndoActionsCount(): number

Not applicable

Methods: getUndoActionsCount(): number

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { console.log(gridRef.current?.getUndoActionsCount()); }}>Undo Count</Button> <Grid<DataItem> ref={gridRef} editSettings={{ allowEdit: true, allowUndoRedo: true }} modules={EditModule}></Grid> </div> );
New method. Use useRef<GridRef<T>>. Returns the number of actions available for undo. Requires editSettings.allowUndoRedo and modules={EditModule}.

Methods: getRedoActionsCount(): number

Not applicable

Methods: getRedoActionsCount(): number

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { console.log(gridRef.current?.getRedoActionsCount()); }}>Redo Count</Button> <Grid<DataItem> ref={gridRef} editSettings={{ allowEdit: true, allowUndoRedo: true }} modules={EditModule}></Grid> </div> );
New method. Use useRef<GridRef<T>>. Returns the number of actions available for redo after an undo. Requires editSettings.allowUndoRedo and modules={EditModule}.

Methods: clearUndoRedoHistory(): void

Not applicable

Methods: clearUndoRedoHistory(): void

const gridRef = useRef<GridRef<DataItem>>(null); return ( <div> <Button onClick={() => { gridRef.current?.clearUndoRedoHistory(); }}>Clear History</Button> <Grid<DataItem> ref={gridRef} editSettings={{ allowEdit: true, allowUndoRedo: true }} modules={EditModule}></Grid> </div> );
New method. Use useRef<GridRef<T>>. Clears the undo and redo history. Requires editSettings.allowUndoRedo and modules={EditModule}.

Events

EJ2 ReactReactDescription

Event: recordClick: (event: RecordClickEventArgs) => void

const recordClick = (event: RecordClickEventArgs): void => { // Action code here } return ( <div> <GridComponent recordClick={recordClick}></GridComponent> </div> );

Event: onCellClick: (event: CellFocusEvent<T>) => void

const onCellClick = (event: CellFocusEvent<DataItem>): void => { // Action code here } return ( <div> <Grid<DataItem> onCellClick={onCellClick}></Grid> </div> );
Replace recordClick with onCellClick. Use CellFocusEvent<T> for type safety. Fires on cell click.

Event: onCellFocus: (event: CellFocusEvent<T>) => void Not applicable

Event: onCellFocus: (event: CellFocusEvent<T>) => void

const onCellFocus = (event: CellFocusEvent<DataItem>): void => { // Action code here } return ( <div> <Grid<DataItem> onCellFocus={onCellFocus}></Grid> </div> );
New event. Use CellFocusEvent<T>. Fires when a cell gains focus.

Event: onDataChangeCancel: (event: FormCancelEvent<T>) => void Not applicable

Event: onDataChangeCancel: (event: FormCancelEvent<T>) => void

const onDataChangeCancel = (event: FormCancelEvent<DataItem>): void => { // Action code here } return ( <div> <Grid<DataItem> onDataChangeCancel={onDataChangeCancel}></Grid> </div> );
New event. Use FormCancelEvent<T>. Fires when CRUD operation is canceled.

Event: onDataChangeComplete: (event: SaveEvent<T> | DeleteEvent<T>) => void Not applicable

Event: onDataChangeComplete: (event: SaveEvent<T> | DeleteEvent<T>) => void

const onDataChangeComplete = (event: SaveEvent<DataItem> | DeleteEvent<DataItem>): void => { // Action code here } return ( <div> <Grid<DataItem> onDataChangeComplete={onDataChangeComplete}></Grid> </div> );
New event. Use SaveEvent<T> | DeleteEvent<T>. Fires on CRUD completion, excluding paging/sorting.

Event: dataSourceChanged: (event: DataSourceChangedEventArgs) => void

const dataSourceChanged = (event: DataSourceChangedEventArgs): void => { // Action code here } return ( <div> <GridComponent dataSourceChanged={dataSourceChanged}></GridComponent> </div> );

Event: onDataChangeRequest: (event: DataChangeRequestEvent<T>) => void

const onDataChangeRequest = (event: DataChangeRequestEvent<DataItem>): void => { // Action code here } return ( <div> <Grid<DataItem> onDataChangeRequest={onDataChangeRequest}></Grid> </div> );
Replace dataSourceChanged with onDataChangeRequest. Use DataChangeRequestEvent<T>. Fires before data source mutation.

Event: onDataChangeStart: (event: SaveEvent<T> | DeleteEvent<T>) => void Not applicable

Event: onDataChangeStart: (event: SaveEvent<T> | DeleteEvent<T>) => void

const onDataChangeStart = (event: SaveEvent<DataItem> | DeleteEvent<DataItem>): void => { // Action code here } return ( <div> <Grid<DataItem> onDataChangeStart={onDataChangeStart}></Grid> </div> );
New event. Use SaveEvent<T> | DeleteEvent<T>. Fires when CRUD operation starts.

Event: dataBound: (event: Object) => void

const dataBound = (event: Object): void => { // Action code here } return ( <div> <GridComponent dataBound={dataBound}></GridComponent> </div> );

Event: onDataLoad: ( ) => void

const onDataLoad = (): void => { // Action code here } return ( <div> <Grid<DataItem> onDataLoad={onDataLoad}></Grid> </div> );
Replace dataBound with onDataLoad. No event args. Fires after data binding completes.

Event: dataStateChange: (event: DataStateChangeEventArgs) => void

const dataStateChange = (event: DataStateChangeEventArgs): void => { // Action code here } return ( <div> <GridComponent dataStateChange={dataStateChange}></GridComponent> </div> );

Event: onDataRequest: (event: DataRequestEvent) => void

const onDataRequest = (event: DataRequestEvent): void => { // Action code here } return ( <div> <Grid<DataItem> onDataRequest={onDataRequest}></Grid> </div> );
Replace dataStateChange with onDataRequest. Use DataRequestEvent. Fires on grid state changes (e.g., sorting, paging).

Event: actionFailure: (event: FailureEventArgs) => void

const actionFailure = (event: FailureEventArgs): void => { // Action code here } return ( <div> <GridComponent actionFailure={actionFailure}></GridComponent> </div> );

Event: onError: (event: Error) => void

const onError = (event: Error): void => { // Action code here } return ( <div> <Grid<DataItem> onError={onError}></Grid> </div> );
Replace actionFailure with onError. Use Error type. Fires on grid operation errors.

Event: onFilter: (event: FilterEvent) => void Not applicable

Event: onFilter: (event: FilterEvent) => void

const onFilter = (event: FilterEvent): void => { // Action code here } return ( <div> <Grid<DataItem> onFilter={onFilter}></Grid> </div> );
New event. Use FilterEvent. Fires after filtering completes.

Event: onFormRender: (event: FormRenderEvent<T>) => void Not applicable

Event: onFormRender: (event: FormRenderEvent<T>) => void

const onFormRender = (event: FormRenderEvent<DataItem>): void => { // Action code here } return ( <div> <Grid<DataItem> onFormRender={onFormRender}></Grid> </div> );
New event. Use FormRenderEvent<T>. Fires when edit/add form is rendered.

Event: created: (event: Object) => void

const created = (event: Object): void => { // Action code here } return ( <div> <GridComponent created={created}></GridComponent> </div> );

Event: onGridRenderComplete: ( ) => void

const onGridRenderComplete = (): void => { // Action code here } return ( <div> <Grid<DataItem> onGridRenderComplete={onGridRenderComplete}></Grid> </div> );
Replace created with onGridRenderComplete. No event args. Fires after grid rendering completes.

Event: load: (event: Object) => void

const load = (event: Object): void => { // Action code here } return ( <div> <GridComponent load={load}></GridComponent> </div> );

Event: onGridRenderStart: ( ) => void

const onGridRenderStart = (): void => { // Action code here } return ( <div> <Grid<DataItem> onGridRenderStart={onGridRenderStart}></Grid> </div> );
Replace load with onGridRenderStart. No event args. Fires before grid initialization.

Event: onPageChange: (event: PageEvent) => void Not applicable

Event: onPageChange: (event: PageEvent) => void

const onPageChange = (event: PageEvent): void => { // Action code here } return ( <div> <Grid<DataItem> onPageChange={onPageChange}></Grid> </div> );
New event. Use PageEvent. Fires after paging completes.

Event: onRefresh: ( ) => void Not applicable

Event: onRefresh: ( ) => void

const onRefresh = (): void => { // Action code here } return ( <div> <Grid<DataItem> onRefresh={onRefresh}></Grid> </div> );
New event. No args. Fires when grid data is refreshed.

Event: onRowAddStart: (event: RowAddEvent<T>) => void Not applicable

Event: onRowAddStart: (event: RowAddEvent<T>) => void

const onRowAddStart = (event: RowAddEvent<DataItem>): void => { // Action code here } return ( <div> <Grid<DataItem> onRowAddStart={onRowAddStart}></Grid> </div> );
New event. Use RowAddEvent<T>. Fires when row addition starts.

Event: rowDeselected: (event: RowDeselectEventArgs) => void

const rowDeselected = (event: RowDeselectEventArgs): void => { // Action code here } return ( <div> <GridComponent rowDeselected={rowDeselected}></GridComponent> </div> );

Event: onRowDeselect: (event: RowSelectEvent<T>) => void

const onRowDeselect = (event: RowSelectEvent<DataItem>): void => { // Action code here } return ( <div> <Grid<DataItem> onRowDeselect={onRowDeselect}></Grid> </div> );
Replace rowDeselected with onRowDeselect. Use RowSelectEvent<T>. Fires after row deselection.

Event: recordDoubleClick: (event: RecordDoubleClickEventArgs) => void

const recordDoubleClick = (event: RecordDoubleClickEventArgs): void => { // Action code here } return ( <div> <GridComponent recordDoubleClick={recordDoubleClick}></GridComponent> </div> );

Event: onRowDoubleClick: (event: RecordDoubleClickEvent<T>) => void

const onRowDoubleClick = (event: RecordDoubleClickEvent<DataItem>): void => { // Action code here } return ( <div> <Grid<DataItem> onRowDoubleClick={onRowDoubleClick}></Grid> </div> );
Replace recordDoubleClick with onRowDoubleClick. Use RecordDoubleClickEvent<T>. Fires on row double-click.

Event: onRowEditStart: (event: RowEditEvent<T>) => void Not applicable

Event: onRowEditStart: (event: RowEditEvent<T>) => void

const onRowEditStart = (event: RowEditEvent<DataItem>): void => { // Action code here } return ( <div> <Grid<DataItem> onRowEditStart={onRowEditStart}></Grid> </div> );
New event. Use RowEditEvent<T>. Fires when row editing starts.

Event: rowSelected: (event: RowSelectEventArgs) => void

const rowSelected = (event: RowSelectEventArgs): void => { // Action code here } return ( <div> <GridComponent rowSelected={rowSelected}></GridComponent> </div> );

Event: onRowSelect: (event: RowSelectEvent<T>) => void

const onRowSelect = (event: RowSelectEvent<DataItem>): void => { // Action code here } return ( <div> <Grid<DataItem> onRowSelect={onRowSelect}></Grid> </div> );
Replace rowSelected with onRowSelect. Use RowSelectEvent<T>. Fires after row selection.

Event: onSearch: (event: SearchEvent) => void Not applicable

Event: onSearch: (event: SearchEvent) => void

const onSearch = (event: SearchEvent): void => { // Action code here } return ( <div> <Grid<DataItem> onSearch={onSearch}></Grid> </div> );
New event. Use SearchEvent. Fires after search completion.

Event: onSort: (event: SortEvent) => void Not applicable

Event: onSort: (event: SortEvent) => void

const onSort = (event: SortEvent): void => { // Action code here } return ( <div> <Grid<DataItem> onSort={onSort}></Grid> </div> );
New event. Use SortEvent. Fires after sorting completes.

Event: toolbarClick: (event: ClickEventArgs) => void

const toolbarClick = (event: ClickEventArgs): void => { // Action code here } return ( <div> <GridComponent toolbarClick={toolbarClick}></GridComponent> </div> );

Event: onToolbarItemClick: (event: ToolbarClickEvent) => void

const onToolbarItemClick = (event: ToolbarClickEvent): void => { // Action code here } return ( <div> <Grid<DataItem> onToolbarItemClick={onToolbarItemClick}></Grid> </div> );
Replace toolbarClick with onToolbarItemClick. Use ToolbarClickEvent. Fires on toolbar item click.

Event: contextMenuOpen : (event: ClickEventArgs) => void

const contextMenuOpen = (event: ClickEventArgs) => void { // Action code here }; return ( <div> <GridComponent contextMenuItems={contextMenuItems} contextMenuOpen={contextMenuOpen}> <Inject services={[ContextMenu]}/> </GridComponent> </div> );

Event: onContextMenuOpen : (event: ContextMenuOpenEvent) => void

const handleContextMenuOpen = (event: ContextMenuOpenEvent) => void { // Action code here }; return ( <div> <Grid contextMenuSettings={{ enabled: true }} onContextMenuOpen={handleContextMenuOpen} /> </div> );
Replace contextMenuOpen with onContextMenuOpen. Fires when the menu is displayed.

Event: contextMenuClick : (event: ClickEventArgs) => void

const contextMenuClick = (event: ClickEventArgs) => void { // Action code here }; return ( <div> <GridComponent contextMenuItems={contextMenuItems} contextMenuClick={contextMenuClick}> <Inject services={[ContextMenu]}/> </GridComponent> </div> );

Event: onContextMenuClick : (event: MenuSelectEvent) => void

const handleContextMenuClick = (event: MenuSelectEvent) => { // Action code here }; return ( <div> <Grid contextMenuSettings={{ enabled: true }} onContextMenuClick={handleContextMenuClick} /> </div> );
Replace contextMenuClick with onContextMenuClick. Fires when a context menu item is selected.

Event: contextMenuClose : () => void

let grid; const contextMenuClose = () => void { // Action code here }; return ( <div> <GridComponent ref={g => grid = g} contextMenuItems={contextMenuItems} contextMenuClose={contextMenuClose}> <Inject services={[ContextMenu]}/> </GridComponent> </div> );

Event: onContextMenuClose : () => void

const handleContextMenuClose = () => { // Action code here }; return ( <div> <Grid contextMenuSettings={{ enabled: true }} onContextMenuClose={handleContextMenuClose}/> </div> );
Replace contextMenuClose with onContextMenuClose. Fires when the menu is dismissed.

Event: actionBegin (event: GroupEventArgs) => void

const actionBegin = (args: GroupEventArgs): void => { // Action code here } return ( <GridComponent dataSource={data} allowGrouping={true} actionBegin={actionBegin}> <Inject services={[Group]} /> </GridComponent>)

Event: onGroup (event: OnGroupArgs) => void

const handleGroup = (args: OnGroupArgs): void => { // Action code here }; return ( <Grid dataSource={data} onGroup={handleGroup} groupSettings={{ enabled: true }} />)
Replace actionBegin with onGroup for grouping operations. Use OnGroupArgs for type safety. Remove<Inject services={[Group]}/>.

Event: detailExpand (event: DetailExpandCollapseArgs) => void

const detailExpand = (args: DetailExpandCollapseArgs): void => { // Action code here } return ( <GridComponent childGrid={childGridOptions} detailExpand={detailExpand}> <Inject services={[DetailRow]} /> </GridComponent> );

Event: onRowExpand (event: RowExpandEvent<T>) => void

const handleRowExpand = (args: RowExpandEvent<DataItem>): void => { // Action code here } return ( <Grid isMasterDetail={true} onRowExpand={handleRowExpand}> </Grid> );

Replace detailExpand with onRowExpand. Use modules={DetailGridModule} instead of <Inject services={[DetailRow]}/>. Use RowExpandEvent<T> for type safety.

Event: detailCollapse (event: DetailExpandCollapseArgs) => void

const detailCollapse = (args: DetailExpandCollapseArgs): void => { // Action code here } return ( <GridComponent childGrid={childGridOptions} detailCollapse={detailCollapse}> <Inject services={[DetailRow]} /> </GridComponent> );

Event: onRowCollapse (event: RowCollapseEvent<T>) => void

const handleRowCollapse = (args: RowCollapseEvent<DataItem>): void => { // Action code here } return ( <Grid isMasterDetail={true} onRowCollapse={handleRowCollapse}> </Grid> );

Replace detailCollapse with onRowCollapse. Use modules={DetailGridModule} instead of <Inject services={[DetailRow]}/>. Use RowCollapseEvent<T> for type safety. Fires when a master row is collapsed.

Event: onColumnChooserBeforeOpen: (event: ColumnChooserBeforeOpenEvent) => void Not applicable

Event: onColumnChooserBeforeOpen: (event: ColumnChooserBeforeOpenEvent) => void

const handleColumnChooserBeforeOpen = (event: ColumnChooserBeforeOpenEvent): void => { // Action code here } return ( <div> <Grid ref={gridRef} showColumnChooser={true} onColumnChooserBeforeOpen={handleColumnChooserBeforeOpen}> </Grid> </div> );

New event. Use ColumnChooserBeforeOpenEvent. Fires before column chooser dialog opens; can cancel or customize.

Event: onColumnChooserApply: (event: ColumnChooserApplyEvent) => void Not applicable

Event: onColumnChooserApply: (event: ColumnChooserApplyEvent) => void

const handleColumnChooserApply = (event: ColumnChooserApplyEvent): void => { // Action code here } return ( <div> <Grid ref={gridRef} showColumnChooser={true} onColumnChooserApply={handleColumnChooserApply}> </Grid> </div> );

New event. Use ColumnChooserApplyEvent. Fires when user applies changes in column chooser.

Event: onCellFillStart: (event: CellFillStartEvent<T>) => void

Not applicable

Event: onCellFillStart: (event: CellFillStartEvent<T>) => void

const onCellFillStart = (event: CellFillStartEvent<DataItem>): void => { console.log('Fill operation started', event); } return ( <div> <Grid<DataItem> autoFillSettings={{ enabled: true }} onCellFillStart={onCellFillStart}> </Grid> </div> );

Fires when user starts dragging to fill cells. Use CellFillStartEvent<T>. Requires autoFillSettings.enabled=true.

Event: onCellFillComplete: (event: CellFillCompleteEvent<T>) => void

Not applicable

Event: onCellFillComplete: (event: CellFillCompleteEvent<T>) => void

const onCellFillComplete = (event: CellFillCompleteEvent<DataItem>): void => { console.log('Fill operation completed', event.data); } return ( <div> <Grid<DataItem> autoFillSettings={{ enabled: true }} onCellFillComplete={onCellFillComplete}> </Grid> </div> );

Fires when user completes dragging to fill cells. Use CellFillCompleteEvent<T>. Requires autoFillSettings.enabled=true.

Event: onClipboardCopy: (event: ClipboardCopyEvent<T>) => void

Not applicable

Event: onClipboardCopy: (event: ClipboardCopyEvent<T>) => void

const onClipboardCopy = (event: ClipboardCopyEvent<DataItem>): void => { console.log('Copy successful', event.copiedText); } return ( <div> <Grid<DataItem> modules={{ ClipboardModule }} onClipboardCopy={onClipboardCopy}> </Grid> </div> );

New event. Fires when cells are copied to clipboard. Use ClipboardCopyEvent<T>. Requires ClipboardModule in modules.

Event: onClipboardCut: (event: ClipboardCutEvent<T>) => void

Not applicable

Event: onClipboardCut: (event: ClipboardCutEvent<T>) => void

const onClipboardCut = (event: ClipboardCutEvent<DataItem>): void => { console.log('Cut successful', event.cutData); } return ( <div> <Grid<DataItem> modules={{ ClipboardModule }} onClipboardCut={onClipboardCut}> </Grid> </div> );

New event. Fires when cells are cut to clipboard. Use ClipboardCutEvent<T>. Requires ClipboardModule in modules.

Event: onClipboardPaste: (event: ClipboardPasteEvent<T>) => void

Not applicable

Event: onClipboardPaste: (event: ClipboardPasteEvent<T>) => void

const onClipboardPaste = (event: ClipboardPasteEvent<DataItem>): void => { console.log('Paste completed', event.pastedData); } return ( <div> <Grid<DataItem> modules={{ ClipboardModule }} onClipboardPaste={onClipboardPaste}> </Grid> </div> );

New event. Fires when clipboard content is pasted into grid. Use ClipboardPasteEvent<T>. Requires ClipboardModule in modules.

Event: onUndoStart: (event: UndoStartEvent<T>) => void

Not applicable

Event: onUndoStart: (event: UndoStartEvent<T>) => void

const onUndoStart = (event: UndoStartEvent<DataItem>): void => { console.log('Undo operation started'); } return ( <div> <Grid<DataItem> editSettings={{ allowUndoRedo: true }} onUndoStart={onUndoStart}> </Grid> </div> );

Fires when undo operation starts. Use UndoStartEvent<T>. Requires editSettings.allowUndoRedo=true.

Event: onUndoComplete: (event: UndoCompleteEvent<T>) => void

Not applicable

Event: onUndoComplete: (event: UndoCompleteEvent<T>) => void

const onUndoComplete = (event: UndoCompleteEvent<DataItem>): void => { console.log('Undo operation completed'); } return ( <div> <Grid<DataItem> editSettings={{ allowUndoRedo: true }} onUndoComplete={onUndoComplete}> </Grid> </div> );

Fires when undo operation completes. Use UndoCompleteEvent<T>. Requires editSettings.allowUndoRedo=true.

Event: onRedoStart: (event: RedoStartEvent<T>) => void

Not applicable

Event: onRedoStart: (event: RedoStartEvent<T>) => void

const onRedoStart = (event: RedoStartEvent<DataItem>): void => { console.log('Redo operation started'); } return ( <div> <Grid<DataItem> editSettings={{ allowUndoRedo: true }} onRedoStart={onRedoStart}> </Grid> </div> );

Fires when redo operation starts. Use RedoStartEvent<T>. Requires editSettings.allowUndoRedo=true.

Event: onRedoComplete: (event: RedoCompleteEvent<T>) => void

Not applicable

Event: onRedoComplete: (event: RedoCompleteEvent<T>) => void

const onRedoComplete = (event: RedoCompleteEvent<DataItem>): void => { console.log('Redo operation completed'); } return ( <div> <Grid<DataItem> editSettings={{ allowUndoRedo: true }} onRedoComplete={onRedoComplete}> </Grid> </div> );

Fires when redo operation completes. Use RedoCompleteEvent<T>. Requires editSettings.allowUndoRedo=true.

Event: onPivotChange: (event: PivotChangeEvent<T>) => void

Not applicable

Event: onPivotChange: (event: PivotChangeEvent<T>) => void

const onPivotChange = (event: PivotChangeEvent<DataItem>): void => { console.log('Pivot configuration changed', event.pivotSettings); } return ( <div> <Grid<DataItem> pivotSettings={{ rows: ['Category'] }} onPivotChange={onPivotChange}> </Grid> </div> );

Fires when pivot configuration changes. Use PivotChangeEvent<T>. Requires pivotSettings configured.

Event: onPivotError: (event: PivotErrorEvent<T>) => void

Not applicable

Event: onPivotError: (event: PivotErrorEvent<T>) => void

const onPivotError = (event: PivotErrorEvent<DataItem>): void => { console.error('Pivot error:', event.error); } return ( <div> <Grid<DataItem> pivotSettings={{ rows: ['Category'] }} onPivotError={onPivotError}> </Grid> </div> );

Fires when pivot operation encounters an error. Use PivotErrorEvent<T>. Requires pivotSettings configured.

Event: resizeStart: (args: ResizeArgs) => void

const resizeStart = (args: ResizeArgs): void => { // Action code here } <GridComponent resizeStart={resizeStart}></GridComponent>

Event: onColumnResizeStart: (event: ColumnResizeStartEvent) => void

const onColumnResizeStart = (event: ColumnResizeStartEvent): void => { // Action code here } <Grid resizeSettings={{ enabled: true }} modules={ResizeModule} onColumnResizeStart={onColumnResizeStart}></Grid>
Replace resizeStart with onColumnResizeStart. Fires when a column resize interaction begins. Use ColumnResizeStartEvent. Requires ResizeModule in modules.

Event: resizing: (args: ResizeArgs) => void

const resizing = (args: ResizeArgs): void => { // Action code here } <GridComponent resizing={resizing}></GridComponent>

Event: onColumnResize: (event: ColumnResizeEvent) => void

const onColumnResize = (event: ColumnResizeEvent): void => { // Action code here } <Grid resizeSettings={{ enabled: true }} modules={ResizeModule} onColumnResize={onColumnResize}></Grid>
Replace resizing with onColumnResize. Fires continuously while column width changes during an active resize. Use ColumnResizeEvent. Requires ResizeModule in modules.

Event: resizeStop: (args: ResizeArgs) => void

const resizeStop = (args: ResizeArgs): void => { // Action code here } <GridComponent resizeStop={resizeStop}></GridComponent>

Event: onColumnResizeEnd: (event: ColumnResizeEndEvent) => void

const onColumnResizeEnd = (event: ColumnResizeEndEvent): void => { // Action code here } <Grid resizeSettings={{ enabled: true }} modules={ResizeModule} onColumnResizeEnd={onColumnResizeEnd}></Grid>
Replace resizeStop with onColumnResizeEnd. Fires after a column resize operation completes. Use ColumnResizeEndEvent. Requires ResizeModule in modules.

Event: columnMenuClick: (args: ColumnMenuClickEventArgs) => void

const columnMenuClick = (args: ColumnMenuClickEventArgs): void => { // Action code here } <GridComponent columnMenuClick={columnMenuClick}></GridComponent>

Event: onColumnMenuClick: (event: ColumnMenuClickEventArgs) => void

const onColumnMenuClick = (event: ColumnMenuClickEvent): void => { // Action code here } <Grid columnMenuSettings={{ enabled: true }} modules={ColumnMenuModule} onColumnMenuClick={onColumnMenuClick}></Grid>
Replace columnMenuClick with onColumnMenuClick. Fires when a column menu item is clicked.

Event: columnMenuOpen: (args: ColumnMenuOpenEventArgs) => void

const columnMenuOpen = (args: ColumnMenuOpenEventArgs): void => { // Action code here } <GridComponent columnMenuOpen={columnMenuOpen}></GridComponent>

Event: onColumnMenuOpen: (event: ColumnMenuOpenEvent) => void

const onColumnMenuOpen = (event: ColumnMenuOpenEvent): void => { // Action code here } <Grid columnMenuSettings={{ enabled: true }} modules={ColumnMenuModule} onColumnMenuOpen={onColumnMenuOpen}></Grid>
Replace columnMenuOpen with onColumnMenuOpen. Fires before the column menu opens.

Event: columnMenuClose() => void

Not applicable

Event: onColumnMenuClose: (event: ColumnMenuCloseEvent) => void

const onColumnMenuClose = (event: ColumnMenuCloseEvent): void => { // Action code here } <Grid columnMenuSettings={{ enabled: true }} modules={ColumnMenuModule} onColumnMenuClose={onColumnMenuClose}></Grid>
New event. Fires after the column menu is closed.

Event: columnDragStart: (args: ColumnDragEventArgs) => void

const columnDragStart = (args: ColumnDragEventArgs): void => { // Action code here } <GridComponent columnDragStart={columnDragStart}></GridComponent>

Event: onColumnReorderStart: (event: ColumnReorderStartEvent) => void

const onColumnReorderStart = (event: ColumnReorderStartEvent): void => { // Action code here } <Grid reorderSettings={{ enabled: true }} modules={ReorderModule} onColumnReorderStart={onColumnReorderStart}></Grid>
Replace columnDragStart with onColumnReorderStart. Fires when column drag begins.

Event: columnDrag: (args: ColumnDragEventArgs) => void

const columnDrag = (args: ColumnDragEventArgs): void => { // Action code here } <GridComponent columnDrag={columnDrag}></GridComponent>

Event: onColumnDrag: (event: ColumnReorderEvent) => void

const onColumnDrag = (event: ColumnReorderEvent): void => { // Action code here } <Grid reorderSettings={{ enabled: true }} modules={ReorderModule} onColumnDrag={onColumnDrag}></Grid>
Replace columnDrag with onColumnDrag. Fires continuously while dragging a column.

Event: columnDrop: (args: ColumnDropEventArgs) => void

const columnDrop = (args: ColumnDropEventArgs): void => { // Action code here } <GridComponent columnDrop={columnDrop}></GridComponent>

Event: onColumnReorderEnd: (event: ColumnReorderEndEvent) => void

const onColumnReorderEnd = (event: ColumnReorderEndEvent): void => { // Action code here } <Grid reorderSettings={{ enabled: true }} modules={ReorderModule} onColumnReorderEnd={onColumnReorderEnd}></Grid>
Replace columnDrop with onColumnReorderEnd. Fires after column reorder completes.

Event: rowDragStartHelper (event: RowDragEventArgs) => void

const rowDragStartHelper = (args: RowDragEventArgs): void => { // Custom logic before row drag starts }; <GridComponent allowRowDragAndDrop={true} rowDragStartHelper={rowDragStartHelper}> <Inject services={[RowDD]}/> </GridComponent>

Event: onRowDragStart (event: RowDragStartArgs) => void

const handleRowDragStart = (args: RowDragStartArgs): void => { // Custom logic before row drag starts }; <Grid modules={ReorderModule} dragAndDropSettings={{ enabled: true }} onRowDragStart={handleRowDragStart}> </Grid>

Replace rowDragStartHelper with onRowDragStart. Use RowDragStartArgs. Requires ReorderModule. Fires when row drag begins.

Event: rowDrop (event: RowDropEventArgs) => void

const rowDrop = (args: RowDropEventArgs): void => { // Custom logic on row drop }; <GridComponent allowRowDragAndDrop={true} rowDrop={rowDrop}> <Inject services={[RowDD]}/> </GridComponent>

Event: onRowDrop (event: RowDragEventArgs) => void

const handleRowDrop = (args: RowDragEventArgs): void => { // Custom logic on row drop }; <Grid modules={ReorderModule} dragAndDropSettings={{ enabled: true }} onRowDrop={handleRowDrop}> </Grid>

Replace rowDrop with onRowDrop. Uses RowDragEventArgs. Requires ReorderModule. Fires after row reorder completes.

Event: rowDrag (event: RowDragEventArgs) => void

const rowDrag = (args: RowDragEventArgs): void => { // Custom logic during row drag }; <GridComponent allowRowDragAndDrop={true} rowDrag={rowDrag}> <Inject services={[RowDD]}/> </GridComponent>

Event: onRowDrag (event: RowDragEventArgs) => void

const handleRowDrag = (args: RowDragEventArgs): void => { // Custom logic during row drag }; <Grid modules={ReorderModule} dragAndDropSettings={{ enabled: true }} onRowDrag={handleRowDrag}> </Grid>

Replace rowDrag with onRowDrag. Use RowDragEventArgs. Requires ReorderModule. Fires continuously while dragging a row.

Event: beforeBatchSave: (event: BeforeBatchSaveArgs) => void

const beforeBatchSave = (args: BeforeBatchSaveArgs): void => { // Action code here } return ( <GridComponent editSettings={{ allowEditing: true, mode: 'Batch' }} beforeBatchSave={beforeBatchSave}> <Inject services={[Edit]} /> </GridComponent>)

Event: onBatchCommitStart: (stagedRows: StagedRowData<T>[]) => boolean

const handleBatchCommitStart = (stagedRows: StagedRowData<DataItem>[]): boolean => { // Return false to cancel the commit return true; }; return ( <Grid<DataItem> editSettings={{ allowEdit: true, allowBatchSave: true, mode: 'Cell' }} onBatchCommitStart={handleBatchCommitStart} modules={EditModule} />)
Replace beforeBatchSave with onBatchCommitStart. Use StagedRowData<T>[] for the pending rows. Use modules={EditModule} instead of <Inject services={[Edit]}/>.

Event: actionComplete: (event: SaveEventArgs) => void (requestType is 'batchsave')

const actionComplete = (args: SaveEventArgs): void => { if (args.requestType === 'batchsave') { // Action code here } } return ( <GridComponent editSettings={{ allowEditing: true, mode: 'Batch' }} actionComplete={actionComplete}> <Inject services={[Edit]} /> </GridComponent>)

Event: onBatchCommitSuccess: (rowsCommitted: number) => void

const handleBatchCommitSuccess = (rowsCommitted: number): void => { // Action code here }; return ( <Grid<DataItem> editSettings={{ allowEdit: true, allowBatchSave: true, mode: 'Cell' }} onBatchCommitSuccess={handleBatchCommitSuccess} modules={EditModule} />)
Replace the actionComplete with onBatchCommitSuccess. Use modules={EditModule} instead of <Inject services={[Edit]}/>.

Event: actionFailure: (event: FailureEventArgs) => void

const actionFailure = (args: FailureEventArgs): void => { // Action code here } return ( <GridComponent editSettings={{ allowEditing: true, mode: 'Batch' }} actionFailure={actionFailure}> <Inject services={[Edit]} /> </GridComponent>)

Event: onBatchCommitError: (error: Error, stagedRows: StagedRowData<T>[]) => void

const handleBatchCommitError = (error: Error, stagedRows: StagedRowData<DataItem>[]): void => { // Action code here }; return ( <Grid<DataItem> editSettings={{ allowEdit: true, allowBatchSave: true, mode: 'Cell' }} onBatchCommitError={handleBatchCommitError} modules={EditModule} />)
Replace actionFailure with onBatchCommitError. Use Error and StagedRowData<T>[]. Use modules={EditModule} instead of <Inject services={[Edit]}/>.

Event: cellSaved: (event: CellSaveArgs) => void

const cellSaved = (args: CellSaveArgs): void => { // Action code here } return ( <GridComponent editSettings={{ allowEditing: true, mode: 'Batch' }} cellSaved={cellSaved}> <Inject services={[Edit]} /> </GridComponent>)

Event: onBatchEditRender: (stagedRow: StagedRowData<T>, fieldName: string) => void

const handleBatchEditRender = (stagedRow: StagedRowData<DataItem>, fieldName: string): void => { // Action code here }; return ( <Grid<DataItem> editSettings={{ allowEdit: true, allowBatchSave: true, mode: 'Cell' }} onBatchEditRender={handleBatchEditRender} modules={EditModule} />)
Replace cellSaved with onBatchEditRender. Arguments are StagedRowData<T> and fieldName. Fires after a field value is staged. Use modules={EditModule} instead of <Inject services={[Edit]}/>.

Event: onBatchEditStart

Not applicable

Event: onBatchEditStart: () => void

const handleBatchEditStart = (): void => { // Action code here }; return ( <Grid<DataItem> editSettings={{ allowEdit: true, allowBatchSave: true, mode: 'Cell' }} onBatchEditStart={handleBatchEditStart} modules={EditModule} />)
New event. Fires when batch editing starts. Requires allowBatchSave and modules={EditModule}.

Event: onBatchStateChange

Not applicable

Event: onBatchStateChange: (rowKey: string | number, isDirty: boolean) => void

const handleBatchStateChange = (rowKey: string | number, isDirty: boolean): void => { // Action code here }; return ( <Grid<DataItem> editSettings={{ allowEdit: true, allowBatchSave: true, mode: 'Cell' }} onBatchStateChange={handleBatchStateChange} modules={EditModule} />)
New event. Arguments are rowKey and isDirty. Fires when a row changes between clean and dirty batch state. Requires allowBatchSave and modules={EditModule}.

Event: onUndoStart()

Not applicable

Event: onUndoStart: (event: UndoStartEvent) => void

const handleUndoStart = (event: UndoStartEvent): void => { // Action code here }; return ( <Grid<DataItem> editSettings={{ allowEdit: true, allowUndoRedo: true }} onUndoStart={handleUndoStart} modules={EditModule} />)
New event. Use UndoStartEvent. Fires before an undo action is applied. Requires editSettings.allowUndoRedo and modules={EditModule}.

Event: onUndoComplete()

Not applicable

Event: onUndoComplete: (event: UndoCompleteEvent) => void

const handleUndoComplete = (event: UndoCompleteEvent): void => { // Action code here }; return ( <Grid<DataItem> editSettings={{ allowEdit: true, allowUndoRedo: true }} onUndoComplete={handleUndoComplete} modules={EditModule} />)
New event. Use UndoCompleteEvent. Fires after an undo action completes. Requires editSettings.allowUndoRedo and modules={EditModule}.

Event: onRedoStart()

Not applicable

Event: onRedoStart: (event: RedoStartEvent) => void

const handleRedoStart = (event: RedoStartEvent): void => { // Action code here }; return ( <Grid<DataItem> editSettings={{ allowEdit: true, allowUndoRedo: true }} onRedoStart={handleRedoStart} modules={EditModule} />)
New event. Use RedoStartEvent. Fires before a redo action is applied. Requires editSettings.allowUndoRedo and modules={EditModule}.

Event: onRedoComplete()

Not applicable

Event: onRedoComplete: (event: RedoCompleteEvent) => void

const handleRedoComplete = (event: RedoCompleteEvent): void => { // Action code here }; return ( <Grid<DataItem> editSettings={{ allowEdit: true, allowUndoRedo: true }} onRedoComplete={handleRedoComplete} modules={EditModule} />)
New event. Use RedoCompleteEvent. Fires after a redo action completes. Requires editSettings.allowUndoRedo and modules={EditModule}.