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

package/esm/plugins/filterable/helper.js

@@ -1,58 +1,63 @@
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import _toConsumableArray from '@babel/runtime/helpers/esm/toConsumableArray';
+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.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.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 { uniqBy, property, get, isFunction, groupBy } 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 getFilterLabel = function getFilterLabel(column, value) {
-  return column.filterLabels ? column.filterLabels[value] || value : value;
-};
-var getFilterLabels = function getFilterLabels(column, rows) {
-  return uniqBy(rows, property(column.searchBy || column.property)).map(function (row) {
-    var value = get(row, column.searchBy || column.property);
-    if (value === undefined) return {};
-    var rowColumnValue = String(get(row, column.searchBy || column.property));
-
-    if (isFunction(column.valueTransformation)) {
-      var nextValue = column.valueTransformation(rowColumnValue);
-      return {
-        id: nextValue,
-        label: nextValue
-      };
-    }
+const getFilterLabel = (column, value) => column.filterLabels ? column.filterLabels[value] || value : value;
+const getFilterLabels = (column, rows) => uniqBy(rows, property(column.searchBy || column.property)).map(row => {
+  const value = get(row, column.searchBy || column.property);
+  if (value === undefined) return {};
+  const rowColumnValue = String(get(row, column.searchBy || column.property));
 
-    var label = getFilterLabel(column, rowColumnValue);
+  if (isFunction(column.valueTransformation)) {
+    const nextValue = column.valueTransformation(rowColumnValue);
     return {
-      id: rowColumnValue || label,
-      label: label
+      id: nextValue,
+      label: nextValue
     };
-  }).filter(function (row) {
-    return row.id;
-  }).filter(function (row) {
-    if (row.id.startsWith) return !row.id.startsWith('grouped-by');
-    return true;
-  });
-};
-var getFilterLabelsGroup = function getFilterLabelsGroup(column, rows) {
-  var flat = [];
-  rows.forEach(function (r) {
+  }
+
+  const label = getFilterLabel(column, rowColumnValue);
+  return {
+    id: rowColumnValue || label,
+    label
+  };
+}).filter(row => row.id).filter(row => {
+  if (row.id.startsWith) return !row.id.startsWith('grouped-by');
+  return true;
+});
+const getFilterLabelsGroup = (column, rows) => {
+  let flat = [];
+  rows.forEach(r => {
     if (r.children) {
-      flat = [].concat(_toConsumableArray(flat), _toConsumableArray(r.children));
+      flat = [...flat, ...r.children];
     }
   });
   return getFilterLabels(column, flat);
 };
 function getFilterValue(filter, column) {
-  var value = filter.value;
+  const {
+    value
+  } = filter;
   if (!column) return value;
-  var filterOptions = column.filterOptions,
-      filterLabels = column.filterLabels;
+  const {
+    filterOptions,
+    filterLabels
+  } = column;
 
   if (filterOptions) {
-    var foundOption = column.filterOptions.filter(function (option) {
-      return option.id === value;
-    })[0];
+    const foundOption = column.filterOptions.filter(option => option.id === value)[0];
     if (foundOption) return foundOption.label;
     return value;
   }
@@ -65,15 +70,9 @@ function getFilterValue(filter, column) {
 }
 function buildFilterArray(newFilter, filters) {
   // if (newFilter.type && newFilter.type === 'date') return [...filters.slice(1), newFilter]
-  return uniqBy([].concat(_toConsumableArray(filters), [newFilter]), function (v) {
-    return [v.group, v.value].join();
-  });
+  return uniqBy([...filters, newFilter], v => [v.group, v.value].join());
 }
-var groupFilters = function groupFilters(filters) {
-  return filters.filter(function (filter) {
-    return !filter.fixed;
-  });
-};
+const groupFilters = filters => filters.filter(filter => !filter.fixed);
 
 function parseFilterToRule(filter) {
   return _objectSpread(_objectSpread({}, filter), {}, {
@@ -83,11 +82,9 @@ function parseFilterToRule(filter) {
 }
 
 function parseFiltersToQuery(filters) {
-  var groupedFilters = groupBy(groupFilters(filters), function (filter) {
-    return filter.group;
-  });
-  return Object.keys(groupedFilters).reduce(function (queryResult, field) {
-    var filter = groupedFilters[field];
+  const groupedFilters = groupBy(groupFilters(filters), filter => filter.group);
+  return Object.keys(groupedFilters).reduce((queryResult, field) => {
+    const filter = groupedFilters[field];
 
     if (Array.isArray(filter) && filter.length > 1) {
       // create query group with 'OR' condition
@@ -107,4 +104,3 @@ function parseFiltersToQuery(filters) {
 }
 
 export { buildFilterArray, getFilterLabel, getFilterLabels, getFilterLabelsGroup, getFilterValue, groupFilters, parseFiltersToQuery };
-//# sourceMappingURL=helper.js.map

package/esm/plugins/filterable/index.js

@@ -1,41 +1 @@
 export { FilterablePlugin } from './FilterablePlugin.js';
-import '@elliemae/ds-utilities';
-import '@elliemae/ds-shared/createDataInstance/createInstancePlugin';
-import './addFilterToColumn.js';
-import '@babel/runtime/helpers/esm/defineProperty';
-import 'react';
-import '@elliemae/ds-shared/useDataGrid/initColumnDefinition';
-import './filterableFormatter.js';
-import './components/FilterableHeader.js';
-import '@babel/runtime/helpers/esm/extends';
-import '@babel/runtime/helpers/esm/slicedToArray';
-import 'prop-types';
-import '@elliemae/ds-classnames';
-import '@elliemae/ds-system';
-import './components/filterable-menus/getFilterMenuByType.js';
-import './components/filterable-menus/DateRangeFilterMenu.js';
-import '@elliemae/ds-controlled-form';
-import '@elliemae/ds-popper';
-import '@elliemae/ds-icons';
-import '@elliemae/ds-button';
-import 'moment';
-import './components/filterable-menus/defaultDateFormat.js';
-import './components/filterable-menus/SingleDateFilterMenu.js';
-import '@elliemae/ds-grid';
-import './components/filterable-menus/SingleRangeSwitcherMenu.js';
-import '@elliemae/ds-basic/Popper';
-import '@elliemae/ds-basic/Button';
-import 'styled-components';
-import './components/filterable-menus/TextFilterMenu.js';
-import '@babel/runtime/helpers/esm/toConsumableArray';
-import '@babel/runtime/helpers/esm/objectWithoutProperties';
-import 'lodash';
-import '@elliemae/ds-dropdownmenu';
-import '@elliemae/ds-menu';
-import './helper.js';
-import './filtering-helper/filterRowsByQuery.js';
-import './filtering-helper/strategiesOperators.js';
-import 'comparejs';
-import './useFilterableState.js';
-import 'uuid';
-//# sourceMappingURL=index.js.map

package/esm/plugins/filterable/useFilterableState.js

@@ -1,66 +1,57 @@
+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 _slicedToArray from '@babel/runtime/helpers/esm/slicedToArray';
+import 'core-js/modules/web.dom-collections.iterator.js';
 import { useState, useEffect, useMemo } from 'react';
 import { v4 } from 'uuid';
 import { parseFiltersToQuery, getFilterValue, buildFilterArray } from './helper.js';
-import '@babel/runtime/helpers/esm/toConsumableArray';
-import '@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 noop = function noop() {
-  return null;
-};
+const noop = () => null;
 
 function useFilterableState(grid) {
-  var _grid$props = grid.props,
-      filtersProp = _grid$props.filters,
-      _grid$props$onAddFilt = _grid$props.onAddFilter,
-      onAddFilter = _grid$props$onAddFilt === void 0 ? noop : _grid$props$onAddFilt,
-      _grid$props$onRemoveF = _grid$props.onRemoveFilter,
-      onRemoveFilter = _grid$props$onRemoveF === void 0 ? noop : _grid$props$onRemoveF,
-      _grid$props$onRemoveA = _grid$props.onRemoveAllFilters,
-      onRemoveAllFilters = _grid$props$onRemoveA === void 0 ? noop : _grid$props$onRemoveA,
-      _grid$props$onFilters = _grid$props.onFiltersChange,
-      onFiltersChange = _grid$props$onFilters === void 0 ? noop : _grid$props$onFilters;
-
-  var _useState = useState(filtersProp || []),
-      _useState2 = _slicedToArray(_useState, 2),
-      filters = _useState2[0],
-      setFilters = _useState2[1];
-
-  useEffect(function () {
+  const {
+    filters: filtersProp,
+    onAddFilter = noop,
+    onRemoveFilter = noop,
+    onRemoveAllFilters = noop,
+    onFiltersChange = noop
+  } = grid.props;
+  const [filters, setFilters] = useState(filtersProp || []);
+  useEffect(() => {
     if (filtersProp && filtersProp !== filters) {
       setFilters(filtersProp);
     }
   }, [filtersProp]);
-  var queryFromFilters = useMemo(function () {
-    return parseFiltersToQuery(filters || []);
-  }, [filters]);
-
-  var handleFiltersChange = function handleFiltersChange(nextFilters) {
-    var _grid$getInstance = grid.getInstance(),
-        body = _grid$getInstance.refs.body;
+  const queryFromFilters = useMemo(() => parseFiltersToQuery(filters || []), [filters]);
 
+  const handleFiltersChange = nextFilters => {
+    const {
+      refs: {
+        body
+      }
+    } = grid.getInstance();
     body.current.scrollTop = 0;
     setFilters(nextFilters);
-    grid.observeRows(function (rows) {
-      return onFiltersChange(nextFilters, queryFromFilters, rows);
-    });
+    grid.observeRows(rows => onFiltersChange(nextFilters, queryFromFilters, rows));
   };
 
-  var addFilter = function addFilter(filter, column) {
-    var hasBeenCalled = false;
+  const addFilter = (filter, column) => {
+    let hasBeenCalled = false;
 
-    var trimmedFilter = _objectSpread(_objectSpread({}, filter), {}, {
+    const trimmedFilter = _objectSpread(_objectSpread({}, filter), {}, {
       value: String(filter.value).trim()
     });
     /* eslint-disable indent */
 
 
-    var parsedFilter = !filter.group ? _objectSpread(_objectSpread({}, trimmedFilter), {}, {
+    const parsedFilter = !filter.group ? _objectSpread(_objectSpread({}, trimmedFilter), {}, {
       value: String(filter.value).trim(),
       group: 'all',
       label: 'All',
@@ -74,44 +65,45 @@ function useFilterableState(grid) {
     });
     /* eslint-enable indent */
 
-    setFilters(function (prevFilters) {
+    setFilters(prevFilters => {
       // This was setted for an issue that was recalling this function on the handleFiltersChange
       if (hasBeenCalled) {
         return;
       }
 
       hasBeenCalled = true;
-      var nextFilters = buildFilterArray(parsedFilter, prevFilters);
+      const nextFilters = buildFilterArray(parsedFilter, prevFilters);
       handleFiltersChange(nextFilters);
       onAddFilter(parsedFilter, nextFilters, column);
     });
   };
 
-  var removeFilter = function removeFilter(_ref) {
-    var group = _ref.group,
-        pill = _ref.pill,
-        nextFilters = _ref.nextFilters;
+  const removeFilter = _ref => {
+    let {
+      group,
+      pill,
+      nextFilters
+    } = _ref;
     onRemoveFilter(group, pill.value, nextFilters);
     handleFiltersChange(nextFilters);
   };
 
-  var removeAllFilters = function removeAllFilters() {
+  const removeAllFilters = () => {
     onRemoveAllFilters();
     handleFiltersChange([]);
   };
 
   return {
     actions: {
-      addFilter: addFilter,
-      removeFilter: removeFilter,
-      removeAllFilters: removeAllFilters
+      addFilter,
+      removeFilter,
+      removeAllFilters
     },
     state: {
       query: queryFromFilters,
-      filters: filters
+      filters
     }
   };
 }
 
 export { useFilterableState };
-//# sourceMappingURL=useFilterableState.js.map

package/esm/plugins/grouping-by/GroupingByPlugin.js

@@ -1,30 +1,32 @@
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
 import createInstancePlugin from '@elliemae/ds-shared/createDataInstance/createInstancePlugin';
 import { groupBy } from 'lodash';
 
-var groupedByData = function groupedByData(groupedBy, composedRows) {
-  var grouped = groupBy(composedRows, groupedBy);
-  return Object.keys(grouped).map(function (c, key) {
-    return {
-      id: "grouped-by-".concat(groupedBy, "-").concat(key),
-      key: groupedBy,
-      value: c,
-      children: grouped[c],
-      _isGroup: true,
-      isGroup: true
-    };
-  });
+const groupedByData = (groupedBy, composedRows) => {
+  const grouped = groupBy(composedRows, groupedBy);
+  return Object.keys(grouped).map((c, key) => ({
+    id: "grouped-by-".concat(groupedBy, "-").concat(key),
+    key: groupedBy,
+    value: c,
+    children: grouped[c],
+    _isGroup: true,
+    isGroup: true
+  }));
 };
 
-var GroupingByPlugin = createInstancePlugin('groupedByRows', {
-  decorateGrid: function decorateGrid(grid) {
-    var _grid$getInstance = grid.getInstance(),
-        composedRows = _grid$getInstance.composedRows,
-        groupedBy = _grid$getInstance.props.groupedBy;
-
+const GroupingByPlugin = createInstancePlugin('groupedByRows', {
+  decorateGrid(grid) {
+    const {
+      composedRows,
+      props: {
+        groupedBy
+      }
+    } = grid.getInstance();
     grid.composedRows = groupedBy ? groupedByData(groupedBy, composedRows) : composedRows;
     return grid;
   }
+
 });
 
 export { GroupingByPlugin };
-//# sourceMappingURL=GroupingByPlugin.js.map

package/esm/plugins/grouping-grid/GroupingPlugin.js

@@ -1,142 +1,138 @@
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
 import _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import React, { useMemo } from 'react';
+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.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 { useMemo } from 'react';
 import createInstancePlugin from '@elliemae/ds-shared/createDataInstance/createInstancePlugin';
 import { aggregatedClasses } from '@elliemae/ds-classnames';
 import { VariableSizeList } from 'react-window';
 import { walkTreeStrategy } from './walkStrategy.js';
 import { RowSizes } from '../../rowSizes.js';
 import { dataGridBlockName } from '../../blockNames.js';
-import '@babel/runtime/helpers/esm/toConsumableArray';
+import { jsx, Fragment } from 'react/jsx-runtime';
 
-var _excluded = ["isExpanded"];
+const _excluded = ["isExpanded"];
 
 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 blockName = "".concat(dataGridBlockName, "-group-row-header");
-var GroupRowHeaderWrapper = aggregatedClasses('div')(blockName);
-var GroupRowHeaderTitle = aggregatedClasses('div')(blockName, 'title');
-var GroupingPlugin = createInstancePlugin('groupedRows', {
-  decorateGrid: function decorateGrid(grid) {
-    var _grid$getInstance = grid.getInstance(),
-        columns = _grid$getInstance.columns,
-        composedRows = _grid$getInstance.composedRows; // eslint-disable-next-line react-hooks/rules-of-hooks
-
-
-    var detailColumns = useMemo(function () {
-      return columns.map(function (column) {
-        return _objectSpread(_objectSpread({}, column), {}, {
-          customRenderer: column.detailCustomRenderer
-        });
-      }).filter(function (col) {
-        return !col.expandableColumn;
-      });
-    }, [columns]);
-    var flatRows = [];
+const blockName = "".concat(dataGridBlockName, "-group-row-header");
+const GroupRowHeaderWrapper = aggregatedClasses('div')(blockName);
+const GroupRowHeaderTitle = aggregatedClasses('div')(blockName, 'title');
+const GroupingPlugin = createInstancePlugin('groupedRows', {
+  decorateGrid(grid) {
+    const {
+      columns,
+      composedRows
+    } = grid.getInstance(); // eslint-disable-next-line react-hooks/rules-of-hooks
+
+    const detailColumns = useMemo(() => columns.map(column => _objectSpread(_objectSpread({}, column), {}, {
+      customRenderer: column.detailCustomRenderer
+    })).filter(col => !col.expandableColumn), [columns]);
+    const flatRows = [];
     walkTreeStrategy({
       data: composedRows,
-      cb: function cb(n) {
-        return flatRows.push(n);
-      }
+      cb: n => flatRows.push(n)
     });
     return {
-      detailColumns: detailColumns,
+      detailColumns,
       composedRows: flatRows
     };
   },
-  getBodyProps: function getBodyProps(bodyProps, grid) {
-    var _grid$getInstance2 = grid.getInstance(),
-        rows = _grid$getInstance2.composedRows; // implementation of expandable row single column with aggregation
 
+  getBodyProps(bodyProps, grid) {
+    const {
+      composedRows: rows
+    } = grid.getInstance(); // implementation of expandable row single column with aggregation
 
-    var getItemSize = function getItemSize(index) {
-      var rowData = rows[index];
+    const getItemSize = index => {
+      const rowData = rows[index];
       if (!rowData) return RowSizes.normal;
       return rowData._isGroup || rowData.isGroup ? RowSizes.compact : RowSizes.normal;
     }; // eslint-disable-next-line no-unused-vars
 
 
-    var getListHeight = function getListHeight() {
-      var size = rows.reduce(function (h, r) {
-        var rowHeight = r._isGroup || r.isGroup ? RowSizes.compact : RowSizes.normal;
+    const getListHeight = () => {
+      const size = rows.reduce((h, r) => {
+        const rowHeight = r._isGroup || r.isGroup ? RowSizes.compact : RowSizes.normal;
         return h + rowHeight;
       }, 0);
       return size;
     };
 
     return _objectSpread(_objectSpread({}, bodyProps), {}, {
-      getListHeight: getListHeight,
+      getListHeight,
       listComponent: VariableSizeList,
       listProps: {
         itemSize: getItemSize
       }
     });
   },
-  composeRows: function composeRows(rows, grid) {
-    var _grid$getInstance3 = grid.getInstance(),
-        composedRows = _grid$getInstance3.composedRows,
-        rowKey = _grid$getInstance3.props.rowKey;
+
+  composeRows: (rows, grid) => {
+    const {
+      composedRows,
+      props: {
+        rowKey
+      }
+    } = grid.getInstance();
 
     if (Array.isArray(rows)) {
-      var filterIds = rows.map(function (r) {
-        return r.data[rowKey];
-      });
-      return composedRows.filter(function (c) {
-        return filterIds.includes(c.data[rowKey]);
-      }).map(function (r) {
-        return _objectSpread(_objectSpread({}, r.data), {}, {
-          children: Array.isArray(r.data.children) ? r.data.children.filter(function (c) {
-            return filterIds.includes(c[rowKey]);
-          }) : r.data.children,
-          _isGroup: r.isGroup
-        });
-      }).filter(function (g) {
-        return g.children === undefined || g.children.length > 0;
-      });
+      const filterIds = rows.map(r => r.data[rowKey]);
+      return composedRows.filter(c => filterIds.includes(c.data[rowKey])).map(r => _objectSpread(_objectSpread({}, r.data), {}, {
+        children: Array.isArray(r.data.children) ? r.data.children.filter(c => filterIds.includes(c[rowKey])) : r.data.children,
+        _isGroup: r.isGroup
+      })).filter(g => g.children === undefined || g.children.length > 0);
     }
 
     return _objectSpread(_objectSpread({}, rows), {}, {
-      allRows: rows.allRows.map(function (r) {
-        return _objectSpread(_objectSpread({}, r.data), {}, {
-          _isGroup: r.isGroup
-        });
-      }),
-      rows: rows.rows.map(function (r) {
-        return _objectSpread(_objectSpread({}, r.data), {}, {
-          _isGroup: r.isGroup
-        });
-      })
+      allRows: rows.allRows.map(r => _objectSpread(_objectSpread({}, r.data), {}, {
+        _isGroup: r.isGroup
+      })),
+      rows: rows.rows.map(r => _objectSpread(_objectSpread({}, r.data), {}, {
+        _isGroup: r.isGroup
+      }))
     });
   },
-  decorateRenderers: function decorateRenderers(renderers, grid) {
-    var Row = renderers.body.row; // eslint-disable-next-line react-hooks/rules-of-hooks
 
-    renderers.body.row = useMemo(function () {
-      return (// eslint-disable-next-line react/display-name
-        // eslint-disable-next-line react/prop-types
-        function (_ref) {
-          _ref.isExpanded;
-              var rowProps = _objectWithoutProperties(_ref, _excluded);
+  decorateRenderers(renderers, grid) {
+    const Row = renderers.body.row; // eslint-disable-next-line react-hooks/rules-of-hooks
 
-          var _grid$getInstance4 = grid.getInstance(),
-              composedRows = _grid$getInstance4.composedRows; // // https://jira.elliemae.io/browse/PUI-1667
+    renderers.body.row = useMemo(() => // eslint-disable-next-line react/display-name
+    // eslint-disable-next-line react/prop-types
+    _ref => {
+      let rowProps = _objectWithoutProperties(_ref, _excluded);
 
+      const {
+        composedRows
+      } = grid.getInstance(); // // https://jira.elliemae.io/browse/PUI-1667
 
-          var node = composedRows[rowProps.index] ? composedRows[rowProps.index] : rowProps.rowData;
-          var groupedRowsRenderHeader = grid.props.groupedRowsRenderHeader; // eslint-disable-next-line no-underscore-dangle
+      const node = composedRows[rowProps.index] ? composedRows[rowProps.index] : rowProps.rowData;
+      const {
+        groupedRowsRenderHeader
+      } = grid.props; // eslint-disable-next-line no-underscore-dangle
 
-          if (node && node._isGroup) {
-            return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(GroupRowHeaderWrapper, rowProps, /*#__PURE__*/React.createElement(GroupRowHeaderTitle, null, groupedRowsRenderHeader ? groupedRowsRenderHeader(node) : 'Group')));
-          }
+      if (node && node._isGroup) {
+        return /*#__PURE__*/jsx(Fragment, {
+          children: /*#__PURE__*/jsx(GroupRowHeaderWrapper, _objectSpread(_objectSpread({}, rowProps), {}, {
+            children: /*#__PURE__*/_jsx(GroupRowHeaderTitle, {}, void 0, groupedRowsRenderHeader ? groupedRowsRenderHeader(node) : 'Group')
+          }))
+        });
+      }
 
-          return /*#__PURE__*/React.createElement(Row, rowProps);
-        }
-      );
+      return /*#__PURE__*/jsx(Row, _objectSpread({}, rowProps));
     }, []);
     return renderers;
   }
+
 });
 
 export { GroupingPlugin };
-//# sourceMappingURL=GroupingPlugin.js.map