@ishibashi0112/spreadsheet-grid 0.1.0

package/dist/logic/columnAutosize.d.ts

@@ -0,0 +1,18 @@
+import type { GridColumn } from '../model/gridTypes';
+export type ColumnAutosizeParams<T> = {
+    columns: GridColumn<T>[];
+    getRow: (viewIndex: number) => T;
+    viewRowCount: number;
+    gridRoot: HTMLElement | null;
+    currentWidths: Record<string, number>;
+};
+export type ColumnWidthAccumulator<T> = {
+    collect: (row: T) => void;
+    finalize: (params: {
+        gridRoot: HTMLElement | null;
+        currentWidths: Record<string, number>;
+    }) => Record<string, number>;
+};
+export declare function createColumnWidthAccumulator<T>(columns: GridColumn<T>[]): ColumnWidthAccumulator<T>;
+export declare function canMeasureAutosize(): boolean;
+export declare function computeAutosizedColumnWidths<T>({ columns, getRow, viewRowCount, gridRoot, currentWidths, }: ColumnAutosizeParams<T>): Record<string, number>;

package/dist/logic/cx.d.ts

@@ -0,0 +1 @@
+export declare function cx(...classNames: Array<string | false | null | undefined>): string;

package/dist/logic/domGuards.d.ts

@@ -0,0 +1,7 @@
+export declare const isPrintableKey: (event: {
+    key: string;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    altKey: boolean;
+}) => boolean;
+export declare const shouldIgnoreGridKeydown: (eventTarget: EventTarget | null) => boolean;

package/dist/logic/filtering.d.ts

@@ -0,0 +1,12 @@
+import type { ColumnFilterValue, GridColumn, NumberColumnFilterValue, ParsedNumberFilter, SetColumnFilterValue } from '../model/gridTypes';
+export type RowOrder = Int32Array;
+export declare const createSourceOrder: (rowCount: number) => RowOrder;
+export declare const isSetColumnFilterValue: (value: ColumnFilterValue | undefined) => value is SetColumnFilterValue;
+export declare const isActiveColumnFilterValue: (value: ColumnFilterValue | undefined) => boolean;
+export declare const parseNumberFilterExpression: (rawValue: string) => ParsedNumberFilter | null;
+export declare const isNumberColumnFilterValue: (value: ColumnFilterValue | undefined) => value is NumberColumnFilterValue;
+export declare const buildNumberColumnFilterValue: (rawInput: string) => NumberColumnFilterValue | null;
+export declare const columnFilterValueToDraftText: (value: ColumnFilterValue | undefined) => string;
+export declare const applyNumberFilter: (cellValue: unknown, filterValue: unknown) => boolean;
+export declare const filterOrderByGlobalText: <T>(rows: T[], order: RowOrder, columns: GridColumn<T>[], globalText: string) => RowOrder;
+export declare const filterOrderByColumns: <T>(rows: T[], order: RowOrder, columns: GridColumn<T>[], columnFilters: Record<string, ColumnFilterValue>, numericKeys?: ReadonlyMap<string, Float64Array>) => RowOrder;

package/dist/logic/geometry.d.ts

@@ -0,0 +1,72 @@
+import type { GridColumn } from '../model/gridTypes';
+export type ColumnMeasurement<T> = {
+    index: number;
+    column: GridColumn<T>;
+    start: number;
+    size: number;
+    end: number;
+};
+export declare const clamp: (value: number, min: number, max: number) => number;
+export declare const buildColumnMeasurements: <T>(columns: GridColumn<T>[], columnWidths: Record<string, number>) => ColumnMeasurement<T>[];
+export declare const findColumnIndexFromOffset: <T>(measurements: ColumnMeasurement<T>[], offset: number) => number;
+export type ColumnPane = 'left' | 'center' | 'right';
+export declare const getColumnPane: <T>(column: GridColumn<T>) => ColumnPane;
+export declare const reorderColumnsByPane: <T>(columns: GridColumn<T>[]) => GridColumn<T>[];
+export type PaneColumnEntry<T> = {
+    column: GridColumn<T>;
+    logicalIndex: number;
+    paneLocalStart: number;
+    paneLocalSize: number;
+    paneLocalEnd: number;
+};
+export type PaneGeometry<T> = {
+    pane: ColumnPane;
+    entries: PaneColumnEntry<T>[];
+    totalWidth: number;
+};
+export type GridPaneLayout<T> = {
+    left: PaneGeometry<T>;
+    center: PaneGeometry<T>;
+    right: PaneGeometry<T>;
+};
+export type PaneSourceColumn<T> = {
+    column: GridColumn<T>;
+    logicalIndex: number;
+};
+export type PaneSourceColumns<T> = {
+    left: PaneSourceColumn<T>[];
+    center: PaneSourceColumn<T>[];
+    right: PaneSourceColumn<T>[];
+};
+export declare const splitOrderedColumnsByPane: <T>(orderedColumns: GridColumn<T>[]) => PaneSourceColumns<T>;
+export declare const buildPaneWidthsKey: <T>(items: PaneSourceColumn<T>[], columnWidths: Record<string, number>) => string;
+export declare const buildPaneGeometry: <T>(pane: ColumnPane, items: PaneSourceColumn<T>[], resolvedWidths: number[]) => PaneGeometry<T>;
+export declare const buildPaneGeometryFromWidthsKey: <T>(pane: ColumnPane, items: PaneSourceColumn<T>[], widthsKey: string) => PaneGeometry<T>;
+export declare const buildGridPaneLayout: <T>(orderedColumns: GridColumn<T>[], columnWidths: Record<string, number>) => GridPaneLayout<T>;
+export type PaneColumnLookupResult<T> = {
+    pane: ColumnPane;
+    entry: PaneColumnEntry<T>;
+};
+export declare const lookupPaneColumn: <T>(layout: GridPaneLayout<T>, logicalIndex: number) => PaneColumnLookupResult<T> | null;
+export declare const findLogicalIndexFromPaneOffset: <T>(paneGeometry: PaneGeometry<T>, offset: number) => number;
+export declare const findPaneDropSlot: <T>(paneGeometry: PaneGeometry<T>, paneLocalOffset: number) => number;
+export declare const paneDropSlotBoundaryX: <T>(paneGeometry: PaneGeometry<T>, slot: number) => number;
+export declare const countPinnedColumns: <T>(layout: GridPaneLayout<T>) => {
+    left: number;
+    center: number;
+    right: number;
+};
+export declare const isPlainLayout: <T>(layout: GridPaneLayout<T>) => boolean;
+export type PaneColumnExtent = {
+    start: number;
+    end: number;
+    width: number;
+};
+export type PaneColumnExtentMap = Record<ColumnPane, PaneColumnExtent | null>;
+export declare const computePaneColumnExtents: <T>(layout: GridPaneLayout<T>, startLogicalIndex: number, endLogicalIndex: number) => PaneColumnExtentMap;
+export declare const computeFullWidthPaneExtents: <T>(layout: GridPaneLayout<T>) => PaneColumnExtentMap;
+export type SinglePaneColumnExtent = {
+    pane: ColumnPane;
+    extent: PaneColumnExtent;
+};
+export declare const computeSinglePaneColumnExtent: <T>(layout: GridPaneLayout<T>, logicalIndex: number) => SinglePaneColumnExtent | null;

package/dist/logic/rowHeightStore.d.ts

@@ -0,0 +1,13 @@
+import type { GridRowKey } from '../model/gridTypes';
+import type { RowMetrics } from './verticalGeometry';
+export type RowHeightStore = {
+    rowCount: number;
+    estimate: number;
+    heights: Float64Array;
+    prefix: Float64Array;
+    measured: Map<GridRowKey, number>;
+};
+export declare const rebuildPrefixFrom: (store: RowHeightStore, fromIndex: number) => void;
+export declare const buildRowHeightStore: (rowCount: number, estimate: number, getRowKey: (viewIndex: number) => GridRowKey, measured?: Map<GridRowKey, number>) => RowHeightStore;
+export declare const setMeasuredRowHeight: (store: RowHeightStore, viewIndex: number, rowKey: GridRowKey, height: number) => boolean;
+export declare const createAutoHeightRowMetrics: (store: RowHeightStore) => RowMetrics;

package/dist/logic/selectOptions.d.ts

@@ -0,0 +1,9 @@
+export type SelectOptionEntry = {
+    label: string;
+    value: string;
+};
+export declare const createSelectOptionsAccumulator: () => {
+    collect(rawValue: unknown): void;
+    finalize(): SelectOptionEntry[];
+};
+export declare const collectSelectOptions: (rowCount: number, getRawValueAt: (index: number) => unknown) => SelectOptionEntry[];

package/dist/logic/serverSideBlocks.d.ts

@@ -0,0 +1,2 @@
+export declare function blockIndexForRow(viewIndex: number, blockSize: number): number;
+export declare function computeBlockIndexes(startIndex: number, endIndex: number, blockSize: number, rowCount: number): number[];

package/dist/logic/serverSideCache.d.ts

@@ -0,0 +1,13 @@
+export type ServerSideRowCacheOptions = {
+    blockSize: number;
+    maxBlocks: number;
+};
+export type ServerSideRowCache<T> = {
+    getRow: (viewIndex: number) => T | undefined;
+    hasBlock: (blockIndex: number) => boolean;
+    setBlock: (blockIndex: number, rows: T[]) => void;
+    touchBlocks: (blockIndexes: number[]) => void;
+    clear: () => void;
+    loadedBlockIndexes: () => number[];
+};
+export declare function createServerSideRowCache<T>(options: ServerSideRowCacheOptions): ServerSideRowCache<T>;

package/dist/logic/serverSideQuery.d.ts

@@ -0,0 +1,7 @@
+import type { ColumnFilterValue, GridSortState, ServerSideQuery } from '../model/gridTypes';
+export declare const buildServerSideQuery: (input: {
+    globalText: string;
+    columnFilters: Record<string, ColumnFilterValue>;
+    sort: GridSortState;
+}) => ServerSideQuery;
+export declare const serializeServerSideQuery: (query: ServerSideQuery) => string;

package/dist/logic/sorting.d.ts

@@ -0,0 +1,11 @@
+import type { GridColumn, GridSortState } from '../model/gridTypes';
+import type { RowOrder } from './filtering';
+export declare const STRING_COLLATOR: Intl.Collator;
+export declare const compareUnknownValues: (left: unknown, right: unknown) => number;
+export declare const nextSortEntries: (current: GridSortState, columnKey: string, direction: "asc" | "desc", additive: boolean) => GridSortState;
+export declare const addSortEntry: (current: GridSortState, columnKey: string, direction: "asc" | "desc") => GridSortState;
+export declare const setSortEntryDirection: (current: GridSortState, index: number, direction: "asc" | "desc") => GridSortState;
+export declare const setSortEntryColumn: (current: GridSortState, index: number, columnKey: string) => GridSortState;
+export declare const removeSortEntryAt: (current: GridSortState, index: number) => GridSortState;
+export declare const moveSortEntry: (current: GridSortState, from: number, to: number) => GridSortState;
+export declare const sortOrder: <T>(rows: T[], order: RowOrder, columns: GridColumn<T>[], sort: GridSortState) => RowOrder;

package/dist/logic/verticalGeometry.d.ts

@@ -0,0 +1,50 @@
+export declare const MAX_BODY_PX = 15000000;
+export declare const AUTO_HEIGHT_MAX_ROWS = 50000;
+export declare const shouldUseAutoHeight: (autoHeightEnabled: boolean, hasAutoHeightColumn: boolean, viewRowCount: number, maxRows: number) => boolean;
+export declare const WINDOW_BASE_CHUNK_PX: number;
+export type VerticalRow = {
+    index: number;
+    start: number;
+    size?: number;
+};
+export type VerticalGeometry = {
+    physicalBodyHeight: number;
+    logicalBodyHeight: number;
+    scaleFactor: number;
+    translateY: number;
+    windowBaseOffsetPx: number;
+    rows: VerticalRow[];
+    rowIndexSet: Set<number>;
+};
+export type ComputeVerticalGeometryArgs = {
+    rowCount: number;
+    rowHeight: number;
+    headerHeight: number;
+    viewportHeight: number;
+    scrollTop: number;
+    overscan: number;
+    maxBodyPx: number;
+};
+export type RowMetrics = {
+    rowCount: number;
+    rowTop(index: number): number;
+    rowsHeight(startInclusive: number, endInclusive: number): number;
+    totalBodyHeight: number;
+    rowAtContentY(y: number): number;
+};
+export declare const createUniformRowMetrics: (rowCount: number, rowHeight: number) => RowMetrics;
+export declare const clipRowRangeToWindow: (selStartRow: number, selEndRow: number, windowFirstRow: number, windowLastRow: number) => {
+    start: number;
+    end: number;
+} | null;
+export declare const physicalToLogicalScrollTop: (physical: number, scaleFactor: number) => number;
+export declare const logicalToPhysicalScrollTop: (logical: number, scaleFactor: number) => number;
+export declare const clientYToRowIndex: (yRelativeToBodyTop: number, scrollTop: number, scaleFactor: number, rowMetrics: RowMetrics) => number;
+export declare const computeVerticalGeometry: ({ rowCount, rowHeight, headerHeight, viewportHeight, scrollTop, overscan, maxBodyPx, }: ComputeVerticalGeometryArgs) => VerticalGeometry;
+export type ComputeAutoHeightVerticalGeometryArgs = {
+    headerHeight: number;
+    viewportHeight: number;
+    scrollTop: number;
+    overscan: number;
+};
+export declare const computeAutoHeightVerticalGeometry: ({ headerHeight, viewportHeight, scrollTop, overscan, }: ComputeAutoHeightVerticalGeometryArgs, rowMetrics: RowMetrics) => VerticalGeometry;

package/dist/model/gridActions.d.ts

@@ -0,0 +1,87 @@
+import type { CellCoord, ColumnFilterValue, GridSortEntry } from './gridTypes';
+export type GridUiAction = {
+    type: 'cell/activate';
+    cell: CellCoord | null;
+} | {
+    type: 'selection/start';
+    cell: CellCoord;
+} | {
+    type: 'selection/update';
+    cell: CellCoord;
+} | {
+    type: 'rowSelection/start';
+    row: number;
+} | {
+    type: 'rowSelection/update';
+    row: number;
+} | {
+    type: 'columnSelection/start';
+    col: number;
+} | {
+    type: 'columnSelection/update';
+    col: number;
+} | {
+    type: 'selection/end';
+} | {
+    type: 'selection/clear';
+} | {
+    type: 'edit/start';
+    cell: CellCoord;
+} | {
+    type: 'edit/stop';
+} | {
+    type: 'column/resizeStart';
+    columnKey: string;
+    startX: number;
+    startWidth: number;
+    minWidth: number;
+    maxWidth: number;
+} | {
+    type: 'column/resizeUpdate';
+    clientX: number;
+} | {
+    type: 'column/resizeEnd';
+} | {
+    type: 'columnWidths/sync';
+    widths: Record<string, number>;
+} | {
+    type: 'filter/setGlobal';
+    value: string;
+} | {
+    type: 'filter/setColumn';
+    columnKey: string;
+    value: ColumnFilterValue;
+} | {
+    type: 'filter/clearColumn';
+    columnKey: string;
+} | {
+    type: 'filter/resetAll';
+} | {
+    type: 'sort/set';
+    entries: GridSortEntry[];
+} | {
+    type: 'sort/clear';
+};
+export declare const gridActions: {
+    activateCell: (cell: CellCoord | null) => GridUiAction;
+    startSelection: (cell: CellCoord) => GridUiAction;
+    updateSelection: (cell: CellCoord) => GridUiAction;
+    startRowSelection: (row: number) => GridUiAction;
+    updateRowSelection: (row: number) => GridUiAction;
+    startColumnSelection: (col: number) => GridUiAction;
+    updateColumnSelection: (col: number) => GridUiAction;
+    endSelection: () => GridUiAction;
+    clearSelection: () => GridUiAction;
+    startEdit: (cell: CellCoord) => GridUiAction;
+    stopEdit: () => GridUiAction;
+    startColumnResize: (columnKey: string, startX: number, startWidth: number, minWidth: number, maxWidth: number) => GridUiAction;
+    updateColumnResize: (clientX: number) => GridUiAction;
+    endColumnResize: () => GridUiAction;
+    syncColumnWidths: (widths: Record<string, number>) => GridUiAction;
+    setGlobalFilter: (value: string) => GridUiAction;
+    setColumnFilter: (columnKey: string, value: ColumnFilterValue) => GridUiAction;
+    clearColumnFilter: (columnKey: string) => GridUiAction;
+    resetAllFilters: () => GridUiAction;
+    setSort: (entries: GridSortEntry[]) => GridUiAction;
+    clearSort: () => GridUiAction;
+};

package/dist/model/gridReducer.d.ts

@@ -0,0 +1,4 @@
+import type { GridUiAction } from './gridActions';
+import type { GridColumn, GridUiState } from './gridTypes';
+export declare const createInitialGridUiState: <T>(columns: GridColumn<T>[]) => GridUiState;
+export declare const gridUiReducer: (state: GridUiState, action: GridUiAction) => GridUiState;

package/dist/model/gridSelectors.d.ts

@@ -0,0 +1,40 @@
+import type { CellCoord, CellRange, GridUiState } from './gridTypes';
+export declare const normalizeCellRange: (range: CellRange) => CellRange;
+export declare const normalizeRowRange: (startRow: number, endRow: number) => {
+    startRow: number;
+    endRow: number;
+};
+export declare const normalizeColumnRange: (startCol: number, endCol: number) => {
+    startCol: number;
+    endCol: number;
+};
+export declare const selectActiveCell: (state: GridUiState) => CellCoord | null;
+export declare const selectSelection: (state: GridUiState) => import("./gridTypes").GridSelection;
+export declare const selectEditingCell: (state: GridUiState) => CellCoord | null;
+export declare const selectColumnWidth: (state: GridUiState, columnKey: string) => number;
+export declare const selectGlobalFilter: (state: GridUiState) => string;
+export declare const selectColumnFilter: (state: GridUiState, columnKey: string) => import("./gridTypes").ColumnFilterValue;
+export declare const selectIsActiveCell: (state: GridUiState, rowIndex: number, colIndex: number) => boolean;
+export declare const selectIsEditingCell: (state: GridUiState, rowIndex: number, colIndex: number) => boolean;
+export declare const selectIsCellSelected: (state: GridUiState, rowIndex: number, colIndex: number) => boolean;
+export declare const selectIsRowSelected: (state: GridUiState, rowIndex: number) => boolean;
+export declare const selectIsColumnSelected: (state: GridUiState, colIndex: number) => boolean;
+export type SelectionSnapshot = {
+    kind: 'none';
+} | {
+    kind: 'cell';
+    startRow: number;
+    endRow: number;
+    startCol: number;
+    endCol: number;
+} | {
+    kind: 'row';
+    startRow: number;
+    endRow: number;
+} | {
+    kind: 'col';
+    startCol: number;
+    endCol: number;
+};
+export declare const buildSelectionSnapshot: (selection: GridUiState["selection"]) => SelectionSnapshot;
+export declare const isSameCellCoord: (left: CellCoord | null, right: CellCoord | null) => boolean;

package/dist/model/gridTypes.d.ts

@@ -0,0 +1,267 @@
+import type { ReactNode } from 'react';
+export type GridRowKey = string | number;
+export type RowModel<T> = {
+    getRowCount: () => number;
+    getRow: (viewIndex: number) => T;
+    getSourceIndex: (viewIndex: number) => number;
+    getRowKey: (viewIndex: number) => GridRowKey;
+};
+export type ServerSideQuery = {
+    globalText?: string;
+    columnFilters?: Record<string, ColumnFilterValue>;
+    sort?: GridSortState;
+};
+export type ServerSideGetRowsParams = {
+    startIndex: number;
+    endIndex: number;
+    query: ServerSideQuery;
+    signal: AbortSignal;
+};
+export type ServerSideGetRowsResult<T> = {
+    rows: T[];
+    totalRowCount: number;
+};
+export type ServerSideDataSource<T> = {
+    getRows: (params: ServerSideGetRowsParams) => Promise<ServerSideGetRowsResult<T>>;
+    initialRowCount?: number;
+    blockSize?: number;
+    maxCachedBlocks?: number;
+};
+export type CellCoord = {
+    row: number;
+    col: number;
+};
+export type CellRange = {
+    start: CellCoord;
+    end: CellCoord;
+};
+export type GridSelection = {
+    type: 'cell';
+    range: CellRange;
+} | {
+    type: 'row';
+    startRow: number;
+    endRow: number;
+} | {
+    type: 'col';
+    startCol: number;
+    endCol: number;
+} | null;
+export type GridFilterState = {
+    globalText: string;
+    columnFilters: Record<string, ColumnFilterValue>;
+};
+export type GridSortDirection = 'asc' | 'desc' | null;
+export type GridSortEntry = {
+    columnKey: string;
+    direction: 'asc' | 'desc';
+};
+export type GridSortState = GridSortEntry[];
+export type GridSelectFilterOption = {
+    label: string;
+    value: string;
+};
+export type SetColumnFilterValue = {
+    kind: 'set';
+    mode?: 'include' | 'exclude';
+    values: string[];
+};
+export type ParsedNumberFilter = {
+    mode: 'comparison';
+    operator: '>' | '>=' | '<' | '<=' | '=';
+    value: number;
+} | {
+    mode: 'range';
+    min: number;
+    max: number;
+};
+export type NumberColumnFilterValue = {
+    kind: 'number';
+    raw: string;
+    parsed: ParsedNumberFilter | null;
+};
+export type TextColumnFilterValue = {
+    kind: 'text';
+    value: string;
+};
+export type DateColumnFilterValue = {
+    kind: 'date';
+    value: string;
+};
+export type SelectColumnFilterValue = {
+    kind: 'select';
+    value: string;
+};
+export type CustomColumnFilterValue = {
+    kind: 'custom';
+    value: unknown;
+};
+export type ColumnFilterValue = SetColumnFilterValue | NumberColumnFilterValue | TextColumnFilterValue | DateColumnFilterValue | SelectColumnFilterValue | CustomColumnFilterValue;
+export type CellRenderContext<T> = {
+    row: T;
+    rowIndex: number;
+    colIndex: number;
+    value: unknown;
+    column: GridColumn<T>;
+    isActive: boolean;
+    isSelected: boolean;
+    isEditing: boolean;
+    readOnly: boolean;
+    setValue: (value: unknown) => void;
+};
+export type CellStyleContext<T> = {
+    row: T;
+    rowIndex: number;
+    colIndex: number;
+    value: unknown;
+    column: GridColumn<T>;
+    isActive: boolean;
+    isSelected: boolean;
+    isEditing: boolean;
+    readOnly: boolean;
+};
+export type CellRenderState = {
+    isActive: boolean;
+    isSelected: boolean;
+    isEditing: boolean;
+    readOnly: boolean;
+};
+export type HeaderRenderContext<T> = {
+    colIndex: number;
+    width: number;
+    column: GridColumn<T>;
+    filterValue?: unknown;
+    isFiltered?: boolean;
+};
+export type GridColumnPinned = 'left' | 'right';
+export type GridColumn<T> = {
+    key: string;
+    title?: string;
+    width: number;
+    minWidth?: number;
+    maxWidth?: number;
+    autoHeight?: boolean;
+    visible?: boolean;
+    editable?: boolean;
+    readOnly?: boolean;
+    pinned?: GridColumnPinned;
+    getValue?: (row: T) => unknown;
+    setValue?: (row: T, value: unknown) => T;
+    renderCell?: (ctx: CellRenderContext<T>) => ReactNode;
+    cellClassName?: string | ((ctx: CellStyleContext<T>) => string | undefined);
+    renderHeader?: (ctx: HeaderRenderContext<T>) => ReactNode;
+    filterType?: 'text' | 'number' | 'date' | 'select' | 'set' | 'custom';
+    filterOptions?: GridSelectFilterOption[];
+    filterFn?: (row: T, filterValue: unknown) => boolean;
+    parseClipboardValue?: (raw: string, row: T) => unknown;
+    formatClipboardValue?: (value: unknown, row: T) => string;
+};
+export type ColumnResizeDragState = {
+    type: 'columnResize';
+    columnKey: string;
+    startX: number;
+    startWidth: number;
+    minWidth: number;
+    maxWidth: number;
+};
+export type CellSelectionDragState = {
+    type: 'selection';
+    selectionKind: 'cell';
+    anchor: CellCoord;
+};
+export type RowSelectionDragState = {
+    type: 'selection';
+    selectionKind: 'row';
+    anchorRow: number;
+};
+export type ColumnSelectionDragState = {
+    type: 'selection';
+    selectionKind: 'col';
+    anchorCol: number;
+};
+export type GridUiState = {
+    activeCell: CellCoord | null;
+    selection: GridSelection;
+    editingCell: CellCoord | null;
+    dragState: CellSelectionDragState | RowSelectionDragState | ColumnSelectionDragState | ColumnResizeDragState | null;
+    columnWidths: Record<string, number>;
+    filters: GridFilterState;
+    sort: GridSortState;
+};
+export type SpreadsheetGridSelectionStats = {
+    selectedCellCount: number;
+    selectedRowCount: number;
+    selectedColumnCount: number;
+};
+export type SpreadsheetGridDerivedSummary = {
+    rowSummaryText: string;
+    columnSummaryText: string;
+    filterSummaryText: string;
+    sortSummaryText: string;
+    activeCellLabel: string;
+    selectionLabel: string;
+    selectionStatsText: string;
+    selectionStats: SpreadsheetGridSelectionStats;
+    hasGlobalFilter: boolean;
+    globalFilterPreview: string | null;
+    activeColumnFilterCount: number;
+    hasAnyFilter: boolean;
+    hasSorting: boolean;
+    sortedColumnLabel: string | null;
+};
+export type SpreadsheetGridSlotContext<T> = {
+    rows: T[];
+    filteredRows: T[];
+    columns: GridColumn<T>[];
+    visibleColumns: GridColumn<T>[];
+    globalFilterText: string;
+    columnFilterValues: Record<string, ColumnFilterValue>;
+    sortState: GridSortState;
+    setGlobalFilterText: (value: string) => void;
+    activeCell: CellCoord | null;
+    selection: GridSelection;
+    derivedSummary: SpreadsheetGridDerivedSummary;
+};
+export type GridClassNames = {
+    root?: string;
+    toolbar?: string;
+    statusBar?: string;
+    headerRow?: string;
+    headerCell?: string;
+    bodyRow?: string;
+    bodyCell?: string;
+    rowHeaderCell?: string;
+    iconButton?: string;
+};
+export type SpreadsheetGridProps<T> = {
+    rows?: T[];
+    dataSource?: ServerSideDataSource<T>;
+    serverSideRefreshToken?: number;
+    columns: GridColumn<T>[];
+    onRowsChange?: (nextRows: T[]) => void;
+    onColumnsChange?: (nextColumns: GridColumn<T>[]) => void;
+    rowKeyGetter?: (row: T, index: number) => GridRowKey;
+    createRow?: () => T;
+    createOverflowColumn?: (columnIndex: number) => GridColumn<T>;
+    rowHeight?: number;
+    autoHeight?: boolean;
+    estimateRowHeight?: number;
+    headerHeight?: number;
+    rowHeaderWidth?: number;
+    readOnly?: boolean;
+    canEditCell?: (rowIndex: number, colIndex: number, row: T, column: GridColumn<T>) => boolean;
+    enableRangeSelection?: boolean;
+    enableGlobalFilter?: boolean;
+    enableColumnFilter?: boolean;
+    enableSorting?: boolean;
+    enableRowHover?: boolean;
+    enableColumnHeaderHover?: boolean;
+    enableColumnMenu?: boolean;
+    noMatchingRowsText?: string;
+    noRowsText?: string;
+    renderTopBar?: (context: SpreadsheetGridSlotContext<T>) => ReactNode;
+    renderBottomBar?: (context: SpreadsheetGridSlotContext<T>) => ReactNode;
+    className?: string;
+    classNames?: GridClassNames;
+    getRowClassName?: (row: T, rowIndex: number) => string | undefined;
+};