@ishibashi0112/spreadsheet-grid 0.35.0 → 0.37.0

package/dist/controllers/viewportSyncController.d.ts

@@ -0,0 +1,30 @@
+import type { ColumnMeasurement } from '../logic/geometry';
+import type { CellCoord } from '../model/gridTypes.core';
+export type ViewportCellRect = {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+export type ViewportSyncArgs<T> = {
+    scrollElement: HTMLElement | null;
+    columnVirtualizer: {
+        measure: () => void;
+    };
+    columnMeasurements: ColumnMeasurement<T>[];
+    totalScrollWidth: number;
+    physicalBodyHeight: number;
+    headerHeight: number;
+    leftPaneWidth: number;
+    rightPaneWidth: number;
+    centerLeadingWidth: number;
+    activeCellRect: ViewportCellRect | null;
+    activeCell: CellCoord | null;
+    verticalScaleFactor: number;
+};
+export type ViewportSyncController<T> = {
+    update: (args: ViewportSyncArgs<T>) => void;
+};
+export declare const clampScrollToContent: (scrollElement: HTMLElement, args: Pick<ViewportSyncArgs<unknown>, "totalScrollWidth" | "physicalBodyHeight" | "headerHeight">) => void;
+export declare const scrollCellIntoView: (scrollElement: HTMLElement, rect: ViewportCellRect, args: Pick<ViewportSyncArgs<unknown>, "headerHeight" | "leftPaneWidth" | "rightPaneWidth" | "centerLeadingWidth" | "verticalScaleFactor">) => void;
+export declare const createViewportSyncController: <T>() => ViewportSyncController<T>;

package/dist/hooks/useCellContextMenuController.d.ts

@@ -1,23 +1,17 @@
 import { type RefObject } from 'react';
-import type { GridContextMenuItem, GridContextMenuParams } from '../model/gridTypes';
-export type CellContextMenuLayout = {
-    top: number;
-    left: number;
-    width: number;
-};
-type CellContextMenuState<T> = {
-    params: GridContextMenuParams<T>;
-    items: GridContextMenuItem[];
-};
+import { type CellContextMenuLayout } from '../controllers/contextMenuController';
+export type { CellContextMenuLayout } from '../controllers/contextMenuController';
 type UseCellContextMenuControllerArgs = {
     gridRootRef: RefObject<HTMLDivElement | null>;
 };
 export declare const useCellContextMenuController: <T>({ gridRootRef, }: UseCellContextMenuControllerArgs) => {
-    contextMenuState: CellContextMenuState<T> | null;
+    contextMenuState: import("../controllers/contextMenuController").CellContextMenuState<T> | null;
     contextMenuLayout: CellContextMenuLayout | null;
-    contextMenuRef: RefObject<HTMLDivElement | null>;
+    contextMenuRef: {
+        current: HTMLDivElement | null;
+    };
     isContextMenuOpen: boolean;
-    openContextMenu: (params: GridContextMenuParams<T>, items: GridContextMenuItem[]) => void;
+    openContextMenu: (params: import("..").GridContextMenuParams<T>, items: import("..").GridContextMenuItem[]) => void;
     closeContextMenu: () => void;
 };
 export default useCellContextMenuController;

package/dist/hooks/useColumnAutosizeRunner.d.ts

@@ -1,16 +1,6 @@
-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>) => {
+import { type ColumnAutosizeRunnerArgs } from '../controllers/columnAutosizeRunner';
+export declare const useColumnAutosizeRunner: <T>(args: ColumnAutosizeRunnerArgs<T>) => {
     isAutosizing: boolean;
-    runAutosize: (columns: GridColumn<T>[]) => Promise<void>;
+    runAutosize: (columns: import("..").GridColumn<T>[]) => Promise<void>;
 };
 export default useColumnAutosizeRunner;

package/dist/hooks/useColumnHeaderDragController.d.ts

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

package/dist/hooks/useColumnMenuController.d.ts

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

package/dist/hooks/useColumnSelectOptionsCollector.d.ts

@@ -1,14 +1,6 @@
 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;
+import { type ColumnSelectOptionsResult, type RawValueAccessor } from '../controllers/selectOptionsCollector';
+export { ASYNC_SELECT_COLLECT_ROW_THRESHOLD, type ColumnSelectOptionsResult, type ColumnSelectOptionsStatus, } from '../controllers/selectOptionsCollector';
 type UseColumnSelectOptionsCollectorArgs<T> = {
     column: GridColumn<T> | null;
     rowCount: number;

package/dist/hooks/useController.d.ts

@@ -0,0 +1,5 @@
+export type ControllerLike<Args> = {
+    update: (args: Args) => void;
+    dispose?: () => void;
+};
+export declare function useController<Args, C extends ControllerLike<Args>>(create: () => C, args: Args): C;

package/dist/hooks/useFilterPopoverController.d.ts

@@ -1,22 +1,7 @@
 import { type RefObject } from 'react';
 import type { ColumnFilterUiType, ColumnFilterValue, GridColumn } from '../model/gridTypes';
-import { type NumberFilterConditionDraft } from '../logic/numberFilterCondition';
-import { type TextFilterConditionDraft } from '../logic/textFilterCondition';
-import { type DateFilterConditionDraft } from '../logic/dateFilterCondition';
-type HeaderFilterPopoverState = {
-    columnKey: string;
-    filterType: ColumnFilterUiType;
-    draftValue: string;
-    numberDraft: NumberFilterConditionDraft | null;
-    textDraft: TextFilterConditionDraft | null;
-    dateDraft: DateFilterConditionDraft | null;
-};
-export type FilterPopoverLayout = {
-    top: number;
-    left: number;
-    width: number;
-    maxHeight: number;
-};
+import { type FilterPopoverLayout } from '../controllers/filterPopoverController';
+export type { FilterPopoverLayout } from '../controllers/filterPopoverController';
 type UseFilterPopoverControllerArgs<T> = {
     visibleColumns: GridColumn<T>[];
     columnFilterValues: Record<string, ColumnFilterValue>;
@@ -24,20 +9,26 @@ type UseFilterPopoverControllerArgs<T> = {
     gridRootRef: RefObject<HTMLDivElement | null>;
     resolveColumnFilterType?: (column: GridColumn<T>) => ColumnFilterUiType;
 };
-export declare const useFilterPopoverController: <T>({ visibleColumns, columnFilterValues, enableColumnFilter, gridRootRef, resolveColumnFilterType, }: UseFilterPopoverControllerArgs<T>) => {
-    filterPopoverState: HeaderFilterPopoverState | null;
+export declare const useFilterPopoverController: <T>(args: UseFilterPopoverControllerArgs<T>) => {
+    filterPopoverState: import("../controllers/filterPopoverController").HeaderFilterPopoverState | null;
     filterPopoverLayout: FilterPopoverLayout | null;
-    filterPopoverRef: RefObject<HTMLDivElement | null>;
-    filterTextInputRef: RefObject<HTMLInputElement | null>;
-    filterSelectRef: RefObject<HTMLSelectElement | null>;
+    filterPopoverRef: {
+        current: HTMLDivElement | null;
+    };
+    filterTextInputRef: {
+        current: HTMLInputElement | null;
+    };
+    filterSelectRef: {
+        current: HTMLSelectElement | null;
+    };
     isFilterPopoverOpen: boolean;
     openedFilterColumn: GridColumn<T> | null;
     openedFilterType: ColumnFilterUiType | null;
     openColumnFilterPopover: (column: GridColumn<T>) => void;
     closeColumnFilterPopover: () => void;
     updateFilterPopoverDraft: (value: string) => void;
-    updateFilterPopoverNumberDraft: (draft: NumberFilterConditionDraft) => void;
-    updateFilterPopoverTextDraft: (draft: TextFilterConditionDraft) => void;
-    updateFilterPopoverDateDraft: (draft: DateFilterConditionDraft) => void;
+    updateFilterPopoverNumberDraft: (draft: import("../logic/numberFilterCondition").NumberFilterConditionDraft) => void;
+    updateFilterPopoverTextDraft: (draft: import("../logic/textFilterCondition").TextFilterConditionDraft) => void;
+    updateFilterPopoverDateDraft: (draft: import("../logic/dateFilterCondition").DateFilterConditionDraft) => void;
 };
 export default useFilterPopoverController;

package/dist/hooks/useGlobalFilteredOrder.d.ts

@@ -1,11 +1,7 @@
-import type { GlobalFilterStatus, GridColumn } from '../model/gridTypes';
-import { type RowOrder } from '../logic/filtering';
-export declare const ASYNC_GLOBAL_FILTER_ROW_THRESHOLD = 50000;
-export type GlobalFilteredOrderResult = {
-    order: RowOrder;
-    status: GlobalFilterStatus;
-    progress: number;
-};
+import type { GridColumn } from '../model/gridTypes';
+import { type GlobalFilteredOrderResult } from '../controllers/globalFilteredOrder';
+import type { RowOrder } from '../logic/filtering';
+export { ASYNC_GLOBAL_FILTER_ROW_THRESHOLD, type GlobalFilteredOrderResult, } from '../controllers/globalFilteredOrder';
 type UseGlobalFilteredOrderArgs<T> = {
     rows: T[];
     baseOrder: RowOrder;

package/dist/hooks/useGridClipboardController.d.ts

@@ -1,25 +1,8 @@
-import { type Dispatch } from 'react';
-import { type GridUiAction } from '../model/gridActions';
-import type { GridColumn, SpreadsheetGridProps, GridUiState, RowModel } from '../model/gridTypes';
-import type { ServerSideCellEditInput } from '../logic/serverSideEdits';
-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;
-    applyServerSideCellEdits?: (edits: ServerSideCellEditInput<T>[]) => number;
-    isRowExportable?: SpreadsheetGridProps<T>['isRowExportable'];
-    dispatch: Dispatch<GridUiAction>;
-};
-export declare const useGridClipboardController: <T extends object>({ rows, rowModel, visibleColumns, uiState, readOnly, canEditCell, createRow, createOverflowColumn, onRowsChange, onColumnsChange, applyServerSideCellEdits, isRowExportable, dispatch, }: UseGridClipboardControllerArgs<T>) => {
+import { type ClipboardEvent } from 'react';
+import { type ClipboardControllerArgs } from '../controllers/clipboardController';
+export declare const useGridClipboardController: <T extends object>(args: ClipboardControllerArgs<T>) => {
     isWholeGridSelected: boolean;
     handleCopy: () => Promise<void>;
-    handlePaste: (event: React.ClipboardEvent<HTMLDivElement>) => void;
+    handlePaste: (event: ClipboardEvent<HTMLDivElement>) => void;
 };
 export default useGridClipboardController;

package/dist/hooks/useGridEditController.d.ts

@@ -1,23 +1,8 @@
-import { type Dispatch, type RefObject } from 'react';
-import { type GridUiAction } from '../model/gridActions';
-import type { CellCoord, EditorCommitDirection, EditorCommitResult, GridColumn, GridUiState, RowModel } from '../model/gridTypes';
-import type { ServerSideCellEditInput } from '../logic/serverSideEdits';
-type UseGridEditControllerArgs<T extends object> = {
-    uiState: GridUiState;
-    rows: T[];
-    visibleColumns: GridColumn<T>[];
-    rowModel: RowModel<T>;
-    setEditorInitialValue: (value: string) => void;
-    onRowsChange?: (nextRows: T[]) => void;
-    applyServerSideCellEdits?: (edits: ServerSideCellEditInput<T>[]) => number;
-    dispatch: Dispatch<GridUiAction>;
-    gridRootRef: RefObject<HTMLDivElement | null>;
-    editorActionGuardRef: RefObject<boolean>;
-};
-export declare const useGridEditController: <T extends object>({ uiState, rows, visibleColumns, rowModel, setEditorInitialValue, onRowsChange, applyServerSideCellEdits, dispatch, gridRootRef, editorActionGuardRef, }: UseGridEditControllerArgs<T>) => {
-    activateSingleCell: (cell: CellCoord) => void;
-    startEditWithValue: (cell: CellCoord, initialValue: string) => void;
-    commitEdit: (committedValue: unknown, direction?: EditorCommitDirection) => EditorCommitResult;
+import { type EditControllerArgs } from '../controllers/editController';
+export declare const useGridEditController: <T extends object>(args: EditControllerArgs<T>) => {
+    activateSingleCell: (cell: import("..").CellCoord) => void;
+    startEditWithValue: (cell: import("..").CellCoord, initialValue: string) => void;
+    commitEdit: (committedValue: unknown, direction?: import("..").EditorCommitDirection) => import("..").EditorCommitResult;
     cancelEdit: () => void;
 };
 export default useGridEditController;

package/dist/hooks/useGridHistoryController.d.ts

@@ -1,18 +1,5 @@
-import type { Dispatch } from 'react';
-import { type GridUiAction } from '../model/gridActions';
-import type { CellCoord, GridSelection, UndoRedoState } from '../model/gridTypes';
-type UseGridHistoryControllerArgs<T> = {
-    rows: T[];
-    selection: GridSelection;
-    activeCell: CellCoord | null;
-    onRowsChange?: (nextRows: T[]) => void;
-    dispatch: Dispatch<GridUiAction>;
-    enabled: boolean;
-    limit: number;
-    onUndoRedoStateChange?: (state: UndoRedoState) => void;
-    onAfterRestore?: (activeCell: CellCoord | null) => void;
-};
-export declare const useGridHistoryController: <T>({ rows, selection, activeCell, onRowsChange, dispatch, enabled, limit, onUndoRedoStateChange, onAfterRestore, }: UseGridHistoryControllerArgs<T>) => {
+import { type HistoryControllerArgs } from '../controllers/historyController';
+export declare const useGridHistoryController: <T>(args: HistoryControllerArgs<T>) => {
     handleRowsChange: ((nextRows: T[]) => void) | undefined;
     undo: () => void;
     redo: () => void;

package/dist/hooks/useGridKeyboardInteractions.d.ts

@@ -1,26 +1,6 @@
-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;
-    onUndo: () => void;
-    onRedo: () => void;
-    onClearSelection: () => void;
-    enableClearOnDelete: boolean;
-    onToggleCheckboxCell: (cell: CellCoord) => void;
-    onToggleGroup: (groupKey: string) => void;
-};
-export declare const useGridKeyboardInteractions: <T>({ uiState, rowModel, visibleColumns, readOnly, canEditCell, setEditorInitialValue, dispatch, handleCopy, handleCellDoubleClick, isWholeGridSelected, selectEntireGrid, onUndo, onRedo, onClearSelection, enableClearOnDelete, onToggleCheckboxCell, onToggleGroup, }: UseGridKeyboardInteractionsArgs<T>) => {
+import { type KeyboardEvent } from 'react';
+import { type KeyboardControllerArgs } from '../controllers/keyboardController';
+export declare const useGridKeyboardInteractions: <T>(args: KeyboardControllerArgs<T>) => {
     handleKeyDown: (event: KeyboardEvent<HTMLDivElement>) => Promise<void>;
 };
 export default useGridKeyboardInteractions;

package/dist/hooks/useGridPointerInteractions.d.ts

@@ -1,11 +1,8 @@
-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';
-export declare const TOUCH_TAP_SLOP_PX = 10;
-export declare const TOUCH_DOUBLE_TAP_MS = 300;
-type UseGridPointerInteractionsArgs<T> = {
+import type { RefObject } from 'react';
+import type { CellCoord } from '../model/gridTypes';
+import { type PointerInteractionsArgs } from '../controllers/pointerInteractionsController';
+export { TOUCH_DOUBLE_TAP_MS, TOUCH_TAP_SLOP_PX, } from '../controllers/pointerInteractionsController';
+type UseGridPointerInteractionsArgs<T> = Omit<PointerInteractionsArgs<T>, 'gridRootRef' | 'bodyScrollRef' | 'scrollContainerRef' | 'leftPaneScrollRef' | 'rightPaneScrollRef' | 'pointerClientRef' | 'autoScrollFrameRef' | 'onCellDoubleClickRef'> & {
     gridRootRef: RefObject<HTMLDivElement | null>;
     bodyScrollRef: RefObject<HTMLDivElement | null>;
     scrollContainerRef: RefObject<HTMLDivElement | null>;
@@ -16,40 +13,19 @@ type UseGridPointerInteractionsArgs<T> = {
         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;
-    enableRowSelection: boolean;
-    onGutterRowSelect: (viewIndex: number, opts: {
-        shiftKey: boolean;
-    }) => void;
-    onGutterRowSelectDrag: (viewIndex: number) => void;
     onCellDoubleClickRef: RefObject<(cell: CellCoord) => void>;
 };
-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, enableRowSelection, onGutterRowSelect, onGutterRowSelectDrag, onCellDoubleClickRef, }: UseGridPointerInteractionsArgs<T>) => {
+export declare const useGridPointerInteractions: <T>(args: UseGridPointerInteractionsArgs<T>) => {
     updateSelectionFromPointer: (clientX: number, clientY: number) => void;
-    handleCellPointerDown: (cell: CellCoord, event: PointerEvent<HTMLDivElement>) => void;
+    handleCellPointerDown: (cell: CellCoord, event: import("../controllers/pointerInteractionsController").GridPointerEventLike) => void;
     handleCellDoubleClick: (cell: CellCoord) => 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;
+    handleCellPointerEnter: (cell: CellCoord, event: import("../controllers/pointerInteractionsController").GridPointerEventLike) => void;
+    handleNativeDragStart: (event: {
+        preventDefault: () => void;
+    }) => void;
+    handleRowHeaderPointerDown: (rowIndex: number, event: import("../controllers/pointerInteractionsController").GridPointerEventLike) => void;
+    handleRowHeaderPointerEnter: (rowIndex: number, event: import("../controllers/pointerInteractionsController").GridPointerEventLike) => void;
+    handleColumnHeaderPointerDown: (colIndex: number, event: import("../controllers/pointerInteractionsController").GridPointerEventLike) => void;
+    handleColumnHeaderPointerEnter: (colIndex: number, event: import("../controllers/pointerInteractionsController").GridPointerEventLike) => void;
 };
 export default useGridPointerInteractions;

package/dist/hooks/useGridStore.d.ts

@@ -0,0 +1,7 @@
+import { type GridStore, type GridViewState, type Updater } from '../model/gridStore';
+import type { GridUiState } from '../model/gridTypes';
+export declare function useGridStore(store: GridStore): [GridUiState, GridStore['dispatch']];
+export type GridViewStateSetters = {
+    [K in keyof GridViewState as `set${Capitalize<K>}`]: (next: Updater<GridViewState[K]>) => void;
+};
+export declare function useGridViewState(store: GridStore): [GridViewState, GridViewStateSetters];

package/dist/hooks/useGridViewportSync.d.ts

@@ -1,23 +1,7 @@
 import { type RefObject } from 'react';
-import type { ActiveCellOverlayRect } from '../ActiveCellOverlay';
-import type { ColumnMeasurement } from '../logic/geometry';
-import type { CellCoord } from '../model/gridTypes';
-type VirtualizerLike = {
-    measure: () => void;
-};
-type UseGridViewportSyncArgs<T> = {
+import { type ViewportSyncArgs } from '../controllers/viewportSyncController';
+type UseGridViewportSyncArgs<T> = Omit<ViewportSyncArgs<T>, 'scrollElement'> & {
     scrollRef: RefObject<HTMLDivElement | null>;
-    columnVirtualizer: VirtualizerLike;
-    columnMeasurements: ColumnMeasurement<T>[];
-    totalScrollWidth: number;
-    physicalBodyHeight: number;
-    headerHeight: number;
-    leftPaneWidth: number;
-    rightPaneWidth: number;
-    centerLeadingWidth: number;
-    activeCellRect: ActiveCellOverlayRect | null;
-    activeCell: CellCoord | null;
-    verticalScaleFactor: number;
 };
-export declare const useGridViewportSync: <T>({ scrollRef, columnVirtualizer, columnMeasurements, totalScrollWidth, physicalBodyHeight, headerHeight, leftPaneWidth, rightPaneWidth, centerLeadingWidth, activeCellRect, activeCell, verticalScaleFactor, }: UseGridViewportSyncArgs<T>) => void;
+export declare const useGridViewportSync: <T>({ scrollRef, ...args }: UseGridViewportSyncArgs<T>) => void;
 export default useGridViewportSync;

package/dist/hooks/useResolvedGridTheme.d.ts

@@ -1,2 +1,3 @@
+import { type ResolvedGridTheme } from '../logic/theme';
 import type { GridTheme } from '../model/gridTypes';
-export declare function useResolvedGridTheme(theme: GridTheme): 'light' | 'dark';
+export declare function useResolvedGridTheme(theme: GridTheme): ResolvedGridTheme;

package/dist/hooks/useRowDragController.d.ts

@@ -1,20 +1,11 @@
-import { type PointerEvent, type RefObject } from 'react';
-import type { RowMetrics } from '../logic/verticalGeometry';
-import type { GridResolvedSlot } from '../model/gridTypes';
-type UseRowDragControllerArgs = {
-    enabled: boolean;
-    rowMetrics: RowMetrics;
-    headerHeight: number;
-    verticalScaleFactor: number;
-    windowBaseOffsetPx: number;
+import { type RefObject } from 'react';
+import { type RowDragArgs } from '../controllers/rowDragController';
+type UseRowDragControllerArgs = Omit<RowDragArgs, 'scrollContainerRef' | 'bodyScrollRef' | 'leftIndicatorRef' | 'centerIndicatorRef' | 'rightIndicatorRef'> & {
     scrollContainerRef: RefObject<HTMLDivElement | null>;
     bodyScrollRef: RefObject<HTMLDivElement | null>;
-    getRowDragLabel: (viewIndex: number) => string;
-    commitRowMove: (fromIndex: number, toIndex: number) => void;
-    ghostSlot?: GridResolvedSlot;
 };
 export declare const useRowDragController: (args: UseRowDragControllerArgs) => {
-    onRowDragHandlePointerDown: (viewIndex: number, event: PointerEvent<HTMLElement>) => void;
+    onRowDragHandlePointerDown: (viewIndex: number, event: import("../controllers/rowDragController").RowDragHandlePointerEvent) => void;
     leftIndicatorRef: RefObject<HTMLDivElement | null>;
     centerIndicatorRef: RefObject<HTMLDivElement | null>;
     rightIndicatorRef: RefObject<HTMLDivElement | null>;

package/dist/hooks/useServerSideRowModel.d.ts

@@ -1,21 +1,8 @@
-import type { GridRowKey, RowModel, ServerSideDataSource, ServerSideLoadErrorParams, ServerSideQuery, ServerSideWriteErrorParams } from '../model/gridTypes';
-import { type ServerSideCellEditInput } from '../logic/serverSideEdits';
-export type UseServerSideRowModelParams<T> = {
-    dataSource?: ServerSideDataSource<T>;
-    rowKeyGetter: (row: T, index: number) => GridRowKey;
-    query: ServerSideQuery;
-    queryKey: string;
-    refreshToken?: number;
-    onLoadError?: (error: unknown, params: ServerSideLoadErrorParams) => void;
-    onWriteError?: (error: unknown, params: ServerSideWriteErrorParams<T>) => void;
-    debounceMs?: number;
-};
-export type ServerSideLoadErrorState = {
-    failedBlockCount: number;
-};
-export type ServerSideWriteErrorState = {
-    failedRowCount: number;
-};
+import type { RowModel } from '../model/gridTypes';
+import { type ServerSideLoadErrorState, type ServerSideRowModelArgs, type ServerSideWriteErrorState } from '../controllers/serverSideRowModel';
+import type { ServerSideCellEditInput } from '../logic/serverSideEdits';
+export type { ServerSideLoadErrorState, ServerSideWriteErrorState, } from '../controllers/serverSideRowModel';
+export type UseServerSideRowModelParams<T> = ServerSideRowModelArgs<T>;
 export type UseServerSideRowModelResult<T> = {
     rowModel: RowModel<T>;
     rowCount: number;

package/dist/hooks/useToolPanelController.d.ts

@@ -1,10 +1,6 @@
-import type { RefObject } from 'react';
-export type ToolPanelTab = 'filter' | 'columns' | 'sort';
-export type ToolPanelLayout = {
-    top: number;
-    left: number;
-    width: number;
-};
+import { type RefObject } from 'react';
+import { type ToolPanelLayout, type ToolPanelTab } from '../controllers/toolPanelController';
+export type { ToolPanelLayout, ToolPanelTab } from '../controllers/toolPanelController';
 type UseToolPanelControllerArgs = {
     canUseFilterTab: boolean;
     canUseColumnsTab: boolean;
@@ -14,12 +10,14 @@ type UseToolPanelControllerArgs = {
     suppressEscape?: boolean;
     onSuppressedEscape?: () => void;
 };
-export declare const useToolPanelController: ({ canUseFilterTab, canUseColumnsTab, canUseSortTab, gridRootRef, alliedRef, suppressEscape, onSuppressedEscape, }: UseToolPanelControllerArgs) => {
+export declare const useToolPanelController: (args: UseToolPanelControllerArgs) => {
     activeToolPanelTab: ToolPanelTab | null;
     availableToolPanelTabs: ToolPanelTab[];
     toolPanelLayout: ToolPanelLayout | null;
     toolPanelFlashTick: number;
-    toolPanelRef: RefObject<HTMLDivElement | null>;
+    toolPanelRef: {
+        current: HTMLDivElement | null;
+    };
     openToolPanel: (tab: ToolPanelTab) => void;
     closeToolPanel: () => void;
     moveToolPanel: (top: number, left: number) => void;