@ishibashi0112/spreadsheet-grid 0.36.0 → 0.38.0

package/dist/engine/createGridEngine.d.ts

@@ -0,0 +1,46 @@
+import { type GridStore } from '../model/gridStore';
+import { type DetailIndexCacheHolder } from '../logic/detailRow';
+import { type AutoHeightMeasurer } from '../controllers/autoHeightMeasurer';
+import { type ScrollSyncController } from '../controllers/scrollSyncController';
+import { type DebouncedValueStore } from '../controllers/debouncedValueStore';
+import { type AutoSizeOnDataTrigger } from '../controllers/columnAutosizeRunner';
+import { type ColumnResolution, type ColumnResolutionInputs, type PaneLayoutInputs, type PaneLayoutResolution } from './columnLayout';
+import { type RowPipelineResolver, type ServerSideQueryResolution } from './rowPipeline';
+import { type VerticalLayoutInputs, type VerticalLayoutResolution } from './verticalLayout';
+import { type ColumnCommands } from './columnCommands';
+import { type FilterPopoverCommands, type FilterPopoverDerived, type FilterPopoverDerivedInputs } from './filterPopoverCommands';
+import { type RowSelectionCommands } from './rowSelectionCommands';
+import { type GridApi } from './gridApi';
+import { type DetailKeysNotifier, type HoverRowNotifier, type StateChangeNotifier } from './notifiers';
+export declare const SERVER_SIDE_QUERY_DEBOUNCE_MS = 300;
+export type GridEngineInit<T> = {
+    columnInputs: ColumnResolutionInputs<T>;
+    serverSide: {
+        isServerSide: boolean;
+        enableGlobalFilter: boolean;
+        enableColumnFilter: boolean;
+        enableSorting: boolean;
+    };
+};
+export type GridEngine<T> = {
+    store: GridStore;
+    resolveColumns: (inputs: ColumnResolutionInputs<T>) => ColumnResolution<T>;
+    resolvePaneLayout: (inputs: PaneLayoutInputs<T>) => PaneLayoutResolution<T>;
+    rowPipeline: RowPipelineResolver<T>;
+    resolveVerticalLayout: (inputs: VerticalLayoutInputs<T>) => VerticalLayoutResolution;
+    resolveFilterPopoverDerived: (inputs: FilterPopoverDerivedInputs<T>) => FilterPopoverDerived;
+    columnCommands: ColumnCommands<T>;
+    filterPopoverCommands: FilterPopoverCommands<T>;
+    rowSelectionCommands: RowSelectionCommands<T>;
+    gridApi: GridApi<T>;
+    hoverRowNotifier: HoverRowNotifier;
+    detailKeysNotifier: DetailKeysNotifier;
+    stateChangeNotifier: StateChangeNotifier<T>;
+    autoHeightMeasurer: AutoHeightMeasurer<T>;
+    scrollSync: ScrollSyncController;
+    serverSideQueryStore: DebouncedValueStore<ServerSideQueryResolution>;
+    autoSizeOnData: AutoSizeOnDataTrigger<T>;
+    detailIndexCache: DetailIndexCacheHolder;
+    dispose: () => void;
+};
+export declare const createGridEngine: <T>(init: GridEngineInit<T>) => GridEngine<T>;

package/dist/engine/filterPopoverCommands.d.ts

@@ -0,0 +1,56 @@
+import type { ColumnFilterUiType, ColumnFilterValue, GridColumn } from '../model/gridTypes';
+import { type GridUiAction } from '../model/gridActions';
+import { type ColumnFilterSetSelection } from '../logic/setFilterSelection';
+import { type NumberFilterConditionDraft } from '../logic/numberFilterCondition';
+import { type TextFilterConditionDraft } from '../logic/textFilterCondition';
+import { type DateFilterConditionDraft } from '../logic/dateFilterCondition';
+import type { SelectOptionEntry } from '../logic/selectOptions';
+export type FilterPopoverDerivedInputs<T> = {
+    openedFilterColumn: GridColumn<T> | null;
+    openedFilterType: ColumnFilterUiType | null;
+    openedFilterSelectOptions: SelectOptionEntry[];
+    openedFilterAllValues: ReadonlySet<string>;
+    columnFilters: Record<string, ColumnFilterValue>;
+};
+export type FilterPopoverDerived = {
+    isDateSetFilterColumn: boolean;
+    openedPopoverSelectOptions: SelectOptionEntry[];
+    openedPopoverAllValues: ReadonlySet<string>;
+    openedSetFilterValue: ColumnFilterValue | undefined;
+    openedSetSelection: ColumnFilterSetSelection | null;
+    openedColumnCanInvert: boolean;
+    isComboFilterColumn: boolean;
+};
+export declare const createFilterPopoverDerivedResolver: <T>() => (inputs: FilterPopoverDerivedInputs<T>) => FilterPopoverDerived;
+export type FilterPopoverStateLike = {
+    columnKey: string;
+    draftValue: string;
+    numberDraft: NumberFilterConditionDraft | null;
+};
+export type FilterPopoverCommandsArgs<T> = {
+    filterPopoverState: FilterPopoverStateLike | null;
+    openedFilterColumn: GridColumn<T> | null;
+    openedFilterType: ColumnFilterUiType | null;
+    columnFilters: Record<string, ColumnFilterValue>;
+    derived: FilterPopoverDerived;
+    dispatch: (action: GridUiAction) => void;
+    closeColumnFilterPopover: () => void;
+    updateNumberDraft: (draft: NumberFilterConditionDraft) => void;
+    updateTextDraft: (draft: TextFilterConditionDraft) => void;
+    updateDateDraft: (draft: DateFilterConditionDraft) => void;
+};
+export type FilterPopoverCommands<T> = {
+    update: (args: FilterPopoverCommandsArgs<T>) => void;
+    handleSetFilterValueToggle: (value: string) => void;
+    handleSetFilterSelectAllChange: (scope: 'all' | string[], nextChecked: boolean) => void;
+    handleSetFilterReplaceSelection: (values: string[]) => void;
+    clearSetFilterPopoverValue: () => void;
+    handleNumberConditionDraftChange: (draft: NumberFilterConditionDraft) => void;
+    handleTextConditionDraftChange: (draft: TextFilterConditionDraft) => void;
+    handleDateConditionDraftChange: (draft: DateFilterConditionDraft) => void;
+    handleComboConditionClear: () => void;
+    handleComboSelectionClear: () => void;
+    applyFilterPopoverValue: () => void;
+    clearFilterPopoverValue: () => void;
+};
+export declare const createFilterPopoverCommands: <T>() => FilterPopoverCommands<T>;

package/dist/engine/gridApi.d.ts

@@ -0,0 +1,61 @@
+import type { DetailRowOptions, GridColumn, GridRowKey, GridUiState, RowModel, RowSelectionState, ScrollAlign, SpreadsheetGridHandle, SpreadsheetGridProps } from '../model/gridTypes';
+import { type GridUiAction } from '../model/gridActions';
+import { type GridPaneLayout } from '../logic/geometry';
+import { type RowMetrics } from '../logic/verticalGeometry';
+import { type DetailIndexCache } from '../logic/detailRow';
+import { type GroupTree } from '../logic/grouping';
+import type { ToolPanelTab } from '../controllers/toolPanelController';
+type ReadonlyRef<V> = {
+    readonly current: V;
+};
+export type GridApiArgs<T> = {
+    scrollContainerRef: ReadonlyRef<HTMLElement | null>;
+    dispatch: (action: GridUiAction) => void;
+    rowModel: RowModel<T>;
+    viewRowCount: number;
+    leafRowCount: number;
+    groupTree: GroupTree<T> | null;
+    rowMetrics: RowMetrics;
+    paneLayout: GridPaneLayout<T>;
+    orderedColumns: GridColumn<T>[];
+    columns: GridColumn<T>[];
+    onColumnsChange: ((nextColumns: GridColumn<T>[]) => void) | undefined;
+    uiState: GridUiState;
+    headerHeight: number;
+    verticalScaleFactor: number;
+    leftPaneTotalWidth: number;
+    rightPaneTotalWidth: number;
+    centerLeadingWidth: number;
+    windowFirstRow: number;
+    windowLastRow: number;
+    physicalBodyHeight: number;
+    rows: T[];
+    isServerSide: boolean;
+    serverSideRefresh: () => void;
+    resolvedRowKeyGetter: (row: T, sourceRowIndex: number) => GridRowKey;
+    isRowExportable: SpreadsheetGridProps<T>['isRowExportable'];
+    activeToolPanelTab: ToolPanelTab | null;
+    openToolPanel: (tab: ToolPanelTab) => void;
+    closeToolPanel: () => void;
+    undoRows: () => void;
+    redoRows: () => void;
+    canUndoRows: () => boolean;
+    canRedoRows: () => boolean;
+    clearUndoHistory: () => void;
+    detailRowEnabled: boolean;
+    detailIsExpandable: DetailRowOptions<T>['isExpandable'];
+    detailIndexCacheRef: ReadonlyRef<DetailIndexCache>;
+    moveRowByKey: (rowKey: GridRowKey, toIndex: number) => void;
+    commitRowSelection: (next: RowSelectionState) => void;
+    markApiScroll: () => void;
+};
+export type GridApi<T> = {
+    update: (args: GridApiArgs<T>) => void;
+    handle: SpreadsheetGridHandle<T>;
+    applyScroll: (logicalTop: number | null, left: number | null) => void;
+    verticalTargetFor: (viewRowIndex: number, align: ScrollAlign) => number | null;
+    horizontalTargetFor: (colIndex: number, align: ScrollAlign) => number | null;
+    scrollToCellInternal: (viewRowIndex: number, colIndex: number, align: ScrollAlign) => void;
+};
+export declare const createGridApi: <T>() => GridApi<T>;
+export {};

package/dist/engine/memo.d.ts

@@ -0,0 +1,2 @@
+export type MemoFn<Args extends readonly unknown[], R> = (...args: Args) => R;
+export declare const createMemo: <Args extends readonly unknown[], R>(compute: (...args: Args) => R) => MemoFn<Args, R>;

package/dist/engine/notifiers.d.ts

@@ -0,0 +1,35 @@
+import type { GridColumn, GridRowKey, GridSortState, GridState, GridUiState } from '../model/gridTypes';
+export type HoverRowNotifierArgs = {
+    enableRowHover: boolean;
+    isHoverControlled: boolean;
+    onHoveredRowChange: ((index: number | null, meta: {
+        source: 'pointer';
+    }) => void) | undefined;
+    setHoveredRowIndex: (index: number | null) => void;
+};
+export type HoverRowAction = number | null | ((current: number | null) => number | null);
+export type HoverRowNotifier = {
+    update: (args: HoverRowNotifierArgs) => void;
+    applyHoveredRowChange: (action: HoverRowAction) => void;
+};
+export declare const createHoverRowNotifier: () => HoverRowNotifier;
+export type DetailKeysNotifierArgs = {
+    expandedKeys: ReadonlySet<GridRowKey>;
+    onChange: ((keys: GridRowKey[]) => void) | undefined;
+};
+export type DetailKeysNotifier = {
+    update: (args: DetailKeysNotifierArgs) => void;
+};
+export declare const createDetailKeysNotifier: () => DetailKeysNotifier;
+export type StateChangeNotifierArgs<T> = {
+    columnWidths: GridUiState['columnWidths'];
+    filters: GridUiState['filters'];
+    sort: GridSortState;
+    dragState: GridUiState['dragState'];
+    columns: GridColumn<T>[];
+    onStateChange: ((state: GridState) => void) | undefined;
+};
+export type StateChangeNotifier<T> = {
+    update: (args: StateChangeNotifierArgs<T>) => void;
+};
+export declare const createStateChangeNotifier: <T>() => StateChangeNotifier<T>;

package/dist/engine/rowPipeline.d.ts

@@ -0,0 +1,50 @@
+import type { ColumnFilterValue, GridColumn, GridRowKey, GridSortState, RowModel, ServerSideQuery } from '../model/gridTypes';
+import { type RowOrder } from '../logic/filtering';
+import { type GroupTree, type GroupedDisplay } from '../logic/grouping';
+export type RowOrderInputs<T> = {
+    rows: T[];
+    visibleColumns: GridColumn<T>[];
+    columnFilters: Record<string, ColumnFilterValue>;
+    globalFilteredOrder: RowOrder;
+    sort: GridSortState;
+    rowDragAvailable: boolean;
+};
+export type RowOrderResolution = {
+    order: RowOrder;
+    orderIsIdentity: boolean;
+    rowDragOperable: boolean;
+};
+export type ClientSideRowModelInputs<T> = {
+    rows: T[];
+    order: RowOrder;
+    rowGroupingActive: boolean;
+    groupColumns: GridColumn<T>[];
+    aggColumns: GridColumn<T>[];
+    collapsedGroupKeys: ReadonlySet<string>;
+    rowKeyGetter: (row: T, index: number) => GridRowKey;
+};
+export type ClientSideRowModelResolution<T> = {
+    groupTree: GroupTree<T> | null;
+    groupedDisplay: GroupedDisplay | null;
+    rowModel: RowModel<T>;
+};
+export type ServerSideQueryInputs = {
+    isServerSide: boolean;
+    globalFilterEnabled: boolean;
+    globalText: string;
+    columnFilterEnabled: boolean;
+    columnFilters: Record<string, ColumnFilterValue>;
+    sortingEnabled: boolean;
+    sort: GridSortState;
+};
+export type ServerSideQueryResolution = {
+    query: ServerSideQuery;
+    queryKey: string;
+};
+export declare const createRowPipelineResolver: <T>() => {
+    resolveBaseOrder: (rowCount: number) => RowOrder;
+    resolveOrder: (inputs: RowOrderInputs<T>) => RowOrderResolution;
+    resolveClientSideRowModel: (inputs: ClientSideRowModelInputs<T>) => ClientSideRowModelResolution<T>;
+    resolveServerSideQuery: (inputs: ServerSideQueryInputs) => ServerSideQueryResolution;
+};
+export type RowPipelineResolver<T> = ReturnType<typeof createRowPipelineResolver<T>>;

package/dist/engine/rowSelectionCommands.d.ts

@@ -0,0 +1,21 @@
+import type { RowModel, RowSelectionModel, RowSelectionState } from '../model/gridTypes';
+import { type GridUiAction } from '../model/gridActions';
+export type RowSelectionCommandsArgs<T> = {
+    rowModel: RowModel<T>;
+    rowSelectionState: RowSelectionState;
+    rowSelectionMode: 'single' | 'multiple';
+    onRowSelectionChange: ((model: RowSelectionModel) => void) | undefined;
+    controlledRowSelectionModel: RowSelectionModel | undefined;
+    leafRowCount: number;
+    dispatch: (action: GridUiAction) => void;
+};
+export type RowSelectionCommands<T> = {
+    update: (args: RowSelectionCommandsArgs<T>) => void;
+    commitRowSelection: (next: RowSelectionState) => void;
+    handleGutterRowSelect: (viewIndex: number, opts: {
+        shiftKey: boolean;
+    }) => void;
+    handleGutterRowSelectDrag: (viewIndex: number) => void;
+    handleToggleSelectAllRows: () => void;
+};
+export declare const createRowSelectionCommands: <T>() => RowSelectionCommands<T>;

package/dist/engine/verticalLayout.d.ts

@@ -0,0 +1,52 @@
+import type { GridColumn, GridRowKey, RowModel } from '../model/gridTypes';
+import { type DetailRowExtra, type RowMetrics, type VerticalGeometry, type VerticalRow } from '../logic/verticalGeometry';
+import { type RowHeightStore } from '../logic/rowHeightStore';
+import { resolveDetailRowExtras, type DetailIndexCache } from '../logic/detailRow';
+type ReadonlyRef<V> = {
+    readonly current: V;
+};
+export type DetailLayerEntry = {
+    rowKey: GridRowKey;
+    virtualRow: VerticalRow;
+};
+type DetailIsExpandable<T> = Parameters<typeof resolveDetailRowExtras<T>>[0]['isExpandable'];
+export type VerticalLayoutInputs<T> = {
+    isServerSide: boolean;
+    autoHeight: boolean;
+    visibleColumns: GridColumn<T>[];
+    viewRowCount: number;
+    estimateRowHeight: number;
+    rowHeight: number;
+    headerHeight: number;
+    viewportHeight: number;
+    scrollTop: number;
+    rowModel: RowModel<T>;
+    measuredHeights: Map<GridRowKey, number>;
+    autoHeightVersion: number;
+    detailRowEnabled: boolean;
+    expandedDetailRowKeys: ReadonlySet<GridRowKey>;
+    detailHeight: number;
+    detailIsExpandable: DetailIsExpandable<T>;
+    detailIndexCacheRef: ReadonlyRef<DetailIndexCache>;
+};
+export type VerticalLayoutResolution = {
+    hasAutoHeightColumn: boolean;
+    autoHeightActive: boolean;
+    rowHeightStore: RowHeightStore | null;
+    baseRowMetrics: RowMetrics;
+    detailExtras: readonly DetailRowExtra[];
+    detailActive: boolean;
+    rowMetrics: RowMetrics;
+    verticalGeometry: VerticalGeometry;
+    virtualRows: VerticalGeometry['rows'];
+    virtualRowIndexes: VerticalGeometry['rowIndexSet'];
+    detailEntries: readonly DetailLayerEntry[];
+    windowFirstRow: number;
+    windowLastRow: number;
+    physicalBodyHeight: number;
+    bodyLayerTransform: string | undefined;
+    verticalScaleFactor: number;
+    overlayBaseOffset: number;
+};
+export declare const createVerticalLayoutResolver: <T>() => (inputs: VerticalLayoutInputs<T>) => VerticalLayoutResolution;
+export {};

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

@@ -2,4 +2,6 @@ export type ControllerLike<Args> = {
     update: (args: Args) => void;
     dispose?: () => void;
 };
-export declare function useController<Args, C extends ControllerLike<Args>>(create: () => C, args: Args): C;
+export type ControllerUpdateTiming = 'layout' | 'passive';
+export declare function useControllerLifecycle<Args, C extends ControllerLike<Args>>(controller: C, args: Args, timing?: ControllerUpdateTiming): void;
+export declare function useController<Args, C extends ControllerLike<Args>>(create: () => C, args: Args, timing?: ControllerUpdateTiming): 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/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;