@opencorestack/opengridx 2.1.0 → 3.0.1

package/lib/hooks/core/useGridLiveRowSelection.ts

@@ -0,0 +1,67 @@
+import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
+import type { GridRowId, GridRowMeta, GridRowModel } from '../../types';
+
+export interface UseGridLiveRowSelectionParams {
+    /** The selection model (controlled prop or internal state). */
+    selectedRowIds: Set<GridRowId>;
+    /** The row store: ids of the rows the grid holds. */
+    rowsLookup: ReadonlyMap<GridRowId, GridRowModel>;
+    /** Hierarchy rows the grid made (group rows, generated tree parents); their ids are kept. */
+    rowMetaMap: ReadonlyMap<GridRowId, GridRowMeta>;
+    /**
+     * Prune only when the grid holds every row (client rows, not a server page or a pivot of
+     * them); otherwise ids of rows that are not loaded are kept.
+     */
+    enabled: boolean;
+    /** Applies a model: internal state when uncontrolled, plus onRowSelectionModelChange. */
+    onSelectionModelChange: (model: GridRowId[]) => void;
+}
+
+// Content key of a set of ids; the type is part of it, so 1 and '1' stay apart.
+const idsKey = (ids: Iterable<GridRowId>): string =>
+    JSON.stringify(Array.from(ids, id => (typeof id === 'number' ? ['n', id] : ['s', id])));
+
+/**
+ * The selection the grid acts on: the model without the ids of rows that no longer exist.
+ * Everything that reads or builds on the selection (row highlighting, the header checkbox,
+ * `getSelectedRows`, the next model a click produces) uses this set. When rows are removed,
+ * the pruned model is reported once through `onSelectionModelChange`, so an uncontrolled
+ * selection forgets the ids (a row that comes back is not selected again) and a controlled
+ * consumer can follow. A pruned model is reported once per distinct (model, pruned model) pair:
+ * a controlled parent that keeps passing the stale ids (a fresh inline array each render, or its
+ * own state that re-adds them) is not notified again and cannot loop, and StrictMode's re-run of
+ * the effect does not report twice.
+ */
+export function useGridLiveRowSelection(params: UseGridLiveRowSelectionParams): Set<GridRowId> {
+    const { selectedRowIds, rowsLookup, rowMetaMap, enabled, onSelectionModelChange } = params;
+
+    const liveRowIds = useMemo(() => {
+        if (!enabled || selectedRowIds.size === 0) return selectedRowIds;
+        let stale = false;
+        const live = new Set<GridRowId>();
+        for (const id of selectedRowIds) {
+            if (rowsLookup.has(id) || rowMetaMap.has(id)) live.add(id);
+            else stale = true;
+        }
+        return stale ? live : selectedRowIds;
+    }, [enabled, selectedRowIds, rowsLookup, rowMetaMap]);
+
+    // Latest callback, so an inline onRowSelectionModelChange does not report again on every render.
+    const onChangeRef = useRef(onSelectionModelChange);
+    useLayoutEffect(() => { onChangeRef.current = onSelectionModelChange; });
+
+    // Survives StrictMode's effect re-run and re-renders; cleared once nothing is stale.
+    const reportedRef = useRef<string | null>(null);
+    useEffect(() => {
+        if (liveRowIds === selectedRowIds) {
+            reportedRef.current = null;
+            return;
+        }
+        const key = `${idsKey(selectedRowIds)}|${idsKey(liveRowIds)}`;
+        if (reportedRef.current === key) return;
+        reportedRef.current = key;
+        onChangeRef.current(Array.from(liveRowIds));
+    }, [liveRowIds, selectedRowIds]);
+
+    return liveRowIds;
+}

package/lib/hooks/core/useGridPageCorrection.ts

@@ -0,0 +1,55 @@
+import { useEffect, useLayoutEffect, useRef } from 'react';
+import type { GridPaginationModel } from '../../types';
+
+export interface UseGridPageCorrectionParams {
+    /** The pagination model the grid was given (controlled) or holds (uncontrolled). */
+    paginationModel: GridPaginationModel;
+    /** The page the row pipeline actually shows: the requested page clamped to the last page. */
+    currentPage: number;
+    /**
+     * Whether the row count is settled. While data is loading, or while there are no rows at all
+     * (rows not fetched yet), a clamp would throw away a restored page such as
+     * `initialState.pagination`, so the model is only corrected once rows are present.
+     */
+    enabled: boolean;
+    /** Stores the model when uncontrolled and calls `onPaginationModelChange`. */
+    onPaginationModelChange: (model: GridPaginationModel) => void;
+}
+
+/**
+ * When the rows shrink (new `rows`, a filter, collapsed tree nodes) the requested page can end up
+ * past the last page. The row pipeline already renders the clamped page during render; this hook
+ * reports the corrected model so the stored model, the consumer's state and later Previous/Next
+ * navigation agree with what is on screen. Reporting a model is a side effect, so it runs in an
+ * effect, keyed on the page numbers only: a consumer that passes a fresh model object every render
+ * or ignores the callback is told once per change, not on every render, and StrictMode's re-run
+ * of the effect does not report it twice.
+ */
+export function useGridPageCorrection({
+    paginationModel,
+    currentPage,
+    enabled,
+    onPaginationModelChange,
+}: UseGridPageCorrectionParams): void {
+    const latestRef = useRef({ paginationModel, onPaginationModelChange });
+    useLayoutEffect(() => {
+        latestRef.current = { paginationModel, onPaginationModelChange };
+    });
+
+    const requestedPage = paginationModel.page;
+
+    // The correction last reported; cleared once the requested page is the shown one again.
+    const reportedRef = useRef<string | null>(null);
+    useEffect(() => {
+        if (!enabled) return;
+        if (currentPage === requestedPage) {
+            reportedRef.current = null;
+            return;
+        }
+        const key = `${requestedPage}>${currentPage}`;
+        if (reportedRef.current === key) return;
+        reportedRef.current = key;
+        const { paginationModel: model, onPaginationModelChange: notify } = latestRef.current;
+        notify({ ...model, page: currentPage });
+    }, [enabled, currentPage, requestedPage]);
+}

package/lib/hooks/core/useGridRowIdOf.ts

@@ -0,0 +1,32 @@
+import { useCallback, useLayoutEffect, useRef } from 'react';
+import type { GridRowId, GridRowModel } from '../../types';
+
+/** The default `getRowId`: the row's own `id` field. */
+export function getDefaultRowId(row: GridRowModel): GridRowId {
+    return row.id;
+}
+
+export interface UseGridRowIdOfResult {
+    /**
+     * The key of any row the grid renders: stored rows resolve through the store, and grid-made
+     * rows (group rows, skeletons, generated tree parents) through their own `id`.
+     */
+    getRowIdOf: (row: GridRowModel) => GridRowId;
+    /**
+     * Same resolver with a stable identity, for event handlers only (it reads the last committed
+     * store), so column definitions are not rebuilt on every rows change.
+     */
+    getRowIdOfInEvents: (row: GridRowModel) => GridRowId;
+}
+
+/** Row-id resolvers over the row store's `idByRow` map. */
+export function useGridRowIdOf(idByRow: Map<GridRowModel, GridRowId>): UseGridRowIdOfResult {
+    const getRowIdOf = useCallback(
+        (row: GridRowModel): GridRowId => idByRow.get(row) ?? row.id,
+        [idByRow]
+    );
+    const getRowIdOfRef = useRef(getRowIdOf);
+    useLayoutEffect(() => { getRowIdOfRef.current = getRowIdOf; });
+    const getRowIdOfInEvents = useCallback((row: GridRowModel) => getRowIdOfRef.current(row), []);
+    return { getRowIdOf, getRowIdOfInEvents };
+}

package/lib/hooks/core/useGridRowInteractions.ts

@@ -0,0 +1,81 @@
+import { useCallback, useMemo } from 'react';
+import { useGridRowSelection, type UseGridRowSelectionReturn } from './useGridRowSelection';
+import { PIVOT_GRAND_TOTAL_ID } from '../../utils/pivot';
+import { isSyntheticRowId } from '../../utils/syntheticRows';
+import type { GridRowId, GridRowMeta, GridRowModel, GridRowParams } from '../../types';
+
+export interface UseGridRowInteractionsParams<R extends GridRowModel> {
+    /** Data rows that pass the filter (pinned included, synthetic group rows excluded). */
+    dataRows: R[];
+    getRowId: (row: GridRowModel) => GridRowId;
+    isPivotActive: boolean;
+    selectedRowIds: Set<GridRowId>;
+    onSelectionModelChange: (model: GridRowId[]) => void;
+    disableMultipleRowSelection: boolean;
+    disableRowSelectionOnClick: boolean;
+    isHierarchyEnabled: boolean;
+    rowMetaMap: Map<GridRowId, GridRowMeta>;
+    /** The active tree-data / row-grouping handlers, if any. */
+    activeHierarchyHandlers: { toggleExpansion: (id: GridRowId) => void } | null;
+    onRowClick: ((params: GridRowParams<R>) => void) | undefined;
+}
+
+export interface UseGridRowInteractionsResult<R extends GridRowModel> {
+    rowSelection: UseGridRowSelectionReturn;
+    /** Row click (and keyboard row activation). */
+    handleRowClick: (params: GridRowParams<R>) => void;
+    /** Row checkbox / Space key. */
+    handleSelectionChange: (rowId: GridRowId, isSelected: boolean) => void;
+}
+
+/** Row selection and the row-level click / checkbox handlers. */
+export function useGridRowInteractions<R extends GridRowModel>(
+    params: UseGridRowInteractionsParams<R>
+): UseGridRowInteractionsResult<R> {
+    const {
+        dataRows, getRowId, isPivotActive, selectedRowIds, onSelectionModelChange, disableMultipleRowSelection,
+        disableRowSelectionOnClick, isHierarchyEnabled, rowMetaMap, activeHierarchyHandlers, onRowClick,
+    } = params;
+
+    // Select-all acts on, and the header checkbox reflects, the data rows that pass the
+    // filter: never rows hidden by it, synthetic group rows, the pivot grand total, or stale
+    // ids in the selection.
+    const selectableRowIds = useMemo(() => {
+        const ids = dataRows.map(getRowId);
+        return isPivotActive ? ids.filter(id => id !== PIVOT_GRAND_TOTAL_ID) : ids;
+    }, [dataRows, getRowId, isPivotActive]);
+    const rowSelection = useGridRowSelection({
+        selectedRowIds,
+        onSelectionModelChange,
+        disableMultipleRowSelection,
+        selectableRowIds,
+    });
+
+    const handleRowClick = useCallback((rowParams: GridRowParams<R>) => {
+        const { id } = rowParams;
+
+        // Synthetic group rows toggle on click and are never selected. Tree-data parents are real rows:
+        // they fire onRowClick and select like any row, and expand through their chevron.
+        const rowMeta = isHierarchyEnabled ? rowMetaMap.get(id) : undefined;
+        if (rowMeta?.isGroupRow) {
+            if (rowMeta.hasChildren) activeHierarchyHandlers?.toggleExpansion(id);
+            return;
+        }
+
+        onRowClick?.(rowParams);
+
+        // The pivot Grand Total is clickable (onRowClick) but, like any synthetic row, not selectable.
+        if (!disableRowSelectionOnClick && !isSyntheticRowId(id, rowMetaMap)) {
+            rowSelection.clickRow(id);
+        }
+    }, [isHierarchyEnabled, activeHierarchyHandlers, onRowClick, rowMetaMap, disableRowSelectionOnClick, rowSelection]);
+
+    // Honors disableMultipleRowSelection like a row click does. Synthetic group / subtotal rows
+    // and the pivot Grand Total are not data: their ids never enter the selection model.
+    const handleSelectionChange = useCallback((rowId: GridRowId, isSelected: boolean) => {
+        if (isSyntheticRowId(rowId, rowMetaMap)) return;
+        rowSelection.toggleRow(rowId, isSelected);
+    }, [rowMetaMap, rowSelection]);
+
+    return { rowSelection, handleRowClick, handleSelectionChange };
+}

package/lib/hooks/core/useGridRowPipeline.ts

@@ -2,10 +2,13 @@ import { useMemo } from 'react';
 import { filterRows } from '../../utils/filtering';
 import { sortRows } from '../../utils/sorting';
 import { getPinnedRowGroups } from '../../utils/pinning';
-import type { GridRowModel, GridFilterModel, GridSortItem, GridPaginationModel, GridRowPinning, GridDataSource } from '../../types';
+import { normalizePageSize, getPageCount, clampPage } from '../../utils/pagination';
+import type { GridColumnLookup } from '../../utils/columnLookup';
+import type { GridRowModel, GridRowId, GridFilterModel, GridSortItem, GridPaginationModel, GridRowPinning } from '../../types';
 
 interface HierarchyHandlers<R extends GridRowModel> {
-    getVisibleRows: () => R[];
+    /** `labelField` is the column showing the hierarchy, so sorting by it can order group rows by their labels. */
+    getVisibleRows: (options?: { labelField?: string; expandAll?: boolean }) => R[] | null;
 }
 
 export interface UseGridRowPipelineParams<R extends GridRowModel> {
@@ -13,24 +16,49 @@ export interface UseGridRowPipelineParams<R extends GridRowModel> {
     activeHierarchyHandlers: HierarchyHandlers<R> | null;
     filterMode: string;
     filterModel: GridFilterModel;
-    dataSource?: GridDataSource<R>;
     sortModel: GridSortItem[];
     sortingMode: string;
     pagination: boolean;
     paginationMode: string;
     effectivePaginationModel: GridPaginationModel;
     pinnedRows?: GridRowPinning;
-    isLoading: boolean;
-    pageSize: number;
+    /** Resolves a row's id for pinnedRows lookups; defaults to `row.id`. */
+    getRowId?: (row: R) => GridRowId;
+    /**
+     * Column definitions for client-side filtering and sorting: cells are read through
+     * `valueGetter`, `type` drives numeric/date comparison, and the quick filter searches only
+     * the visible, filterable columns. Without it, `row[field]` is read directly.
+     */
+    columnLookup?: GridColumnLookup;
+    /** Tree data / row grouping: the column that shows the expand toggle and group labels. */
+    hierarchyField?: string;
 }
 
 export interface GridRowPipelineResult<R extends GridRowModel> {
     filteredRows: R[];
+    /**
+     * The filtered data rows, independent of hierarchy expansion. Under row grouping and tree
+     * data, filteredRows is the visible hierarchy instead (group rows that already carry their
+     * subtotals plus whichever children are expanded), so anything that totals or counts rows
+     * must use dataRows.
+     */
+    dataRows: R[];
     pinnedTopRows: R[];
     unpinnedRows: R[];
     pinnedBottomRows: R[];
     sortedUnpinnedRows: R[];
     paginatedUnpinnedRows: R[];
+    /**
+     * The page the rows are sliced at: `effectivePaginationModel.page` clamped to the last page
+     * when the grid pages client-side, so a page left past the end after the rows shrink shows
+     * the last page instead of nothing. Under server pagination it is the requested page.
+     */
+    currentPage: number;
+    /**
+     * Pinned-top rows, the rows on the current page (all rows without pagination) and
+     * pinned-bottom rows: exactly the rows the grid view renders. Loading placeholders for
+     * infinite scroll are not included; GridVirtualRows draws those itself.
+     */
     allRenderableRows: R[];
 }
 
@@ -42,68 +70,70 @@ export function useGridRowPipeline<R extends GridRowModel>(
         activeHierarchyHandlers,
         filterMode,
         filterModel,
-        dataSource,
         sortModel,
         sortingMode,
         pagination,
         paginationMode,
         effectivePaginationModel,
         pinnedRows,
-        isLoading,
-        pageSize,
+        getRowId,
+        columnLookup,
+        hierarchyField,
     } = params;
 
+    // Server modes mean "the rows are already filtered/sorted/paged", with or without a
+    // dataSource (a consumer can fetch pages itself from onPaginationModelChange etc.).
     const filteredRows = useMemo<R[]>(() => {
-        if (activeHierarchyHandlers) return (activeHierarchyHandlers.getVisibleRows() || []) as R[];
-        if (filterMode === 'server' && dataSource) return effectiveRows;
-        return filterRows(effectiveRows, filterModel) as R[];
-    }, [effectiveRows, filterModel, activeHierarchyHandlers, filterMode, dataSource]);
+        if (activeHierarchyHandlers) return (activeHierarchyHandlers.getVisibleRows({ labelField: hierarchyField }) || []) as R[];
+        if (filterMode === 'server') return effectiveRows;
+        return filterRows(effectiveRows, filterModel, columnLookup) as R[];
+    }, [effectiveRows, filterModel, activeHierarchyHandlers, hierarchyField, filterMode, columnLookup]);
+
+    const dataRows = useMemo<R[]>(() => {
+        if (!activeHierarchyHandlers) return filteredRows;
+        if (filterMode === 'server') return effectiveRows;
+        return filterRows(effectiveRows, filterModel, columnLookup) as R[];
+    }, [activeHierarchyHandlers, filteredRows, filterMode, effectiveRows, filterModel, columnLookup]);
 
     const { top: pinnedTopRows, center: unpinnedRows, bottom: pinnedBottomRows } = useMemo(() => {
         if (activeHierarchyHandlers) return { top: [] as R[], center: filteredRows, bottom: [] as R[] };
-        return getPinnedRowGroups(filteredRows, pinnedRows);
-    }, [filteredRows, pinnedRows, activeHierarchyHandlers]);
+        return getPinnedRowGroups(filteredRows, pinnedRows, getRowId);
+    }, [filteredRows, pinnedRows, activeHierarchyHandlers, getRowId]);
 
     const sortedUnpinnedRows = useMemo<R[]>(() => {
         if (activeHierarchyHandlers) return unpinnedRows;
-        if (sortingMode === 'server' && dataSource) return unpinnedRows;
-        return sortRows(unpinnedRows, sortModel) as R[];
-    }, [unpinnedRows, sortModel, activeHierarchyHandlers, sortingMode, dataSource]);
+        if (sortingMode === 'server') return unpinnedRows;
+        return sortRows(unpinnedRows, sortModel, columnLookup) as R[];
+    }, [unpinnedRows, sortModel, activeHierarchyHandlers, sortingMode, columnLookup]);
+
+    const isClientPaged = pagination && paginationMode !== 'server';
+    const pageSize = normalizePageSize(effectivePaginationModel.pageSize);
+    const currentPage = isClientPaged
+        ? clampPage(effectivePaginationModel.page, getPageCount(sortedUnpinnedRows.length, pageSize))
+        : effectivePaginationModel.page;
 
     const paginatedUnpinnedRows = useMemo<R[]>(() => {
-        if (!pagination) return sortedUnpinnedRows;
-        if (paginationMode === 'server' && dataSource) return sortedUnpinnedRows;
-        const start = effectivePaginationModel.page * effectivePaginationModel.pageSize;
-        return sortedUnpinnedRows.slice(start, start + effectivePaginationModel.pageSize);
-    }, [sortedUnpinnedRows, pagination, effectivePaginationModel.page, effectivePaginationModel.pageSize, paginationMode, dataSource]);
+        if (!isClientPaged) return sortedUnpinnedRows;
+        const start = currentPage * pageSize;
+        return sortedUnpinnedRows.slice(start, start + pageSize);
+    }, [sortedUnpinnedRows, isClientPaged, currentPage, pageSize]);
 
+    // What keyboard navigation walks: the rendered rows. With tree data and pagination that is the
+    // current page, the same as a flat grid (hierarchy modes have no pinned rows).
     const allRenderableRows = useMemo<R[]>(() => {
-        if (activeHierarchyHandlers) return unpinnedRows;
         const centerRows = pagination ? paginatedUnpinnedRows : sortedUnpinnedRows;
-        const base = [...pinnedTopRows, ...centerRows, ...pinnedBottomRows];
-
-        if (paginationMode === 'infinite' && isLoading && base.length > 0) {
-            const skeletonCount = Math.min(pageSize, 20);
-            const skeletons = Array.from({ length: skeletonCount }, (_, i) => ({
-                id: `__skeleton_${i}__`,
-                _isSkeleton: true,
-            }));
-            return [...base, ...skeletons] as R[];
-        }
-
-        return base;
-    }, [
-        pinnedTopRows, paginatedUnpinnedRows, sortedUnpinnedRows, pinnedBottomRows,
-        pagination, activeHierarchyHandlers, unpinnedRows, paginationMode, isLoading, pageSize,
-    ]);
+        return [...pinnedTopRows, ...centerRows, ...pinnedBottomRows];
+    }, [pinnedTopRows, paginatedUnpinnedRows, sortedUnpinnedRows, pinnedBottomRows, pagination]);
 
     return {
         filteredRows,
+        dataRows,
         pinnedTopRows,
         unpinnedRows,
         pinnedBottomRows,
         sortedUnpinnedRows,
         paginatedUnpinnedRows,
+        currentPage,
         allRenderableRows,
     };
 }

package/lib/hooks/core/useGridRowSelection.ts

@@ -0,0 +1,91 @@
+import { useCallback, useMemo } from 'react';
+import type { GridRowId } from '../../types';
+
+// ── Pure selection transitions (shared by the UI handlers and the imperative API) ──────────
+
+/** Selects or deselects `ids`. With `single`, selecting keeps only the last id. */
+export function nextSelectionForRows(
+    current: ReadonlySet<GridRowId>,
+    ids: readonly GridRowId[],
+    isSelected: boolean,
+    single: boolean
+): GridRowId[] {
+    if (isSelected && single) {
+        return ids.length > 0 ? [ids[ids.length - 1]] : Array.from(current);
+    }
+    const next = new Set(current);
+    ids.forEach(id => (isSelected ? next.add(id) : next.delete(id)));
+    return Array.from(next);
+}
+
+/** A row click toggles the row; with `single` it replaces the selection instead of adding to it. */
+export function nextSelectionForClick(current: ReadonlySet<GridRowId>, id: GridRowId, single: boolean): GridRowId[] {
+    if (single) return current.has(id) ? [] : [id];
+    return nextSelectionForRows(current, [id], !current.has(id), false);
+}
+
+/** Whether `next` holds exactly the ids of `current` (order ignored). */
+export function isSameSelection(current: ReadonlySet<GridRowId>, next: readonly GridRowId[]): boolean {
+    return next.length === current.size && next.every(id => current.has(id));
+}
+
+export interface UseGridRowSelectionParams {
+    selectedRowIds: Set<GridRowId>;
+    /** Applies a new model: internal state when uncontrolled, plus onRowSelectionModelChange. */
+    onSelectionModelChange: (model: GridRowId[]) => void;
+    disableMultipleRowSelection: boolean;
+    /**
+     * The rows the header checkbox acts on and reflects: the data rows that pass the filter
+     * (including pinned rows, excluding synthetic group rows).
+     */
+    selectableRowIds: readonly GridRowId[];
+}
+
+export interface UseGridRowSelectionReturn {
+    /** Checkbox / Space-key toggle of one row. */
+    toggleRow: (id: GridRowId, isSelected: boolean) => void;
+    /** Row-click toggle. */
+    clickRow: (id: GridRowId) => void;
+    /** Header checkbox; undefined when disableMultipleRowSelection is set (no select-all). */
+    selectAll: ((isSelected: boolean) => void) | undefined;
+    allSelected: boolean;
+    someSelected: boolean;
+}
+
+export function useGridRowSelection(params: UseGridRowSelectionParams): UseGridRowSelectionReturn {
+    const { selectedRowIds, onSelectionModelChange, disableMultipleRowSelection, selectableRowIds } = params;
+
+    const commit = useCallback((next: GridRowId[]) => {
+        if (isSameSelection(selectedRowIds, next)) return;
+        onSelectionModelChange(next);
+    }, [selectedRowIds, onSelectionModelChange]);
+
+    const toggleRow = useCallback((id: GridRowId, isSelected: boolean) => {
+        commit(nextSelectionForRows(selectedRowIds, [id], isSelected, disableMultipleRowSelection));
+    }, [commit, selectedRowIds, disableMultipleRowSelection]);
+
+    const clickRow = useCallback((id: GridRowId) => {
+        commit(nextSelectionForClick(selectedRowIds, id, disableMultipleRowSelection));
+    }, [commit, selectedRowIds, disableMultipleRowSelection]);
+
+    // Select-all adds the selectable rows to the selection and deselect-all removes them, so
+    // rows hidden by the filter are never selected by it (and keep their own state).
+    const selectAllHandler = useCallback((isSelected: boolean) => {
+        commit(nextSelectionForRows(selectedRowIds, selectableRowIds, isSelected, false));
+    }, [commit, selectedRowIds, selectableRowIds]);
+
+    const { allSelected, someSelected } = useMemo(() => {
+        let selectedCount = 0;
+        for (const id of selectableRowIds) if (selectedRowIds.has(id)) selectedCount++;
+        const all = selectableRowIds.length > 0 && selectedCount === selectableRowIds.length;
+        return { allSelected: all, someSelected: !all && selectedCount > 0 };
+    }, [selectableRowIds, selectedRowIds]);
+
+    return {
+        toggleRow,
+        clickRow,
+        selectAll: disableMultipleRowSelection ? undefined : selectAllHandler,
+        allSelected,
+        someSelected,
+    };
+}