@elliemae/ds-data-table 2.3.0-alpha.8 → 2.3.0-next.2

package/esm/parts/TableContent.js

@@ -0,0 +1,85 @@
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import React, { useContext, useState, useMemo } from 'react';
+import { connect } from 'react-redux';
+import { StyledDataTableWrapper, StyledTableWrapper } from '../styled.js';
+import DataTableContext from '../DataTableContext.js';
+import { Pagination } from '../addons/Pagination/Pagination.js';
+import VirtualRowsList from './VirtualRowsList.js';
+import { DATA_TESTID } from '../configs/constants.js';
+import 'core-js/modules/esnext.async-iterator.reduce.js';
+import 'core-js/modules/esnext.iterator.reduce.js';
+import 'react-virtual';
+import '../configs/useRowFlattenization.js';
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import '@elliemae/ds-icons';
+import 'styled-components';
+import { jsxs, jsx } from 'react/jsx-runtime';
+import '@elliemae/ds-form';
+import '@elliemae/ds-grid';
+import '@elliemae/ds-circular-progress-indicator';
+import '@elliemae/ds-system';
+import '@elliemae/ds-button';
+import './Row.js';
+import './Footer.js';
+import './HoC/SortableItemContext.js';
+
+var _VirtualRowsList, _Pagination;
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+const mapStateToProps = state => ({
+  reduxFilters: state.filters
+}); // must manually declare typescript types for mapStateToProps props
+// because react-redux is not smart enough
+
+
+const TableContentComponent = props => {
+  const {
+    forwardedRef
+  } = props;
+  const {
+    tableProps: {
+      height,
+      width,
+      pagination
+    },
+    allDataFlattened,
+    visibleColumns
+  } = useContext(DataTableContext);
+  const [shiftKeyPressed, setShiftKeyPressed] = useState(false);
+  const PureTableContent = useMemo(() => /*#__PURE__*/jsxs(StyledDataTableWrapper, {
+    "data-testid": DATA_TESTID.DATA_TABLE_CONTENT_WRAPPER,
+    height: height,
+    width: width,
+    ref: forwardedRef,
+    noSelectionAllowed: shiftKeyPressed,
+    onKeyDown: e => setShiftKeyPressed(prevShiftKeyPressed => prevShiftKeyPressed || e.shiftKey),
+    onKeyUp: e => setShiftKeyPressed(prevShiftKeyPressed => prevShiftKeyPressed && e.code !== 'Shift'),
+    children: [/*#__PURE__*/_jsx(StyledTableWrapper, {
+      role: "table",
+      "aria-rowcount": allDataFlattened.length,
+      "aria-colcount": visibleColumns.length,
+      "data-testid": DATA_TESTID.DATA_TABLE_TABLE,
+      height: height,
+      width: width
+    }, void 0, _VirtualRowsList || (_VirtualRowsList = /*#__PURE__*/_jsx(VirtualRowsList, {}))), pagination ? _Pagination || (_Pagination = /*#__PURE__*/_jsx(Pagination, {})) : null]
+  }), [height, width, forwardedRef, allDataFlattened.length, visibleColumns.length, pagination, shiftKeyPressed]);
+  return PureTableContent;
+};
+
+const ConnectedTableContent = connect(mapStateToProps)(TableContentComponent);
+const TableContent = /*#__PURE__*/React.forwardRef((props, ref) => /*#__PURE__*/jsx(ConnectedTableContent, _objectSpread(_objectSpread({}, props), {}, {
+  forwardedRef: ref
+})));
+
+export { TableContent as default };

package/esm/parts/VirtualRowsList.js

@@ -0,0 +1,103 @@
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import { useContext, useMemo, useCallback } from 'react';
+import { connect } from 'react-redux';
+import RowLoading from './RowLoading.js';
+import EmptyContent from './EmptyContent.js';
+import Rows from './Rows.js';
+import Headers from './Headers/index.js';
+import Footer from './Footer.js';
+import DataTableContext from '../DataTableContext.js';
+import { FIXED_SIZES } from '../configs/fixedSizes.js';
+import { StyledVirtualListWrapper, StyledTableContentWrapper } from '../styled.js';
+import Loader from './Loader.js';
+import '../redux/reducers/index.js';
+import { DATA_TESTID } from '../configs/constants.js';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/esnext.async-iterator.reduce.js';
+import 'core-js/modules/esnext.iterator.reduce.js';
+import 'react-virtual';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import '../configs/useRowFlattenization.js';
+import '@babel/runtime/helpers/esm/defineProperty';
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import '@elliemae/ds-icons';
+import 'styled-components';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import '@elliemae/ds-form';
+import './TableContent.js';
+import './Row.js';
+import './HoC/SortableItemContext.js';
+import { useDispatchRowsActions } from '../redux/reducers/rowsReducers/useDispatchRowsActions.js';
+
+var _Headers, _Loader, _Rows, _Footer, _RowLoading;
+
+function mapStateToProps(state) {
+  return {
+    relativeRowMouseCord: state.rows.relativeRowMouseCord
+  };
+}
+
+const VirtualRowsListComponent = () => {
+  const {
+    virtualListRef,
+    tableProps: {
+      height,
+      width,
+      isLoading,
+      isLoadingAppended
+    },
+    virtualListHelpers,
+    layoutHelpers: {
+      totalColumnsWidth
+    },
+    flattenedData
+  } = useContext(DataTableContext);
+  const {
+    totalSize,
+    scrollToIndex
+  } = virtualListHelpers;
+  const {
+    setFocusedRowId
+  } = useDispatchRowsActions();
+  const isEmptyContent = useMemo(() => !isLoading && flattenedData.length === 0, [isLoading, flattenedData.length]);
+  const tableHeight = useMemo(() => {
+    if (typeof height === 'string') return height.includes('%') ? height : Number.parseInt(height, 10) - FIXED_SIZES.PAGINATION_HEIGHT;
+    return height;
+  }, [height]);
+  const onKeyDown = useCallback(e => {
+    if (e.ctrlKey && e.code === 'End') {
+      scrollToIndex(flattenedData.length - 1);
+      setFocusedRowId(flattenedData[flattenedData.length - 1].uid);
+    } else if (e.ctrlKey && e.code === 'Home') {
+      scrollToIndex(0, {
+        align: 'center'
+      });
+      setFocusedRowId(flattenedData[0].uid);
+    }
+  }, [scrollToIndex, setFocusedRowId, flattenedData]);
+  return /*#__PURE__*/jsx(StyledVirtualListWrapper, {
+    ref: virtualListRef,
+    height: tableHeight,
+    width: width,
+    "data-testid": DATA_TESTID.DATA_TABLE_SCROLLABLE_CONTAINER,
+    onKeyDown: onKeyDown,
+    tabIndex: -1,
+    children: /*#__PURE__*/_jsx(StyledTableContentWrapper, {
+      role: "rowgroup",
+      height: totalSize || '100%'
+    }, void 0, _Headers || (_Headers = /*#__PURE__*/_jsx(Headers, {})), isEmptyContent && /*#__PURE__*/_jsx(EmptyContent, {
+      width: totalColumnsWidth
+    }), isLoading ? _Loader || (_Loader = /*#__PURE__*/_jsx(Loader, {})) : null, !isLoading && !isEmptyContent && /*#__PURE__*/jsxs(Fragment, {
+      children: [_Rows || (_Rows = /*#__PURE__*/_jsx(Rows, {})), _Footer || (_Footer = /*#__PURE__*/_jsx(Footer, {})), isLoadingAppended && (_RowLoading || (_RowLoading = /*#__PURE__*/_jsx(RowLoading, {})))]
+    }))
+  });
+};
+
+const VirtualRowsList = connect(mapStateToProps)(VirtualRowsListComponent);
+
+export { VirtualRowsList as default };

package/esm/parts/index.js

@@ -0,0 +1,6 @@
+export { default as TableContent } from './TableContent.js';
+export { default as Loader } from './Loader.js';
+export { default as EmptyContent } from './EmptyContent.js';
+export { default as Row } from './Row.js';
+export { default as Footer } from './Footer.js';
+export { default as DnDHandle } from './DnDHandle.js';

package/esm/prop-types.js

@@ -0,0 +1,47 @@
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import PropTypes from 'prop-types';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+const tableStateShape = {
+  allColumns: PropTypes.array,
+  columns: PropTypes.array,
+  visibleColumns: PropTypes.array,
+  data: PropTypes.array,
+  preFilteredFlatRows: PropTypes.array,
+  preFilteredRows: PropTypes.array,
+  rows: PropTypes.array,
+  page: PropTypes.array,
+  preFilteredRowsById: PropTypes.object,
+  rowsById: PropTypes.object,
+  setAllFilters: PropTypes.func,
+  setFilter: PropTypes.func,
+  totalColumnsWidth: PropTypes.number
+};
+const filterComponentPropType = _objectSpread(_objectSpread({}, tableStateShape), {}, {
+  column: PropTypes.object
+});
+const editableCellPropType = {
+  cell: PropTypes.object.isRequired,
+  DefaultCellRender: PropTypes.oneOfType([PropTypes.func, PropTypes.object]).isRequired
+};
+const CellPropType = tableStateShape;
+const headerGroupsType = PropTypes.arrayOf(PropTypes.shape({
+  getHeaderGroupProps: PropTypes.func.isRequired,
+  headers: PropTypes.arrayOf(PropTypes.object).isRequired
+}));
+const renderRowActionsPropType = PropTypes.oneOfType([PropTypes.oneOf([false]), PropTypes.shape({
+  columnWidth: PropTypes.number.isRequired,
+  renderer: PropTypes.func.isRequired
+})]);
+const paginationPropType = PropTypes.oneOfType([PropTypes.bool, PropTypes.shape({
+  perPageOptions: PropTypes.arrayOf(PropTypes.number)
+})]);
+
+export { CellPropType, editableCellPropType, filterComponentPropType, headerGroupsType, paginationPropType, renderRowActionsPropType, tableStateShape };

package/esm/redux/reducers/headersReducers/defaults.js

@@ -0,0 +1,3 @@
+const defaultHeadersState = {};
+
+export { defaultHeadersState };

package/esm/redux/reducers/headersReducers/headersReducers.js

@@ -0,0 +1,27 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { patchHeaderFilterButtonAndMenu, patchUpdateOneHeader } from './logic.js';
+import { defaultHeadersState } from './defaults.js';
+
+const headersSlice = createSlice({
+  name: 'headers',
+  initialState: defaultHeadersState,
+  reducers: {
+    patchHeaderFilterButtonAndMenuAction(state, action) {
+      patchHeaderFilterButtonAndMenu(action.payload, state);
+    },
+
+    patchUpdateOneHeaderAction(state, action) {
+      patchUpdateOneHeader(action.payload, state);
+    }
+
+  }
+});
+const {
+  patchHeaderFilterButtonAndMenuAction,
+  patchUpdateOneHeaderAction
+} = headersSlice.actions;
+const {
+  reducer
+} = headersSlice;
+
+export { headersSlice, patchHeaderFilterButtonAndMenuAction, patchUpdateOneHeaderAction, reducer };

package/esm/redux/reducers/headersReducers/index.js

@@ -0,0 +1,2 @@
+export { headersSlice, patchHeaderFilterButtonAndMenuAction, patchUpdateOneHeaderAction, reducer } from './headersReducers.js';
+export { useDispatchHeadersActions } from './useDispatchHeadersActions.js';

package/esm/redux/reducers/headersReducers/logic.js

@@ -0,0 +1,27 @@
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+const patchUpdateOneHeader = (payload, state) => {
+  state[payload.headerId] = _objectSpread(_objectSpread({}, (state === null || state === void 0 ? void 0 : state[payload.headerId]) || {}), payload.newHeader);
+};
+const patchHeaderFilterButtonAndMenu = (_ref, state) => {
+  let {
+    headerId,
+    newState
+  } = _ref;
+  const updatedState = {
+    hideFilterMenu: newState,
+    hideFilterButton: newState
+  };
+  state[headerId] = _objectSpread(_objectSpread({}, (state === null || state === void 0 ? void 0 : state[headerId]) || {}), updatedState);
+};
+
+export { patchHeaderFilterButtonAndMenu, patchUpdateOneHeader };

package/esm/redux/reducers/headersReducers/useDispatchHeadersActions.js

@@ -0,0 +1,21 @@
+import { useCallback } from 'react';
+import { useDispatch } from 'react-redux';
+import { patchUpdateOneHeaderAction, patchHeaderFilterButtonAndMenuAction } from './headersReducers.js';
+
+const useDispatchHeadersActions = () => {
+  const dispatch = useDispatch();
+  const patchHeader = useCallback((headerId, newHeader) => dispatch(patchUpdateOneHeaderAction({
+    headerId,
+    newHeader
+  })), [dispatch]);
+  const patchHeaderFilterButtonAndMenu = useCallback((headerId, newState) => dispatch(patchHeaderFilterButtonAndMenuAction({
+    headerId,
+    newState
+  })), [dispatch]);
+  return {
+    patchHeader,
+    patchHeaderFilterButtonAndMenu
+  };
+};
+
+export { useDispatchHeadersActions };

package/esm/redux/reducers/index.js

@@ -0,0 +1,12 @@
+import { combineReducers } from 'redux';
+import { reducer } from './headersReducers/headersReducers.js';
+export { useDispatchHeadersActions } from './headersReducers/useDispatchHeadersActions.js';
+import { reducer as reducer$1 } from './rowsReducers/rowsReducer.js';
+export { useDispatchRowsActions } from './rowsReducers/useDispatchRowsActions.js';
+
+var rootReducer = combineReducers({
+  headers: reducer,
+  rows: reducer$1
+});
+
+export { rootReducer as default };

package/esm/redux/reducers/rowsReducers/actions_types.js

@@ -0,0 +1,9 @@
+const ROWS_REDUCER_SET_IS_DRAGGING_TYPE = 'ROWS_REDUCER_SET_IS_DRAGGING';
+const ROWS_REDUCER_SET_IS_KEYBOARD_DRAGGING_TYPE = 'ROWS_REDUCER_SET_IS_KEYBOARD_DRAGGING';
+const ROWS_REDUCER_SET_DRAGGED_ROW_TYPE = 'ROWS_REDUCER_SET_DRAGGED_ROW';
+const ROWS_REDUCER_SET_HOVER_ROW_TYPE = 'ROWS_REDUCER_SET_HOVER_ROW';
+const ROWS_REDUCER_SET_SELECTED_ROW_TYPE = 'ROWS_REDUCER_SET_SELECTED_ROW';
+const ROWS_REDUCER_SET_FOCUSED_ROW_TYPE = 'ROWS_REDUCER_SET_FOCUSED_ROW';
+const ROWS_REDUCER_SET_RELATIVE_MOUSE_CORD_TYPE = 'ROWS_REDUCER_SET_RELATIVE_MOUSE_CORD';
+
+export { ROWS_REDUCER_SET_DRAGGED_ROW_TYPE, ROWS_REDUCER_SET_FOCUSED_ROW_TYPE, ROWS_REDUCER_SET_HOVER_ROW_TYPE, ROWS_REDUCER_SET_IS_DRAGGING_TYPE, ROWS_REDUCER_SET_IS_KEYBOARD_DRAGGING_TYPE, ROWS_REDUCER_SET_RELATIVE_MOUSE_CORD_TYPE, ROWS_REDUCER_SET_SELECTED_ROW_TYPE };

package/esm/redux/reducers/rowsReducers/defaults.js

@@ -0,0 +1,22 @@
+const defaultRelativeRowMouseCoord = {
+  isBefore: false,
+  isAfter: false,
+  isValid: true,
+  hoveredRowIndex: null,
+  x: null,
+  y: null,
+  relativeElementDOMRect: null,
+  relativeElementIndex: null
+};
+const defaultRowsReducerState = {
+  isDraggingRow: false,
+  isKeyboardDraggingRow: false,
+  relativeRowMouseCord: defaultRelativeRowMouseCoord,
+  draggedRowId: null,
+  hoverRowId: null,
+  activeRowId: null,
+  selectedRowId: null,
+  focusedRowId: null
+};
+
+export { defaultRelativeRowMouseCoord, defaultRowsReducerState };

package/esm/redux/reducers/rowsReducers/index.js

@@ -0,0 +1,2 @@
+export { reducer, rowsSlice, setRowDnDActiveRowIdAction, setRowDraggedRowIdAction, setRowFocusedRowIdAction, setRowHoverRowIdAction, setRowIsKeyboardDraggingAction, setRowRelativeMouseCoordAction, setRowSelectedRowIdAction, setRowsIsDraggingAction } from './rowsReducer.js';
+export { useDispatchRowsActions } from './useDispatchRowsActions.js';

package/esm/redux/reducers/rowsReducers/logic.js

@@ -0,0 +1,27 @@
+/* eslint-disable max-params */
+const setRowsIsDragging = (payload, state) => {
+  state.isDraggingRow = payload;
+};
+const setRowIsKeyboardDragging = (payload, state) => {
+  state.isKeyboardDraggingRow = payload;
+};
+const setRowRelativeMouseCoord = (payload, state) => {
+  state.relativeRowMouseCord = payload;
+};
+const setRowDraggedRowId = (payload, state) => {
+  state.draggedRowId = payload;
+};
+const setRowHoverRowId = (payload, state) => {
+  state.hoverRowId = payload;
+};
+const setRowSelectedRowId = (payload, state) => {
+  state.selectedRowId = payload;
+};
+const setRowFocusedRowId = (payload, state) => {
+  state.focusedRowId = payload;
+};
+const setRowDnDActiveRowId = (payload, state) => {
+  state.DnDActiveId = payload;
+};
+
+export { setRowDnDActiveRowId, setRowDraggedRowId, setRowFocusedRowId, setRowHoverRowId, setRowIsKeyboardDragging, setRowRelativeMouseCoord, setRowSelectedRowId, setRowsIsDragging };

package/esm/redux/reducers/rowsReducers/rowsReducer.js

@@ -0,0 +1,57 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { setRowsIsDragging, setRowIsKeyboardDragging, setRowRelativeMouseCoord, setRowDraggedRowId, setRowHoverRowId, setRowSelectedRowId, setRowFocusedRowId, setRowDnDActiveRowId } from './logic.js';
+import { defaultRowsReducerState } from './defaults.js';
+
+const rowsSlice = createSlice({
+  name: 'rows',
+  initialState: defaultRowsReducerState,
+  reducers: {
+    setRowsIsDraggingAction(state, action) {
+      setRowsIsDragging(action.payload, state);
+    },
+
+    setRowIsKeyboardDraggingAction(state, action) {
+      setRowIsKeyboardDragging(action.payload, state);
+    },
+
+    setRowRelativeMouseCoordAction(state, action) {
+      setRowRelativeMouseCoord(action.payload, state);
+    },
+
+    setRowDraggedRowIdAction(state, action) {
+      setRowDraggedRowId(action.payload, state);
+    },
+
+    setRowHoverRowIdAction(state, action) {
+      setRowHoverRowId(action.payload, state);
+    },
+
+    setRowSelectedRowIdAction(state, action) {
+      setRowSelectedRowId(action.payload, state);
+    },
+
+    setRowFocusedRowIdAction(state, action) {
+      setRowFocusedRowId(action.payload, state);
+    },
+
+    setRowDnDActiveRowIdAction(state, action) {
+      setRowDnDActiveRowId(action.payload, state);
+    }
+
+  }
+});
+const {
+  setRowsIsDraggingAction,
+  setRowIsKeyboardDraggingAction,
+  setRowDraggedRowIdAction,
+  setRowHoverRowIdAction,
+  setRowSelectedRowIdAction,
+  setRowFocusedRowIdAction,
+  setRowRelativeMouseCoordAction,
+  setRowDnDActiveRowIdAction
+} = rowsSlice.actions;
+const {
+  reducer
+} = rowsSlice;
+
+export { reducer, rowsSlice, setRowDnDActiveRowIdAction, setRowDraggedRowIdAction, setRowFocusedRowIdAction, setRowHoverRowIdAction, setRowIsKeyboardDraggingAction, setRowRelativeMouseCoordAction, setRowSelectedRowIdAction, setRowsIsDraggingAction };

package/esm/redux/reducers/rowsReducers/useDispatchRowsActions.js

@@ -0,0 +1,30 @@
+import { useCallback } from 'react';
+import { useDispatch } from 'react-redux';
+import { setRowHoverRowIdAction, setRowDnDActiveRowIdAction, setRowSelectedRowIdAction, setRowFocusedRowIdAction, setRowsIsDraggingAction, setRowIsKeyboardDraggingAction, setRowRelativeMouseCoordAction, setRowDraggedRowIdAction } from './rowsReducer.js';
+import { defaultRelativeRowMouseCoord } from './defaults.js';
+
+const useDispatchRowsActions = () => {
+  const dispatch = useDispatch();
+  const setHoverRowId = useCallback(newHoverRowId => dispatch(setRowHoverRowIdAction(newHoverRowId)), [dispatch]);
+  const setDnDActiveRowId = useCallback(newDnDActiveRowId => dispatch(setRowDnDActiveRowIdAction(newDnDActiveRowId)), [dispatch]);
+  const setSelectedRowId = useCallback(newSelectedRowId => dispatch(setRowSelectedRowIdAction(newSelectedRowId)), [dispatch]);
+  const setFocusedRowId = useCallback(newFocusedRowId => dispatch(setRowFocusedRowIdAction(newFocusedRowId)), [dispatch]);
+  const setIsDraggingRow = useCallback(newIsDraggingRow => dispatch(setRowsIsDraggingAction(newIsDraggingRow)), [dispatch]);
+  const setIsKeyboardDraggingRow = useCallback(newIsKeyboardDraggingRow => dispatch(setRowIsKeyboardDraggingAction(newIsKeyboardDraggingRow)), [dispatch]);
+  const setRelativeRowMouseCord = useCallback(newRelativeRowMouseCord => dispatch(setRowRelativeMouseCoordAction(newRelativeRowMouseCord)), [dispatch]);
+  const resetRelativeRowMouseCord = useCallback(() => dispatch(setRowRelativeMouseCoordAction(defaultRelativeRowMouseCoord)), [dispatch]);
+  const setDraggedRowId = useCallback(newDraggedRowId => dispatch(setRowDraggedRowIdAction(newDraggedRowId)), [dispatch]);
+  return {
+    setHoverRowId,
+    setDnDActiveRowId,
+    setSelectedRowId,
+    setFocusedRowId,
+    setIsDraggingRow,
+    setIsKeyboardDraggingRow,
+    setRelativeRowMouseCord,
+    resetRelativeRowMouseCord,
+    setDraggedRowId
+  };
+};
+
+export { useDispatchRowsActions };

package/esm/redux/storeConfig.js

@@ -0,0 +1,7 @@
+import rootReducer from './reducers/index.js';
+
+const storeConfig = {
+  reducer: rootReducer
+};
+
+export { storeConfig };