@hitachivantara/uikit-react-lab 3.38.0

package/dist/legacy/Table/hooks/useRowSelection.d.ts

@@ -0,0 +1,75 @@
+import { ChangeEvent } from "react";
+import { Hooks, IdType, PropGetter, Row } from "react-table";
+
+// getRowProps:
+export interface UseHvRowSelectionTableRowProps {
+  selected?: boolean;
+}
+
+export interface UseHvRowSelectionRowCheckboxProps {
+  onChange?: (e: ChangeEvent, checked?: boolean) => void;
+  checked?: boolean;
+  disabled?: boolean;
+  indeterminate?: boolean;
+}
+
+export interface UseHvRowSelectionBulkCheckboxProps {
+  onChange?: (e: ChangeEvent, checked?: boolean) => void;
+  checked?: boolean;
+  indeterminate?: boolean;
+}
+
+export type UseHvRowSelectionTableOptions = Partial<{
+  autoResetSelectedRows: boolean;
+  autoResetLockedSelectionRows: boolean;
+  selectSubRows: boolean;
+  manualRowSelectedKey: string;
+  applyToggleAllRowsSelectedToPrefilteredRows: boolean;
+}>;
+
+export interface UseHvRowSelectionHooks<D extends object> {
+  getToggleRowSelectedProps: Array<PropGetter<D, UseHvRowSelectionRowCheckboxProps>>;
+  getToggleAllRowsSelectedProps: Array<PropGetter<D, UseHvRowSelectionBulkCheckboxProps>>;
+  getToggleAllPageRowsSelectedProps: Array<PropGetter<D, UseHvRowSelectionBulkCheckboxProps>>;
+}
+
+export interface UseHvRowSelectionState<D extends object> {
+  selectedRowIds: Record<IdType<D>, boolean>;
+  lockedSelectionRowIds: Record<IdType<D>, boolean>;
+}
+
+export interface UseHvRowSelectionTableInstance<D extends object> {
+  toggleRowSelected: (rowId: IdType<D>, set?: boolean) => void;
+  toggleAllRowsSelected: (value?: boolean) => void;
+  toggleAllPageRowsSelected: (value?: boolean) => void;
+  getToggleAllRowsSelectedProps: (
+    props?: Partial<UseHvRowSelectionBulkCheckboxProps>
+  ) => UseHvRowSelectionBulkCheckboxProps;
+  getToggleAllPageRowsSelectedProps: (
+    props?: Partial<UseHvRowSelectionBulkCheckboxProps>
+  ) => UseHvRowSelectionBulkCheckboxProps;
+
+  isNoRowsSelected: boolean;
+  isNoPageRowsSelected: boolean;
+  isAllRowsSelected: boolean;
+  isAllPageRowsSelected: boolean;
+  isAllSelectableRowsSelected: boolean;
+  isAllSelectablePageRowsSelected: boolean;
+  isAllSelectableRowsUnselected: boolean;
+  isAllSelectablePageRowsUnselected: boolean;
+
+  selectedFlatRows: Array<Row<D>>;
+}
+
+export interface UseHvRowSelectionRowInstance {
+  isSelected: boolean;
+  isSomeSelected: boolean;
+  toggleRowSelected: (set?: boolean) => void;
+  getToggleRowSelectedProps: (
+    props?: Partial<UseHvRowSelectionRowCheckboxProps>
+  ) => UseHvRowSelectionRowCheckboxProps;
+}
+
+export default function useRowSelection<D extends object = Record<string, unknown>>(
+  hooks: Hooks<D>
+): void;

package/dist/legacy/Table/hooks/useRowSelection.js

@@ -0,0 +1,563 @@
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.object.get-own-property-descriptor.js";
+import "core-js/modules/es.object.get-own-property-descriptors.js";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+import "core-js/modules/es.array.concat.js";
+import "core-js/modules/es.object.keys.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import "core-js/modules/es.array.filter.js";
+
+/* eslint-disable no-param-reassign */
+
+/* eslint-disable react/prop-types */
+import React from "react";
+import { actions, ensurePluginOrder, useGetLatest, useMountedLayoutEffect, makePropGetter } from "react-table";
+import { HvCheckBox, useLabels } from "@hitachivantara/uikit-react-core"; // Actions
+
+actions.resetSelectedRows = "resetSelectedRows";
+actions.toggleAllRowsSelected = "toggleAllRowsSelected";
+actions.toggleRowSelected = "toggleRowSelected";
+actions.toggleAllPageRowsSelected = "toggleAllPageRowsSelected";
+actions.resetLockedSelectionRows = "resetLockedSelectionRows";
+actions.toggleRowLockedSelection = "toggleRowLockedSelection";
+export var DEFAULT_LABELS = {
+  selectRowCheckBoxAriaLabel: "Select this row"
+};
+export var CellWithCheckBox = function CellWithCheckBox(_ref) {
+  var row = _ref.row,
+      labelsProp = _ref.labels;
+  var labels = useLabels(DEFAULT_LABELS, labelsProp);
+
+  var _row$getToggleRowSele = row.getToggleRowSelectedProps(),
+      onChange = _row$getToggleRowSele.onChange,
+      checked = _row$getToggleRowSele.checked,
+      disabled = _row$getToggleRowSele.disabled,
+      indeterminate = _row$getToggleRowSele.indeterminate;
+
+  return /*#__PURE__*/React.createElement(HvCheckBox, {
+    onChange: onChange,
+    checked: checked,
+    disabled: disabled,
+    indeterminate: indeterminate,
+    "aria-label": labels.selectRowCheckBoxAriaLabel
+  });
+};
+export var visibleColumnsHook = function visibleColumnsHook(columns) {
+  var selectionColumn = {
+    id: "_hv_selection",
+    variant: "checkbox",
+    width: 32,
+    // this will only work when using useHvTableSticky
+    // but ensures it stays left of any sticky column
+    sticky: "left",
+    Cell: CellWithCheckBox
+  };
+  return [selectionColumn].concat(_toConsumableArray(columns));
+};
+export var getRowPropsHook = function getRowPropsHook(props, _ref2) {
+  var row = _ref2.row;
+  var nextProps = {
+    selected: row.isSelected
+  };
+  return [props, nextProps];
+};
+export var defaultGetToggleRowSelectedProps = function defaultGetToggleRowSelectedProps(props, _ref3) {
+  var instance = _ref3.instance,
+      row = _ref3.row;
+  var _instance$manualRowSe = instance.manualRowSelectedKey,
+      manualRowSelectedKey = _instance$manualRowSe === void 0 ? "isSelected" : _instance$manualRowSe;
+  var checked = false;
+
+  if (row.original && row.original[manualRowSelectedKey]) {
+    checked = true;
+  } else {
+    checked = row.isSelected;
+  }
+
+  return [props, {
+    onChange: function onChange(e, check) {
+      var _e$target;
+
+      row.toggleRowSelected(check !== null && check !== void 0 ? check : e === null || e === void 0 ? void 0 : (_e$target = e.target) === null || _e$target === void 0 ? void 0 : _e$target.checked);
+    },
+    disabled: row.isSelectionLocked,
+    checked: checked,
+    indeterminate: row.isSomeSelected
+  }];
+};
+export var defaultGetToggleAllRowsSelectedProps = function defaultGetToggleAllRowsSelectedProps(props, _ref4) {
+  var instance = _ref4.instance;
+  return [props, {
+    onChange: function onChange(e) {
+      instance.toggleAllRowsSelected(e.target.checked);
+    },
+    checked: instance.isAllRowsSelected,
+    indeterminate: Boolean(!instance.isAllRowsSelected && Object.keys(instance.state.selectedRowIds).length)
+  }];
+};
+export var defaultGetToggleAllPageRowsSelectedProps = function defaultGetToggleAllPageRowsSelectedProps(props, _ref5) {
+  var instance = _ref5.instance;
+  return [props, {
+    onChange: function onChange(e) {
+      instance.toggleAllPageRowsSelected(e.target.checked);
+    },
+    checked: instance.isAllPageRowsSelected,
+    indeterminate: Boolean(!instance.isAllPageRowsSelected && instance.page.some(function (_ref6) {
+      var id = _ref6.id;
+      return instance.state.selectedRowIds[id];
+    }))
+  }];
+};
+export function reducer(state, action, previousState, instance) {
+  if (action.type === actions.init) {
+    return _objectSpread({
+      selectedRowIds: {},
+      lockedSelectionRowIds: {}
+    }, state);
+  }
+
+  if (action.type === actions.resetSelectedRows) {
+    return _objectSpread(_objectSpread({}, state), {}, {
+      selectedRowIds: instance.initialState.selectedRowIds || {}
+    });
+  }
+
+  if (action.type === actions.toggleAllRowsSelected) {
+    var setSelected = action.value;
+    var isAllRowsSelected = instance.isAllRowsSelected,
+        rowsById = instance.rowsById,
+        initialRowsById = instance.initialRowsById,
+        _instance$nonGroupedR = instance.nonGroupedRowsById,
+        nonGroupedRowsById = _instance$nonGroupedR === void 0 ? rowsById : _instance$nonGroupedR,
+        applyToggleAllRowsSelectedToPrefilteredRows = instance.applyToggleAllRowsSelectedToPrefilteredRows;
+    var rowsToSelect = applyToggleAllRowsSelectedToPrefilteredRows ? initialRowsById : nonGroupedRowsById;
+    var selectAll = typeof setSelected !== "undefined" ? setSelected : !isAllRowsSelected; // Only remove/add the rows that are visible on the screen
+    //  Leave all the other rows that are selected alone.
+
+    var selectedRowIds = _objectSpread({}, state.selectedRowIds);
+
+    if (selectAll) {
+      Object.keys(rowsToSelect).forEach(function (rowId) {
+        var isSelectionLocked = state.lockedSelectionRowIds[rowId];
+
+        if (!isSelectionLocked) {
+          selectedRowIds[rowId] = true;
+        }
+      });
+    } else {
+      Object.keys(rowsToSelect).forEach(function (rowId) {
+        var isSelectionLocked = state.lockedSelectionRowIds[rowId];
+
+        if (!isSelectionLocked) {
+          delete selectedRowIds[rowId];
+        }
+      });
+    }
+
+    return _objectSpread(_objectSpread({}, state), {}, {
+      selectedRowIds: selectedRowIds
+    });
+  }
+
+  if (action.type === actions.toggleRowSelected) {
+    var id = action.id,
+        _setSelected = action.value;
+    var isSelectionLocked = state.lockedSelectionRowIds[id];
+
+    if (isSelectionLocked) {
+      return state;
+    }
+
+    var _rowsById = instance.rowsById,
+        _instance$selectSubRo = instance.selectSubRows,
+        selectSubRows = _instance$selectSubRo === void 0 ? true : _instance$selectSubRo,
+        getSubRows = instance.getSubRows;
+    var isSelected = state.selectedRowIds[id];
+    var shouldExist = typeof _setSelected !== "undefined" ? _setSelected : !isSelected;
+
+    if (isSelected === shouldExist) {
+      return state;
+    }
+
+    var newSelectedRowIds = _objectSpread({}, state.selectedRowIds);
+
+    var handleRowById = function handleRowById(rowId) {
+      var row = _rowsById[rowId];
+
+      if (!row.isGrouped) {
+        if (shouldExist) {
+          newSelectedRowIds[rowId] = true;
+        } else {
+          delete newSelectedRowIds[rowId];
+        }
+      }
+
+      if (selectSubRows && getSubRows(row)) {
+        getSubRows(row).forEach(function (subrow) {
+          handleRowById(subrow.id);
+        });
+      }
+    };
+
+    handleRowById(id);
+    return _objectSpread(_objectSpread({}, state), {}, {
+      selectedRowIds: newSelectedRowIds
+    });
+  }
+
+  if (action.type === actions.toggleAllPageRowsSelected) {
+    var _setSelected2 = action.value;
+
+    var page = instance.page,
+        _rowsById2 = instance.rowsById,
+        _instance$selectSubRo2 = instance.selectSubRows,
+        _selectSubRows = _instance$selectSubRo2 === void 0 ? true : _instance$selectSubRo2,
+        isAllPageRowsSelected = instance.isAllPageRowsSelected,
+        _getSubRows = instance.getSubRows;
+
+    var _selectAll = typeof _setSelected2 !== "undefined" ? _setSelected2 : !isAllPageRowsSelected;
+
+    var _newSelectedRowIds = _objectSpread({}, state.selectedRowIds);
+
+    var _handleRowById = function _handleRowById(rowId) {
+      var row = _rowsById2[rowId];
+      var isSelectionLocked = state.lockedSelectionRowIds[rowId];
+
+      if (!isSelectionLocked && !row.isGrouped) {
+        if (_selectAll) {
+          _newSelectedRowIds[rowId] = true;
+        } else {
+          delete _newSelectedRowIds[rowId];
+        }
+      }
+
+      if (_selectSubRows && _getSubRows(row)) {
+        _getSubRows(row).forEach(function (subrow) {
+          _handleRowById(subrow.id);
+        });
+      }
+    };
+
+    page.forEach(function (row) {
+      return _handleRowById(row.id);
+    });
+    return _objectSpread(_objectSpread({}, state), {}, {
+      selectedRowIds: _newSelectedRowIds
+    });
+  }
+
+  if (action.type === actions.resetLockedSelectionRows) {
+    return _objectSpread(_objectSpread({}, state), {}, {
+      lockedSelectionRowIds: instance.initialState.lockedSelectionRowIds || {}
+    });
+  }
+
+  if (action.type === actions.toggleRowLockedSelection) {
+    var _id = action.id,
+        setLockedSelection = action.value;
+
+    var _rowsById3 = instance.rowsById,
+        _instance$selectSubRo3 = instance.selectSubRows,
+        _selectSubRows2 = _instance$selectSubRo3 === void 0 ? true : _instance$selectSubRo3,
+        _getSubRows2 = instance.getSubRows;
+
+    var isLockedSelection = state.lockedSelectionRowIds[_id];
+
+    var _shouldExist = typeof setLockedSelection !== "undefined" ? setLockedSelection : !isLockedSelection;
+
+    if (isLockedSelection === _shouldExist) {
+      return state;
+    }
+
+    var newLockedSelectionRowIds = _objectSpread({}, state.lockedSelectionRowIds);
+
+    var _handleRowById2 = function _handleRowById2(rowId) {
+      var row = _rowsById3[rowId];
+
+      if (!row.isGrouped) {
+        if (_shouldExist) {
+          newLockedSelectionRowIds[rowId] = true;
+        } else {
+          delete newLockedSelectionRowIds[rowId];
+        }
+      }
+
+      if (_selectSubRows2 && _getSubRows2(row)) {
+        _getSubRows2(row).forEach(function (subrow) {
+          _handleRowById2(subrow.id);
+        });
+      }
+    };
+
+    _handleRowById2(_id);
+
+    return _objectSpread(_objectSpread({}, state), {}, {
+      lockedSelectionRowIds: newLockedSelectionRowIds
+    });
+  }
+
+  return state;
+}
+
+function getRowIsSelected(row, selectedRowIds, getSubRows) {
+  if (selectedRowIds[row.id]) {
+    return true;
+  }
+
+  var subRows = getSubRows(row);
+
+  if (subRows && subRows.length) {
+    var allChildrenSelected = true;
+    var someSelected = false;
+    subRows.forEach(function (subRow) {
+      // Bail out early if we know both of these
+      if (someSelected && !allChildrenSelected) {
+        return;
+      }
+
+      if (getRowIsSelected(subRow, selectedRowIds, getSubRows)) {
+        someSelected = true;
+      } else {
+        allChildrenSelected = false;
+      }
+    });
+
+    if (allChildrenSelected) {
+      return true;
+    }
+
+    if (someSelected) {
+      return null;
+    }
+  }
+
+  return false;
+}
+
+export function useInstance(instance) {
+  var data = instance.data,
+      rows = instance.rows,
+      getHooks = instance.getHooks,
+      plugins = instance.plugins,
+      rowsById = instance.rowsById,
+      initialRowsById = instance.initialRowsById,
+      _instance$nonGroupedR2 = instance.nonGroupedRowsById,
+      nonGroupedRowsById = _instance$nonGroupedR2 === void 0 ? rowsById : _instance$nonGroupedR2,
+      _instance$autoResetSe = instance.autoResetSelectedRows,
+      autoResetSelectedRows = _instance$autoResetSe === void 0 ? true : _instance$autoResetSe,
+      _instance$autoResetLo = instance.autoResetLockedSelectionRows,
+      autoResetLockedSelectionRows = _instance$autoResetLo === void 0 ? true : _instance$autoResetLo,
+      _instance$state = instance.state,
+      selectedRowIds = _instance$state.selectedRowIds,
+      lockedSelectionRowIds = _instance$state.lockedSelectionRowIds,
+      _instance$selectSubRo4 = instance.selectSubRows,
+      selectSubRows = _instance$selectSubRo4 === void 0 ? true : _instance$selectSubRo4,
+      dispatch = instance.dispatch,
+      page = instance.page,
+      getSubRows = instance.getSubRows,
+      applyToggleAllRowsSelectedToPrefilteredRows = instance.applyToggleAllRowsSelectedToPrefilteredRows;
+  ensurePluginOrder(plugins, ["useFilters", "useGroupBy", "useSortBy", "useExpanded", "usePagination"], "useHvRowSelection");
+  var rowsToSelect = applyToggleAllRowsSelectedToPrefilteredRows ? initialRowsById : nonGroupedRowsById;
+  var selectedFlatRows = React.useMemo(function () {
+    var selectedRows = [];
+    rows.forEach(function (row) {
+      var isSelected = selectSubRows ? getRowIsSelected(row, selectedRowIds, getSubRows) : !!selectedRowIds[row.id];
+      row.isSelected = !!isSelected;
+      row.isSomeSelected = isSelected === null;
+
+      if (isSelected) {
+        selectedRows.push(row);
+      }
+    });
+    return selectedRows;
+  }, [rows, selectSubRows, selectedRowIds, getSubRows]);
+  var existsLockedRows = !!Object.keys(lockedSelectionRowIds).length;
+  var isNoRowsSelected = !(Object.keys(rowsToSelect).length && selectedFlatRows.length);
+  var isNoPageRowsSelected;
+  var isAllRowsSelected;
+  var isAllPageRowsSelected;
+  var isAllSelectableRowsUnselected;
+  var isAllSelectablePageRowsUnselected;
+  var isAllSelectableRowsSelected;
+  var isAllSelectablePageRowsSelected;
+
+  if (isNoRowsSelected) {
+    isAllRowsSelected = false;
+    isAllPageRowsSelected = false;
+    isAllSelectableRowsSelected = existsLockedRows && !Object.keys(rowsToSelect).some(function (id) {
+      return !lockedSelectionRowIds[id];
+    });
+    isAllSelectablePageRowsSelected = isAllSelectableRowsSelected;
+    isAllSelectableRowsUnselected = isAllSelectableRowsSelected;
+    isAllSelectablePageRowsUnselected = isAllSelectableRowsSelected;
+    isNoPageRowsSelected = true;
+  } else {
+    isAllRowsSelected = !Object.keys(rowsToSelect).some(function (id) {
+      return !selectedRowIds[id];
+    });
+
+    if (isAllRowsSelected) {
+      isAllSelectableRowsSelected = true;
+      isAllSelectablePageRowsSelected = true;
+      isAllSelectableRowsUnselected = existsLockedRows && Object.keys(rowsToSelect).filter(function (id) {
+        return !lockedSelectionRowIds[id];
+      }).length === 0;
+      isAllSelectablePageRowsUnselected = isAllSelectableRowsUnselected;
+      isNoPageRowsSelected = false;
+      isAllPageRowsSelected = true;
+    } else {
+      isAllSelectableRowsSelected = existsLockedRows && !Object.keys(rowsToSelect).filter(function (id) {
+        return !lockedSelectionRowIds[id];
+      }).some(function (id) {
+        return !selectedRowIds[id];
+      });
+      isAllSelectableRowsUnselected = !existsLockedRows || !Object.keys(rowsToSelect).filter(function (id) {
+        return !lockedSelectionRowIds[id];
+      }).some(function (id) {
+        return selectedRowIds[id];
+      });
+      isAllPageRowsSelected = !(page && page.length && page.some(function (_ref7) {
+        var id = _ref7.id;
+        return !selectedRowIds[id];
+      }));
+
+      if (isAllPageRowsSelected) {
+        isAllSelectablePageRowsSelected = true;
+        isAllSelectablePageRowsUnselected = existsLockedRows && page && page.length && page.filter(function (_ref8) {
+          var id = _ref8.id;
+          return !lockedSelectionRowIds[id];
+        }).length === 0;
+        isNoPageRowsSelected = false;
+      } else {
+        isAllSelectablePageRowsSelected = existsLockedRows && !(page && page.length && page.filter(function (_ref9) {
+          var id = _ref9.id;
+          return !lockedSelectionRowIds[id];
+        }).some(function (_ref10) {
+          var id = _ref10.id;
+          return !selectedRowIds[id];
+        }));
+        isAllSelectablePageRowsUnselected = !existsLockedRows || !(page && page.length && page.filter(function (_ref11) {
+          var id = _ref11.id;
+          return !lockedSelectionRowIds[id];
+        }).some(function (_ref12) {
+          var id = _ref12.id;
+          return selectedRowIds[id];
+        }));
+        isNoPageRowsSelected = !(page && page.length && page.some(function (_ref13) {
+          var id = _ref13.id;
+          return selectedRowIds[id];
+        }));
+      }
+    }
+  }
+
+  var getAutoResetSelectedRows = useGetLatest(autoResetSelectedRows);
+  var getAutoResetLockedSelectionRows = useGetLatest(autoResetLockedSelectionRows);
+  useMountedLayoutEffect(function () {
+    if (getAutoResetSelectedRows()) {
+      dispatch({
+        type: actions.resetSelectedRows
+      });
+    }
+
+    if (getAutoResetLockedSelectionRows()) {
+      dispatch({
+        type: actions.resetLockedSelectionRows
+      });
+    }
+  }, [dispatch, data]);
+  var toggleAllRowsSelected = React.useCallback(function (value) {
+    return dispatch({
+      type: actions.toggleAllRowsSelected,
+      value: value
+    });
+  }, [dispatch]);
+  var toggleAllPageRowsSelected = React.useCallback(function (value) {
+    return dispatch({
+      type: actions.toggleAllPageRowsSelected,
+      value: value
+    });
+  }, [dispatch]);
+  var toggleRowSelected = React.useCallback(function (id, value) {
+    return dispatch({
+      type: actions.toggleRowSelected,
+      id: id,
+      value: value
+    });
+  }, [dispatch]);
+  var getInstance = useGetLatest(instance);
+  var getToggleAllRowsSelectedProps = makePropGetter(getHooks().getToggleAllRowsSelectedProps, {
+    instance: getInstance()
+  });
+  var getToggleAllPageRowsSelectedProps = makePropGetter(getHooks().getToggleAllPageRowsSelectedProps, {
+    instance: getInstance()
+  });
+  var toggleRowLockedSelection = React.useCallback(function (id, value) {
+    return dispatch({
+      type: actions.toggleRowLockedSelection,
+      id: id,
+      value: value
+    });
+  }, [dispatch]);
+
+  _extends(instance, {
+    selectedFlatRows: selectedFlatRows,
+    isNoRowsSelected: isNoRowsSelected,
+    isNoPageRowsSelected: isNoPageRowsSelected,
+    isAllRowsSelected: isAllRowsSelected,
+    isAllPageRowsSelected: isAllPageRowsSelected,
+    isAllSelectableRowsSelected: isAllSelectableRowsSelected,
+    isAllSelectablePageRowsSelected: isAllSelectablePageRowsSelected,
+    isAllSelectableRowsUnselected: isAllSelectableRowsUnselected,
+    isAllSelectablePageRowsUnselected: isAllSelectablePageRowsUnselected,
+    toggleRowSelected: toggleRowSelected,
+    toggleAllRowsSelected: toggleAllRowsSelected,
+    getToggleAllRowsSelectedProps: getToggleAllRowsSelectedProps,
+    getToggleAllPageRowsSelectedProps: getToggleAllPageRowsSelectedProps,
+    toggleAllPageRowsSelected: toggleAllPageRowsSelected,
+    toggleRowLockedSelection: toggleRowLockedSelection
+  });
+}
+export function prepareRow(row, _ref14) {
+  var _instance$state2, _instance$state2$lock;
+
+  var instance = _ref14.instance;
+
+  row.toggleRowSelected = function (set) {
+    return instance.toggleRowSelected(row.id, set);
+  };
+
+  row.getToggleRowSelectedProps = makePropGetter(instance.getHooks().getToggleRowSelectedProps, {
+    instance: instance,
+    row: row
+  });
+
+  row.toggleRowLockedSelection = function (set) {
+    return instance.toggleRowLockedSelection(row.id, set);
+  };
+
+  row.isSelectionLocked = ((_instance$state2 = instance.state) === null || _instance$state2 === void 0 ? void 0 : (_instance$state2$lock = _instance$state2.lockedSelectionRowIds) === null || _instance$state2$lock === void 0 ? void 0 : _instance$state2$lock[row.id]) || false;
+}
+
+var useRowSelection = function useRowSelection(hooks) {
+  hooks.visibleColumns.push(visibleColumnsHook);
+  hooks.getRowProps.push(getRowPropsHook);
+  hooks.getToggleRowSelectedProps = [defaultGetToggleRowSelectedProps];
+  hooks.getToggleAllRowsSelectedProps = [defaultGetToggleAllRowsSelectedProps];
+  hooks.getToggleAllPageRowsSelectedProps = [defaultGetToggleAllPageRowsSelectedProps];
+  hooks.stateReducers.push(reducer);
+  hooks.useInstance.push(useInstance);
+  hooks.prepareRow.push(prepareRow);
+};
+
+useRowSelection.pluginName = "useHvRowSelection";
+export default useRowSelection;
+//# sourceMappingURL=useRowSelection.js.map