@ishibashi0112/spreadsheet-grid 0.36.0 → 0.37.0

package/dist/controllers/columnAutosizeRunner.d.ts

@@ -0,0 +1,20 @@
+import { gridActions } from '../model/gridActions';
+import type { GridColumn, RowModel } from '../model/gridTypes';
+type ReadonlyRef<V> = {
+    readonly current: V;
+};
+export type ColumnAutosizeRunnerArgs<T> = {
+    rowModelRef: ReadonlyRef<RowModel<T>>;
+    gridRootRef: ReadonlyRef<HTMLElement | null>;
+    columnWidthsRef: ReadonlyRef<Record<string, number>>;
+    dispatch: (action: ReturnType<typeof gridActions.syncColumnWidths>) => void;
+};
+export type ColumnAutosizeRunner<T> = {
+    update: (args: ColumnAutosizeRunnerArgs<T>) => void;
+    runAutosize: (columns: GridColumn<T>[]) => Promise<void>;
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => boolean;
+    dispose: () => void;
+};
+export declare const createColumnAutosizeRunner: <T>() => ColumnAutosizeRunner<T>;
+export {};

package/dist/controllers/columnHeaderDragController.d.ts

@@ -0,0 +1,44 @@
+import type { GridColumn, GridColumnPinned, GridResolvedSlot } from '../model/gridTypes';
+import { type ColumnPane, type GridPaneLayout } from '../logic/geometry';
+type ApplyColumnOrderAndPin = (orderedKeys: string[], pinOverride?: Map<string, GridColumnPinned | undefined>) => void;
+export declare function computeHeaderReorderedKeys<T>(columns: GridColumn<T>[], draggedKey: string, targetPane: ColumnPane, slotInTargetVisible: number): string[] | null;
+type ReadonlyRef<V> = {
+    readonly current: V;
+};
+export type ColumnHeaderDragArgs<T> = {
+    enabled: boolean;
+    columns: GridColumn<T>[];
+    paneLayout: GridPaneLayout<T>;
+    leftPaneScrollRef: ReadonlyRef<HTMLElement | null>;
+    rightPaneScrollRef: ReadonlyRef<HTMLElement | null>;
+    bodyScrollRef: ReadonlyRef<HTMLElement | null>;
+    scrollContainerRef: ReadonlyRef<HTMLElement | null>;
+    leftIndicatorRef: ReadonlyRef<HTMLElement | null>;
+    centerIndicatorRef: ReadonlyRef<HTMLElement | null>;
+    rightIndicatorRef: ReadonlyRef<HTMLElement | null>;
+    leftLeadingWidth: number;
+    centerLeadingWidth: number;
+    rightLeadingWidth: number;
+    applyColumnOrderAndPin: ApplyColumnOrderAndPin;
+    ghostSlot?: GridResolvedSlot;
+};
+export type ColumnDragHandlePointerEvent = {
+    button: number;
+    pointerId: number;
+    clientX: number;
+    clientY: number;
+    currentTarget: {
+        setPointerCapture: (pointerId: number) => void;
+        releasePointerCapture: (pointerId: number) => void;
+    };
+    preventDefault: () => void;
+    stopPropagation: () => void;
+};
+export type ColumnHeaderDragController<T> = {
+    update: (args: ColumnHeaderDragArgs<T>) => void;
+    onColumnDragHandlePointerDown: (column: GridColumn<T>, event: ColumnDragHandlePointerEvent) => void;
+    applyReorderSettle: () => void;
+    dispose: () => void;
+};
+export declare const createColumnHeaderDragController: <T>() => ColumnHeaderDragController<T>;
+export {};

package/dist/controllers/columnMenuController.d.ts

@@ -0,0 +1,49 @@
+import type { GridColumn } from '../model/gridTypes';
+import { type ReadonlyElementRef } from './popoverSupport';
+export type ColumnMenuLayout = {
+    top: number;
+    left: number;
+    width: number;
+    maxHeight?: number;
+};
+export type ColumnMenuSnapshot = {
+    columnKey: string | null;
+    layout: ColumnMenuLayout | null;
+};
+export type ColumnMenuControllerArgs<T> = {
+    visibleColumns: GridColumn<T>[];
+    enableColumnMenu: boolean;
+    gridRootRef: ReadonlyElementRef;
+};
+export type MenuButtonPointerEvent = {
+    button: number;
+    pointerType: string;
+    currentTarget: HTMLButtonElement;
+    preventDefault: () => void;
+    stopPropagation: () => void;
+};
+export type MenuButtonClickEvent = {
+    currentTarget: HTMLButtonElement;
+    preventDefault: () => void;
+    stopPropagation: () => void;
+};
+export type MenuContextEvent = {
+    clientX: number;
+    clientY: number;
+    preventDefault: () => void;
+    stopPropagation: () => void;
+};
+export type ColumnMenuController<T> = {
+    update: (args: ColumnMenuControllerArgs<T>) => void;
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => ColumnMenuSnapshot;
+    panelRef: {
+        current: HTMLDivElement | null;
+    };
+    openFromButton: (column: GridColumn<T>, event: MenuButtonPointerEvent) => void;
+    openFromButtonClick: (column: GridColumn<T>, event: MenuButtonClickEvent) => void;
+    openFromContextMenu: (column: GridColumn<T>, event: MenuContextEvent) => void;
+    close: () => void;
+    dispose: () => void;
+};
+export declare const createColumnMenuController: <T>() => ColumnMenuController<T>;

package/dist/controllers/contextMenuController.d.ts

@@ -0,0 +1,30 @@
+import type { GridContextMenuItem, GridContextMenuParams } from '../model/gridTypes';
+import { type ReadonlyElementRef } from './popoverSupport';
+export type CellContextMenuLayout = {
+    top: number;
+    left: number;
+    width: number;
+};
+export type CellContextMenuState<T> = {
+    params: GridContextMenuParams<T>;
+    items: GridContextMenuItem[];
+};
+export type ContextMenuSnapshot<T> = {
+    state: CellContextMenuState<T> | null;
+    layout: CellContextMenuLayout | null;
+};
+export type ContextMenuControllerArgs = {
+    gridRootRef: ReadonlyElementRef;
+};
+export type ContextMenuController<T> = {
+    update: (args: ContextMenuControllerArgs) => void;
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => ContextMenuSnapshot<T>;
+    panelRef: {
+        current: HTMLDivElement | null;
+    };
+    open: (params: GridContextMenuParams<T>, items: GridContextMenuItem[]) => void;
+    close: () => void;
+    dispose: () => void;
+};
+export declare const createContextMenuController: <T>() => ContextMenuController<T>;

package/dist/controllers/filterPopoverController.d.ts

@@ -0,0 +1,53 @@
+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';
+import { type ReadonlyElementRef } from './popoverSupport';
+export 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;
+};
+export type FilterPopoverSnapshot = {
+    state: HeaderFilterPopoverState | null;
+    layout: FilterPopoverLayout | null;
+};
+export type FilterPopoverControllerArgs<T> = {
+    visibleColumns: GridColumn<T>[];
+    columnFilterValues: Record<string, ColumnFilterValue>;
+    enableColumnFilter: boolean;
+    gridRootRef: ReadonlyElementRef;
+    resolveColumnFilterType?: (column: GridColumn<T>) => ColumnFilterUiType;
+};
+export type FilterPopoverController<T> = {
+    update: (args: FilterPopoverControllerArgs<T>) => void;
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => FilterPopoverSnapshot;
+    panelRef: {
+        current: HTMLDivElement | null;
+    };
+    textInputRef: {
+        current: HTMLInputElement | null;
+    };
+    selectRef: {
+        current: HTMLSelectElement | null;
+    };
+    open: (column: GridColumn<T>) => void;
+    close: () => void;
+    updateDraft: (value: string) => void;
+    updateNumberDraft: (draft: NumberFilterConditionDraft) => void;
+    updateTextDraft: (draft: TextFilterConditionDraft) => void;
+    updateDateDraft: (draft: DateFilterConditionDraft) => void;
+    dispose: () => void;
+};
+export declare const resolveOpenedFilterColumn: <T>(visibleColumns: GridColumn<T>[], state: HeaderFilterPopoverState | null) => GridColumn<T> | null;
+export declare const createFilterPopoverController: <T>() => FilterPopoverController<T>;

package/dist/controllers/globalFilteredOrder.d.ts

@@ -0,0 +1,38 @@
+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;
+};
+export type GlobalFilterKey<T> = {
+    rows: T[];
+    baseOrder: RowOrder;
+    columns: GridColumn<T>[];
+    needle: string;
+};
+export declare const resolveSyncGlobalFilteredOrder: <T>(key: GlobalFilterKey<T>, deferredText: string, enabled: boolean) => GlobalFilteredOrderResult | null;
+export type GlobalFilteredOrderArgs<T> = GlobalFilterKey<T> & {
+    needsAsync: boolean;
+};
+type ReadyState<T> = GlobalFilterKey<T> & {
+    order: RowOrder;
+    rowsLength: number;
+};
+type ProgressState<T> = GlobalFilterKey<T> & {
+    progress: number;
+};
+export type GlobalFilteredOrderSnapshot<T> = {
+    ready: ReadyState<T> | null;
+    progress: ProgressState<T> | null;
+};
+export declare const selectGlobalFilteredOrderResult: <T>(syncResult: GlobalFilteredOrderResult | null, snapshot: GlobalFilteredOrderSnapshot<T>, key: GlobalFilterKey<T>) => GlobalFilteredOrderResult;
+export type GlobalFilteredOrderRunner<T> = {
+    update: (args: GlobalFilteredOrderArgs<T>) => void;
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => GlobalFilteredOrderSnapshot<T>;
+    dispose: () => void;
+};
+export declare const createGlobalFilteredOrderRunner: <T>() => GlobalFilteredOrderRunner<T>;
+export {};

package/dist/controllers/pointerInteractionsController.d.ts

@@ -0,0 +1,74 @@
+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 MutableRef<V> = {
+    current: V;
+};
+type ReadonlyRef<V> = {
+    readonly current: V;
+};
+export type GridPointerEventLike = {
+    button: number;
+    pointerType: string;
+    pointerId: number;
+    clientX: number;
+    clientY: number;
+    shiftKey: boolean;
+    preventDefault: () => void;
+};
+export type PointerInteractionsArgs<T> = {
+    gridRootRef: ReadonlyRef<HTMLElement | null>;
+    bodyScrollRef: ReadonlyRef<HTMLElement | null>;
+    scrollContainerRef: ReadonlyRef<HTMLElement | null>;
+    leftPaneScrollRef: ReadonlyRef<HTMLElement | null>;
+    rightPaneScrollRef: ReadonlyRef<HTMLElement | null>;
+    pointerClientRef: MutableRef<{
+        x: number;
+        y: number;
+    } | null>;
+    autoScrollFrameRef: MutableRef<number | null>;
+    uiState: GridUiState;
+    dispatch: (action: GridUiAction) => void;
+    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: ReadonlyRef<(cell: CellCoord) => void>;
+};
+export type PointerInteractionsController<T> = {
+    update: (args: PointerInteractionsArgs<T>) => void;
+    updateSelectionFromPointer: (clientX: number, clientY: number) => void;
+    handleCellPointerDown: (cell: CellCoord, event: GridPointerEventLike) => void;
+    handleCellDoubleClick: (cell: CellCoord) => void;
+    handleCellPointerEnter: (cell: CellCoord, event: GridPointerEventLike) => void;
+    handleNativeDragStart: (event: {
+        preventDefault: () => void;
+    }) => void;
+    handleRowHeaderPointerDown: (rowIndex: number, event: GridPointerEventLike) => void;
+    handleRowHeaderPointerEnter: (rowIndex: number, event: GridPointerEventLike) => void;
+    handleColumnHeaderPointerDown: (colIndex: number, event: GridPointerEventLike) => void;
+    handleColumnHeaderPointerEnter: (colIndex: number, event: GridPointerEventLike) => void;
+    dispose: () => void;
+};
+export declare const createPointerInteractionsController: <T>() => PointerInteractionsController<T>;
+export {};

package/dist/controllers/popoverSupport.d.ts

@@ -0,0 +1,18 @@
+export type ReadonlyElementRef<E extends HTMLElement = HTMLElement> = {
+    readonly current: E | null;
+};
+export declare const blurForPopover: (gridRoot: HTMLElement | null) => void;
+export declare const restoreGridFocus: (gridRootRef: ReadonlyElementRef) => void;
+export type PopoverWindowHandlers = {
+    onResize?: () => void;
+    onScroll?: (event: Event) => void;
+    isInside: (target: Node) => boolean;
+    onOutsidePointerDown: () => void;
+    onKeyDown?: (event: KeyboardEvent) => void;
+};
+export type PopoverWindowBindings = {
+    attach: () => void;
+    detach: () => void;
+    isAttached: () => boolean;
+};
+export declare const createPopoverWindowBindings: (handlers: PopoverWindowHandlers) => PopoverWindowBindings;

package/dist/controllers/rowDragController.d.ts

@@ -0,0 +1,40 @@
+import type { RowMetrics } from '../logic/verticalGeometry';
+import type { GridResolvedSlot } from '../model/gridTypes';
+type ReadonlyRef<V> = {
+    readonly current: V;
+};
+export type RowDragArgs = {
+    enabled: boolean;
+    rowMetrics: RowMetrics;
+    headerHeight: number;
+    verticalScaleFactor: number;
+    windowBaseOffsetPx: number;
+    scrollContainerRef: ReadonlyRef<HTMLElement | null>;
+    bodyScrollRef: ReadonlyRef<HTMLElement | null>;
+    leftIndicatorRef: ReadonlyRef<HTMLElement | null>;
+    centerIndicatorRef: ReadonlyRef<HTMLElement | null>;
+    rightIndicatorRef: ReadonlyRef<HTMLElement | null>;
+    getRowDragLabel: (viewIndex: number) => string;
+    commitRowMove: (fromIndex: number, toIndex: number) => void;
+    ghostSlot?: GridResolvedSlot;
+};
+export type RowDragHandlePointerEvent = {
+    button: number;
+    pointerId: number;
+    clientX: number;
+    clientY: number;
+    currentTarget: {
+        setPointerCapture: (pointerId: number) => void;
+        releasePointerCapture: (pointerId: number) => void;
+    };
+    preventDefault: () => void;
+    stopPropagation: () => void;
+};
+export type RowDragController = {
+    update: (args: RowDragArgs) => void;
+    onRowDragHandlePointerDown: (viewIndex: number, event: RowDragHandlePointerEvent) => void;
+    applyReorderSettle: () => void;
+    dispose: () => void;
+};
+export declare const createRowDragController: () => RowDragController;
+export {};

package/dist/controllers/selectOptionsCollector.d.ts

@@ -0,0 +1,31 @@
+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;
+};
+export declare const IDLE_SELECT_OPTIONS_RESULT: ColumnSelectOptionsResult;
+export type RawValueAccessor = (index: number) => unknown;
+export declare const resolveSyncSelectOptions: <T>(column: GridColumn<T> | null, rowCount: number, getRawValueAt: RawValueAccessor) => ColumnSelectOptionsResult | null;
+export type SelectOptionsCollectorArgs = {
+    needsAsync: boolean;
+    rowCount: number;
+    getRawValueAt: RawValueAccessor;
+};
+export type SelectOptionsCollectSnapshot = {
+    source: RawValueAccessor | null;
+    rowCount: number;
+    result: ColumnSelectOptionsResult;
+};
+export declare const selectCollectorResult: (snapshot: SelectOptionsCollectSnapshot, rowCount: number, getRawValueAt: RawValueAccessor) => ColumnSelectOptionsResult;
+export type SelectOptionsCollector = {
+    update: (args: SelectOptionsCollectorArgs) => void;
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => SelectOptionsCollectSnapshot;
+    dispose: () => void;
+};
+export declare const createSelectOptionsCollector: () => SelectOptionsCollector;

package/dist/controllers/serverSideRowModel.d.ts

@@ -0,0 +1,36 @@
+import type { GridRowKey, RowModel, ServerSideDataSource, ServerSideLoadErrorParams, ServerSideQuery, ServerSideWriteErrorParams } from '../model/gridTypes';
+import { type ServerSideCellEditInput } from '../logic/serverSideEdits';
+export type ServerSideRowModelArgs<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;
+};
+export type ServerSideRowModelSnapshot<T> = {
+    rowModel: RowModel<T>;
+    rowCount: number;
+    loadError: ServerSideLoadErrorState | null;
+    writeError: ServerSideWriteErrorState | null;
+};
+export type ServerSideRowModelController<T> = {
+    update: (args: ServerSideRowModelArgs<T>) => void;
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => ServerSideRowModelSnapshot<T>;
+    isRowLoaded: (viewIndex: number) => boolean;
+    requestRange: (startIndex: number, endIndex: number) => void;
+    refresh: () => void;
+    retryFailedBlocks: () => void;
+    applyCellEdits: (edits: ServerSideCellEditInput<T>[]) => number;
+    dispose: () => void;
+};
+export declare const createServerSideRowModel: <T>(initial: ServerSideRowModelArgs<T>) => ServerSideRowModelController<T>;

package/dist/controllers/toolPanelController.d.ts

@@ -0,0 +1,36 @@
+import { type ReadonlyElementRef } from './popoverSupport';
+export type ToolPanelTab = 'filter' | 'columns' | 'sort';
+export type ToolPanelLayout = {
+    top: number;
+    left: number;
+    width: number;
+};
+export type ToolPanelControllerArgs = {
+    canUseFilterTab: boolean;
+    canUseColumnsTab: boolean;
+    canUseSortTab: boolean;
+    gridRootRef: ReadonlyElementRef;
+    alliedRef?: ReadonlyElementRef;
+    suppressEscape?: boolean;
+    onSuppressedEscape?: () => void;
+};
+export type ToolPanelSnapshot = {
+    requestedTab: ToolPanelTab | null;
+    layout: ToolPanelLayout | null;
+    flashTick: number;
+};
+export type ToolPanelController = {
+    update: (args: ToolPanelControllerArgs) => void;
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => ToolPanelSnapshot;
+    panelRef: {
+        current: HTMLDivElement | null;
+    };
+    open: (tab: ToolPanelTab) => void;
+    close: () => void;
+    move: (top: number, left: number) => void;
+    dispose: () => void;
+};
+export declare const resolveAvailableToolPanelTabs: (args: Pick<ToolPanelControllerArgs, "canUseFilterTab" | "canUseColumnsTab" | "canUseSortTab">) => ToolPanelTab[];
+export declare const resolveActiveToolPanelTab: (requestedTab: ToolPanelTab | null, availableTabs: ToolPanelTab[]) => ToolPanelTab | null;
+export declare const createToolPanelController: () => ToolPanelController;

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;