@elliemae/ds-datagrids 2.2.0-alpha.4 → 3.0.0-next.2

package/esm/plugins/filterable/components/filterable-menus/TextFilterMenu.js

@@ -1,141 +1,163 @@
-import * as React from "react";
-import React2, { useState } from "react";
-import PropTypes from "prop-types";
-import { compact } from "lodash";
-import { DSDropdownMenu } from "@elliemae/ds-dropdownmenu";
-import { DSButton } from "@elliemae/ds-button";
-import { PopperPositions as Position } from "@elliemae/ds-popper";
-import { Menu, MenuCombobox } from "@elliemae/ds-menu";
-import { SearchSmall } from "@elliemae/ds-icons";
-function TextFilterMenu({
-  column,
-  menuStyle = {},
-  className,
-  filters = [],
-  isMenuOpened = false,
-  onOpenMenu = () => null,
-  onClose = () => null,
-  placement = Position.BOTTOM_END,
-  menuProps = {},
-  onAddFilter = () => null,
-  onRemoveFilter = () => null,
-  maxOptions = 10,
-  isMulti = false
-}) {
-  const { options, ...otherMenuProps } = menuProps;
-  const generateOption = (option, idx) => /* @__PURE__ */ React2.createElement(Menu.ItemCheckbox, {
-    key: idx,
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.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.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import React, { useState } from 'react';
+import { compact } from 'lodash';
+import DSDropdownMenu from '@elliemae/ds-dropdownmenu';
+import DSButton from '@elliemae/ds-button';
+import { PopperPositions } from '@elliemae/ds-popper';
+import { Menu, MenuCombobox } from '@elliemae/ds-menu';
+import { SearchSmall } from '@elliemae/ds-icons';
+import { jsx } from 'react/jsx-runtime';
+
+var _SearchSmall;
+
+const _excluded = ["options"];
+
+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; }
+
+function TextFilterMenu(_ref) {
+  let {
+    column,
+    menuStyle = {},
+    className,
+    filters = [],
+    isMenuOpened = false,
+    onOpenMenu = () => null,
+    onClose = () => null,
+    placement = PopperPositions.BOTTOM_END,
+    menuProps = {},
+    onAddFilter = () => null,
+    onRemoveFilter = () => null,
+    maxOptions = 10,
+    isMulti = false
+  } = _ref;
+
+  const {
+    options
+  } = menuProps,
+        otherMenuProps = _objectWithoutProperties(menuProps, _excluded);
+
+  const generateOption = (option, idx) => /*#__PURE__*/_jsx(Menu.ItemCheckbox, {
     label: option.label,
     name: option.id
-  });
-  const renderOptions = (arr) => arr.map(generateOption);
-  const filtersForColumn = filters.filter((f) => f.group === column.property);
-  const initialSelectedOptions = filtersForColumn.map((f) => f.value);
+  }, idx);
+
+  const renderOptions = arr => arr.map(generateOption);
+
+  const filtersForColumn = filters.filter(f => f.group === column.property);
+  const initialSelectedOptions = filtersForColumn.map(f => f.value);
   const [selected, setSelected] = useState(initialSelectedOptions);
-  React2.useEffect(() => {
-    const filtersForColumn2 = filters.filter((f) => f.group === column.property);
-    setSelected(filtersForColumn2.map((f) => f.value));
+  React.useEffect(() => {
+    const filtersForColumn2 = filters.filter(f => f.group === column.property);
+    setSelected(filtersForColumn2.map(f => f.value));
   }, [filters]);
   const filterGroup = column.searchBy || column.property;
+
   const onCloseMulti = () => {
     let nextFilters = [...filters];
-    const shouldRemove = [];
-    initialSelectedOptions.forEach((item) => {
+    const shouldRemove = []; // if selected doesn't includes item, then we have to remove the filter
+    // but given that we are maintaining state here and updating the grid state
+    // is not implemented on useFilterableState, we have to do this in 2 traverses
+    // as doing it in one gives trouble when removing and adding at the same time.
+
+    initialSelectedOptions.forEach(item => {
       if (!selected.includes(item)) {
-        nextFilters = nextFilters.filter((filter) => !(filter.group === filterGroup && filter.value === item));
-        shouldRemove.push({ group: filterGroup, pill: { value: item } });
+        nextFilters = nextFilters.filter(filter => !(filter.group === filterGroup && filter.value === item));
+        shouldRemove.push({
+          group: filterGroup,
+          pill: {
+            value: item
+          }
+        });
       }
     });
-    shouldRemove.forEach((removedFilter) => {
-      onRemoveFilter({
-        ...removedFilter,
+    shouldRemove.forEach(removedFilter => {
+      onRemoveFilter(_objectSpread(_objectSpread({}, removedFilter), {}, {
         nextFilters
-      });
+      }));
     });
-    selected.forEach((item) => {
+    selected.forEach(item => {
+      // if initialSelectedOptions includes item, then we do nothing
       if (!initialSelectedOptions.includes(item)) {
+        var _column$filter;
+
         onAddFilter({
           group: filterGroup,
           label: column.label,
           value: item,
-          operator: column?.filter?.operator || "contains",
+          operator: (column === null || column === void 0 ? void 0 : (_column$filter = column.filter) === null || _column$filter === void 0 ? void 0 : _column$filter.operator) || 'contains',
           transformRowValue: column.valueTransformation
         }, column);
       }
     });
     onClose();
   };
-  return /* @__PURE__ */ React2.createElement(DSDropdownMenu, {
+
+  return /*#__PURE__*/_jsx(DSDropdownMenu, {
     closeMenuOnItemSelection: true,
     contentStyle: menuStyle,
-    customMenu: isMulti ? /* @__PURE__ */ React2.createElement(Menu, {
-      containerProps: { id: "text-filter-menu-multiple" },
+    customMenu: isMulti ? /*#__PURE__*/_jsx(Menu, {
+      containerProps: {
+        id: 'text-filter-menu-multiple'
+      },
       className: "dg-multiple-filter",
       visible: true
-    }, /* @__PURE__ */ React2.createElement(Menu.SelectionGroup, {
+    }, void 0, /*#__PURE__*/_jsx(Menu.SelectionGroup, {
       active: selected,
-      onSelect: (newValues) => {
+      onSelect: newValues => {
         setSelected(newValues);
       },
       focusOnOpen: true,
       multi: true,
       searchable: true
-    }, renderOptions(options))) : /* @__PURE__ */ React2.createElement(MenuCombobox, {
-      ...otherMenuProps,
-      className,
-      dropdownFilterOptions: {
-        ...column.dropdownFilterOptions,
+    }, void 0, renderOptions(options))) : /*#__PURE__*/jsx(MenuCombobox, _objectSpread(_objectSpread({}, otherMenuProps), {}, {
+      className: className,
+      dropdownFilterOptions: _objectSpread(_objectSpread({}, column.dropdownFilterOptions), {}, {
         maxOptions
-      },
+      }),
       maxWidth: column.filterMenuMaxWidth,
       minWidth: column.filterMenuMinWidth,
-      onSelectMenuItem: (selectedValue) => {
+      onSelectMenuItem: selectedValue => {
         if (selectedValue) {
+          var _column$filter2;
+
           onAddFilter({
             group: column.searchBy || column.property,
             label: column.label,
             value: selectedValue,
-            operator: column?.filter?.operator || "contains",
+            operator: (column === null || column === void 0 ? void 0 : (_column$filter2 = column.filter) === null || _column$filter2 === void 0 ? void 0 : _column$filter2.operator) || 'contains',
             transformRowValue: column.valueTransformation
           }, column);
           onOpenMenu(false);
         }
       }
-    }),
+    })),
     isOpen: isMenuOpened,
     maxWidth: column.filterMenuMaxWidth,
-    menuProps,
+    menuProps: menuProps,
     minWidth: column.filterMenuMinWidth,
-    onOpenMenu,
+    onOpenMenu: onOpenMenu,
     onClose: isMulti ? onCloseMulti : onClose,
     options: compact(options),
-    placement,
-    triggerComponent: /* @__PURE__ */ React2.createElement(DSButton, {
+    placement: placement,
+    triggerComponent: /*#__PURE__*/_jsx(DSButton, {
       buttonType: "text",
-      icon: /* @__PURE__ */ React2.createElement(SearchSmall, null),
+      icon: _SearchSmall || (_SearchSmall = /*#__PURE__*/_jsx(SearchSmall, {})),
       onClick: () => isMenuOpened ? onOpenMenu(false) : onOpenMenu(true),
       size: "s"
     })
   });
 }
-TextFilterMenu.propTypes = {
-  column: PropTypes.any,
-  menuStyle: PropTypes.shape({}),
-  className: PropTypes.string,
-  filters: PropTypes.arrayOf(PropTypes.shape({})),
-  isMenuOpened: PropTypes.bool,
-  onOpenMenu: PropTypes.func,
-  onClose: PropTypes.func,
-  placement: PropTypes.string,
-  menuProps: PropTypes.shape({}),
-  onAddFilter: PropTypes.func,
-  onRemoveFilter: PropTypes.func,
-  maxOptions: PropTypes.number,
-  isMulti: PropTypes.bool
-};
-var TextFilterMenu_default = TextFilterMenu;
-export {
-  TextFilterMenu,
-  TextFilterMenu_default as default
-};
-//# sourceMappingURL=TextFilterMenu.js.map
+
+export { TextFilterMenu as default };

package/esm/plugins/filterable/components/filterable-menus/defaultDateFormat.js

@@ -1,6 +1,3 @@
-import * as React from "react";
-const DEFAULT_DATE_FORMAT = "MM/DD/YYYY";
-export {
-  DEFAULT_DATE_FORMAT
-};
-//# sourceMappingURL=defaultDateFormat.js.map
+const DEFAULT_DATE_FORMAT = 'MM/DD/YYYY';
+
+export { DEFAULT_DATE_FORMAT };

package/esm/plugins/filterable/components/filterable-menus/getFilterMenuByType.js

@@ -1,20 +1,16 @@
-import * as React from "react";
-import { DateRangeFilterMenu } from "./DateRangeFilterMenu";
-import { SingleDateFilterMenu } from "./SingleDateFilterMenu";
-import { SingleRangeSwitcherMenu } from "./SingleRangeSwitcherMenu";
-import { TextFilterMenu } from "./TextFilterMenu";
+import DateRangeFilterMenu from './DateRangeFilterMenu.js';
+import SingleDateFilterMenu from './SingleDateFilterMenu.js';
+import SingleRangeSwitcherMenu from './SingleRangeSwitcherMenu.js';
+import TextFilterMenu from './TextFilterMenu.js';
+
 const ComponentTypes = {
-  "date-range": DateRangeFilterMenu,
-  "single-date": SingleDateFilterMenu,
-  "date-switcher": SingleRangeSwitcherMenu,
+  'date-range': DateRangeFilterMenu,
+  'single-date': SingleDateFilterMenu,
+  'date-switcher': SingleRangeSwitcherMenu,
   string: TextFilterMenu
 };
-const getFilterMenuByType = (type) => {
+function getFilterMenuByType(type) {
   return ComponentTypes[type] || ComponentTypes.string;
-};
-var getFilterMenuByType_default = getFilterMenuByType;
-export {
-  getFilterMenuByType_default as default,
-  getFilterMenuByType
-};
-//# sourceMappingURL=getFilterMenuByType.js.map
+}
+
+export { getFilterMenuByType as default };

package/esm/plugins/filterable/filterableFormatter.js

@@ -1,44 +1,57 @@
-import * as React from "react";
-import React2 from "react";
-import { FilterableHeader } from "./components/FilterableHeader";
-import { getFilterLabels, getFilterLabelsGroup } from "./helper";
-const FilterableFormatter = ({
-  grid,
-  onAddFilter,
-  onRemoveFilter,
-  query,
-  filterMenuRef
-}) => {
-  return (value, { column }) => {
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+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 'react';
+import FilterableHeader from './components/FilterableHeader.js';
+import { getFilterLabelsGroup, getFilterLabels } from './helper.js';
+
+function FilterableFormatter(_ref) {
+  let {
+    grid,
+    onAddFilter,
+    onRemoveFilter,
+    query,
+    filterMenuRef
+  } = _ref;
+  return (value, _ref2) => {
+    let {
+      column
+    } = _ref2;
     const {
       rows,
       composedRows,
-      props: { groupedRows, groupedBy, onFilterMenuClose, onFilterMenuOpen },
-      state: { filters }
+      props: {
+        groupedRows,
+        groupedBy,
+        onFilterMenuClose,
+        onFilterMenuOpen
+      },
+      state: {
+        filters
+      }
     } = grid.getInstance();
     let rowsToUse = composedRows;
+
     if (column.filter && column.filter.isMulti) {
       rowsToUse = rows;
     }
-    const filteredLabels = groupedRows && !groupedBy ? getFilterLabelsGroup(column, rows, query) : getFilterLabels(column, rowsToUse.rows || rowsToUse, query);
+
+    const filteredLabels = groupedRows && !groupedBy ? getFilterLabelsGroup(column, rows) : getFilterLabels(column, rowsToUse.rows || rowsToUse);
     const columnData = column.filterOptions || filteredLabels;
-    return /* @__PURE__ */ React2.createElement(FilterableHeader, {
-      column,
-      columnData,
-      filters,
-      filterMenuRef,
-      onAddFilter,
-      onFilterMenuClose,
-      onFilterMenuOpen,
-      onRemoveFilter,
+    return /*#__PURE__*/_jsx(FilterableHeader, {
+      column: column,
+      columnData: columnData,
+      filters: filters,
+      filterMenuRef: filterMenuRef,
+      onAddFilter: onAddFilter,
+      onFilterMenuClose: onFilterMenuClose,
+      onFilterMenuOpen: onFilterMenuOpen,
+      onRemoveFilter: onRemoveFilter,
       isMulti: column.filter && column.filter.isMulti,
-      value
+      value: value
     });
   };
-};
-var filterableFormatter_default = FilterableFormatter;
-export {
-  FilterableFormatter,
-  filterableFormatter_default as default
-};
-//# sourceMappingURL=filterableFormatter.js.map
+}
+
+export { FilterableFormatter as default };

package/esm/plugins/filterable/filtering-helper/filterRowsByQuery.js

@@ -1,50 +1,65 @@
-import * as React from "react";
-import { isFunction } from "@elliemae/ds-utilities";
-import { strategiesOperators } from "./strategiesOperators";
-const getRuleStrategyOperator = (rule) => rule.strategy || strategiesOperators(rule.operator);
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+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.reduce.js';
+import 'core-js/modules/esnext.iterator.reduce.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import { isFunction } from '@elliemae/ds-utilities';
+import strategiesOperators from './strategiesOperators.js';
+
+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 getRuleStrategyOperator = rule => rule.strategy || strategiesOperators(rule.operator);
+
 const executeFilterStrategy = (rule, row) => {
-  const { value, field, transform, transformRowValue } = rule;
-  if (field === "all")
-    return Object.values(row).some((colValue) => strategiesOperators("contains")(colValue, value));
+  const {
+    value,
+    field,
+    transform,
+    transformRowValue
+  } = rule;
+  if (field === 'all') return Object.values(row).some(colValue => strategiesOperators('contains')(colValue, value));
   const rowValue = row[field];
   const transformedValue = isFunction(transform) ? transform(value) : value;
   const transformedRowValue = isFunction(transformRowValue) ? transformRowValue(rowValue) : rowValue;
   const filterStrategy = getRuleStrategyOperator(rule);
   return filterStrategy(transformedRowValue, transformedValue);
 };
-const filterByRules = (rules, condition = "AND") => (row) => condition === "AND" ? rules.reduce((isFiltered, rule) => rule.rules && rule.rules.length ? isFiltered && filterByRules(rule.rules, rule.condition)(row) : isFiltered && executeFilterStrategy(rule, row), true) : rules.some((rule) => rule.rules && rule.rules.length ? filterByRules(rule.rules, rule.condition)(row) : executeFilterStrategy(rule, row));
+
+const filterByRules = function (rules) {
+  let condition = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'AND';
+  return row => condition === 'AND' ? rules.reduce((isFiltered, rule) => rule.rules && rule.rules.length ? isFiltered && filterByRules(rule.rules, rule.condition)(row) : isFiltered && executeFilterStrategy(rule, row), true) : rules.some(rule => rule.rules && rule.rules.length ? filterByRules(rule.rules, rule.condition)(row) : executeFilterStrategy(rule, row));
+};
+
 function filterRowsByQueryGroup(rows, query, composedRows) {
-  if (query && query.rules && query.rules.length === 0)
-    return rows;
+  if (query && query.rules && query.rules.length === 0) return rows;
   const newRows = [];
   const parentMap = {};
-  composedRows.forEach((parentRow) => {
+  composedRows.forEach(parentRow => {
     if (parentRow.isGroup) {
-      newRows.push({
-        ...parentRow,
+      newRows.push(_objectSpread(_objectSpread({}, parentRow), {}, {
         _filtered: true
-      });
+      }));
     } else if (!parentRow.isGroup && filterByRules(query.rules, query.condition)(parentRow.data)) {
-      newRows.push({
-        ...parentRow,
+      newRows.push(_objectSpread(_objectSpread({}, parentRow), {}, {
         _filtered: true
-      });
+      }));
       parentMap[parentRow.parentNode.id] = true;
     }
   });
-  return newRows.filter((r) => {
-    if (r.isGroup && !parentMap[r.id])
-      return false;
+  return newRows.filter(r => {
+    if (r.isGroup && !parentMap[r.id]) return false;
     return true;
   });
 }
-const filterRowsByQuery = (rows, query) => {
+function filterRowsByQuery(rows, query) {
   return rows.filter(filterByRules(query.rules, query.condition));
-};
-var filterRowsByQuery_default = filterRowsByQuery;
-export {
-  filterRowsByQuery_default as default,
-  filterRowsByQuery,
-  filterRowsByQueryGroup
-};
-//# sourceMappingURL=filterRowsByQuery.js.map
+}
+
+export { filterRowsByQuery as default, filterRowsByQueryGroup };

package/esm/plugins/filterable/filtering-helper/strategiesOperators.js

@@ -1,15 +1,17 @@
-import * as React from "react";
-import compare from "comparejs";
-const strategiesOperators = (op) => ({
-  range: (rowValue, { start, end }) => start <= rowValue && end >= rowValue,
+import compare from 'comparejs';
+
+var strategiesOperators = (op => ({
+  range: (rowValue, _ref) => {
+    let {
+      start,
+      end
+    } = _ref;
+    return start <= rowValue && end >= rowValue;
+  },
   equal: (value1, value2) => compare.id(value1, value2),
   greaterThan: compare.gt,
   lessThan: compare.lt,
   contains: (rowValue, value) => String(rowValue).toLowerCase().indexOf(String(value).toLowerCase()) !== -1
-})[op] || compare.id;
-var strategiesOperators_default = strategiesOperators;
-export {
-  strategiesOperators_default as default,
-  strategiesOperators
-};
-//# sourceMappingURL=strategiesOperators.js.map
+})[op] || compare.id);
+
+export { strategiesOperators as default };

package/esm/plugins/filterable/helper.js

@@ -1,31 +1,45 @@
-import * as React from "react";
-import {
-  isFunction,
-  uniqBy,
-  get,
-  groupBy,
-  property
-} from "@elliemae/ds-utilities";
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+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); 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 getFilterLabel = (column, value) => column.filterLabels ? column.filterLabels[value] || value : value;
-const getFilterLabels = (column, rows) => uniqBy(rows, property(column.searchBy || column.property)).map((row) => {
+const getFilterLabels = (column, rows) => uniqBy(rows, property(column.searchBy || column.property)).map(row => {
   const value = get(row, column.searchBy || column.property);
-  if (value === void 0)
-    return {};
+  if (value === undefined) return {};
   const rowColumnValue = String(get(row, column.searchBy || column.property));
+
   if (isFunction(column.valueTransformation)) {
     const nextValue = column.valueTransformation(rowColumnValue);
-    return { id: nextValue, label: nextValue };
+    return {
+      id: nextValue,
+      label: nextValue
+    };
   }
+
   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 {
+    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) => {
+  rows.forEach(r => {
     if (r.children) {
       flat = [...flat, ...r.children];
     }
@@ -33,54 +47,60 @@ const getFilterLabelsGroup = (column, rows) => {
   return getFilterLabels(column, flat);
 };
 function getFilterValue(filter, column) {
-  const { value } = filter;
-  if (!column)
-    return value;
-  const { filterOptions, filterLabels } = column;
+  const {
+    value
+  } = filter;
+  if (!column) return value;
+  const {
+    filterOptions,
+    filterLabels
+  } = column;
+
   if (filterOptions) {
-    const foundOption = column.filterOptions.filter((option) => option.id === value)[0];
-    if (foundOption)
-      return foundOption.label;
+    const foundOption = column.filterOptions.filter(option => option.id === value)[0];
+    if (foundOption) return foundOption.label;
     return value;
   }
+
   if (filterLabels) {
     return filterLabels[value];
   }
+
   return value;
 }
 function buildFilterArray(newFilter, filters) {
-  return uniqBy([...filters, newFilter], (v) => [v.group, v.value].join());
+  // if (newFilter.type && newFilter.type === 'date') return [...filters.slice(1), newFilter]
+  return uniqBy([...filters, newFilter], v => [v.group, v.value].join());
 }
-const groupFilters = (filters) => filters.filter((filter) => !filter.fixed);
+const groupFilters = filters => filters.filter(filter => !filter.fixed);
+
 function parseFilterToRule(filter) {
-  return {
-    ...filter,
+  return _objectSpread(_objectSpread({}, filter), {}, {
     value: filter.filterParams || filter.value,
     field: filter.group
-  };
+  });
 }
+
 function parseFiltersToQuery(filters) {
-  const groupedFilters = groupBy(groupFilters(filters), (filter) => filter.group);
+  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
       queryResult.rules.push({
-        condition: "OR",
+        condition: 'OR',
         rules: filter.map(parseFilterToRule)
       });
     } else {
       queryResult.rules.push(parseFilterToRule(filter[0]));
     }
+
     return queryResult;
-  }, { condition: "AND", rules: [] });
+  }, {
+    condition: 'AND',
+    rules: []
+  });
 }
-export {
-  buildFilterArray,
-  getFilterLabel,
-  getFilterLabels,
-  getFilterLabelsGroup,
-  getFilterValue,
-  groupFilters,
-  parseFiltersToQuery
-};
-//# sourceMappingURL=helper.js.map
+
+export { buildFilterArray, getFilterLabel, getFilterLabels, getFilterLabelsGroup, getFilterValue, groupFilters, parseFiltersToQuery };