@hitachivantara/uikit-react-lab 3.38.0

package/dist/Table/hooks/useRowSelection.js

@@ -0,0 +1,614 @@
+"use strict";
+
+require("core-js/modules/es.symbol.js");
+
+require("core-js/modules/es.object.get-own-property-descriptor.js");
+
+require("core-js/modules/es.object.get-own-property-descriptors.js");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getRowPropsHook = exports.defaultGetToggleRowSelectedProps = exports.defaultGetToggleAllRowsSelectedProps = exports.defaultGetToggleAllPageRowsSelectedProps = exports.default = exports.DEFAULT_LABELS = exports.CellWithCheckBox = void 0;
+exports.prepareRow = prepareRow;
+exports.reducer = reducer;
+exports.useInstance = useInstance;
+exports.visibleColumnsHook = void 0;
+
+require("core-js/modules/es.array.concat.js");
+
+require("core-js/modules/es.object.keys.js");
+
+require("core-js/modules/es.object.to-string.js");
+
+require("core-js/modules/web.dom-collections.for-each.js");
+
+require("core-js/modules/es.array.filter.js");
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _reactTable = require("react-table");
+
+var _uikitReactCore = require("@hitachivantara/uikit-react-core");
+
+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) { (0, _defineProperty2.default)(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; }
+
+// Actions
+_reactTable.actions.resetSelectedRows = "resetSelectedRows";
+_reactTable.actions.toggleAllRowsSelected = "toggleAllRowsSelected";
+_reactTable.actions.toggleRowSelected = "toggleRowSelected";
+_reactTable.actions.toggleAllPageRowsSelected = "toggleAllPageRowsSelected";
+_reactTable.actions.resetLockedSelectionRows = "resetLockedSelectionRows";
+_reactTable.actions.toggleRowLockedSelection = "toggleRowLockedSelection";
+var DEFAULT_LABELS = {
+  selectRowCheckBoxAriaLabel: "Select this row"
+};
+exports.DEFAULT_LABELS = DEFAULT_LABELS;
+
+var CellWithCheckBox = function CellWithCheckBox(_ref) {
+  var row = _ref.row,
+      labelsProp = _ref.labels;
+  var labels = (0, _uikitReactCore.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.default.createElement(_uikitReactCore.HvCheckBox, {
+    onChange: onChange,
+    checked: checked,
+    disabled: disabled,
+    indeterminate: indeterminate,
+    "aria-label": labels.selectRowCheckBoxAriaLabel
+  });
+};
+
+exports.CellWithCheckBox = CellWithCheckBox;
+
+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((0, _toConsumableArray2.default)(columns));
+};
+
+exports.visibleColumnsHook = visibleColumnsHook;
+
+var getRowPropsHook = function getRowPropsHook(props, _ref2) {
+  var row = _ref2.row;
+  var nextProps = {
+    selected: row.isSelected
+  };
+  return [props, nextProps];
+};
+
+exports.getRowPropsHook = getRowPropsHook;
+
+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
+  }];
+};
+
+exports.defaultGetToggleRowSelectedProps = defaultGetToggleRowSelectedProps;
+
+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)
+  }];
+};
+
+exports.defaultGetToggleAllRowsSelectedProps = defaultGetToggleAllRowsSelectedProps;
+
+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];
+    }))
+  }];
+};
+
+exports.defaultGetToggleAllPageRowsSelectedProps = defaultGetToggleAllPageRowsSelectedProps;
+
+function reducer(state, action, previousState, instance) {
+  if (action.type === _reactTable.actions.init) {
+    return _objectSpread({
+      selectedRowIds: {},
+      lockedSelectionRowIds: {}
+    }, state);
+  }
+
+  if (action.type === _reactTable.actions.resetSelectedRows) {
+    return _objectSpread(_objectSpread({}, state), {}, {
+      selectedRowIds: instance.initialState.selectedRowIds || {}
+    });
+  }
+
+  if (action.type === _reactTable.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 === _reactTable.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 === _reactTable.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 === _reactTable.actions.resetLockedSelectionRows) {
+    return _objectSpread(_objectSpread({}, state), {}, {
+      lockedSelectionRowIds: instance.initialState.lockedSelectionRowIds || {}
+    });
+  }
+
+  if (action.type === _reactTable.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;
+}
+
+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;
+  (0, _reactTable.ensurePluginOrder)(plugins, ["useFilters", "useGroupBy", "useSortBy", "useExpanded", "usePagination"], "useHvRowSelection");
+  var rowsToSelect = applyToggleAllRowsSelectedToPrefilteredRows ? initialRowsById : nonGroupedRowsById;
+
+  var selectedFlatRows = _react.default.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 = (0, _reactTable.useGetLatest)(autoResetSelectedRows);
+  var getAutoResetLockedSelectionRows = (0, _reactTable.useGetLatest)(autoResetLockedSelectionRows);
+  (0, _reactTable.useMountedLayoutEffect)(function () {
+    if (getAutoResetSelectedRows()) {
+      dispatch({
+        type: _reactTable.actions.resetSelectedRows
+      });
+    }
+
+    if (getAutoResetLockedSelectionRows()) {
+      dispatch({
+        type: _reactTable.actions.resetLockedSelectionRows
+      });
+    }
+  }, [dispatch, data]);
+
+  var toggleAllRowsSelected = _react.default.useCallback(function (value) {
+    return dispatch({
+      type: _reactTable.actions.toggleAllRowsSelected,
+      value: value
+    });
+  }, [dispatch]);
+
+  var toggleAllPageRowsSelected = _react.default.useCallback(function (value) {
+    return dispatch({
+      type: _reactTable.actions.toggleAllPageRowsSelected,
+      value: value
+    });
+  }, [dispatch]);
+
+  var toggleRowSelected = _react.default.useCallback(function (id, value) {
+    return dispatch({
+      type: _reactTable.actions.toggleRowSelected,
+      id: id,
+      value: value
+    });
+  }, [dispatch]);
+
+  var getInstance = (0, _reactTable.useGetLatest)(instance);
+  var getToggleAllRowsSelectedProps = (0, _reactTable.makePropGetter)(getHooks().getToggleAllRowsSelectedProps, {
+    instance: getInstance()
+  });
+  var getToggleAllPageRowsSelectedProps = (0, _reactTable.makePropGetter)(getHooks().getToggleAllPageRowsSelectedProps, {
+    instance: getInstance()
+  });
+
+  var toggleRowLockedSelection = _react.default.useCallback(function (id, value) {
+    return dispatch({
+      type: _reactTable.actions.toggleRowLockedSelection,
+      id: id,
+      value: value
+    });
+  }, [dispatch]);
+
+  (0, _extends2.default)(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
+  });
+}
+
+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 = (0, _reactTable.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";
+var _default = useRowSelection;
+exports.default = _default;
+//# sourceMappingURL=useRowSelection.js.map