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

package/cjs/plugins/filterable/components/filterable-menus/SingleDateFilterMenu.js

@@ -0,0 +1,107 @@
+'use strict';
+
+var _jsx = require('@babel/runtime/helpers/jsx');
+require('core-js/modules/web.dom-collections.iterator.js');
+var React = require('react');
+var Grid = require('@elliemae/ds-grid');
+var dsControlledForm = require('@elliemae/ds-controlled-form');
+var DSPopper = require('@elliemae/ds-popper');
+var dsIcons = require('@elliemae/ds-icons');
+var DSButton = require('@elliemae/ds-button');
+var moment = require('moment');
+var defaultDateFormat = require('./defaultDateFormat.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+var Grid__default = /*#__PURE__*/_interopDefaultLegacy(Grid);
+var DSPopper__default = /*#__PURE__*/_interopDefaultLegacy(DSPopper);
+var DSButton__default = /*#__PURE__*/_interopDefaultLegacy(DSButton);
+var moment__default = /*#__PURE__*/_interopDefaultLegacy(moment);
+
+var _DatePicker;
+
+const SingleDatePickerContainer = _ref => {
+  let {
+    onChange = () => null,
+    showHeader
+  } = _ref;
+  const [date, setDate] = React.useState('');
+  const handleDateChange = React.useCallback(data => {
+    if (!data.includes('_')) onChange(moment__default["default"](data));
+    setDate(data);
+  }, [onChange]);
+  return /*#__PURE__*/_jsx__default["default"]("div", {
+    style: {
+      boxShadow: '0 6px 20px 0 rgb(0 0 0 / 24%)'
+    }
+  }, void 0, showHeader && /*#__PURE__*/_jsx__default["default"](Grid__default["default"], {
+    p: "xxs"
+  }, void 0, /*#__PURE__*/_jsx__default["default"](dsControlledForm.DSControlledDateTimePicker, {
+    date: date,
+    onDateChange: handleDateChange,
+    type: "date-inputs",
+    isClearable: true
+  })), /*#__PURE__*/_jsx__default["default"](dsControlledForm.DSControlledDateTimePicker, {
+    date: date,
+    onDateChange: handleDateChange,
+    type: "date-picker-controller-only"
+  }));
+};
+
+const formatDate = function (date) {
+  let format = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultDateFormat.DEFAULT_DATE_FORMAT;
+  return date.format(format);
+};
+
+function SingleDateFilterMenu(_ref2) {
+  let {
+    column,
+    className,
+    isMenuOpened = false,
+    onOpenMenu = () => null,
+    placement = DSPopper.PopperPositions.BOTTOM_END,
+    onAddFilter = () => null,
+    dateFormatter = formatDate,
+    showHeader = false,
+    menuProps
+  } = _ref2;
+  return /*#__PURE__*/_jsx__default["default"](DSPopper__default["default"], {
+    contentComponent: /*#__PURE__*/_jsx__default["default"]("div", {
+      className: className,
+      "data-testid": "date-single__wrapper"
+    }, void 0, /*#__PURE__*/_jsx__default["default"](SingleDatePickerContainer, {
+      minimumNights: 0,
+      onChange: date => {
+        const t = date.clone();
+        onAddFilter({
+          group: column.property,
+          label: column.label,
+          value: dateFormatter(date, column.dateFormat),
+          type: 'date',
+          operator: 'range',
+          filterParams: {
+            start: date.startOf('day'),
+            end: t.endOf('day')
+          },
+          transformRowValue: value => moment__default["default"](value, column.dateFormat || defaultDateFormat.DEFAULT_DATE_FORMAT)
+        }, column);
+        onOpenMenu(false);
+      },
+      showHeader: showHeader
+    })),
+    isOpen: isMenuOpened,
+    onOpen: onOpenMenu,
+    placement: placement,
+    showArrow: false,
+    triggerComponent: /*#__PURE__*/_jsx__default["default"](DSButton__default["default"], {
+      buttonType: "text",
+      icon: _DatePicker || (_DatePicker = /*#__PURE__*/_jsx__default["default"](dsIcons.DatePicker2, {})),
+      onClick: () => !isMenuOpened ? onOpenMenu(true) : onOpenMenu(false),
+      size: "s"
+    }),
+    zIndex: menuProps.zIndex
+  });
+}
+
+module.exports = SingleDateFilterMenu;

package/cjs/plugins/filterable/components/filterable-menus/SingleRangeSwitcherMenu.js

@@ -0,0 +1,195 @@
+'use strict';
+
+var _jsx = require('@babel/runtime/helpers/jsx');
+require('core-js/modules/web.dom-collections.iterator.js');
+var React = require('react');
+var dsControlledForm = require('@elliemae/ds-controlled-form');
+var DSPopper = require('@elliemae/ds-basic/Popper');
+var dsIcons = require('@elliemae/ds-icons');
+var DSButton = require('@elliemae/ds-basic/Button');
+var Grid = require('@elliemae/ds-grid');
+var moment = require('moment');
+var styled = require('styled-components');
+var defaultDateFormat = require('./defaultDateFormat.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+var DSPopper__default = /*#__PURE__*/_interopDefaultLegacy(DSPopper);
+var DSButton__default = /*#__PURE__*/_interopDefaultLegacy(DSButton);
+var Grid__default = /*#__PURE__*/_interopDefaultLegacy(Grid);
+var moment__default = /*#__PURE__*/_interopDefaultLegacy(moment);
+var styled__default = /*#__PURE__*/_interopDefaultLegacy(styled);
+
+var _DatePicker;
+const StyledGridWrapper = /*#__PURE__*/styled__default["default"](Grid__default["default"]).withConfig({
+  componentId: "sc-jay5xg-0"
+})([".notCurrentMonth{opacity:", ";pointer-events:", ";}"], props => props.enableOutsideDays ? '1' : '0', props => props.enableOutsideDays ? 'auto' : 'none'); // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function
+
+const noop = function () {};
+
+const SingleRangeSwitcherContainer = _ref => {
+  let {
+    onChange = noop,
+    enableOutsideDays
+  } = _ref;
+  const [startDate, setStartDate] = React.useState('');
+  const [endDate, setEndDate] = React.useState(''); // For some reason it worked like this
+
+  const [lastChangeWasPicker, setLastChangeWasPicker] = React.useState(false);
+  const [isDateRange, setIsDateRange] = React.useState(false);
+  React.useEffect(() => {
+    const startMoment = moment__default["default"](startDate);
+    const endMoment = moment__default["default"](endDate);
+
+    if (lastChangeWasPicker && startDate && !startDate.includes('_') && endDate && !endDate.includes('_') && endMoment.diff(startMoment) >= 0) {
+      onChange({
+        startDate: startMoment,
+        endDate: endMoment
+      });
+    } // eslint-disable-next-line react-hooks/exhaustive-deps
+
+  }, [startDate, endDate, lastChangeWasPicker]);
+  return /*#__PURE__*/_jsx__default["default"](StyledGridWrapper, {
+    "data-testid": "date-single-range__wrapper",
+    style: {
+      backgroundColor: 'white',
+      boxShadow: '0 6px 20px 0 rgb(0 0 0 / 24%)',
+      width: '261px',
+      display: 'grid',
+      justifyContent: 'center'
+    },
+    cols: ['100%'],
+    enableOutsideDays: enableOutsideDays,
+    onKeyDown: e => e.code === 'Enter' && setLastChangeWasPicker(true)
+  }, void 0, /*#__PURE__*/_jsx__default["default"](Grid__default["default"], {
+    gutter: "xxs",
+    alignItems: "center",
+    p: "xxs"
+  }, void 0, /*#__PURE__*/_jsx__default["default"](dsControlledForm.DSControlledCheckbox, {
+    checked: isDateRange,
+    name: "Date range",
+    label: "Range",
+    id: "date-range-switcher-id-internal",
+    onChange: () => {
+      setIsDateRange(!isDateRange);
+      setStartDate('');
+      setEndDate('');
+    }
+  }), /*#__PURE__*/_jsx__default["default"]("div", {
+    style: {
+      width: 'fit-content'
+    }
+  }, void 0, isDateRange ? /*#__PURE__*/_jsx__default["default"](dsControlledForm.DSControlledDateRangePicker, {
+    fromDate: startDate,
+    onFromDateChange: _start => {
+      setStartDate(_start);
+      setLastChangeWasPicker(false);
+    },
+    toDate: endDate,
+    onToDateChange: _end => {
+      setEndDate(_end);
+      setLastChangeWasPicker(false);
+    },
+    type: "date-range-inputs"
+  }) : /*#__PURE__*/_jsx__default["default"](dsControlledForm.DSControlledDateTimePicker, {
+    date: startDate,
+    onDateChange: _date => {
+      setLastChangeWasPicker(false);
+      setStartDate(_date);
+      setEndDate(_date);
+    },
+    type: "date-inputs"
+  }))), /*#__PURE__*/_jsx__default["default"](Grid__default["default"], {}, void 0, isDateRange ? /*#__PURE__*/_jsx__default["default"](dsControlledForm.DSControlledDateRangePicker, {
+    fromDate: startDate,
+    onFromDateChange: _start => {
+      setStartDate(_start);
+      setLastChangeWasPicker(true);
+    },
+    toDate: endDate,
+    onToDateChange: _end => {
+      setEndDate(_end);
+      setLastChangeWasPicker(true);
+    },
+    type: "date-range-picker-controller-only"
+  }) : /*#__PURE__*/_jsx__default["default"](dsControlledForm.DSControlledDateTimePicker, {
+    date: startDate,
+    onDateChange: _date => {
+      setLastChangeWasPicker(true);
+      setStartDate(_date);
+      setEndDate(_date);
+    },
+    type: "date-picker-controller-only"
+  })));
+};
+
+const formatRangeDate = function (_ref2) {
+  let {
+    startDate,
+    endDate
+  } = _ref2;
+  let format = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultDateFormat.DEFAULT_DATE_FORMAT;
+  const sameDay = startDate.isSame(endDate, 'day');
+  if (sameDay) return "".concat(endDate.format(format));
+  return "".concat(startDate.format(format), " - ").concat(endDate.format(format));
+}; // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+
+
+function SingleRangeSwitcherMenu(_ref3) {
+  let {
+    column,
+    className,
+    isMenuOpened = false,
+    onOpenMenu = noop,
+    placement = DSPopper.PopperPositions.BOTTOM_END,
+    onAddFilter = noop,
+    dateFormatter = formatRangeDate,
+    enableOutsideDays = true,
+    menuProps
+  } = _ref3;
+  return /*#__PURE__*/_jsx__default["default"](DSPopper__default["default"], {
+    contentComponent: /*#__PURE__*/_jsx__default["default"]("div", {
+      className: className
+    }, void 0, /*#__PURE__*/_jsx__default["default"](SingleRangeSwitcherContainer, {
+      enableOutsideDays: enableOutsideDays,
+      onChange: _ref4 => {
+        let {
+          startDate,
+          endDate
+        } = _ref4;
+        startDate.startOf('day');
+        endDate.endOf('day');
+        onAddFilter({
+          group: column.property,
+          label: column.label,
+          value: dateFormatter({
+            startDate,
+            endDate
+          }, column.format),
+          type: 'date',
+          // todo: create constants for filter types
+          filterParams: {
+            start: startDate,
+            end: endDate
+          },
+          transformRowValue: value => moment__default["default"](value, column.dateFormat || defaultDateFormat.DEFAULT_DATE_FORMAT),
+          operator: 'range'
+        }, column);
+        onOpenMenu(false);
+      }
+    })),
+    isOpen: isMenuOpened,
+    onOpen: onOpenMenu,
+    placement: placement,
+    showArrow: false,
+    triggerComponent: /*#__PURE__*/_jsx__default["default"](DSButton__default["default"], {
+      buttonType: "text",
+      icon: _DatePicker || (_DatePicker = /*#__PURE__*/_jsx__default["default"](dsIcons.DatePicker2, {})),
+      onClick: () => !isMenuOpened ? onOpenMenu(true) : onOpenMenu(false),
+      size: "s"
+    }),
+    zIndex: menuProps.zIndex
+  });
+}
+
+module.exports = SingleRangeSwitcherMenu;

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

@@ -0,0 +1,174 @@
+'use strict';
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var _jsx = require('@babel/runtime/helpers/jsx');
+var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
+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/web.dom-collections.iterator.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+var React = require('react');
+var lodash = require('lodash');
+var DSDropdownMenu = require('@elliemae/ds-dropdownmenu');
+var DSButton = require('@elliemae/ds-button');
+var DSPopper = require('@elliemae/ds-popper');
+var dsMenu = require('@elliemae/ds-menu');
+var dsIcons = require('@elliemae/ds-icons');
+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 _objectWithoutProperties__default = /*#__PURE__*/_interopDefaultLegacy(_objectWithoutProperties);
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+var DSDropdownMenu__default = /*#__PURE__*/_interopDefaultLegacy(DSDropdownMenu);
+var DSButton__default = /*#__PURE__*/_interopDefaultLegacy(DSButton);
+
+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__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 TextFilterMenu(_ref) {
+  let {
+    column,
+    menuStyle = {},
+    className,
+    filters = [],
+    isMenuOpened = false,
+    onOpenMenu = () => null,
+    onClose = () => null,
+    placement = DSPopper.PopperPositions.BOTTOM_END,
+    menuProps = {},
+    onAddFilter = () => null,
+    onRemoveFilter = () => null,
+    maxOptions = 10,
+    isMulti = false
+  } = _ref;
+
+  const {
+    options
+  } = menuProps,
+        otherMenuProps = _objectWithoutProperties__default["default"](menuProps, _excluded);
+
+  const generateOption = (option, idx) => /*#__PURE__*/_jsx__default["default"](dsMenu.Menu.ItemCheckbox, {
+    label: option.label,
+    name: option.id
+  }, 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] = React.useState(initialSelectedOptions);
+  React__default["default"].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 = []; // 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
+          }
+        });
+      }
+    });
+    shouldRemove.forEach(removedFilter => {
+      onRemoveFilter(_objectSpread(_objectSpread({}, removedFilter), {}, {
+        nextFilters
+      }));
+    });
+    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 === 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__*/_jsx__default["default"](DSDropdownMenu__default["default"], {
+    closeMenuOnItemSelection: true,
+    contentStyle: menuStyle,
+    customMenu: isMulti ? /*#__PURE__*/_jsx__default["default"](dsMenu.Menu, {
+      containerProps: {
+        id: 'text-filter-menu-multiple'
+      },
+      className: "dg-multiple-filter",
+      visible: true
+    }, void 0, /*#__PURE__*/_jsx__default["default"](dsMenu.Menu.SelectionGroup, {
+      active: selected,
+      onSelect: newValues => {
+        setSelected(newValues);
+      },
+      focusOnOpen: true,
+      multi: true,
+      searchable: true
+    }, void 0, renderOptions(options))) : /*#__PURE__*/jsxRuntime.jsx(dsMenu.MenuCombobox, _objectSpread(_objectSpread({}, otherMenuProps), {}, {
+      className: className,
+      dropdownFilterOptions: _objectSpread(_objectSpread({}, column.dropdownFilterOptions), {}, {
+        maxOptions
+      }),
+      maxWidth: column.filterMenuMaxWidth,
+      minWidth: column.filterMenuMinWidth,
+      onSelectMenuItem: selectedValue => {
+        if (selectedValue) {
+          var _column$filter2;
+
+          onAddFilter({
+            group: column.searchBy || column.property,
+            label: column.label,
+            value: selectedValue,
+            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,
+    minWidth: column.filterMenuMinWidth,
+    onOpenMenu: onOpenMenu,
+    onClose: isMulti ? onCloseMulti : onClose,
+    options: lodash.compact(options),
+    placement: placement,
+    triggerComponent: /*#__PURE__*/_jsx__default["default"](DSButton__default["default"], {
+      buttonType: "text",
+      icon: _SearchSmall || (_SearchSmall = /*#__PURE__*/_jsx__default["default"](dsIcons.SearchSmall, {})),
+      onClick: () => isMenuOpened ? onOpenMenu(false) : onOpenMenu(true),
+      size: "s"
+    })
+  });
+}
+
+module.exports = TextFilterMenu;

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

@@ -0,0 +1,7 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const DEFAULT_DATE_FORMAT = 'MM/DD/YYYY';
+
+exports.DEFAULT_DATE_FORMAT = DEFAULT_DATE_FORMAT;

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

@@ -0,0 +1,18 @@
+'use strict';
+
+var DateRangeFilterMenu = require('./DateRangeFilterMenu.js');
+var SingleDateFilterMenu = require('./SingleDateFilterMenu.js');
+var SingleRangeSwitcherMenu = require('./SingleRangeSwitcherMenu.js');
+var TextFilterMenu = require('./TextFilterMenu.js');
+
+const ComponentTypes = {
+  'date-range': DateRangeFilterMenu,
+  'single-date': SingleDateFilterMenu,
+  'date-switcher': SingleRangeSwitcherMenu,
+  string: TextFilterMenu
+};
+function getFilterMenuByType(type) {
+  return ComponentTypes[type] || ComponentTypes.string;
+}
+
+module.exports = getFilterMenuByType;

package/cjs/plugins/filterable/filterableFormatter.js

@@ -0,0 +1,63 @@
+'use strict';
+
+var _jsx = require('@babel/runtime/helpers/jsx');
+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('react');
+var FilterableHeader = require('./components/FilterableHeader.js');
+var helper = require('./helper.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+
+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
+      }
+    } = grid.getInstance();
+    let rowsToUse = composedRows;
+
+    if (column.filter && column.filter.isMulti) {
+      rowsToUse = rows;
+    }
+
+    const filteredLabels = groupedRows && !groupedBy ? helper.getFilterLabelsGroup(column, rows) : helper.getFilterLabels(column, rowsToUse.rows || rowsToUse);
+    const columnData = column.filterOptions || filteredLabels;
+    return /*#__PURE__*/_jsx__default["default"](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
+    });
+  };
+}
+
+module.exports = FilterableFormatter;

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

@@ -0,0 +1,74 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+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.reduce.js');
+require('core-js/modules/esnext.iterator.reduce.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.filter.js');
+require('core-js/modules/esnext.iterator.filter.js');
+var dsUtilities = require('@elliemae/ds-utilities');
+var strategiesOperators = require('./strategiesOperators.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; }
+
+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 rowValue = row[field];
+  const transformedValue = dsUtilities.isFunction(transform) ? transform(value) : value;
+  const transformedRowValue = dsUtilities.isFunction(transformRowValue) ? transformRowValue(rowValue) : rowValue;
+  const filterStrategy = getRuleStrategyOperator(rule);
+  return filterStrategy(transformedRowValue, transformedValue);
+};
+
+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;
+  const newRows = [];
+  const parentMap = {};
+  composedRows.forEach(parentRow => {
+    if (parentRow.isGroup) {
+      newRows.push(_objectSpread(_objectSpread({}, parentRow), {}, {
+        _filtered: true
+      }));
+    } else if (!parentRow.isGroup && filterByRules(query.rules, query.condition)(parentRow.data)) {
+      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 true;
+  });
+}
+function filterRowsByQuery(rows, query) {
+  return rows.filter(filterByRules(query.rules, query.condition));
+}
+
+exports["default"] = filterRowsByQuery;
+exports.filterRowsByQueryGroup = filterRowsByQueryGroup;

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

@@ -0,0 +1,23 @@
+'use strict';
+
+var compare = require('comparejs');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var compare__default = /*#__PURE__*/_interopDefaultLegacy(compare);
+
+var strategiesOperators = (op => ({
+  range: (rowValue, _ref) => {
+    let {
+      start,
+      end
+    } = _ref;
+    return start <= rowValue && end >= rowValue;
+  },
+  equal: (value1, value2) => compare__default["default"].id(value1, value2),
+  greaterThan: compare__default["default"].gt,
+  lessThan: compare__default["default"].lt,
+  contains: (rowValue, value) => String(rowValue).toLowerCase().indexOf(String(value).toLowerCase()) !== -1
+})[op] || compare__default["default"].id);
+
+module.exports = strategiesOperators;