@ishibashi0112/spreadsheet-grid 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yuki Sakakibara
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,228 @@
+# @ishibashi0112/spreadsheet-grid
+
+[![npm version](https://img.shields.io/npm/v/@ishibashi0112/spreadsheet-grid.svg)](https://www.npmjs.com/package/@ishibashi0112/spreadsheet-grid)
+[![license](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
+
+A high-performance, virtualized spreadsheet / data grid for **React 19**, written in TypeScript.
+
+高性能な仮想化スプレッドシート／データグリッド（**React 19**・TypeScript 製）。
+
+**English** | [日本語](#日本語)
+
+---
+
+## Features
+
+- Scroll-space virtualization that handles up to ~1,000,000 rows.
+- Three-pane pinned columns (left / center / right) via sticky positioning.
+- Sorting, per-column filters (`text` / `number` / `date` / `select` / `set` / `custom`), and a global filter.
+- In-cell editing and clipboard copy / paste, with range selection and keyboard navigation.
+- Optional auto-height rows for wrapped, variable-height content.
+- Both **client-side** (`rows`) and **server-side** (`dataSource`, SSRM) row models.
+- Themeable with CSS custom properties (`--ssg-*`) and a low-priority `@layer ssg-base`, so your own CSS or Tailwind utilities override the defaults without specificity battles. `className` / `classNames` slots are also provided.
+- TypeScript-first, fully controlled API.
+
+## Installation
+
+```sh
+npm install @ishibashi0112/spreadsheet-grid
+# pnpm add @ishibashi0112/spreadsheet-grid
+# yarn add @ishibashi0112/spreadsheet-grid
+```
+
+Requires **react** and **react-dom** `>= 19` as peer dependencies (install them in your app if you have not already). `@tanstack/react-virtual` is a regular dependency and is installed automatically.
+
+## Styles
+
+The grid ships its CSS as a separate file. Import it once (for example, in your app entry):
+
+```ts
+import '@ishibashi0112/spreadsheet-grid/style.css'
+```
+
+The base styles live in `@layer ssg-base`, so any unlayered CSS or Tailwind utilities you write will win over the defaults.
+
+## Quick start
+
+```tsx
+import { useState } from 'react'
+import { SpreadsheetGrid, type GridColumn } from '@ishibashi0112/spreadsheet-grid'
+import '@ishibashi0112/spreadsheet-grid/style.css'
+
+type Row = { id: number; name: string; qty: number }
+
+const columns: GridColumn<Row>[] = [
+  { key: 'name', title: 'Name', width: 200, editable: true, filterType: 'text' },
+  { key: 'qty',  title: 'Qty',  width: 120, editable: true, filterType: 'number' },
+]
+
+export function Example() {
+  const [rows, setRows] = useState<Row[]>([
+    { id: 1, name: 'Apple',  qty: 3 },
+    { id: 2, name: 'Banana', qty: 5 },
+  ])
+
+  return (
+    <SpreadsheetGrid
+      rows={rows}
+      columns={columns}
+      onRowsChange={setRows}
+      rowKeyGetter={(row) => row.id}
+    />
+  )
+}
+```
+
+`rows` and `onRowsChange` make the grid a controlled component. A column needs at least `key` and `width`.
+
+## Server-side mode (SSRM)
+
+Pass a `dataSource` instead of `rows` to switch to server-side mode. The grid keeps the full scroll height for the total row count and fetches only the blocks near the viewport:
+
+```tsx
+<SpreadsheetGrid
+  columns={columns}
+  dataSource={{
+    async getRows({ startIndex, endIndex, query, signal }) {
+      // Apply `query` (filters / sort) on the server and return only [startIndex, endIndex).
+      const { rows, totalRowCount } = await fetchPage({ startIndex, endIndex, query, signal })
+      return { rows, totalRowCount }
+    },
+  }}
+/>
+```
+
+Sorting, column filters, and the global filter stay enabled and are forwarded to the server through `query`. See the [API reference](./src/components/spreadsheet-grid/API_REFERENCE.md) for the full `getRows` contract, the filter wire format, and `serverSideRefreshToken`.
+
+## Styling & theming
+
+- Override the CSS variables on `.ssg-root` (or scope them via the `className` prop):
+
+  ```css
+  .ssg-root {
+    --ssg-accent: #16a34a;
+    --ssg-radius: 4px;
+  }
+  ```
+
+- Use the `classNames` prop for per-part class slots, `cellClassName` per column, and `getRowClassName` per row. Because the defaults are in `@layer ssg-base`, your overrides apply without `!important`.
+
+## API reference
+
+The full prop and type reference lives in [`src/components/spreadsheet-grid/API_REFERENCE.md`](./src/components/spreadsheet-grid/API_REFERENCE.md).
+
+## License
+
+[MIT](./LICENSE) © 2026 Yuki Sakakibara
+
+---
+
+## 日本語
+
+[English](#ishibashi0112spreadsheet-grid)
+
+**React 19** 製の高性能な仮想化スプレッドシート／データグリッドです。TypeScript で書かれています。
+
+### 特徴
+
+- スクロール空間の仮想化により最大 100 万行規模に対応。
+- `position: sticky` による 3 ペイン固定列（左 / 中央 / 右）。
+- ソート、列ごとのフィルター（`text` / `number` / `date` / `select` / `set` / `custom`）、グローバルフィルター。
+- セル内編集とクリップボードのコピー／貼り付け、範囲選択、キーボード操作。
+- 折り返し・可変行高に対応する auto-height 行（任意）。
+- **クライアントサイド**（`rows`）と**サーバーサイド**（`dataSource`、SSRM）の両行モデル。
+- CSS カスタムプロパティ（`--ssg-*`）と優先度の低い `@layer ssg-base` によるテーマ設定。利用側の通常 CSS や Tailwind ユーティリティが特異度の競合なしに既定を上書きできます。`className` / `classNames` スロットも用意。
+- TypeScript ファースト、完全 controlled な API。
+
+### インストール
+
+```sh
+npm install @ishibashi0112/spreadsheet-grid
+# pnpm add @ishibashi0112/spreadsheet-grid
+# yarn add @ishibashi0112/spreadsheet-grid
+```
+
+peer 依存として **react** / **react-dom** `>= 19` が必要です（未導入なら利用側で入れてください）。`@tanstack/react-virtual` は通常依存として自動的に入ります。
+
+### スタイル
+
+CSS は別ファイルとして同梱されます。アプリのエントリ等で 1 度だけ import してください:
+
+```ts
+import '@ishibashi0112/spreadsheet-grid/style.css'
+```
+
+基底スタイルは `@layer ssg-base` にあるため、利用側が書く未レイヤーの CSS や Tailwind ユーティリティが既定に必ず勝ちます。
+
+### クイックスタート
+
+```tsx
+import { useState } from 'react'
+import { SpreadsheetGrid, type GridColumn } from '@ishibashi0112/spreadsheet-grid'
+import '@ishibashi0112/spreadsheet-grid/style.css'
+
+type Row = { id: number; name: string; qty: number }
+
+const columns: GridColumn<Row>[] = [
+  { key: 'name', title: '名前', width: 200, editable: true, filterType: 'text' },
+  { key: 'qty',  title: '数量', width: 120, editable: true, filterType: 'number' },
+]
+
+export function Example() {
+  const [rows, setRows] = useState<Row[]>([
+    { id: 1, name: 'りんご', qty: 3 },
+    { id: 2, name: 'バナナ', qty: 5 },
+  ])
+
+  return (
+    <SpreadsheetGrid
+      rows={rows}
+      columns={columns}
+      onRowsChange={setRows}
+      rowKeyGetter={(row) => row.id}
+    />
+  )
+}
+```
+
+`rows` と `onRowsChange` でグリッドは controlled になります。列には最低限 `key` と `width` が必要です。
+
+### サーバーサイドモード（SSRM）
+
+`rows` の代わりに `dataSource` を渡すとサーバーサイドモードになります。総行数ぶんのスクロール高さを保ったまま、可視窓に近いブロックだけを取得します:
+
+```tsx
+<SpreadsheetGrid
+  columns={columns}
+  dataSource={{
+    async getRows({ startIndex, endIndex, query, signal }) {
+      // query(フィルター/ソート)をサーバで適用し、[startIndex, endIndex) のみ返す。
+      const { rows, totalRowCount } = await fetchPage({ startIndex, endIndex, query, signal })
+      return { rows, totalRowCount }
+    },
+  }}
+/>
+```
+
+ソート・列フィルター・グローバルフィルターは有効なまま `query` 経由でサーバへ送られます。`getRows` の契約、フィルターの wire format、`serverSideRefreshToken` の詳細は [API リファレンス](./src/components/spreadsheet-grid/API_REFERENCE.md) を参照してください。
+
+### スタイリング / テーマ
+
+- `.ssg-root` 上で CSS 変数を上書きします（`className` prop でスコープも可能）:
+
+  ```css
+  .ssg-root {
+    --ssg-accent: #16a34a;
+    --ssg-radius: 4px;
+  }
+  ```
+
+- パーツ別の class は `classNames` prop、列単位は `cellClassName`、行単位は `getRowClassName` で付与できます。既定は `@layer ssg-base` にあるため、上書きに `!important` は不要です。
+
+### API リファレンス
+
+prop と型の完全なリファレンスは [`src/components/spreadsheet-grid/API_REFERENCE.md`](./src/components/spreadsheet-grid/API_REFERENCE.md) にあります。
+
+### ライセンス
+
+[MIT](./LICENSE) © 2026 Yuki Sakakibara

package/dist/ActiveCellOverlay.d.ts

@@ -0,0 +1,14 @@
+export type ActiveCellOverlayRect = {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+type ActiveCellOverlayProps = {
+    rect: ActiveCellOverlayRect | null;
+    headerHeight: number;
+    leadingWidth: number;
+    baseOffset?: number;
+};
+export declare function ActiveCellOverlay({ rect, headerHeight, leadingWidth, baseOffset, }: ActiveCellOverlayProps): import("react").JSX.Element | null;
+export default ActiveCellOverlay;

package/dist/CellEditorLayer.d.ts

@@ -0,0 +1,18 @@
+export type EditorCommitDirection = 'down' | 'right' | 'left';
+type CellEditorRect = {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+type CellEditorLayerProps = {
+    rect: CellEditorRect | null;
+    headerHeight: number;
+    leadingWidth: number;
+    baseOffset?: number;
+    initialValue: string;
+    onCommit: (value: string, direction?: EditorCommitDirection) => void;
+    onCancel: () => void;
+};
+export declare function CellEditorLayer({ rect, headerHeight, leadingWidth, baseOffset, initialValue, onCommit, onCancel, }: CellEditorLayerProps): import("react").JSX.Element | null;
+export default CellEditorLayer;

package/dist/SelectionOverlay.d.ts

@@ -0,0 +1,14 @@
+export type SelectionOverlayRect = {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+type SelectionOverlayProps = {
+    rect: SelectionOverlayRect | null;
+    headerHeight: number;
+    leadingWidth: number;
+    baseOffset?: number;
+};
+export declare function SelectionOverlay({ rect, headerHeight, leadingWidth, baseOffset, }: SelectionOverlayProps): import("react").JSX.Element | null;
+export default SelectionOverlay;

package/dist/SpreadsheetGrid.d.ts

@@ -0,0 +1,3 @@
+import './styles.css';
+import type { SpreadsheetGridProps } from './model/gridTypes';
+export declare function SpreadsheetGrid<T extends object>({ rows, dataSource, serverSideRefreshToken, columns, onRowsChange, onColumnsChange, rowKeyGetter, createRow, createOverflowColumn, rowHeight, autoHeight, estimateRowHeight, headerHeight, rowHeaderWidth, readOnly, canEditCell, enableRangeSelection, enableGlobalFilter, enableColumnFilter, enableSorting, enableRowHover, enableColumnHeaderHover, enableColumnMenu, noMatchingRowsText, noRowsText, renderTopBar, renderBottomBar, className, classNames, getRowClassName, }: SpreadsheetGridProps<T>): import("react").JSX.Element;

package/dist/hooks/useColumnAutosizeRunner.d.ts

@@ -0,0 +1,16 @@
+import { gridActions } from '../model/gridActions';
+import type { GridColumn, RowModel } from '../model/gridTypes';
+type ReadonlyRef<V> = {
+    readonly current: V;
+};
+type UseColumnAutosizeRunnerArgs<T> = {
+    rowModelRef: ReadonlyRef<RowModel<T>>;
+    gridRootRef: ReadonlyRef<HTMLElement | null>;
+    columnWidthsRef: ReadonlyRef<Record<string, number>>;
+    dispatch: (action: ReturnType<typeof gridActions.syncColumnWidths>) => void;
+};
+export declare const useColumnAutosizeRunner: <T>({ rowModelRef, gridRootRef, columnWidthsRef, dispatch, }: UseColumnAutosizeRunnerArgs<T>) => {
+    isAutosizing: boolean;
+    runAutosize: (columns: GridColumn<T>[]) => Promise<void>;
+};
+export default useColumnAutosizeRunner;

package/dist/hooks/useColumnChooserController.d.ts

@@ -0,0 +1,18 @@
+import { type RefObject } from 'react';
+export type ColumnChooserLayout = {
+    top: number;
+    left: number;
+    width: number;
+};
+type UseColumnChooserControllerArgs = {
+    enableColumnMenu: boolean;
+    gridRootRef: RefObject<HTMLDivElement | null>;
+};
+export declare const useColumnChooserController: ({ enableColumnMenu, gridRootRef, }: UseColumnChooserControllerArgs) => {
+    isColumnChooserOpen: boolean;
+    columnChooserLayout: ColumnChooserLayout | null;
+    columnChooserRef: RefObject<HTMLDivElement | null>;
+    openColumnChooser: () => void;
+    closeColumnChooser: () => void;
+};
+export default useColumnChooserController;

package/dist/hooks/useColumnHeaderDragController.d.ts

@@ -0,0 +1,24 @@
+import { type PointerEvent, type RefObject } from 'react';
+import type { GridColumn, GridColumnPinned } from '../model/gridTypes';
+import { type GridPaneLayout } from '../logic/geometry';
+type ApplyColumnOrderAndPin = (orderedKeys: string[], pinOverride?: Map<string, GridColumnPinned | undefined>) => void;
+type UseColumnHeaderDragControllerArgs<T> = {
+    enabled: boolean;
+    columns: GridColumn<T>[];
+    paneLayout: GridPaneLayout<T>;
+    leftPaneScrollRef: RefObject<HTMLDivElement | null>;
+    rightPaneScrollRef: RefObject<HTMLDivElement | null>;
+    bodyScrollRef: RefObject<HTMLDivElement | null>;
+    scrollContainerRef: RefObject<HTMLDivElement | null>;
+    leftLeadingWidth: number;
+    centerLeadingWidth: number;
+    rightLeadingWidth: number;
+    applyColumnOrderAndPin: ApplyColumnOrderAndPin;
+};
+export declare const useColumnHeaderDragController: <T>(args: UseColumnHeaderDragControllerArgs<T>) => {
+    onColumnDragHandlePointerDown: (column: GridColumn<T>, event: PointerEvent<HTMLElement>) => void;
+    leftIndicatorRef: RefObject<HTMLDivElement | null>;
+    centerIndicatorRef: RefObject<HTMLDivElement | null>;
+    rightIndicatorRef: RefObject<HTMLDivElement | null>;
+};
+export default useColumnHeaderDragController;

package/dist/hooks/useColumnMenuController.d.ts

@@ -0,0 +1,23 @@
+import { type MouseEvent, type PointerEvent, type RefObject } from 'react';
+import type { GridColumn } from '../model/gridTypes';
+export type ColumnMenuLayout = {
+    top: number;
+    left: number;
+    width: number;
+};
+type UseColumnMenuControllerArgs<T> = {
+    visibleColumns: GridColumn<T>[];
+    enableColumnMenu: boolean;
+    gridRootRef: RefObject<HTMLDivElement | null>;
+};
+export declare const useColumnMenuController: <T>({ visibleColumns, enableColumnMenu, gridRootRef, }: UseColumnMenuControllerArgs<T>) => {
+    columnMenuLayout: ColumnMenuLayout | null;
+    columnMenuRef: RefObject<HTMLDivElement | null>;
+    isColumnMenuOpen: boolean;
+    openedMenuColumnKey: string | null;
+    openedMenuColumn: GridColumn<T> | null;
+    openColumnMenuFromButton: (column: GridColumn<T>, event: PointerEvent<HTMLButtonElement>) => void;
+    openColumnMenuFromContextMenu: (column: GridColumn<T>, event: MouseEvent<HTMLDivElement>) => void;
+    closeColumnMenu: () => void;
+};
+export default useColumnMenuController;

package/dist/hooks/useColumnSelectOptionsCollector.d.ts

@@ -0,0 +1,18 @@
+import type { GridColumn } from '../model/gridTypes';
+import { type SelectOptionEntry } from '../logic/selectOptions';
+export declare const ASYNC_SELECT_COLLECT_ROW_THRESHOLD = 50000;
+export type ColumnSelectOptionsStatus = 'idle' | 'collecting' | 'ready';
+export type ColumnSelectOptionsResult = {
+    status: ColumnSelectOptionsStatus;
+    options: SelectOptionEntry[];
+    allValues: ReadonlySet<string>;
+    progress: number;
+};
+type RawValueAccessor = (index: number) => unknown;
+type UseColumnSelectOptionsCollectorArgs<T> = {
+    column: GridColumn<T> | null;
+    rowCount: number;
+    getRawValueAt: RawValueAccessor;
+};
+export declare const useColumnSelectOptionsCollector: <T>({ column, rowCount, getRawValueAt, }: UseColumnSelectOptionsCollectorArgs<T>) => ColumnSelectOptionsResult;
+export default useColumnSelectOptionsCollector;

package/dist/hooks/useFilterPopoverController.d.ts

@@ -0,0 +1,30 @@
+import { type PointerEvent, type RefObject } from 'react';
+import type { ColumnFilterValue, GridColumn } from '../model/gridTypes';
+type HeaderFilterPopoverState = {
+    columnKey: string;
+    draftValue: string;
+};
+export type FilterPopoverLayout = {
+    top: number;
+    left: number;
+    width: number;
+};
+type UseFilterPopoverControllerArgs<T> = {
+    visibleColumns: GridColumn<T>[];
+    columnFilterValues: Record<string, ColumnFilterValue>;
+    enableColumnFilter: boolean;
+    gridRootRef: RefObject<HTMLDivElement | null>;
+};
+export declare const useFilterPopoverController: <T>({ visibleColumns, columnFilterValues, enableColumnFilter, gridRootRef, }: UseFilterPopoverControllerArgs<T>) => {
+    filterPopoverState: HeaderFilterPopoverState | null;
+    filterPopoverLayout: FilterPopoverLayout | null;
+    filterPopoverRef: RefObject<HTMLDivElement | null>;
+    filterTextInputRef: RefObject<HTMLInputElement | null>;
+    filterSelectRef: RefObject<HTMLSelectElement | null>;
+    isFilterPopoverOpen: boolean;
+    openedFilterColumn: GridColumn<T> | null;
+    openColumnFilterPopover: (column: GridColumn<T>, event: PointerEvent<HTMLButtonElement>) => void;
+    closeColumnFilterPopover: () => void;
+    updateFilterPopoverDraft: (value: string) => void;
+};
+export default useFilterPopoverController;

package/dist/hooks/useGridBarContext.d.ts

@@ -0,0 +1,17 @@
+import type { GridColumn, GridUiState, SpreadsheetGridSlotContext } from '../model/gridTypes';
+type GridSlotContextBase<T> = Omit<SpreadsheetGridSlotContext<T>, 'setGlobalFilterText' | 'derivedSummary' | 'filteredRows'>;
+type UseGridBarContextArgs<T> = {
+    rows: T[];
+    viewRowCount: number;
+    getFilteredRows: () => T[];
+    columns: GridColumn<T>[];
+    visibleColumns: GridColumn<T>[];
+    uiState: GridUiState;
+    setGlobalFilterText: (value: string) => void;
+};
+export declare const useGridBarContext: <T>({ rows, viewRowCount, getFilteredRows, columns, visibleColumns, uiState, setGlobalFilterText, }: UseGridBarContextArgs<T>) => {
+    slotContextBase: GridSlotContextBase<T>;
+    derivedSummary: import("..").SpreadsheetGridDerivedSummary;
+    slotContext: SpreadsheetGridSlotContext<T>;
+};
+export default useGridBarContext;

package/dist/hooks/useGridClipboardController.d.ts

@@ -0,0 +1,22 @@
+import { type Dispatch } from 'react';
+import { type GridUiAction } from '../model/gridActions';
+import type { GridColumn, SpreadsheetGridProps, GridUiState, RowModel } from '../model/gridTypes';
+type UseGridClipboardControllerArgs<T extends object> = {
+    rows: T[];
+    rowModel: RowModel<T>;
+    visibleColumns: GridColumn<T>[];
+    uiState: GridUiState;
+    readOnly: boolean;
+    canEditCell: SpreadsheetGridProps<T>['canEditCell'];
+    createRow?: () => T;
+    createOverflowColumn?: (columnIndex: number) => GridColumn<T>;
+    onRowsChange?: (nextRows: T[]) => void;
+    onColumnsChange?: (nextColumns: GridColumn<T>[]) => void;
+    dispatch: Dispatch<GridUiAction>;
+};
+export declare const useGridClipboardController: <T extends object>({ rows, rowModel, visibleColumns, uiState, readOnly, canEditCell, createRow, createOverflowColumn, onRowsChange, onColumnsChange, dispatch, }: UseGridClipboardControllerArgs<T>) => {
+    isWholeGridSelected: boolean;
+    handleCopy: () => Promise<void>;
+    handlePaste: (event: React.ClipboardEvent<HTMLDivElement>) => void;
+};
+export default useGridClipboardController;

package/dist/hooks/useGridEditController.d.ts

@@ -0,0 +1,23 @@
+import { type Dispatch, type RefObject } from 'react';
+import { type GridUiAction } from '../model/gridActions';
+import type { CellCoord, GridColumn, GridUiState, RowModel } from '../model/gridTypes';
+import type { EditorCommitDirection } from '../CellEditorLayer';
+type UseGridEditControllerArgs<T extends object> = {
+    uiState: GridUiState;
+    rows: T[];
+    visibleColumns: GridColumn<T>[];
+    rowModel: RowModel<T>;
+    setEditorInitialValue: (value: string) => void;
+    onRowsChange?: (nextRows: T[]) => void;
+    dispatch: Dispatch<GridUiAction>;
+    getMovedCell: (baseCell: CellCoord, deltaRow: number, deltaCol: number) => CellCoord;
+    gridRootRef: RefObject<HTMLDivElement | null>;
+    editorActionGuardRef: RefObject<boolean>;
+};
+export declare const useGridEditController: <T extends object>({ uiState, rows, visibleColumns, rowModel, setEditorInitialValue, onRowsChange, dispatch, getMovedCell, gridRootRef, editorActionGuardRef, }: UseGridEditControllerArgs<T>) => {
+    activateSingleCell: (cell: CellCoord) => void;
+    startEditWithValue: (cell: CellCoord, initialValue: string) => void;
+    commitEdit: (committedValue: string, direction?: EditorCommitDirection) => void;
+    cancelEdit: () => void;
+};
+export default useGridEditController;

package/dist/hooks/useGridKeyboardInteractions.d.ts

@@ -0,0 +1,21 @@
+import { type Dispatch, type KeyboardEvent } from 'react';
+import { type GridUiAction } from '../model/gridActions';
+import type { CellCoord, GridColumn, GridUiState, RowModel, SpreadsheetGridProps } from '../model/gridTypes';
+type UseGridKeyboardInteractionsArgs<T> = {
+    uiState: GridUiState;
+    rowModel: RowModel<T>;
+    visibleColumns: GridColumn<T>[];
+    readOnly: boolean;
+    canEditCell: SpreadsheetGridProps<T>['canEditCell'];
+    setEditorInitialValue: (value: string) => void;
+    dispatch: Dispatch<GridUiAction>;
+    handleCopy: () => Promise<void>;
+    handleCellDoubleClick: (cell: CellCoord) => void;
+    isWholeGridSelected: boolean;
+    selectEntireGrid: () => void;
+};
+export declare const useGridKeyboardInteractions: <T>({ uiState, rowModel, visibleColumns, readOnly, canEditCell, setEditorInitialValue, dispatch, handleCopy, handleCellDoubleClick, isWholeGridSelected, selectEntireGrid, }: UseGridKeyboardInteractionsArgs<T>) => {
+    getMovedCell: (baseCell: CellCoord, deltaRow: number, deltaCol: number) => CellCoord;
+    handleKeyDown: (event: KeyboardEvent<HTMLDivElement>) => Promise<void>;
+};
+export default useGridKeyboardInteractions;

package/dist/hooks/useGridPointerInteractions.d.ts

@@ -0,0 +1,46 @@
+import { type Dispatch, type PointerEvent, type RefObject } from 'react';
+import { type GridUiAction } from '../model/gridActions';
+import type { CellCoord, GridColumn, GridUiState } from '../model/gridTypes';
+import { type GridPaneLayout } from '../logic/geometry';
+import type { RowMetrics } from '../logic/verticalGeometry';
+type UseGridPointerInteractionsArgs<T> = {
+    gridRootRef: RefObject<HTMLDivElement | null>;
+    bodyScrollRef: RefObject<HTMLDivElement | null>;
+    scrollContainerRef: RefObject<HTMLDivElement | null>;
+    leftPaneScrollRef: RefObject<HTMLDivElement | null>;
+    rightPaneScrollRef: RefObject<HTMLDivElement | null>;
+    pointerClientRef: RefObject<{
+        x: number;
+        y: number;
+    } | null>;
+    autoScrollFrameRef: RefObject<number | null>;
+    uiState: GridUiState;
+    dispatch: Dispatch<GridUiAction>;
+    enableRangeSelection: boolean;
+    enableSorting: boolean;
+    orderedColumns: GridColumn<T>[];
+    filteredRowsLength: number;
+    visibleColumnsLength: number;
+    paneLayout: GridPaneLayout<T>;
+    leftLeadingWidth: number;
+    centerLeadingWidth: number;
+    rightLeadingWidth: number;
+    headerHeight: number;
+    rowMetrics: RowMetrics;
+    verticalScaleFactor: number;
+    setHoveredRowIndex: (value: number | null) => void;
+    setHoveredColumnIndex: (value: number | null) => void;
+    enableRowHover: boolean;
+    enableColumnHeaderHover: boolean;
+};
+export declare const useGridPointerInteractions: <T>({ gridRootRef, bodyScrollRef, scrollContainerRef, leftPaneScrollRef, rightPaneScrollRef, pointerClientRef, autoScrollFrameRef, uiState, dispatch, enableRangeSelection, enableSorting, orderedColumns, filteredRowsLength, visibleColumnsLength, paneLayout, leftLeadingWidth, centerLeadingWidth, rightLeadingWidth, headerHeight, rowMetrics, verticalScaleFactor, setHoveredRowIndex, setHoveredColumnIndex, enableRowHover, enableColumnHeaderHover, }: UseGridPointerInteractionsArgs<T>) => {
+    updateSelectionFromPointer: (clientX: number, clientY: number) => void;
+    handleCellPointerDown: (cell: CellCoord, event: PointerEvent<HTMLDivElement>) => void;
+    handleCellPointerEnter: (cell: CellCoord, event: PointerEvent<HTMLDivElement>) => void;
+    handleNativeDragStart: (event: React.DragEvent<HTMLDivElement>) => void;
+    handleRowHeaderPointerDown: (rowIndex: number, event: PointerEvent<HTMLDivElement>) => void;
+    handleRowHeaderPointerEnter: (rowIndex: number, event: PointerEvent<HTMLDivElement>) => void;
+    handleColumnHeaderPointerDown: (colIndex: number, event: PointerEvent<HTMLDivElement>) => void;
+    handleColumnHeaderPointerEnter: (colIndex: number, event: PointerEvent<HTMLDivElement>) => void;
+};
+export default useGridPointerInteractions;

package/dist/hooks/useGridViewportSync.d.ts

@@ -0,0 +1,21 @@
+import { type RefObject } from 'react';
+import type { ActiveCellOverlayRect } from '../ActiveCellOverlay';
+import type { ColumnMeasurement } from '../logic/geometry';
+type VirtualizerLike = {
+    measure: () => void;
+};
+type UseGridViewportSyncArgs<T> = {
+    scrollRef: RefObject<HTMLDivElement | null>;
+    columnVirtualizer: VirtualizerLike;
+    columnMeasurements: ColumnMeasurement<T>[];
+    totalScrollWidth: number;
+    physicalBodyHeight: number;
+    headerHeight: number;
+    leftPaneWidth: number;
+    rightPaneWidth: number;
+    centerLeadingWidth: number;
+    activeCellRect: ActiveCellOverlayRect | null;
+    verticalScaleFactor: number;
+};
+export declare const useGridViewportSync: <T>({ scrollRef, columnVirtualizer, columnMeasurements, totalScrollWidth, physicalBodyHeight, headerHeight, leftPaneWidth, rightPaneWidth, centerLeadingWidth, activeCellRect, verticalScaleFactor, }: UseGridViewportSyncArgs<T>) => void;
+export default useGridViewportSync;

package/dist/hooks/useServerSideRowModel.d.ts

@@ -0,0 +1,16 @@
+import type { GridRowKey, RowModel, ServerSideDataSource, ServerSideQuery } from '../model/gridTypes';
+export type UseServerSideRowModelParams<T> = {
+    dataSource?: ServerSideDataSource<T>;
+    rowKeyGetter: (row: T, index: number) => GridRowKey;
+    query: ServerSideQuery;
+    queryKey: string;
+    refreshToken?: number;
+    debounceMs?: number;
+};
+export type UseServerSideRowModelResult<T> = {
+    rowModel: RowModel<T>;
+    rowCount: number;
+    isRowLoaded: (viewIndex: number) => boolean;
+    requestRange: (startIndex: number, endIndex: number) => void;
+};
+export declare function useServerSideRowModel<T>(params: UseServerSideRowModelParams<T>): UseServerSideRowModelResult<T>;

package/dist/hooks/useSortManagementController.d.ts

@@ -0,0 +1,18 @@
+import { type RefObject } from 'react';
+export type SortManagementLayout = {
+    top: number;
+    left: number;
+    width: number;
+};
+type UseSortManagementControllerArgs = {
+    enableSorting: boolean;
+    gridRootRef: RefObject<HTMLDivElement | null>;
+};
+export declare const useSortManagementController: ({ enableSorting, gridRootRef, }: UseSortManagementControllerArgs) => {
+    isSortManagerOpen: boolean;
+    sortManagerLayout: SortManagementLayout | null;
+    sortManagerRef: RefObject<HTMLDivElement | null>;
+    openSortManager: () => void;
+    closeSortManager: () => void;
+};
+export default useSortManagementController;