@stenajs-webui/grid 13.2.0 → 13.3.0

package/dist/features/standard-table/components/StandardTableRow.d.ts

@@ -1,9 +1,12 @@
 import * as React from "react";
+import { RefObject } from "react";
 export interface StandardTableRowProps<TItem> {
     item: TItem;
+    itemIdList: Array<string>;
     rowIndex: number;
     numRows: number;
     colIndexOffset: number;
     alwaysVisible?: boolean;
+    shiftPressedRef: RefObject<boolean>;
 }
-export declare const StandardTableRow: React.MemoExoticComponent<(<TItem>({ item, rowIndex, numRows, colIndexOffset, alwaysVisible, }: StandardTableRowProps<TItem>) => JSX.Element)>;
+export declare const StandardTableRow: React.MemoExoticComponent<(<TItem>({ item, itemIdList, rowIndex, numRows, colIndexOffset, alwaysVisible, shiftPressedRef, }: StandardTableRowProps<TItem>) => JSX.Element)>;

package/dist/features/standard-table/context/StandardTableStateContext.d.ts

@@ -2,7 +2,6 @@ import { Dispatch } from "react";
 import { StandardTableConfig } from "../config/StandardTableConfig";
 import { StandardTableState } from "../redux/StandardTableReducer";
 import { StandardTableAction, StandardTableActions } from "../util/ActionsFactory";
-import { InternalStandardTableAction } from "../redux/StandardTableActionsAndSelectors";
 export interface StandardTableInternalActionsContext<TColumnKey extends string> {
     dispatch: Dispatch<StandardTableAction<TColumnKey>>;
     actions: StandardTableActions<TColumnKey>;
@@ -12,7 +11,7 @@ export interface StandardTableInternalActionsContext<TColumnKey extends string>
  * connect the table to a state.
  */
 export interface TableContext<TColumnKey extends string> {
-    dispatch: Dispatch<InternalStandardTableAction<TColumnKey>>;
+    dispatch: Dispatch<StandardTableAction<TColumnKey>>;
     state: StandardTableState<TColumnKey>;
     actions: StandardTableActions<TColumnKey>;
 }

package/dist/features/standard-table/features/checkboxes/StandardTableRowCheckbox.d.ts

@@ -1,10 +1,13 @@
 import { CheckboxProps } from "@stenajs-webui/forms";
 import * as React from "react";
+import { RefObject } from "react";
 interface Props extends Pick<CheckboxProps, "value" | "onValueChange"> {
     colIndex: number;
     rowIndex: number;
     numRows: number;
     disabled?: boolean;
+    onValueChangeAndShift: CheckboxProps["onValueChange"];
+    shiftPressedRef: RefObject<boolean>;
 }
 export declare const StandardTableRowCheckbox: React.FC<Props>;
 export {};

package/dist/features/standard-table/features/checkboxes/UseRowCheckbox.d.ts

@@ -1,4 +1,5 @@
-export declare const useRowCheckbox: <TItem>(item: TItem) => {
+export declare const useRowCheckbox: <TItem>(item: TItem, itemIdList: Array<string>) => {
     isSelected: boolean;
     toggleSelected: () => void;
+    shiftAndToggleSelected: () => void;
 };

package/dist/features/standard-table/redux/ReducerIdFactory.d.ts

@@ -1,3 +1,3 @@
-declare type ReducerIdSuffix = "selectedIds" | "expandedRows" | "sortOrder";
+declare type ReducerIdSuffix = "selectedIds" | "expandedRows" | "sortOrder" | "fields";
 export declare const getReducerIdFor: (reducerId: string, reducerIdSuffix: ReducerIdSuffix) => string;
 export {};

package/dist/features/standard-table/redux/StandardTableActionsAndSelectors.d.ts

@@ -1,19 +1,19 @@
-import { ReducerIdGateAction, SelectedIdsAction, SelectedIdsActions, SelectedIdsSelectors, SortOrderAction, SortOrderActions, SortOrderSelectors } from "@stenajs-webui/redux";
-import { StandardTableState } from "./StandardTableReducer";
+import { EntityActions, EntitySelectors, SelectedIdsActions, SelectedIdsSelectors, SortOrderActions, SortOrderSelectors } from "@stenajs-webui/redux";
+import { StandardTableStateFields } from "./StandardTableReducer";
 export interface InternalStandardTableActions<TColumnKey extends string> {
     sortOrder: SortOrderActions<TColumnKey>;
     selectedIds: SelectedIdsActions;
     expandedRows: SelectedIdsActions;
+    fields: EntityActions<StandardTableStateFields>;
 }
 export interface StandardTableSelectors<TStoreState, TColumnKey extends string> {
     sortOrder: SortOrderSelectors<TStoreState, TColumnKey>;
     selectedIds: SelectedIdsSelectors<TStoreState>;
     expandedRows: SelectedIdsSelectors<TStoreState>;
+    fields: EntitySelectors<TStoreState, StandardTableStateFields>;
 }
 export interface StandardTableActionsAndSelectors<TStoreState, TColumnKey extends string> {
     actions: InternalStandardTableActions<TColumnKey>;
     selectors: StandardTableSelectors<TStoreState, TColumnKey>;
 }
-export declare type InternalStandardTableAction<TColumnKey extends string> = ReducerIdGateAction<SortOrderAction<TColumnKey>> | ReducerIdGateAction<SelectedIdsAction>;
-export declare type StandardTableStateSelector<TStoreState, TColumnKey extends string> = (state: TStoreState) => StandardTableState<TColumnKey>;
 export declare const createInternalStandardTableActions: <TColumnKey extends string>() => InternalStandardTableActions<TColumnKey>;

package/dist/features/standard-table/redux/StandardTableReducer.d.ts

@@ -1,11 +1,15 @@
-import { SelectedIdsState, SortOrderState } from "@stenajs-webui/redux";
-import { InternalStandardTableAction } from "./StandardTableActionsAndSelectors";
+import { EntityState, SelectedIdsState, SortOrderState } from "@stenajs-webui/redux";
 import { Reducer } from "redux";
+import { StandardTableAction } from "../util/ActionsFactory";
 export interface StandardTableState<TColumnKey extends string> {
     sortOrder: SortOrderState<TColumnKey>;
     selectedIds: SelectedIdsState;
     expandedRows: SelectedIdsState;
+    fields: EntityState<StandardTableStateFields>;
+}
+export interface StandardTableStateFields {
+    lastSelectedId?: string;
 }
 export declare const createStandardTableInitialState: <TColumnKey extends string>(sortBy?: TColumnKey | undefined, desc?: boolean, selectedIds?: string[], expandedRows?: string[]) => StandardTableState<TColumnKey>;
-export declare type StandardTableReducer<TColumnKey extends string> = Reducer<StandardTableState<TColumnKey>, InternalStandardTableAction<TColumnKey>>;
-export declare const createStandardTableReducer: <TColumnKey extends string>(reducerId: string) => Reducer<StandardTableState<TColumnKey>, InternalStandardTableAction<TColumnKey>>;
+export declare type StandardTableReducer<TColumnKey extends string> = Reducer<StandardTableState<TColumnKey>, StandardTableAction<TColumnKey>>;
+export declare const createStandardTableReducer: <TColumnKey extends string>(reducerId: string) => Reducer<StandardTableState<TColumnKey>, StandardTableAction<TColumnKey>>;

package/dist/features/standard-table/util/ActionsFactory.d.ts

@@ -1,12 +1,14 @@
 import { InternalStandardTableActions } from "../redux/StandardTableActionsAndSelectors";
-import { ReducerIdGateAction, SelectedIdsAction, SortOrderAction } from "@stenajs-webui/redux";
-export declare type StandardTableAction<TColumnKey> = ReducerIdGateAction<SelectedIdsAction> | ReducerIdGateAction<SortOrderAction<TColumnKey>>;
-export interface StandardTableActions<TColumnKey> {
-    selectByIds: (ids: Array<string>) => StandardTableAction<TColumnKey>;
+import { EntityAction, ReducerIdGateAction, SelectedIdsAction, SortOrderAction } from "@stenajs-webui/redux";
+import { StandardTableStateFields } from "../redux/StandardTableReducer";
+export declare type StandardTableAction<TColumnKey extends string> = ReducerIdGateAction<SortOrderAction<TColumnKey>> | ReducerIdGateAction<SelectedIdsAction> | ReducerIdGateAction<EntityAction<StandardTableStateFields>>;
+export interface StandardTableActions<TColumnKey extends string> {
+    setSelectedIds: (ids: Array<string>) => StandardTableAction<TColumnKey>;
     clearSelection: () => StandardTableAction<TColumnKey>;
     expandByIds: (ids: Array<string>) => StandardTableAction<TColumnKey>;
     collapseAll: () => StandardTableAction<TColumnKey>;
     sortBy: (columnId: TColumnKey, desc?: boolean) => StandardTableAction<TColumnKey>;
     clearSortOrder: () => StandardTableAction<TColumnKey>;
+    setLastSelectedId: (lastSelectedId: string) => StandardTableAction<TColumnKey>;
 }
 export declare const createStandardTableActions: <TColumnKey extends string>(tableId: string, actions: InternalStandardTableActions<TColumnKey>) => StandardTableActions<TColumnKey>;

package/dist/features/standard-table/util/IdListPartial.d.ts

@@ -0,0 +1 @@
+export declare const getIdsBetweenSelected: (idList: Array<string> | undefined, selected1: string | undefined, selected2: string | undefined) => Array<string> | undefined;

package/dist/features/standard-table/util/__tests__/IdListPartial.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.es.js

@@ -16,7 +16,7 @@ import cx from 'classnames';
 import { faArrowRight } from '@fortawesome/free-solid-svg-icons/faArrowRight';
 import { TextInput, Checkbox } from '@stenajs-webui/forms';
 import { useDispatch, useSelector } from 'react-redux';
-import { createSortOrderActions, createSelectedIdsActions, createSortOrderReducerInitialState, createSelectedIdsReducerInitialState, reducerIdGate, createSortOrderReducer, createSelectedIdsReducer, reducerIdGateAction } from '@stenajs-webui/redux';
+import { createSortOrderActions, createSelectedIdsActions, createEntityActions, createSortOrderReducerInitialState, createSelectedIdsReducerInitialState, reducerIdGate, createSortOrderReducer, createSelectedIdsReducer, createEntityReducer, reducerIdGateAction } from '@stenajs-webui/redux';
 import { combineReducers } from 'redux';
 import { ErrorScreen, LoadingScreen } from '@stenajs-webui/panels';
 import { compact, upperFirst, lowerCase } from 'lodash';
@@ -734,6 +734,7 @@ var createInternalStandardTableActions = function () { return ({
     sortOrder: createSortOrderActions(),
     selectedIds: createSelectedIdsActions(),
     expandedRows: createSelectedIdsActions(),
+    fields: createEntityActions(),
 }); };
 
 var getReducerIdFor = function (reducerId, reducerIdSuffix) { return reducerId + "." + reducerIdSuffix; };
@@ -747,16 +748,19 @@ var createStandardTableInitialState = function (sortBy, desc, selectedIds, expan
         sortOrder: createSortOrderReducerInitialState(sortBy, desc),
         selectedIds: createSelectedIdsReducerInitialState(selectedIds),
         expandedRows: createSelectedIdsReducerInitialState(expandedRows),
+        fields: { lastSelectedId: undefined },
     });
 };
 var createStandardTableReducer = function (reducerId) {
     var sortOrder = reducerIdGate(getReducerIdFor(reducerId, "sortOrder"), createSortOrderReducer());
     var selectedIds = reducerIdGate(getReducerIdFor(reducerId, "selectedIds"), createSelectedIdsReducer());
     var expandedRows = reducerIdGate(getReducerIdFor(reducerId, "expandedRows"), createSelectedIdsReducer());
+    var fields = reducerIdGate(getReducerIdFor(reducerId, "fields"), createEntityReducer({}));
     return combineReducers({
         sortOrder: sortOrder,
         selectedIds: selectedIds,
         expandedRows: expandedRows,
+        fields: fields,
     });
 };
 
@@ -1203,7 +1207,7 @@ var getStickyPropsPerColumnWithGroups = function (config) {
 
 var createStandardTableActions = function (tableId, actions) {
     return {
-        selectByIds: function (ids) {
+        setSelectedIds: function (ids) {
             return reducerIdGateAction(getReducerIdFor(tableId, "selectedIds"), actions.selectedIds.setSelectedIds(ids));
         },
         clearSelection: function () {
@@ -1221,6 +1225,9 @@ var createStandardTableActions = function (tableId, actions) {
         clearSortOrder: function () {
             return reducerIdGateAction(getReducerIdFor(tableId, "sortOrder"), actions.sortOrder.clearSortOrder());
         },
+        setLastSelectedId: function (lastSelectedId) {
+            return reducerIdGateAction(getReducerIdFor(tableId, "fields"), actions.fields.setEntityFields({ lastSelectedId: lastSelectedId }));
+        },
     };
 };
 
@@ -1297,7 +1304,7 @@ var useColumnValueResolver = function (columnId) {
 };
 
 var StandardTableRowCheckbox = memo(function StandardTableRowCheckbox(_a) {
-    var value = _a.value, onValueChange = _a.onValueChange, colIndex = _a.colIndex, rowIndex = _a.rowIndex, numRows = _a.numRows, disabled = _a.disabled;
+    var value = _a.value, onValueChange = _a.onValueChange, colIndex = _a.colIndex, rowIndex = _a.rowIndex, numRows = _a.numRows, disabled = _a.disabled, onValueChangeAndShift = _a.onValueChangeAndShift, shiftPressedRef = _a.shiftPressedRef;
     var totalNumColumns = useTotalNumColumnsForRows();
     var tableId = useStandardTableId();
     var gridCell = useGridCell(Boolean(value), {
@@ -1308,27 +1315,82 @@ var StandardTableRowCheckbox = memo(function StandardTableRowCheckbox(_a) {
         tableId: tableId,
     });
     var requiredProps = gridCell.requiredProps;
-    return (createElement(Checkbox, __assign({ size: "small", disabled: disabled, value: value, onValueChange: onValueChange }, requiredProps)));
+    var internalOnValueChange = useCallback(function (value) {
+        if (shiftPressedRef.current) {
+            onValueChangeAndShift === null || onValueChangeAndShift === void 0 ? void 0 : onValueChangeAndShift(value);
+        }
+        else {
+            onValueChange === null || onValueChange === void 0 ? void 0 : onValueChange(value);
+        }
+    }, [onValueChange, onValueChangeAndShift, shiftPressedRef]);
+    return (createElement(Checkbox, __assign({ size: "small", disabled: disabled, value: value, onValueChange: internalOnValueChange }, requiredProps)));
 });
 
-var useRowCheckbox = function (item) {
+var getIdsBetweenSelected = function (idList, selected1, selected2) {
+    if (selected1 == null || selected2 == null || idList == null) {
+        return undefined;
+    }
+    if (selected1 === selected2) {
+        return undefined;
+    }
+    var i1 = idList.indexOf(selected1);
+    var i2 = idList.indexOf(selected2);
+    if (i1 < 0 || i2 < 0) {
+        return undefined;
+    }
+    var start = Math.min(i1, i2);
+    var end = Math.max(i1, i2);
+    return idList.slice(start, end + 1);
+};
+
+var useRowCheckbox = function (item, itemIdList) {
     var keyResolver = useStandardTableConfig().keyResolver;
-    var selectedIds = useStandardTableState().selectedIds.selectedIds;
-    var _a = useStandardTableActions(), selectByIds = _a.actions.selectByIds, dispatch = _a.dispatch;
+    var _a = useStandardTableState(), selectedIds = _a.selectedIds.selectedIds, lastSelectedId = _a.fields.lastSelectedId;
+    var _b = useStandardTableActions(), _c = _b.actions, setSelectedIds = _c.setSelectedIds, setLastSelectedId = _c.setLastSelectedId, dispatch = _b.dispatch;
     var itemKey = useMemo(function () { return keyResolver(item); }, [keyResolver, item]);
     var isSelected = useMemo(function () { return selectedIds.includes(itemKey); }, [
         selectedIds,
         itemKey,
     ]);
-    var toggle = useArraySet(selectedIds, function (ids) {
-        return dispatch(selectByIds(ids));
-    }).toggle;
+    var _d = useArraySet(selectedIds, function (ids) { return dispatch(setSelectedIds(ids)); }), toggle = _d.toggle, addMultiple = _d.addMultiple, removeMultiple = _d.removeMultiple;
+    var shiftAndToggleSelected = useCallback(function () {
+        if (itemIdList && lastSelectedId) {
+            var idList = getIdsBetweenSelected(itemIdList, lastSelectedId, itemKey);
+            if (idList === null || idList === void 0 ? void 0 : idList.length) {
+                if (isSelected) {
+                    removeMultiple(idList);
+                }
+                else {
+                    addMultiple(idList);
+                }
+            }
+            else {
+                toggle(itemKey);
+            }
+        }
+        else {
+            toggle(itemKey);
+        }
+        dispatch(setLastSelectedId(itemKey));
+    }, [
+        itemIdList,
+        lastSelectedId,
+        dispatch,
+        setLastSelectedId,
+        itemKey,
+        isSelected,
+        removeMultiple,
+        addMultiple,
+        toggle,
+    ]);
     var toggleSelected = useCallback(function () {
         toggle(itemKey);
-    }, [toggle, itemKey]);
+        dispatch(setLastSelectedId(itemKey));
+    }, [toggle, itemKey, dispatch, setLastSelectedId]);
     return {
         isSelected: isSelected,
         toggleSelected: toggleSelected,
+        shiftAndToggleSelected: shiftAndToggleSelected,
     };
 };
 
@@ -1560,7 +1622,7 @@ var TrWithHoverBackground = styled.tr(templateObject_1 || (templateObject_1 = __
 var templateObject_1;
 
 var StandardTableRow = memo(function StandardTableRow(_a) {
-    var item = _a.item, rowIndex = _a.rowIndex, numRows = _a.numRows, colIndexOffset = _a.colIndexOffset, alwaysVisible = _a.alwaysVisible;
+    var item = _a.item, itemIdList = _a.itemIdList, rowIndex = _a.rowIndex, numRows = _a.numRows, colIndexOffset = _a.colIndexOffset, alwaysVisible = _a.alwaysVisible, shiftPressedRef = _a.shiftPressedRef;
     var trRef = useRef(null);
     var totalNumColumns = useTotalNumColumns();
     var stickyCheckboxColumn = useStandardTableConfig().stickyCheckboxColumn;
@@ -1568,7 +1630,7 @@ var StandardTableRow = memo(function StandardTableRow(_a) {
     var columnIndexPerColumnId = useColumnIndexPerColumnIdContext().columnIndexPerColumnId;
     var _b = useStandardTableConfig(), showRowCheckbox = _b.showRowCheckbox, rowBackgroundResolver = _b.rowBackgroundResolver, checkboxDisabledResolver = _b.checkboxDisabledResolver, enableGridCell = _b.enableGridCell, rowIndent = _b.rowIndent, enableExpandCollapse = _b.enableExpandCollapse;
     var isExpanded = useExpandCollapseActions(item).isExpanded;
-    var _c = useRowCheckbox(item), isSelected = _c.isSelected, toggleSelected = _c.toggleSelected;
+    var _c = useRowCheckbox(item, itemIdList), isSelected = _c.isSelected, toggleSelected = _c.toggleSelected, shiftAndToggleSelected = _c.shiftAndToggleSelected;
     var visible = useOnScreen(trRef, {
         rootMargin: "400px 0px 400px 0px",
         threshold: 0,
@@ -1621,7 +1683,7 @@ var StandardTableRow = memo(function StandardTableRow(_a) {
                         : undefined,
                 } },
                 createElement(Row, { width: "var(--swui-checkbox-cell-width)", minWidth: "var(--swui-checkbox-cell-width)", alignItems: "center", justifyContent: "center" },
-                    createElement(StandardTableRowCheckbox, { disabled: disabled, value: isSelected, onValueChange: toggleSelected, colIndex: colIndexOffset + (enableExpandCollapse ? 1 : 0), rowIndex: rowIndex, numRows: numRows })))),
+                    createElement(StandardTableRowCheckbox, { disabled: disabled, value: isSelected, onValueChange: toggleSelected, onValueChangeAndShift: shiftAndToggleSelected, colIndex: colIndexOffset + (enableExpandCollapse ? 1 : 0), rowIndex: rowIndex, numRows: numRows, shiftPressedRef: shiftPressedRef })))),
             groupConfigsAndIds.map(function (_a, groupIndex) {
                 var groupConfig = _a.groupConfig, groupId = _a.groupId;
                 return (createElement(Fragment, { key: groupId }, groupConfig.columnOrder.map(function (columnId, index) { return (createElement(StandardTableCell, { key: columnId, columnId: columnId, item: item, colIndex: colIndexOffset + columnIndexPerColumnId[columnId], rowIndex: rowIndex, numRows: numRows, borderFromGroup: getCellBorderFromGroup(groupIndex, index, groupConfig.borderLeft), disableBorderLeft: groupIndex === 0 && index === 0 })); })));
@@ -1644,6 +1706,8 @@ var StandardTableRow = memo(function StandardTableRow(_a) {
         numRows,
         rowIndent,
         rowIndex,
+        shiftAndToggleSelected,
+        shiftPressedRef,
         showRowCheckbox,
         stickyCheckboxColumn,
         toggleSelected,
@@ -1698,6 +1762,7 @@ var StandardTableRowList = memo(function StandardTableRowList(_a) {
      * rows after sorting.
      */
     var sortCounterRef = useRef(0);
+    var shiftPressedRef = useRef(false);
     var _d = useStandardTableConfig(), keyResolver = _d.keyResolver, disableInfiniteList = _d.disableInfiniteList;
     var _e = useStandardTableState().sortOrder, sortBy = _e.sortBy, desc = _e.desc;
     var valueResolver = useColumnValueResolver(sortBy);
@@ -1718,7 +1783,29 @@ var StandardTableRowList = memo(function StandardTableRowList(_a) {
         sortCounterRef.current++;
         return sortedList;
     }, [items, valueResolver, desc]);
-    return (createElement(Fragment, { key: sortCounterRef.current }, sortedItems.map(function (item, index) { return (createElement(StandardTableRow, { alwaysVisible: disableInfiniteList || sortedItems.length < 30, item: item, key: keyResolver(item), colIndexOffset: colIndexOffset, rowIndex: index + rowIndexOffset, numRows: sortedItems.length })); })));
+    var itemIdList = useMemo(function () { return sortedItems.map(function (l) { return keyResolver(l); }); }, [
+        sortedItems,
+        keyResolver,
+    ]);
+    useEffect(function () {
+        var keyUp = function (ev) {
+            if (ev.key === "Shift") {
+                shiftPressedRef.current = false;
+            }
+        };
+        var keyDown = function (ev) {
+            if (ev.key === "Shift") {
+                shiftPressedRef.current = true;
+            }
+        };
+        document.addEventListener("keyup", keyUp);
+        document.addEventListener("keydown", keyDown);
+        return function () {
+            document.removeEventListener("keyup", keyUp);
+            document.removeEventListener("keydown", keyDown);
+        };
+    }, []);
+    return (createElement(Fragment, { key: sortCounterRef.current }, sortedItems.map(function (item, index) { return (createElement(StandardTableRow, { alwaysVisible: disableInfiniteList || sortedItems.length < 30, item: item, itemIdList: itemIdList, key: itemIdList[index], colIndexOffset: colIndexOffset, rowIndex: index + rowIndexOffset, numRows: sortedItems.length, shiftPressedRef: shiftPressedRef })); })));
 });
 
 var StandardTableContent = memo(function StandardTableContent(_a) {
@@ -1752,7 +1839,7 @@ var StandardTableContent = memo(function StandardTableContent(_a) {
 var useTableHeadCheckbox = function (items) {
     var keyResolver = useStandardTableConfig().keyResolver;
     var selectedIds = useStandardTableState().selectedIds.selectedIds;
-    var _a = useStandardTableActions(), _b = _a.actions, selectByIds = _b.selectByIds, clearSelection = _b.clearSelection, dispatch = _a.dispatch;
+    var _a = useStandardTableActions(), _b = _a.actions, setSelectedIds = _b.setSelectedIds, clearSelection = _b.clearSelection, dispatch = _a.dispatch;
     var selectionIsEmpty = selectedIds.length === 0;
     var allItemsAreSelected = !items
         ? false
@@ -1760,7 +1847,7 @@ var useTableHeadCheckbox = function (items) {
     var onClickCheckbox = useCallback(function () {
         if (items) {
             if (selectionIsEmpty) {
-                dispatch(selectByIds(items.map(function (item) { return keyResolver(item); })));
+                dispatch(setSelectedIds(items.map(function (item) { return keyResolver(item); })));
             }
             else {
                 dispatch(clearSelection());
@@ -1772,7 +1859,7 @@ var useTableHeadCheckbox = function (items) {
         dispatch,
         items,
         keyResolver,
-        selectByIds,
+        setSelectedIds,
     ]);
     return {
         selectionIsEmpty: selectionIsEmpty,
@@ -1965,12 +2052,10 @@ var StandardTable = function StandardTable(_a) {
     var localTableContext = useLocalStateTableContext(tableId !== null && tableId !== void 0 ? tableId : generatedTableId, createStandardTableInitialState(initialSortOrder, initialSortOrderDesc)).tableContext;
     var currentTableContext = tableContext || localTableContext;
     var state = currentTableContext.state, actions = currentTableContext.actions, dispatch = currentTableContext.dispatch;
-    var actionsContext = useMemo(function () {
-        return {
-            actions: actions,
-            dispatch: dispatch,
-        };
-    }, [actions, dispatch]);
+    var actionsContext = useMemo(function () { return ({
+        actions: actions,
+        dispatch: dispatch,
+    }); }, [actions, dispatch]);
     var usingColumnGroups = Boolean(columnGroupOrder !== null && columnGroupOrder !== void 0 ? columnGroupOrder : "columnGroupOrder" in config);
     var columnGroupsFromConfig = "columnGroups" in config ? config.columnGroups : undefined;
     var columnGroupOrderFromConfig = "columnGroupOrder" in config ? config.columnGroupOrder : undefined;