@elliemae/ds-datagrids 2.3.0-alpha.9 → 2.3.0-next.0

package/cjs/plugins/selectable/selectableFormatter.js

@@ -0,0 +1,115 @@
+'use strict';
+
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.filter.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var _jsx = require('@babel/runtime/helpers/jsx');
+var React = require('react');
+var dsUtilities = require('@elliemae/ds-utilities');
+var dsForm = require('@elliemae/ds-form');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+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__default["default"](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 SelectableWrapper = _ref => {
+  let {
+    className,
+    children
+  } = _ref;
+  return /*#__PURE__*/_jsx__default["default"]("div", {
+    className: className,
+    onClick: e => e.stopPropagation()
+  }, void 0, children);
+};
+
+const SelectableComponent = /*#__PURE__*/React__default["default"].memo( /*#__PURE__*/React.forwardRef((_ref2, ref) => {
+  let {
+    className,
+    isMultiSelect,
+    isHeader,
+    onSelect,
+    isSelected,
+    value
+  } = _ref2;
+  const SelectComponent = isMultiSelect || isHeader ? dsForm.DSCheckbox : dsForm.DSRadio;
+  return /*#__PURE__*/_jsx__default["default"](SelectableWrapper, {
+    className: className
+  }, void 0, /*#__PURE__*/_jsx__default["default"](SelectComponent, {
+    checked: isSelected,
+    "data-testid": "column-selectable-component",
+    innerRef: ref,
+    onChange: onSelect,
+    tabIndex: -1,
+    value: value
+  }));
+}, (prev, next) => next.isScrolling));
+
+const selectableFormatter = (_ref3, grid) => {
+  let {
+    isMultiSelect = false,
+    renderer,
+    className,
+    isHeader,
+    onSelect
+  } = _ref3;
+  return (valueRender, extraParams) => {
+    const {
+      registerFocus
+    } = extraParams;
+    const ref = React.useRef();
+    const {
+      props: {
+        rowKey
+      },
+      state: {
+        selection
+      },
+      shiftPressed,
+      lastSelectedRow
+    } = grid.getInstance();
+    const {
+      rowData,
+      isScrolling
+    } = extraParams;
+    React.useEffect(() => {
+      if (registerFocus) registerFocus(ref.current);
+    }, [ref.current]);
+    const isSelected = isHeader ? selection.selectAll : !!selection.selectedRows[rowData[rowKey]];
+    const handleSelect = isHeader ? () => onSelect(!isSelected) : () => onSelect(rowData[rowKey], extraParams.rowIndex, shiftPressed, lastSelectedRow);
+
+    if (dsUtilities.isFunction(renderer)) {
+      return /*#__PURE__*/_jsx__default["default"](SelectableWrapper, {
+        className: className
+      }, void 0, renderer(_objectSpread(_objectSpread({
+        rowData: {}
+      }, extraParams), {}, {
+        value: isSelected,
+        isHeader,
+        onSelect: handleSelect
+      })));
+    }
+
+    return /*#__PURE__*/jsxRuntime.jsx(SelectableComponent, {
+      ref: ref,
+      className: className,
+      isMultiSelect: isMultiSelect,
+      isScrolling: isScrolling,
+      isSelected: isSelected,
+      onSelect: handleSelect,
+      value: !isHeader ? rowData[rowKey] : 'header-select-all'
+    });
+  };
+};
+
+module.exports = selectableFormatter;

package/cjs/plugins/selectable/useSelectableState.js

@@ -0,0 +1,143 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+require('core-js/modules/web.dom-collections.iterator.js');
+require('core-js/modules/esnext.async-iterator.some.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.some.js');
+require('core-js/modules/esnext.async-iterator.map.js');
+require('core-js/modules/esnext.iterator.map.js');
+require('core-js/modules/esnext.async-iterator.reduce.js');
+require('core-js/modules/esnext.iterator.reduce.js');
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.filter.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+var dsUtilities = require('@elliemae/ds-utilities');
+var helper = require('./helper.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_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__default["default"](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; }
+
+function deriveSelectedStateFromPropsOnUpdate(rows) {
+  return function () {
+    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) {
+      const nextSelectedRows = nextProp.selectAll ? helper.toggleSelectAll(rows, true) : dsUtilities.hashArray(nextProp.selectedRows || []);
+      return {
+        selectedRows: nextSelectedRows,
+        selectAll: helper.checkAllRowsSelected(rows, Object.keys(nextSelectedRows))
+      };
+    }
+
+    return {
+      selectedRows: dsUtilities.hashArray(nextProp.selectedRows || []),
+      selectAll: helper.checkAllRowsSelected(rows, Object.keys(nextProp.selectedRows))
+    };
+  };
+}
+
+function useSelectableState(grid) {
+  const {
+    props: {
+      rowKey = 'id',
+      selectedRows,
+      selectAll,
+      selectable,
+      onSelectRow,
+      onSelectAll
+    },
+    rows,
+    setLastSelectedRow
+  } = grid.getInstance();
+  const multiple = selectable === 'multi';
+  const [selection, setSelectedRowsState] = dsUtilities.useDerivedStateFromProps({
+    selectedRows,
+    selectAll
+  }, {
+    onUpdate: deriveSelectedStateFromPropsOnUpdate(rows)
+  }); // 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
+      elem => elem == id);
+      let nextSelectedRows = multiple ? dsUtilities.toggleInObject(prevState.selectedRows, id, true) : helper.toggleSingleSelectable(prevState.selectedRows, id);
+      setLastSelectedRow({
+        index,
+        mode: wasSelected ? 'deselect' : 'select'
+      });
+
+      if (shift && lastSelectedRow) {
+        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 = dsUtilities.omit(prevState.selectedRows, rowSegment);
+        } else {
+          const selectedSegment = rowSegment.reduce((o, key) => _objectSpread(_objectSpread({}, o), {}, {
+            [key]: true
+          }), {});
+          nextSelectedRows = _objectSpread(_objectSpread({}, prevState.selectedRows), selectedSegment);
+        }
+      }
+
+      const nextState = {
+        selectedRows: nextSelectedRows,
+        selectAll: helper.checkAllRowsSelected(nextRows, Object.keys(nextSelectedRows))
+      };
+
+      if (index !== null && index !== undefined) {
+        onSelectRow(nextRows.filter(row => nextState.selectedRows[row[rowKey]]), nextState.selectAll, index);
+      }
+
+      return nextState;
+    });
+  };
+
+  const handleSelectAll = checked => {
+    if (!multiple) return;
+    setLastSelectedRow(null);
+    setSelectedRowsState(() => {
+      const {
+        composedRows: nextRows
+      } = grid.getInstance();
+      const nextState = {
+        selectAll: checked,
+        selectedRows: helper.toggleSelectAll(nextRows, checked)
+      };
+      onSelectAll(nextState.selectAll);
+      onSelectRow(checked ? nextRows : [], nextState.selectAll);
+      return nextState;
+    });
+  };
+
+  return {
+    actions: {
+      selectRow: handleSelectRow,
+      selectAll: handleSelectAll
+    },
+    state: {
+      selection
+    }
+  };
+}
+
+exports.useSelectableState = useSelectableState;

package/cjs/plugins/sortable/SortablePlugin.js

@@ -0,0 +1,109 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sortabular = require('sortabular');
+var dsUtilities = require('@elliemae/ds-utilities');
+var initColumnDefinition = require('@elliemae/ds-shared/useDataGrid/initColumnDefinition');
+var createInstancePlugin = require('@elliemae/ds-shared/createDataInstance/createInstancePlugin');
+var sortHeaderFormatter = require('./sortHeaderFormatter.js');
+var useSortableState = require('./useSortableState.js');
+var sorter = require('./sorter.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var sortabular__namespace = /*#__PURE__*/_interopNamespace(sortabular);
+var createInstancePlugin__default = /*#__PURE__*/_interopDefaultLegacy(createInstancePlugin);
+
+const decorateColumn = (column, grid) => {
+  const {
+    props: {
+      isSortableColumnActive = col => col.sortable,
+      groupedRows
+    }
+  } = grid;
+  if (groupedRows) return column;
+  if (!isSortableColumnActive(column)) return column;
+  const formatter = sortHeaderFormatter(sortabular__namespace.sort({
+    getSortingColumns: () => grid.getState().sortingColumns || [],
+    onSort: grid.actions.sort,
+    strategy: sortabular__namespace.strategies.byProperty
+  }), grid);
+  return dsUtilities.compose(initColumnDefinition.appendHeaderFormatter(formatter), initColumnDefinition.mergeClassNameToColumnHeader('with-sortable'))(column);
+};
+
+const composeRows = (rows, grid) => {
+  const {
+    state: {
+      sortingColumns
+    },
+    props: {
+      isDataSorted,
+      groupedRows,
+      groupedBy,
+      sortEmptyLast
+    },
+    rows: rowsData,
+    composedRows,
+    decoratedColumns
+  } = grid.getInstance();
+  const sortingConfig = {
+    columns: decoratedColumns,
+    sortingColumns: !dsUtilities.isEmpty(sortingColumns) && sortingColumns,
+    sort: dsUtilities.orderBy,
+    emptyLast: sortEmptyLast
+  }; // TODO: 1572 FIX
+
+  if (groupedRows && !groupedBy) {
+    return !isDataSorted ? sorter.sorterGroups(sortingConfig)(composedRows, rowsData, groupedBy) : rows;
+  }
+
+  return !isDataSorted ? sorter.sorter(sortingConfig)(rows) : rows;
+};
+
+const SortablePlugin = createInstancePlugin__default["default"]('sortable', {
+  registerStateHook: useSortableState.useSortableState,
+  decorateColumn,
+  composeRows,
+
+  registerHotKeys(grid) {
+    return {
+      key: 'ctrl+s',
+      handler: _ref => {
+        let {
+          cellIndex
+        } = _ref;
+        const {
+          actions: {
+            sort
+          },
+          decoratedColumns
+        } = grid.getInstance();
+        const column = decoratedColumns[cellIndex];
+        if (!column) return;
+        sort(column.property);
+      }
+    };
+  }
+
+});
+
+exports.SortablePlugin = SortablePlugin;

package/cjs/plugins/sortable/checkIfSortable.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/* eslint-disable no-plusplus */
+
+/* eslint-disable no-loops/no-loops */
+const checkIfSortable = (column, rows) => {
+  for (let index = 0; index < rows.length; index++) {
+    const element = rows[index][column];
+
+    if (!(element === null || element === undefined)) {
+      // PUI-6452
+      return true;
+    }
+  }
+
+  return false;
+};
+
+exports.checkIfSortable = checkIfSortable;
+exports["default"] = checkIfSortable;

package/cjs/plugins/sortable/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var SortablePlugin = require('./SortablePlugin.js');
+
+
+
+exports.SortablePlugin = SortablePlugin.SortablePlugin;

package/cjs/plugins/sortable/sortHeaderFormatter.js

@@ -0,0 +1,60 @@
+'use strict';
+
+var _jsx = require('@babel/runtime/helpers/jsx');
+var React = require('react');
+var dsClassnames = require('@elliemae/ds-classnames');
+var dsIcons = require('@elliemae/ds-icons');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+var _ArrowheadUp, _ArrowheadDown;
+const blockName = 'data-grid-sort-header';
+const SortHeaderContainer = dsClassnames.aggregatedClasses('div')(blockName);
+const iconColor = ['brand-primary', 800];
+const SortHeader = /*#__PURE__*/React__default["default"].memo(_ref => {
+  let {
+    value,
+    onClick,
+    sortState
+  } = _ref;
+  const sortIndicator = sortState === 'asc' ? _ArrowheadUp || (_ArrowheadUp = /*#__PURE__*/_jsx__default["default"](dsIcons.ArrowheadUp, {
+    color: iconColor
+  })) : _ArrowheadDown || (_ArrowheadDown = /*#__PURE__*/_jsx__default["default"](dsIcons.ArrowheadDown, {
+    color: iconColor
+  }));
+  return /*#__PURE__*/_jsx__default["default"](SortHeaderContainer, {
+    onClick: onClick
+  }, void 0, /*#__PURE__*/_jsx__default["default"]("span", {
+    className: "header-value"
+  }, void 0, value), sortState && sortIndicator);
+});
+
+const sortHeaderFormatter = (sortable, grid) => (value, _ref2) => {
+  let {
+    columnIndex,
+    property
+  } = _ref2;
+  const {
+    state: {
+      sortingColumns
+    }
+  } = grid.getInstance();
+  const {
+    onClick,
+    className
+  } = sortable(value, {
+    columnIndex,
+    property
+  });
+  return /*#__PURE__*/_jsx__default["default"](SortHeader, {
+    className: className,
+    onClick: onClick,
+    sortState: sortingColumns[property] && sortingColumns[property].direction,
+    value: value
+  });
+};
+
+module.exports = sortHeaderFormatter;

package/cjs/plugins/sortable/sortTree.js

@@ -0,0 +1,51 @@
+'use strict';
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+require('core-js/modules/esnext.async-iterator.map.js');
+require('core-js/modules/esnext.iterator.map.js');
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.filter.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+var sortabular = require('sortabular');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var sortabular__namespace = /*#__PURE__*/_interopNamespace(sortabular);
+
+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__default["default"](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 deepSorting = function (sortConfig) {
+  let rows = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  return sortabular__namespace.sorter(sortConfig)(rows.map(row => row.children && row.children.length ? _objectSpread(_objectSpread({}, row), {}, {
+    children: deepSorting(sortConfig, row.children)
+  }) : row));
+};
+
+function sortTree(sortConfig) {
+  return rows => deepSorting(sortConfig, rows);
+}
+
+module.exports = sortTree;

package/cjs/plugins/sortable/sorter.js

@@ -0,0 +1,176 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.filter.js');
+require('core-js/modules/esnext.async-iterator.some.js');
+require('core-js/modules/esnext.iterator.some.js');
+require('core-js/modules/web.dom-collections.iterator.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+require('core-js/modules/esnext.async-iterator.find.js');
+require('core-js/modules/esnext.iterator.find.js');
+require('core-js/modules/esnext.async-iterator.map.js');
+require('core-js/modules/esnext.iterator.map.js');
+var dsUtilities = require('@elliemae/ds-utilities');
+var moment = require('moment');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var moment__default = /*#__PURE__*/_interopDefaultLegacy(moment);
+
+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__default["default"](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 sorter = function () {
+  let {
+    columns,
+    sortingColumns,
+    sort,
+    emptyLast
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return data => {
+    if (!columns) {
+      throw new Error('sort.sorter - Missing "columns" argument!');
+    }
+
+    if (!sort) {
+      throw new Error('sort.sorter - Missing "sort" argument!');
+    }
+
+    if (!sortingColumns) {
+      return data;
+    }
+
+    const columnIndexList = new Array(sortingColumns.length);
+    const orderList = new Array(sortingColumns.length);
+    let actualSortFunction = sort;
+
+    if (emptyLast) {
+      actualSortFunction = (innerData, innerColumnIndexList, innerOrderList) => {
+        const sortedData = sort(innerData, innerColumnIndexList, innerOrderList);
+        const keys = Object.keys(sortingColumns);
+        const withData = sortedData.filter(r => keys.some(key => !!r[key]));
+        const withoutData = sortedData.filter(r => keys.some(key => !r[key]));
+        return [...withData, ...withoutData];
+      };
+    }
+
+    Object.keys(sortingColumns).forEach(sortingColumnKey => {
+      const realColumn = columns.find(column => column.property === sortingColumnKey);
+      if (!realColumn) return;
+
+      const columnSorter = realColumn.sort || function resolveValue(row) {
+        const {
+          property,
+          sortBy
+        } = realColumn;
+        const value = row[sortBy || property]; // Pick resolved value by convention
+
+        const resolvedValue = dsUtilities.get(row, "_".concat(property), value);
+
+        if (realColumn.type === 'DateTime') {
+          return moment__default["default"](resolvedValue);
+        }
+
+        return typeof resolvedValue === 'string' ? resolvedValue.toLowerCase() : resolvedValue;
+      };
+
+      const sortingColumn = sortingColumns[sortingColumnKey];
+      columnIndexList[sortingColumn.position] = columnSorter;
+      orderList[sortingColumn.position] = sortingColumn.direction;
+    });
+    return actualSortFunction(data, columnIndexList, orderList);
+  };
+};
+const sorterGroups = function () {
+  let {
+    columns,
+    sortingColumns,
+    sort,
+    emptyLast
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return (data, rowsData) => {
+    if (!columns) {
+      throw new Error('sort.sorter - Missing "columns" argument!');
+    }
+
+    if (!sort) {
+      throw new Error('sort.sorter - Missing "sort" argument!');
+    }
+
+    if (!sortingColumns) {
+      return data;
+    }
+
+    const columnIndexList = new Array(sortingColumns.length);
+    const orderList = new Array(sortingColumns.length);
+    let actualSortFunction = sort;
+
+    if (emptyLast) {
+      actualSortFunction = (innerData, innerColumnIndexList, innerOrderList) => {
+        const sortedData = sort(innerData, innerColumnIndexList, innerOrderList);
+        const keys = Object.keys(sortingColumns);
+        const withData = sortedData.filter(r => keys.some(key => !!r[key]));
+        const withoutData = sortedData.filter(r => keys.some(key => !r[key]));
+        return [...withData, ...withoutData];
+      };
+    }
+
+    Object.keys(sortingColumns).forEach(sortingColumnKey => {
+      const realColumn = columns.find(column => column.property === sortingColumnKey);
+      if (!realColumn) return;
+
+      const columnSorter = realColumn.sort || function resolveValue(row) {
+        const {
+          property,
+          sortBy
+        } = realColumn;
+        const value = row[sortBy || property]; // Pick resolved value by convention
+
+        const resolvedValue = dsUtilities.get(row, "_".concat(property), value);
+
+        if (realColumn.type === 'DateTime') {
+          return moment__default["default"](resolvedValue);
+        }
+
+        return typeof resolvedValue === 'string' ? resolvedValue.toLowerCase() : resolvedValue;
+      };
+
+      const sortingColumn = sortingColumns[sortingColumnKey];
+      columnIndexList[sortingColumn.position] = columnSorter;
+      orderList[sortingColumn.position] = sortingColumn.direction;
+    });
+    const groups = {};
+    const preserveData = {};
+    data.forEach(c => {
+      preserveData[c.id] = _objectSpread({}, c);
+    });
+    rowsData.forEach(group => {
+      groups[group.id] = {
+        children: actualSortFunction(group.children.map(c => _objectSpread({
+          parentNode: preserveData[c.id].parentNode,
+          data: c
+        }, c)), columnIndexList, orderList) // sort internally
+
+      };
+    });
+    const sorted = actualSortFunction(data.map(r => _objectSpread(_objectSpread({}, r.data), r)), columnIndexList, orderList); // sort global
+
+    let ssortGlobal = [];
+    sorted.filter(s => !s.isGroup).forEach(sr => {
+      if (groups[sr.parentNode.id]) {
+        ssortGlobal = [...ssortGlobal, preserveData[sr.parentNode.id], ...groups[sr.parentNode.id].children];
+        delete groups[sr.parentNode.id];
+      }
+    });
+    return ssortGlobal;
+  };
+};
+
+exports.sorter = sorter;
+exports.sorterGroups = sorterGroups;