@elliemae/ds-datagrids 1.61.0 → 2.0.0-alpha.12

package/esm/plugins/selectable/addSelectableColumn.js

@@ -1,53 +1,62 @@
+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 _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
 import { appendCellFormatter, appendHeaderFormatter } from '@elliemae/ds-shared/useDataGrid/initColumnDefinition';
 import selectableFormatter from './selectableFormatter.js';
-import 'react';
-import '@elliemae/ds-utilities';
-import '@elliemae/ds-form';
 
-var _excluded = ["visible", "isDataColumn", "width", "minWidth", "cellRenderer", "headerCellRenderer", "customRenderer", "header"];
+const _excluded = ["visible", "isDataColumn", "width", "minWidth", "cellRenderer", "headerCellRenderer", "customRenderer", "header"];
 
 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; }
 function selectionColumnCreator(_ref) {
-  var grid = _ref.grid,
-      selectAll = _ref.selectAll,
-      selectionComponent = _ref.selectionComponent,
-      onSelectRow = _ref.onSelectRow,
-      onSelectAll = _ref.onSelectAll,
-      multiple = _ref.multiple,
-      multiSelectFilterLabel = _ref.multiSelectFilterLabel,
-      multiSelectFilterOptions = _ref.multiSelectFilterOptions,
-      multiSelectFilterLabels = _ref.multiSelectFilterLabels,
-      multiSelectComponent = _ref.multiSelectComponent;
-  var rowKey = grid.props.rowKey;
+  let {
+    grid,
+    selectAll,
+    selectionComponent,
+    onSelectRow,
+    onSelectAll,
+    multiple,
+    // backward compatibility: later this needed to be passed through column definition
+    multiSelectFilterLabel,
+    multiSelectFilterOptions,
+    multiSelectFilterLabels,
+    multiSelectComponent // favor selectionComponent
+
+  } = _ref;
+  const {
+    props: {
+      rowKey
+    }
+  } = grid;
   return function () {
-    var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 
-    var _ref2$visible = _ref2.visible,
-        visible = _ref2$visible === void 0 ? true : _ref2$visible,
-        _ref2$isDataColumn = _ref2.isDataColumn,
-        isDataColumn = _ref2$isDataColumn === void 0 ? false : _ref2$isDataColumn,
-        _ref2$width = _ref2.width,
-        width = _ref2$width === void 0 ? 40 : _ref2$width,
-        minWidth = _ref2.minWidth;
-        _ref2.cellRenderer;
-        _ref2.headerCellRenderer;
-        _ref2.customRenderer;
-        _ref2.header;
-        var column = _objectWithoutProperties(_ref2, _excluded);
+    let {
+      visible = true,
+      isDataColumn = false,
+      width = 40,
+      minWidth,
+      cellRenderer,
+      headerCellRenderer,
+      customRenderer,
+      header
+    } = _ref2,
+        column = _objectWithoutProperties(_ref2, _excluded);
 
-    var selectionColumn = _objectSpread(_objectSpread({}, column), {}, {
+    let selectionColumn = _objectSpread(_objectSpread({}, column), {}, {
       property: 'metaData.selected',
       filterLabel: multiSelectFilterLabel,
       filterOptions: multiSelectFilterOptions,
       filterLabels: multiSelectFilterLabels,
-      visible: visible,
-      width: width,
+      visible,
+      width,
       minWidth: minWidth || width,
-      isDataColumn: isDataColumn
+      isDataColumn
     });
 
     selectionColumn = appendCellFormatter(selectableFormatter({
@@ -58,8 +67,8 @@ function selectionColumnCreator(_ref) {
 
     if (multiple) {
       selectionColumn = appendHeaderFormatter(selectableFormatter({
-        rowKey: rowKey,
-        selectAll: selectAll,
+        rowKey,
+        selectAll,
         isMultiSelect: true,
         isHeader: true,
         className: 'multi-select-wrapper',
@@ -73,4 +82,3 @@ function selectionColumnCreator(_ref) {
 }
 
 export { selectionColumnCreator };
-//# sourceMappingURL=addSelectableColumn.js.map

package/esm/plugins/selectable/helper.js

@@ -1,41 +1,31 @@
+import 'core-js/modules/esnext.async-iterator.filter.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 'core-js/modules/esnext.async-iterator.reduce.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.reduce.js';
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
 import { toggleInObject } from '@elliemae/ds-utilities';
 
 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; }
-var checkAllRowsSelected = function checkAllRowsSelected(rows, selectedRows) {
+const checkAllRowsSelected = (rows, selectedRows) => {
   if (rows.length && selectedRows.length === rows.length) return true;
   if (selectedRows.length) return 'mixed';
   return false;
 };
-var toggleSelectAll = function toggleSelectAll(rows, checked) {
-  return !checked ? {} : rows.reduce(function (nextSelRows, row) {
-    return toggleInObject(nextSelRows, row.id, true);
-  }, {});
-};
-var toggleSingleSelectable = function toggleSingleSelectable(selectedRows, id) {
-  return !selectedRows[id] ? toggleInObject({}, id, true) : {};
-};
+const toggleSelectAll = (rows, checked) => !checked ? {} : rows.reduce((nextSelRows, row) => toggleInObject(nextSelRows, row.id, true), {});
+const toggleSingleSelectable = (selectedRows, id) => !selectedRows[id] ? toggleInObject({}, id, true) : {};
 
-var mergeSelectedToMetaData = function mergeSelectedToMetaData(selected) {
-  return function (row) {
-    return _objectSpread(_objectSpread({}, row), {}, {
-      'metaData.selected': selected
-    });
-  };
-};
+const mergeSelectedToMetaData = selected => row => _objectSpread(_objectSpread({}, row), {}, {
+  'metaData.selected': selected
+});
 
-var selectSingleRow = function selectSingleRow(rows, filter) {
-  return rows.map(function (row) {
-    return mergeSelectedToMetaData(filter(row))(row);
-  });
-};
-var selectMultipleRow = function selectMultipleRow(rows, isRowSelectedPredicate) {
-  return rows.map(function (row) {
-    return mergeSelectedToMetaData(isRowSelectedPredicate(row))(row);
-  });
-};
+const selectSingleRow = (rows, filter) => rows.map(row => mergeSelectedToMetaData(filter(row))(row));
+const selectMultipleRow = (rows, isRowSelectedPredicate) => rows.map(row => mergeSelectedToMetaData(isRowSelectedPredicate(row))(row));
 
 export { checkAllRowsSelected, selectMultipleRow, selectSingleRow, toggleSelectAll, toggleSingleSelectable };
-//# sourceMappingURL=helper.js.map

package/esm/plugins/selectable/index.js

@@ -1,16 +1 @@
 export { SelectablePlugin } from './SelectablePlugin.js';
-import '@babel/runtime/helpers/esm/slicedToArray';
-import '@babel/runtime/helpers/esm/defineProperty';
-import '@babel/runtime/helpers/esm/toConsumableArray';
-import 'react';
-import 'obj-str';
-import '@elliemae/ds-utilities';
-import '@elliemae/ds-shared/createDataInstance/createInstancePlugin';
-import './addSelectableColumn.js';
-import '@babel/runtime/helpers/esm/objectWithoutProperties';
-import '@elliemae/ds-shared/useDataGrid/initColumnDefinition';
-import './selectableFormatter.js';
-import '@elliemae/ds-form';
-import './useSelectableState.js';
-import './helper.js';
-//# sourceMappingURL=index.js.map

package/esm/plugins/selectable/selectableFormatter.js

@@ -1,34 +1,43 @@
+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 React, { useRef, useEffect, forwardRef } from 'react';
 import { isFunction } from '@elliemae/ds-utilities';
 import { DSCheckbox, DSRadio } from '@elliemae/ds-form';
+import { jsx } from 'react/jsx-runtime';
 
 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; }
 
-var SelectableWrapper = function SelectableWrapper(_ref) {
-  var className = _ref.className,
-      children = _ref.children;
-  return /*#__PURE__*/React.createElement("div", {
+const SelectableWrapper = _ref => {
+  let {
+    className,
+    children
+  } = _ref;
+  return /*#__PURE__*/_jsx("div", {
     className: className,
-    onClick: function onClick(e) {
-      return e.stopPropagation();
-    }
-  }, children);
+    onClick: e => e.stopPropagation()
+  }, void 0, children);
 };
 
-var SelectableComponent = /*#__PURE__*/React.memo( /*#__PURE__*/forwardRef(function (_ref2, ref) {
-  var className = _ref2.className,
-      isMultiSelect = _ref2.isMultiSelect,
-      isHeader = _ref2.isHeader,
-      onSelect = _ref2.onSelect,
-      isSelected = _ref2.isSelected,
-      value = _ref2.value;
-  var SelectComponent = isMultiSelect || isHeader ? DSCheckbox : DSRadio;
-  return /*#__PURE__*/React.createElement(SelectableWrapper, {
+const SelectableComponent = /*#__PURE__*/React.memo( /*#__PURE__*/forwardRef((_ref2, ref) => {
+  let {
+    className,
+    isMultiSelect,
+    isHeader,
+    onSelect,
+    isSelected,
+    value
+  } = _ref2;
+  const SelectComponent = isMultiSelect || isHeader ? DSCheckbox : DSRadio;
+  return /*#__PURE__*/_jsx(SelectableWrapper, {
     className: className
-  }, /*#__PURE__*/React.createElement(SelectComponent, {
+  }, void 0, /*#__PURE__*/_jsx(SelectComponent, {
     checked: isSelected,
     "data-testid": "column-selectable-component",
     innerRef: ref,
@@ -36,52 +45,54 @@ var SelectableComponent = /*#__PURE__*/React.memo( /*#__PURE__*/forwardRef(funct
     tabIndex: -1,
     value: value
   }));
-}, function (prev, next) {
-  return next.isScrolling;
-}));
-
-var selectableFormatter = function selectableFormatter(_ref3, grid) {
-  var _ref3$isMultiSelect = _ref3.isMultiSelect,
-      isMultiSelect = _ref3$isMultiSelect === void 0 ? false : _ref3$isMultiSelect,
-      renderer = _ref3.renderer,
-      className = _ref3.className,
-      isHeader = _ref3.isHeader,
-      onSelect = _ref3.onSelect;
-  return function (valueRender, extraParams) {
-    var registerFocus = extraParams.registerFocus;
-    var ref = useRef();
-
-    var _grid$getInstance = grid.getInstance(),
-        rowKey = _grid$getInstance.props.rowKey,
-        selection = _grid$getInstance.state.selection,
-        shiftPressed = _grid$getInstance.shiftPressed,
-        lastSelectedRow = _grid$getInstance.lastSelectedRow;
+}, (prev, next) => next.isScrolling));
 
-    var rowData = extraParams.rowData,
-        isScrolling = extraParams.isScrolling;
-    useEffect(function () {
+const selectableFormatter = (_ref3, grid) => {
+  let {
+    isMultiSelect = false,
+    renderer,
+    className,
+    isHeader,
+    onSelect
+  } = _ref3;
+  return (valueRender, extraParams) => {
+    const {
+      registerFocus
+    } = extraParams;
+    const ref = useRef();
+    const {
+      props: {
+        rowKey
+      },
+      state: {
+        selection
+      },
+      shiftPressed,
+      lastSelectedRow
+    } = grid.getInstance();
+    const {
+      rowData,
+      isScrolling
+    } = extraParams;
+    useEffect(() => {
       if (registerFocus) registerFocus(ref.current);
     }, [ref.current]);
-    var isSelected = isHeader ? selection.selectAll : !!selection.selectedRows[rowData[rowKey]];
-    var handleSelect = isHeader ? function () {
-      return onSelect(!isSelected);
-    } : function () {
-      return onSelect(rowData[rowKey], extraParams.rowIndex, shiftPressed, lastSelectedRow);
-    };
+    const isSelected = isHeader ? selection.selectAll : !!selection.selectedRows[rowData[rowKey]];
+    const handleSelect = isHeader ? () => onSelect(!isSelected) : () => onSelect(rowData[rowKey], extraParams.rowIndex, shiftPressed, lastSelectedRow);
 
     if (isFunction(renderer)) {
-      return /*#__PURE__*/React.createElement(SelectableWrapper, {
+      return /*#__PURE__*/_jsx(SelectableWrapper, {
         className: className
-      }, renderer(_objectSpread(_objectSpread({
+      }, void 0, renderer(_objectSpread(_objectSpread({
         rowData: {}
       }, extraParams), {}, {
         value: isSelected,
-        isHeader: isHeader,
+        isHeader,
         onSelect: handleSelect
       })));
     }
 
-    return /*#__PURE__*/React.createElement(SelectableComponent, {
+    return /*#__PURE__*/jsx(SelectableComponent, {
       ref: ref,
       className: className,
       isMultiSelect: isMultiSelect,
@@ -94,4 +105,3 @@ var selectableFormatter = function selectableFormatter(_ref3, grid) {
 };
 
 export { selectableFormatter as default };
-//# sourceMappingURL=selectableFormatter.js.map

package/esm/plugins/selectable/useSelectableState.js

@@ -1,5 +1,16 @@
+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 _slicedToArray from '@babel/runtime/helpers/esm/slicedToArray';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/esnext.async-iterator.some.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.some.js';
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import 'core-js/modules/esnext.async-iterator.reduce.js';
+import 'core-js/modules/esnext.iterator.reduce.js';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.filter.js';
 import { useDerivedStateFromProps, hashArray, toggleInObject, omit } from '@elliemae/ds-utilities';
 import { toggleSelectAll, checkAllRowsSelected, toggleSingleSelectable } from './helper.js';
 
@@ -9,11 +20,11 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 function deriveSelectedStateFromPropsOnUpdate(rows) {
   return function () {
-    var nextProp = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    var prevProp = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    let nextProp = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let prevProp = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
     if (nextProp.selectAll !== prevProp.selectAll) {
-      var nextSelectedRows = nextProp.selectAll ? toggleSelectAll(rows, true) : hashArray(nextProp.selectedRows || []);
+      const nextSelectedRows = nextProp.selectAll ? toggleSelectAll(rows, true) : hashArray(nextProp.selectedRows || []);
       return {
         selectedRows: nextSelectedRows,
         selectAll: checkAllRowsSelected(rows, Object.keys(nextSelectedRows))
@@ -28,90 +39,79 @@ function deriveSelectedStateFromPropsOnUpdate(rows) {
 }
 
 function useSelectableState(grid) {
-  var _grid$getInstance = grid.getInstance(),
-      _grid$getInstance$pro = _grid$getInstance.props,
-      _grid$getInstance$pro2 = _grid$getInstance$pro.rowKey,
-      rowKey = _grid$getInstance$pro2 === void 0 ? 'id' : _grid$getInstance$pro2,
-      selectedRows = _grid$getInstance$pro.selectedRows,
-      selectAll = _grid$getInstance$pro.selectAll,
-      selectable = _grid$getInstance$pro.selectable,
-      onSelectRow = _grid$getInstance$pro.onSelectRow,
-      onSelectAll = _grid$getInstance$pro.onSelectAll,
-      rows = _grid$getInstance.rows,
-      setLastSelectedRow = _grid$getInstance.setLastSelectedRow;
-
-  var multiple = selectable === 'multi';
-
-  var _useDerivedStateFromP = useDerivedStateFromProps({
-    selectedRows: selectedRows,
-    selectAll: selectAll
+  const {
+    props: {
+      rowKey = 'id',
+      selectedRows,
+      selectAll,
+      selectable,
+      onSelectRow,
+      onSelectAll
+    },
+    rows,
+    setLastSelectedRow
+  } = grid.getInstance();
+  const multiple = selectable === 'multi';
+  const [selection, setSelectedRowsState] = useDerivedStateFromProps({
+    selectedRows,
+    selectAll
   }, {
     onUpdate: deriveSelectedStateFromPropsOnUpdate(rows)
-  }),
-      _useDerivedStateFromP2 = _slicedToArray(_useDerivedStateFromP, 2),
-      selection = _useDerivedStateFromP2[0],
-      setSelectedRowsState = _useDerivedStateFromP2[1]; // ACTIONS
-
-
-  var handleSelectRow = function handleSelectRow(id, index) {
-    var shift = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    var lastSelectedRow = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
-    setSelectedRowsState(function (prevState) {
-      var _grid$getInstance2 = grid.getInstance(),
-          nextRows = _grid$getInstance2.rows;
-
-      var wasSelected = Object.keys(prevState.selectedRows).some( // we need to match softly as the id may be a number
+  }); // ACTIONS
+
+  const handleSelectRow = function (id, index) {
+    let shift = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    let lastSelectedRow = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+    setSelectedRowsState(prevState => {
+      const {
+        rows: nextRows
+      } = grid.getInstance();
+      const wasSelected = Object.keys(prevState.selectedRows).some( // we need to match softly as the id may be a number
       // eslint-disable-next-line eqeqeq
-      function (elem) {
-        return elem == id;
-      });
-      var nextSelectedRows = multiple ? toggleInObject(prevState.selectedRows, id, true) : toggleSingleSelectable(prevState.selectedRows, id);
+      elem => elem == id);
+      let nextSelectedRows = multiple ? toggleInObject(prevState.selectedRows, id, true) : toggleSingleSelectable(prevState.selectedRows, id);
       setLastSelectedRow({
-        index: index,
+        index,
         mode: wasSelected ? 'deselect' : 'select'
       });
 
       if (shift && lastSelectedRow) {
-        var prevSmallest = lastSelectedRow.index < index + 1;
-        var sliceStart = prevSmallest ? lastSelectedRow.index : index;
-        var sliceEnd = prevSmallest ? index + 1 : lastSelectedRow.index + 1;
-        var rowSegment = nextRows.slice(sliceStart, sliceEnd).map(function (row) {
-          return row[rowKey];
-        });
+        const prevSmallest = lastSelectedRow.index < index + 1;
+        const sliceStart = prevSmallest ? lastSelectedRow.index : index;
+        const sliceEnd = prevSmallest ? index + 1 : lastSelectedRow.index + 1;
+        const rowSegment = nextRows.slice(sliceStart, sliceEnd).map(row => row[rowKey]);
 
         if (lastSelectedRow.mode === 'deselect') {
           nextSelectedRows = omit(prevState.selectedRows, rowSegment);
         } else {
-          var selectedSegment = rowSegment.reduce(function (o, key) {
-            return _objectSpread(_objectSpread({}, o), {}, _defineProperty({}, key, true));
-          }, {});
+          const selectedSegment = rowSegment.reduce((o, key) => _objectSpread(_objectSpread({}, o), {}, {
+            [key]: true
+          }), {});
           nextSelectedRows = _objectSpread(_objectSpread({}, prevState.selectedRows), selectedSegment);
         }
       }
 
-      var nextState = {
+      const nextState = {
         selectedRows: nextSelectedRows,
         selectAll: checkAllRowsSelected(nextRows, Object.keys(nextSelectedRows))
       };
 
       if (index !== null && index !== undefined) {
-        onSelectRow(nextRows.filter(function (row) {
-          return nextState.selectedRows[row[rowKey]];
-        }), nextState.selectAll, index);
+        onSelectRow(nextRows.filter(row => nextState.selectedRows[row[rowKey]]), nextState.selectAll, index);
       }
 
       return nextState;
     });
   };
 
-  var handleSelectAll = function handleSelectAll(checked) {
+  const handleSelectAll = checked => {
     if (!multiple) return;
     setLastSelectedRow(null);
-    setSelectedRowsState(function () {
-      var _grid$getInstance3 = grid.getInstance(),
-          nextRows = _grid$getInstance3.composedRows;
-
-      var nextState = {
+    setSelectedRowsState(() => {
+      const {
+        composedRows: nextRows
+      } = grid.getInstance();
+      const nextState = {
         selectAll: checked,
         selectedRows: toggleSelectAll(nextRows, checked)
       };
@@ -127,10 +127,9 @@ function useSelectableState(grid) {
       selectAll: handleSelectAll
     },
     state: {
-      selection: selection
+      selection
     }
   };
 }
 
 export { useSelectableState };
-//# sourceMappingURL=useSelectableState.js.map

package/esm/plugins/sortable/SortablePlugin.js

@@ -5,48 +5,40 @@ import createInstancePlugin from '@elliemae/ds-shared/createDataInstance/createI
 import sortHeaderFormatter from './sortHeaderFormatter.js';
 import { useSortableState } from './useSortableState.js';
 import { sorterGroups, sorter } from './sorter.js';
-import 'react';
-import '@elliemae/ds-classnames';
-import '@elliemae/ds-icons';
-import '@babel/runtime/helpers/esm/defineProperty';
-import '@babel/runtime/helpers/esm/slicedToArray';
-import 'sortabular/dist';
-import './checkIfSortable.js';
-import '@babel/runtime/helpers/esm/toConsumableArray';
-import 'moment';
 
-var decorateColumn = function decorateColumn(column, grid) {
-  var _grid$props = grid.props,
-      _grid$props$isSortabl = _grid$props.isSortableColumnActive,
-      isSortableColumnActive = _grid$props$isSortabl === void 0 ? function (col) {
-    return col.sortable;
-  } : _grid$props$isSortabl,
-      groupedRows = _grid$props.groupedRows;
+const decorateColumn = (column, grid) => {
+  const {
+    props: {
+      isSortableColumnActive = col => col.sortable,
+      groupedRows
+    }
+  } = grid;
   if (groupedRows) return column;
   if (!isSortableColumnActive(column)) return column;
-  var formatter = sortHeaderFormatter(sortabular.sort({
-    getSortingColumns: function getSortingColumns() {
-      return grid.getState().sortingColumns || [];
-    },
+  const formatter = sortHeaderFormatter(sortabular.sort({
+    getSortingColumns: () => grid.getState().sortingColumns || [],
     onSort: grid.actions.sort,
     strategy: sortabular.strategies.byProperty
   }), grid);
   return compose(appendHeaderFormatter(formatter), mergeClassNameToColumnHeader('with-sortable'))(column);
 };
 
-var composeRows = function composeRows(rows, grid) {
-  var _grid$getInstance = grid.getInstance(),
-      sortingColumns = _grid$getInstance.state.sortingColumns,
-      _grid$getInstance$pro = _grid$getInstance.props,
-      isDataSorted = _grid$getInstance$pro.isDataSorted,
-      groupedRows = _grid$getInstance$pro.groupedRows,
-      groupedBy = _grid$getInstance$pro.groupedBy,
-      sortEmptyLast = _grid$getInstance$pro.sortEmptyLast,
-      rowsData = _grid$getInstance.rows,
-      composedRows = _grid$getInstance.composedRows,
-      decoratedColumns = _grid$getInstance.decoratedColumns;
-
-  var sortingConfig = {
+const composeRows = (rows, grid) => {
+  const {
+    state: {
+      sortingColumns
+    },
+    props: {
+      isDataSorted,
+      groupedRows,
+      groupedBy,
+      sortEmptyLast
+    },
+    rows: rowsData,
+    composedRows,
+    decoratedColumns
+  } = grid.getInstance();
+  const sortingConfig = {
     columns: decoratedColumns,
     sortingColumns: !isEmpty(sortingColumns) && sortingColumns,
     sort: orderBy,
@@ -60,27 +52,31 @@ var composeRows = function composeRows(rows, grid) {
   return !isDataSorted ? sorter(sortingConfig)(rows) : rows;
 };
 
-var SortablePlugin = createInstancePlugin('sortable', {
+const SortablePlugin = createInstancePlugin('sortable', {
   registerStateHook: useSortableState,
-  decorateColumn: decorateColumn,
-  composeRows: composeRows,
-  registerHotKeys: function registerHotKeys(grid) {
+  decorateColumn,
+  composeRows,
+
+  registerHotKeys(grid) {
     return {
       key: 'ctrl+s',
-      handler: function handler(_ref) {
-        var cellIndex = _ref.cellIndex;
-
-        var _grid$getInstance2 = grid.getInstance(),
-            sort = _grid$getInstance2.actions.sort,
-            decoratedColumns = _grid$getInstance2.decoratedColumns;
-
-        var column = decoratedColumns[cellIndex];
+      handler: _ref => {
+        let {
+          cellIndex
+        } = _ref;
+        const {
+          actions: {
+            sort
+          },
+          decoratedColumns
+        } = grid.getInstance();
+        const column = decoratedColumns[cellIndex];
         if (!column) return;
         sort(column.property);
       }
     };
   }
+
 });
 
 export { SortablePlugin };
-//# sourceMappingURL=SortablePlugin.js.map