Row Data Source

Copy Page

ClientRowDataSourcePaginatedParams

Parameters required to initialize a client-side row data source.

T[]

T[]

boolean

((path: string[]) => string)

((d: RowLeaf<T>, i: number) => string)

number

T[]

((params: {column: Column<T> values: unknown[]}) => FilterInFilterItem[])

ClientRowDataSourceParams

Enhanced parameters for a client-side row data source with additional filtering support.

T[]

T[]

boolean

((path: string[]) => string)

((d: RowLeaf<T>, i: number) => string)

T[]

((params: {column: Column<T> values: unknown[]}) => FilterInFilterItem[])

ClientTreeDataSourceParams

Parameters for initializing a tree-structured data source in LyteNyte Grid.

T[]

(data: RowLeaf<T>) => (string | null)[]

T[]

boolean

((path: string[]) => string)

((d: RowLeaf<T>, i: number) => string)

T[]

((params: {column: Column<T> values: unknown[]}) => FilterInFilterItem[])

DataColumnPivotFetcherFn

(params: (DataColumnPivotFetcherParams: any) => any) => any

DataColumnPivotFetcherParams

When column pivots are applied in LyteNyte Grid, the grid fetches pivot column definitions separately from the pivot row data. The DataColumnPivotFetcherParams type defines the parameters passed to the fetcher that retrieves these column pivot definitions from the server.

Grid<T>

DataRequestModel<T>

number

DataFetcherFn

(params: (DataFetcherParams: any) => any) => any

DataFetcherParams

The LyteNyte Grid server data source requires a dataFetcher function. The DataFetcherParams type describes the parameters that LyteNyte Grid passes to this function when performing data loading.

These parameters include a set of DataRequest objects based on the current grid view and the DataRequestModel at the time of the call. A reqTime value is also provided, which is a Unix timestamp indicating when the request was made.

Grid<T>

DataRequestModel<T>

number

DataRequest[]

DataInFilterItemFetcherFn

(params: (DataInFilterItemFetcherParams: any) => any) => any

DataInFilterItemFetcherParams

The in filter (set filter) in LyteNyte Grid requests possible values from the row data source attached to the grid state. For a server data source, the unique values for a given column are stored on the server.

Developers can supply a DataInFilterItemFetcherFn to the server data source to retrieve these unique filter items. The DataInFilterItemFetcherParams type defines the parameters passed to the fetcher function.

Column<T>

Grid<T>

number

DataRequest

The DataRequest type represents a request for a slice of data from the server. A slice can target either the root of the view or a specific grouping, identified by the path property.

Each request includes a unique ID, which can be used to deduplicate requests or enable caching. It also defines start and end values that specify the offsets of the requested slice.

LyteNyte Grid may issue multiple DataRequest objects at once, depending on the user's current view. Each request is a snapshot of the grid state at the time it was made.

number

string

(string | null)[]

number

number

number

DataRequestModel

The data request model represents the current LyteNyte Grid state at the time of creation. It concatenates the grid's internal models into a single structure used to request external data. Depending on your server's capabilities, you can choose to omit certain parts of the model.

The model is a snapshot only; it is not reactive and does not stay in sync with the grid's ongoing state.

{[x: string]: {fn: AggModelFn<T>}}

{[x: string]: FilterModelItem<T>}

{[x: string]: FilterIn}

{[x: string]: boolean }

RowGroupModelItem<T>[]

{[x: string]: boolean }

boolean

ColumnPivotModel<T>

string | null

SortModelItem<T>[]

DataResponse

LyteNyte Grid's server data source sends request objects describing the data needed to render the grid. The server responds with one or more DataResponse objects.

A DataResponse contains the rows and metadata required to render a slice of the grid's view. Each response includes a path value, which identifies where in the row tree the data belongs. Parent paths must be provided before their child paths can be created.

The server data source can handle multiple responses at once. Sending multiple responses for different slices is common, especially when data updates frequently.

number

(DataResponseLeafItem | DataResponseBranchItem)[]

number

"center"

(string | null)[]

number

number

DataResponseBranchItem

The DataResponseBranchItem represents a group node. These items are converted into group row nodes and indicate that additional child rows are nested beneath them.

number

any

string

string | null

"branch"

DataResponseLeafItem

The DataResponseLeafItem represents the data for a leaf row node. A leaf node is the last level in the data tree and cannot be expanded further. Leaf nodes appear when the view is flat (no row groups) or when the expanded row is at the final grouping level.

Each DataResponseLeafItem corresponds to a single row node, and responses can mix different node types in the same request. When row groups are present, a leaf item may appear before the final grouping level, which can result in unbalanced groups.

any

string

"leaf"

DataResponsePinned

Pinned rows in LyteNyte Grid remain visible regardless of user interaction such as scrolling. By definition, pinned rows do not move within the view.

The DataResponsePinned type provides data for pinned rows and allows the server to set or update rows pinned to the top or bottom of the view.

number

DataResponseLeafItem[]

"top" | "bottom"

RdsRowSelectParams

Parameters passed to the row selection handler within the row data source.

boolean

string

RowSelectionMode

boolean

string

RowDataSource

The row data source interface used by LyteNyte Grid to retrieve and manage row data. This includes functionality for row expansion, selection, and CRUD operations.

(column: Column<T>) => FilterInFilterItem[] | Promise<FilterInFilterItem[]>

(grid: Grid<T>) => void

(newRows: any[], atIndex?: number | "beginning" | "end") => void

(rowId: string) => string[]

(rowId?: string) => boolean

(id: string) => RowNode<T> | null

(index: number) => RowNode<T> | null

(deletions: (string | number)[]) => void

(expansion: Record<string, boolean>) => void

(params: RdsRowSelectParams) => void

(params: RowSelectAllOptions) => void

(data: any[]) => void

(newRows: any[]) => void

(data: any[]) => void

(rowId: string) => number | null

(updates: Map<string | number, any>) => void

RowDataSourceClient

A client-side row data source used by LyteNyte Grid. All operations are handled on the client, assuming the complete dataset is available in memory.

This implementation is suitable for small to moderately sized datasets. For large-scale datasets, such as those exceeding hundreds of thousands of rows, a server-based data source is recommended for performance and memory efficiency.

(column: Column<T>) => FilterInFilterItem[] | Promise<FilterInFilterItem[]>

(grid: Grid<T>) => void

(newRows: any[], atIndex?: number | "beginning" | "end") => void

(rowId: string) => string[]

(rowId?: string) => boolean

(id: string) => RowNode<T> | null

(index: number) => RowNode<T> | null

(section: RowSection) => T[]

(deletions: (string | number)[]) => void

(expansion: Record<string, boolean>) => void

(params: RdsRowSelectParams) => void

(params: RowSelectAllOptions) => void

(data: any[]) => void

(newRows: any[]) => void

(data: any[]) => void

(rowId: string) => number | null

(updates: Map<string | number, any>) => void

RowDataSourceClientPageState

Represents pagination-related state for the client row data source in LyteNyte Grid. These values enable pagination logic within the grid's UI and interactions.

GridAtom<number>

GridAtomReadonly<number>

GridAtom<number>

RowDataSourceClientPaginated

A paginated client-side row data source for LyteNyte Grid. It divides the full dataset into pages based on the configured page size, reducing the number of rows rendered at any one time to improve UI responsiveness and performance.

(column: Column<T>) => FilterInFilterItem[] | Promise<FilterInFilterItem[]>

(grid: Grid<T>) => void

RowDataSourceClientPageState

(newRows: any[], atIndex?: number | "beginning" | "end") => void

(rowId: string) => string[]

(rowId?: string) => boolean

(id: string) => RowNode<T> | null

(index: number) => RowNode<T> | null

(section: RowSection) => T[]

(deletions: (string | number)[]) => void

(expansion: Record<string, boolean>) => void

(params: RdsRowSelectParams) => void

(params: RowSelectAllOptions) => void

(data: any[]) => void

(newRows: any[]) => void

(data: any[]) => void

(rowId: string) => number | null

(updates: Map<string | number, any>) => void

RowDataSourceServer

A high-performance row data source for LyteNyte Grid that enables server-side data loading in slices. This data source supports virtually unlimited data volumes by querying only the required data ranges from a backend source.

Unlike client-side data sources, all row operations—including filtering, sorting, grouping, and pagination—must be handled on the server. This design provides maximum flexibility and scalability, including support for server-driven trees and pagination, but requires a more complex implementation on the backend.

(column: Column<T>) => FilterInFilterItem[] | Promise<FilterInFilterItem[]>

(grid: Grid<T>) => void

GridAtomReadonly<boolean>

GridAtomReadonly<unknown>

(req: DataRequest[], onSuccess?: (() => void) , onError?: ((e: unknown) => void)) => void

(req: (DataResponse | DataResponsePinned)[]) => void

(onSuccess?: (() => void) , onError?: ((e: unknown) => void)) => void

(row: number | RowGroup) => DataRequest | null

(currentRequest: DataRequest) => DataRequest | null

GridAtomReadonly<DataRequest[]>

() => void

() => void

(newRows: any[], atIndex?: number | "beginning" | "end") => void

(rowId: string) => string[]

(rowId?: string) => boolean

(id: string) => RowNode<T> | null

(index: number) => RowNode<T> | null

(deletions: (string | number)[]) => void

(expansion: Record<string, boolean>) => void

(params: RdsRowSelectParams) => void

(params: RowSelectAllOptions) => void

(data: any[]) => void

(newRows: any[]) => void

(data: any[]) => void

(rowId: string) => number | null

(updates: Map<string | number, any>) => void

Set<string>

RowDataSourceServerParams

The LyteNyte Grid server row data source provides an implementation optimized for fetching data in slices from the server.

The RowDataSourceServerParams type defines the configuration parameters that can be passed to this row data source.

(params: DataFetcherParams<T>) => Promise<(DataResponse | DataResponsePinned)[]>

number

((updates: Map<string, any>) => void)

boolean

DataColumnPivotFetcherFn<T>

unknown[]

DataInFilterItemFetcherFn<T>

RowDataStore

The internal row data store used by LyteNyte Grid to manage row metadata, counts, and access functions.

GridAtom<number>

GridAtom<number>

() => void

GridAtomReadonly<number>

(row: number) => GridAtomReadonlyUnwatchable<RowNode<T> | null>

(row: number) => void

GridAtom<number>

RowDetailHeight

number | "auto"

RowDetailRendererFn

(params: (RowDetailRendererParams: any) => ReactNode) => any

RowDetailRendererParams

Defines the parameters passed to a row detail renderer. These parameters include the row index, the row node metadata, and a reference to the grid instance.

Grid<T>

RowGroup | RowLeaf<T>

number