@bigbinary/neeto-filters-frontend 4.0.1 → 4.1.0

package/dist/utils-61b4223d.js

@@ -0,0 +1,861 @@
+'use strict';
+
+var constants = require('./constants-fb0f688a.js');
+var i18next = require('i18next');
+var neetoCist = require('@bigbinary/neeto-cist');
+var utils = require('@bigbinary/neeto-commons-frontend/utils');
+var ramda = require('ramda');
+var dayjs = require('dayjs');
+var timezone = require('dayjs/plugin/timezone');
+var utc = require('dayjs/plugin/utc');
+var weekday = require('dayjs/plugin/weekday');
+var Help = require('@bigbinary/neeto-icons/Help');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var i18next__default = /*#__PURE__*/_interopDefaultLegacy(i18next);
+var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
+var timezone__default = /*#__PURE__*/_interopDefaultLegacy(timezone);
+var utc__default = /*#__PURE__*/_interopDefaultLegacy(utc);
+var weekday__default = /*#__PURE__*/_interopDefaultLegacy(weekday);
+var Help__default = /*#__PURE__*/_interopDefaultLegacy(Help);
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = !0,
+      o = !1;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = !1;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = !0, n = r;
+    } finally {
+      try {
+        if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+
+dayjs__default["default"].extend(utc__default["default"]);
+dayjs__default["default"].extend(timezone__default["default"]);
+dayjs__default["default"].extend(weekday__default["default"]);
+dayjs__default["default"].Ls.en.weekStart = 1;
+
+var NUMBER_RULES = [{
+  label: i18next.t("neetoFilters.rules.is"),
+  value: "is"
+}, {
+  label: i18next.t("neetoFilters.rules.isNot"),
+  value: "is_not"
+}, {
+  label: i18next.t("neetoFilters.rules.greaterThan"),
+  value: "greater_than"
+}, {
+  label: i18next.t("neetoFilters.rules.lessThan"),
+  value: "less_than"
+}];
+var TEXT_RULES = [{
+  label: i18next.t("neetoFilters.rules.contains"),
+  value: "contains"
+}, {
+  label: i18next.t("neetoFilters.rules.doesNotContain"),
+  value: "does_not_contain"
+}, {
+  label: i18next.t("neetoFilters.rules.is"),
+  value: "is"
+}, {
+  label: i18next.t("neetoFilters.rules.isNot"),
+  value: "is_not"
+}, {
+  label: i18next.t("neetoFilters.rules.startsWith"),
+  value: "starts_with"
+}, {
+  label: i18next.t("neetoFilters.rules.doesNotStartWith"),
+  value: "does_not_start_with"
+}, {
+  label: i18next.t("neetoFilters.rules.endsWith"),
+  value: "ends_with"
+}, {
+  label: i18next.t("neetoFilters.rules.doesNotEndWith"),
+  value: "does_not_end_with"
+}];
+var MULTI_DROPDOWN_RULES = [{
+  label: i18next.t("neetoFilters.rules.in"),
+  value: "in"
+}, {
+  label: i18next.t("neetoFilters.rules.notIn"),
+  value: "not_in"
+}, {
+  label: i18next.t("neetoFilters.rules.isEmpty"),
+  value: "is_unknown"
+}];
+var SINGLE_DROPDOWN_RULES = [{
+  label: i18next.t("neetoFilters.rules.is"),
+  value: "is"
+}, {
+  label: i18next.t("neetoFilters.rules.isNot"),
+  value: "is_not"
+}, {
+  label: i18next.t("neetoFilters.rules.isEmpty"),
+  value: "is_unknown"
+}];
+var DEFAULT_BOOLEAN_OPTIONS = [{
+  label: i18next.t("neetoFilters.common.yes"),
+  value: "true"
+}, {
+  label: i18next.t("neetoFilters.common.no"),
+  value: "false"
+}];
+var TREE_SELECT_RULES = [{
+  label: i18next.t("neetoFilters.rules.in"),
+  value: "in"
+}, {
+  label: i18next.t("neetoFilters.rules.notIn"),
+  value: "not_in"
+}, {
+  label: i18next.t("neetoFilters.rules.isEmpty"),
+  value: "is_unknown"
+}];
+var DEFAULT_HELP_ICON_PROPS = {
+  icon: Help__default["default"]
+};
+var TIME_FORMAT = "h:mm A";
+
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { constants._defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var groupByGroup = ramda.groupBy(function (_ref) {
+  var group = _ref.group;
+  return group || "individual";
+});
+var standardizeColumnType = function standardizeColumnType(kind) {
+  // neeto-fields-nano supports `monetary` and `number` as type of fields, which will be acting as `decimal` in action.
+  if (["custom.monetary", "custom.number"].includes(kind)) {
+    return "custom.decimal";
+  }
+  return kind;
+};
+var getSnakeCasedQueryParams = function getSnakeCasedQueryParams() {
+  return utils.getQueryParams({
+    toCamelCase: false
+  });
+};
+var isBoolean = function isBoolean(type) {
+  return type === "boolean" || type === "custom.boolean";
+};
+var isCheckbox = function isCheckbox(type) {
+  return type === "checkbox" || type === "custom.checkbox";
+};
+var isDate = function isDate(type) {
+  return type === "date" || type === "custom.date" || type === "custom.datetime";
+};
+var isSingleDate = function isSingleDate(type) {
+  return type === "single_date" || type === "custom.single_date";
+};
+var isSingleTime = function isSingleTime(type) {
+  return type === "single_time" || type === "custom.single_time";
+};
+var isTime = function isTime(type) {
+  return type === "time" || type === "custom.time";
+};
+var isMulti = function isMulti(type) {
+  return type === "multi_option" || type === "custom.multi_option";
+};
+var isSingle = function isSingle(type) {
+  return type === "single_option" || type === "custom.single_option";
+};
+var isText = function isText(type) {
+  return type === "text" || type === "custom.text";
+};
+var isDigit = function isDigit(type) {
+  return ["number", "decimal", "custom.decimal", "custom.number"].includes(type);
+};
+var isTreeSelect = function isTreeSelect(type) {
+  return type === "tree_select";
+};
+var isCustomDateRange = function isCustomDateRange(value) {
+  return !ramda.pluck("value", constants.DATE_OPTIONS).includes(value);
+};
+var isCustomTimeRange = function isCustomTimeRange(value) {
+  return !ramda.pluck("value", constants.TIME_OPTIONS).includes(value);
+};
+var isMultiModelFilter = function isMultiModelFilter(_ref2) {
+  var _ref2$model = _ref2.model,
+    model = _ref2$model === void 0 ? "" : _ref2$model;
+  return model.split(",").length > 1;
+};
+var getTimezone = function getTimezone() {
+  return dayjs__default["default"].tz.guess();
+};
+var getLabelFromBool = function getLabelFromBool(_ref3) {
+  var value = _ref3.value,
+    values = _ref3.values;
+  return neetoCist.findBy({
+    value: value
+  }, ramda.either(ramda.isEmpty, ramda.isNil)(values) ? DEFAULT_BOOLEAN_OPTIONS : values).label;
+};
+var getBoolFromLabel = function getBoolFromLabel(_ref4) {
+  var label = _ref4.label,
+    values = _ref4.values;
+  return neetoCist.findBy({
+    label: label
+  }, ramda.either(ramda.isEmpty, ramda.isNil)(values) ? DEFAULT_BOOLEAN_OPTIONS : values).value;
+};
+var buildRuleOptions = function buildRuleOptions(_ref5) {
+  var defaultType = _ref5.defaultType;
+  if (isText(defaultType)) return TEXT_RULES;else if (isDigit(defaultType)) return NUMBER_RULES;
+  return [];
+};
+var getDefaultRuleValue = function getDefaultRuleValue(defaultType) {
+  var _buildRuleOptions;
+  return ((_buildRuleOptions = buildRuleOptions({
+    defaultType: defaultType
+  })) === null || _buildRuleOptions === void 0 || (_buildRuleOptions = _buildRuleOptions[0]) === null || _buildRuleOptions === void 0 ? void 0 : _buildRuleOptions.value) || "";
+};
+var isUndefinedOrEmpty = ramda.anyPass([ramda.isNil, ramda.isEmpty, ramda.any(ramda.isNil)]);
+
+// Following function split node on comma followed by non-comma characters and a dot
+var splitNode = function splitNode(joinedNodes) {
+  return joinedNodes.split(/,(?=[^,]*\.)/);
+};
+var splitFilter = function splitFilter(multiColumnFilter) {
+  var splittedNodes = splitNode(multiColumnFilter.node);
+  var splittedModels = multiColumnFilter.model.split(",");
+  return splittedNodes.map(function (node, index) {
+    return ramda.mergeLeft({
+      node: node,
+      model: splittedModels[index],
+      conditions_join_type: index < splittedNodes.length - 1 ? "or" : "and"
+    }, ramda.omit(["key", "label", "values", "setValue"], multiColumnFilter));
+  });
+};
+var buildDateValue = function buildDateValue(_ref6) {
+  var value = _ref6.value;
+  var rule = constants.DATE_RULES[value] || "between";
+  var dateValue = ["before", "after", "custom-date-range"].includes(value) ? "" : value;
+  return {
+    value: dateValue,
+    rule: rule,
+    timezone: getTimezone()
+  };
+};
+var buildTimeValue = function buildTimeValue(_ref7) {
+  var value = _ref7.value;
+  var dateValue = value === "custom-time-range" ? "" : value;
+  return {
+    value: dateValue,
+    rule: "between"
+  };
+};
+var buildUpdatedFilter = function buildUpdatedFilter(_ref8) {
+  var column = _ref8.column,
+    defaultType = _ref8.defaultType,
+    option = _ref8.option,
+    _ref8$rule = _ref8.rule,
+    rule = _ref8$rule === void 0 ? "" : _ref8$rule,
+    _ref8$value = _ref8.value,
+    value = _ref8$value === void 0 ? "" : _ref8$value;
+  var filter = ramda.omit(["values", "preprocessor"], column);
+  if (isMulti(defaultType)) {
+    return ramda.mergeLeft(filter, {
+      value: ramda.pluck("value", option),
+      rule: rule
+    });
+  } else if (isDate(defaultType)) {
+    return ramda.mergeLeft(filter, buildDateValue(option));
+  } else if (isSingleDate(defaultType)) {
+    return ramda.mergeLeft(filter, {
+      value: value,
+      rule: rule,
+      timezone: getTimezone()
+    });
+  } else if (isText(defaultType) || isDigit(defaultType)) {
+    var _column$preprocessor;
+    return ramda.mergeLeft(filter, {
+      rule: rule,
+      value: (column === null || column === void 0 || (_column$preprocessor = column.preprocessor) === null || _column$preprocessor === void 0 ? void 0 : _column$preprocessor.call(column, value)) || value
+    });
+  } else if (isSingleTime(defaultType)) {
+    return ramda.mergeLeft(filter, {
+      value: value,
+      rule: rule
+    });
+  } else if (isTime(defaultType)) {
+    return ramda.mergeLeft(filter, buildTimeValue(option));
+  } else if (isSingle(defaultType)) {
+    return ramda.mergeLeft(filter, {
+      value: option.value,
+      rule: rule
+    });
+  } else if (isTreeSelect(defaultType)) {
+    return ramda.mergeLeft(filter, {
+      value: option,
+      rule: rule
+    });
+  }
+  return ramda.mergeLeft(filter, {
+    value: option.value,
+    rule: "is"
+  });
+};
+var buildFiltersFromSearchParams = function buildFiltersFromSearchParams(columns) {
+  var skipEmpty = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  var searchParams = getSnakeCasedQueryParams();
+  return columns.map(function (column) {
+    var value = searchParams[column.key];
+    var defaultType = column.defaultType || column.type;
+    if (!skipEmpty && value === "") {
+      return ramda.mergeLeft({
+        value: ""
+      }, column);
+    } else if (ramda.isNil(value) || value === "" || column.key === "keyword") {
+      return null;
+    } else if (column.key === constants.SEARCH_TERM_KEY) {
+      if (ramda.isNil(column.node)) return null;
+      return ramda.mergeLeft({
+        value: value,
+        type: "text",
+        rule: "contains"
+      }, column);
+    } else if (isDate(defaultType) && isCustomDateRange(value)) {
+      return ramda.mergeLeft({
+        value: value
+      }, column);
+    } else if (isMulti(defaultType) || isTreeSelect(defaultType)) {
+      var _value$split = value.split("+rule-"),
+        _value$split2 = _slicedToArray(_value$split, 2),
+        filterValue = _value$split2[0],
+        rule = _value$split2[1];
+      return ramda.mergeLeft({
+        rule: rule !== null && rule !== void 0 ? rule : "in",
+        value: filterValue.split("|")
+      }, column);
+    } else if (isSingle(defaultType)) {
+      var _value$split3 = value.split("+rule-"),
+        _value$split4 = _slicedToArray(_value$split3, 2),
+        _filterValue = _value$split4[0],
+        _rule = _value$split4[1];
+      return ramda.mergeLeft({
+        rule: _rule !== null && _rule !== void 0 ? _rule : "in",
+        value: _filterValue
+      }, column);
+    } else if (isDigit(defaultType) || isText(defaultType)) {
+      var _value$split5 = value.split("+rule-"),
+        _value$split6 = _slicedToArray(_value$split5, 2),
+        _filterValue2 = _value$split6[0],
+        _rule2 = _value$split6[1];
+      return ramda.mergeLeft({
+        rule: _rule2,
+        value: _filterValue2
+      }, column);
+    } else if (isTime(defaultType) && isCustomTimeRange(value)) {
+      return ramda.mergeLeft({
+        value: value
+      }, column);
+    } else if (isSingleDate(defaultType)) {
+      var _value$split7 = value.split("+rule-"),
+        _value$split8 = _slicedToArray(_value$split7, 2),
+        _filterValue3 = _value$split8[0],
+        _rule3 = _value$split8[1];
+      return ramda.mergeLeft({
+        rule: _rule3,
+        value: _rule3 === "between" ? _filterValue3.split(",") : _filterValue3
+      }, column);
+    } else if (isSingleTime(defaultType)) {
+      var _value$split9 = value.split("+rule-"),
+        _value$split10 = _slicedToArray(_value$split9, 2),
+        _filterValue4 = _value$split10[0],
+        _rule4 = _value$split10[1];
+      return ramda.mergeLeft({
+        rule: _rule4,
+        value: _rule4 === "between" ? _filterValue4.split(",") : _filterValue4
+      }, column);
+    } else if (isBoolean(defaultType)) {
+      return ramda.mergeLeft({
+        rule: "is",
+        value: getBoolFromLabel({
+          label: value,
+          values: column.values
+        })
+      }, column);
+    }
+    return ramda.mergeLeft({
+      rule: "is",
+      value: value
+    }, column);
+  }).filter(ramda.identity);
+};
+var buildTimePayload = function buildTimePayload(value) {
+  var timeValue = {
+    "this-hour": [dayjs__default["default"]().startOf("hour"), dayjs__default["default"]().endOf("hour")],
+    "last-hour": [dayjs__default["default"]().add(-1, "hour").startOf("hour"), dayjs__default["default"]().add(-1, "hour").endOf("hour")],
+    "next-hour": [dayjs__default["default"]().add(1, "hour").startOf("hour"), dayjs__default["default"]().add(1, "hour").endOf("hour")]
+  };
+  if (isCustomTimeRange(value)) {
+    return {
+      value: value ? value.join(",") : "",
+      rule: "between"
+    };
+  }
+  return {
+    value: timeValue[value].map(function (time) {
+      return time.toISOString();
+    }).join(","),
+    rule: "between"
+  };
+};
+var buildDatePayload = function buildDatePayload(value) {
+  var dateValue = {
+    "this-week": [dayjs__default["default"]().startOf("week"), dayjs__default["default"]().endOf("week")],
+    "last-week": [dayjs__default["default"]().add(-1, "week").startOf("week"), dayjs__default["default"]().add(-1, "week").endOf("week")],
+    "this-month": [dayjs__default["default"]().startOf("month"), dayjs__default["default"]().endOf("month")],
+    "last-month": [dayjs__default["default"]().add(-1, "month").startOf("month"), dayjs__default["default"]().add(-1, "month").endOf("month")],
+    "this-year": [dayjs__default["default"]().startOf("year"), dayjs__default["default"]().endOf("year")],
+    "last-year": [dayjs__default["default"]().add(-1, "year").startOf("year"), dayjs__default["default"]().add(-1, "year").endOf("year")]
+  };
+  if (value === "today") {
+    return {
+      value: dayjs__default["default"]().toISOString(),
+      rule: "on",
+      timezone: getTimezone()
+    };
+  } else if (value === "yesterday") {
+    return {
+      value: dayjs__default["default"]().add(-1, "day").toISOString(),
+      rule: "on",
+      timezone: getTimezone()
+    };
+  } else if (value === "all-time") {
+    return {
+      value: dayjs__default["default"]().toISOString(),
+      rule: "before",
+      timezone: getTimezone(),
+      type: "datetime"
+    };
+  } else if (isCustomDateRange(value)) {
+    //custom-date-range
+    return {
+      value: value ? value.join(",") : "",
+      rule: "between",
+      timezone: getTimezone()
+    };
+  }
+  return {
+    value: dateValue[value].map(function (date) {
+      return date.toISOString();
+    }).join(","),
+    rule: "between",
+    timezone: getTimezone()
+  };
+};
+var buildSingleDatePayload = function buildSingleDatePayload(filter) {
+  var value = filter.value;
+  var filterValue = Array.isArray(value) ? value.join(",") : value;
+  return _objectSpread(_objectSpread({}, filter), {}, {
+    value: filterValue,
+    type: "date"
+  });
+};
+var buildSingleTimePayload = function buildSingleTimePayload(filter) {
+  var value = filter.value;
+  var filterValue = Array.isArray(value) ? value.join(",") : value;
+  return _objectSpread(_objectSpread({}, filter), {}, {
+    value: filterValue,
+    type: "time"
+  });
+};
+var flattenPayload = function flattenPayload(payload) {
+  var flattenedPayload = [];
+  payload.forEach(function (item) {
+    return Array.isArray(item) ? flattenedPayload.unshift.apply(flattenedPayload, _toConsumableArray(item)) : flattenedPayload.push(item);
+  }, []);
+  return flattenedPayload;
+};
+var buildMultiOptionPayload = function buildMultiOptionPayload(values) {
+  return values.map(function (value) {
+    return value.toString();
+  }).join("|");
+};
+var buildFiltersPayload = function buildFiltersPayload(filters) {
+  var payload = neetoCist.removeBy({
+    value: ""
+  }, filters).map(function (filter) {
+    if (filter.key === constants.SEARCH_TERM_KEY && isMultiModelFilter(filter)) {
+      return splitFilter(filter);
+    }
+    var filterPayload = ramda.omit(["key", "label", "values", "setValue"], filter);
+    var _filterPayload$defaul = filterPayload.defaultType,
+      defaultType = _filterPayload$defaul === void 0 ? filterPayload.type : _filterPayload$defaul,
+      value = filterPayload.value;
+    if (isMultiModelFilter(filterPayload)) {
+      throw i18next__default["default"].t("neetoFilters.errors.cannotPassMultipleModels");
+    }
+    if (isDate(defaultType)) {
+      return ramda.mergeRight(filterPayload, buildDatePayload(value));
+    } else if (isMulti(defaultType) || isTreeSelect(defaultType)) {
+      return ramda.mergeRight(filterPayload, {
+        value: buildMultiOptionPayload(value)
+      });
+    } else if (isSingleDate(defaultType)) {
+      return ramda.mergeRight(filterPayload, buildSingleDatePayload(filterPayload));
+    } else if (isSingleTime(defaultType)) {
+      return ramda.mergeRight(filterPayload, buildSingleTimePayload(filterPayload));
+    } else if (isTime(defaultType)) {
+      return ramda.mergeRight(filterPayload, buildTimePayload(value));
+    }
+    return filterPayload;
+  });
+  return ramda.isEmpty(payload) ? [] : [{
+    conditions: flattenPayload(payload)
+  }];
+};
+var buildSegmentsPayload = function buildSegmentsPayload(filters) {
+  var childrenKeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var payload = neetoCist.removeBy({
+    value: ""
+  }, filters).map(function (filter) {
+    if (filter.key === constants.SEARCH_TERM_KEY) {
+      return false;
+    }
+    var filterPayload = ramda.omit(["label", "values", "setValue", "defaultValue"], filter);
+    var _filterPayload$defaul2 = filterPayload.defaultType,
+      defaultType = _filterPayload$defaul2 === void 0 ? filterPayload.type : _filterPayload$defaul2,
+      value = filterPayload.value;
+    if (filter.key !== constants.SEARCH_TERM_KEY && isMultiModelFilter(filterPayload)) {
+      throw i18next__default["default"].t("neetoFilters.errors.cannotPassMultipleModels");
+    }
+    if (isMulti(defaultType)) {
+      return ramda.mergeRight(filterPayload, {
+        value: buildMultiOptionPayload(value)
+      });
+    }
+    return filterPayload;
+  });
+  var searchParams = getSnakeCasedQueryParams();
+  var modifiedPayload = childrenKeys.reduce(function (acc, key) {
+    if (ramda.has(key, searchParams)) {
+      var filterPayload = {
+        key: key,
+        node: "children",
+        value: searchParams[key]
+      };
+      return acc.concat(filterPayload);
+    }
+    return acc;
+  }, payload);
+  return ramda.isEmpty(modifiedPayload) ? [] : [{
+    conditions: flattenPayload(modifiedPayload)
+  }];
+};
+var buildFiltersFromURL = function buildFiltersFromURL(columns) {
+  return buildFiltersPayload(buildFiltersFromSearchParams(columns.filter(function (column) {
+    return !ramda.isNil(column.node);
+  })));
+};
+var buildSelectorsFromURL = function buildSelectorsFromURL(columns) {
+  var searchParams = getSnakeCasedQueryParams();
+  var selectors = {};
+  columns.filter(function (_ref9) {
+    var node = _ref9.node;
+    return !node;
+  }).forEach(function (_ref10) {
+    var key = _ref10.key,
+      defaultType = _ref10.defaultType,
+      type = _ref10.type;
+    var value = searchParams[key];
+    if (value) {
+      selectors[key] = isMulti(defaultType || type) ? value.split("|") : value;
+    }
+  });
+  return selectors;
+};
+var compareFilters = function compareFilters(oldFilters, newFilters) {
+  var formatFilters = function formatFilters(filters) {
+    return neetoCist.removeBy({
+      value: ""
+    }, filters).map(ramda.pick(["key", "rule", "value"]));
+  };
+  return ramda.equals(formatFilters(oldFilters), formatFilters(newFilters));
+};
+var buildFilteredColumns = function buildFilteredColumns(_ref11) {
+  var _ref11$searchTerm = _ref11.searchTerm,
+    searchTerm = _ref11$searchTerm === void 0 ? "" : _ref11$searchTerm,
+    columns = _ref11.columns;
+  var groupedColumsObject = groupByGroup(columns.filter(function (_ref12) {
+    var label = _ref12.label,
+      _ref12$hidden = _ref12.hidden,
+      hidden = _ref12$hidden === void 0 ? false : _ref12$hidden;
+    return label.toLocaleLowerCase().includes(searchTerm.trim().toLocaleLowerCase()) && !hidden;
+  }));
+  return {
+    groupedColumns: ramda.toPairs(ramda.omit(["individual"], groupedColumsObject)).map(function (_ref13) {
+      var _ref14 = _slicedToArray(_ref13, 2),
+        group = _ref14[0],
+        columns = _ref14[1];
+      return {
+        group: group,
+        columns: columns
+      };
+    }),
+    ungroupedColumns: groupedColumsObject.individual
+  };
+};
+var buildDefaultFilters = function buildDefaultFilters(columns, filters) {
+  return columns.filter(function (column) {
+    return !isUndefinedOrEmpty(column.defaultValue) && !neetoCist.findBy({
+      key: column.key
+    }, filters);
+  }).map(function (column) {
+    var defaultType = column.defaultType || column.type;
+    return buildUpdatedFilter({
+      column: column,
+      defaultType: defaultType,
+      rule: getDefaultRuleValue(defaultType),
+      option: column.defaultValue,
+      value: column.defaultValue
+    });
+  });
+};
+var createUrlParamString = function createUrlParamString(_ref15) {
+  var filter = _ref15.filter,
+    columns = _ref15.columns;
+  var key = filter.key,
+    value = filter.value,
+    _filter$defaultType = filter.defaultType,
+    defaultType = _filter$defaultType === void 0 ? filter.type : _filter$defaultType,
+    rule = filter.rule;
+  if (key === constants.SEARCH_TERM_KEY) {
+    return value;
+  } else if (isDigit(defaultType) || isText(defaultType)) {
+    return "".concat(value, "+rule-").concat(rule);
+  } else if (isSingleDate(defaultType) || isSingleTime(defaultType)) {
+    return value && "".concat(value, "+rule-").concat(rule) || value;
+  } else if (isMulti(defaultType) || isTreeSelect(defaultType)) {
+    return "".concat(value.join("|"), "+rule-").concat(rule);
+  } else if (isSingle(defaultType)) {
+    return "".concat(value, "+rule-").concat(rule);
+  } else if (isBoolean(defaultType)) {
+    return getLabelFromBool({
+      value: value,
+      values: neetoCist.findBy({
+        key: key
+      }, columns).values
+    });
+  }
+  return value;
+};
+var buildUrlFromFilters = function buildUrlFromFilters(_ref16) {
+  var columns = _ref16.columns,
+    filters = _ref16.filters,
+    _ref16$isClearAll = _ref16.isClearAll,
+    isClearAll = _ref16$isClearAll === void 0 ? false : _ref16$isClearAll,
+    _ref16$childrenKeys = _ref16.childrenKeys,
+    childrenKeys = _ref16$childrenKeys === void 0 ? [] : _ref16$childrenKeys;
+  var searchParams = getSnakeCasedQueryParams();
+  var isKeywordFilterPresent = neetoCist.findBy({
+    key: constants.SEARCH_TERM_KEY
+  }, filters);
+  columns.forEach(function (_ref17) {
+    var key = _ref17.key,
+      defaultValue = _ref17.defaultValue;
+    return !defaultValue && delete searchParams[key];
+  });
+  if (isClearAll) {
+    childrenKeys.forEach(function (key) {
+      return delete searchParams[key];
+    });
+    delete searchParams[constants.SEGMENT_ID_KEY];
+  }
+  var defaultFilters = buildDefaultFilters(columns, filters);
+  isKeywordFilterPresent && delete searchParams[constants.SEARCH_TERM_KEY];
+  ramda.concat(filters, defaultFilters).forEach(function (filter) {
+    searchParams[filter.key] = createUrlParamString({
+      filter: filter,
+      columns: columns
+    });
+  });
+  if (ramda.isEmpty(ramda.omit([constants.SEGMENT_ID_KEY], searchParams))) {
+    delete searchParams[constants.SEGMENT_ID_KEY];
+  }
+  return utils.buildUrl("", searchParams).slice(1);
+};
+var createUrlParamStringForSegments = function createUrlParamStringForSegments(_ref18) {
+  var filter = _ref18.filter,
+    columns = _ref18.columns;
+  var value = filter.value,
+    _filter$defaultType2 = filter.defaultType,
+    defaultType = _filter$defaultType2 === void 0 ? filter.type : _filter$defaultType2;
+  if (isMulti(defaultType)) {
+    return value;
+  }
+  return createUrlParamString({
+    filter: filter,
+    columns: columns
+  });
+};
+var buildUrlFromSegment = function buildUrlFromSegment(_ref19) {
+  var columns = _ref19.columns,
+    filters = _ref19.filters,
+    id = _ref19.id;
+  var searchParams = getSnakeCasedQueryParams();
+  columns.forEach(function (_ref20) {
+    var key = _ref20.key,
+      defaultValue = _ref20.defaultValue;
+    return !defaultValue && delete searchParams[key];
+  });
+  delete searchParams[constants.SEARCH_TERM_KEY];
+  var defaultFilters = buildDefaultFilters(columns, filters);
+  var newSearchParams = ramda.concat(filters, defaultFilters).reduce(function (acc, filter) {
+    acc[filter.key] = createUrlParamStringForSegments({
+      filter: filter,
+      columns: columns
+    });
+    return acc;
+  }, neetoCist.isNotEmpty(id) ? constants._defineProperty({}, constants.SEGMENT_ID_KEY, id) : {});
+  return utils.buildUrl("", ramda.mergeLeft(newSearchParams, searchParams)).slice(1);
+};
+var getSearchTermFromUrl = function getSearchTermFromUrl() {
+  return utils.getQueryParams().searchTerm || "";
+};
+var buildFilterColumnsFromFields = function buildFilterColumnsFromFields(_ref22) {
+  var fields = _ref22.fields,
+    _ref22$selectedFields = _ref22.selectedFields,
+    selectedFields = _ref22$selectedFields === void 0 ? [] : _ref22$selectedFields,
+    _ref22$showRuleSelect = _ref22.showRuleSelector,
+    showRuleSelector = _ref22$showRuleSelect === void 0 ? false : _ref22$showRuleSelect,
+    groupName = _ref22.groupName;
+  return fields.reduce(function (columns, field) {
+    if (ramda.isEmpty(selectedFields) || selectedFields.includes(field.name)) {
+      var id = field.id,
+        name = field.name,
+        kind = field.kind;
+      var column = _objectSpread({
+        key: ramda.toLower(name),
+        node: "".concat(name, ":").concat(id),
+        label: neetoCist.capitalize(name),
+        type: "custom.".concat(kind),
+        showRuleSelector: showRuleSelector
+      }, groupName && {
+        group: groupName
+      });
+      if (kind === "single_option" || kind === "multi_option") {
+        column.values = field.data.map(function (item) {
+          return {
+            label: neetoCist.capitalize(item.label),
+            value: item.id
+          };
+        });
+      }
+      columns.push(column);
+    }
+    return columns;
+  }, []);
+};
+var getColumnsWithStandardizedType = function getColumnsWithStandardizedType(columns) {
+  return columns.map(function (column) {
+    return _objectSpread(_objectSpread({}, column), {}, {
+      type: standardizeColumnType(column.type)
+    });
+  });
+};
+var isKeywordFilterPresent = function isKeywordFilterPresent(keyworFilter) {
+  return ramda.not(ramda.isEmpty(keyworFilter.node));
+};
+
+exports.DEFAULT_BOOLEAN_OPTIONS = DEFAULT_BOOLEAN_OPTIONS;
+exports.DEFAULT_HELP_ICON_PROPS = DEFAULT_HELP_ICON_PROPS;
+exports.MULTI_DROPDOWN_RULES = MULTI_DROPDOWN_RULES;
+exports.NUMBER_RULES = NUMBER_RULES;
+exports.SINGLE_DROPDOWN_RULES = SINGLE_DROPDOWN_RULES;
+exports.TEXT_RULES = TEXT_RULES;
+exports.TIME_FORMAT = TIME_FORMAT;
+exports.TREE_SELECT_RULES = TREE_SELECT_RULES;
+exports._slicedToArray = _slicedToArray;
+exports._toConsumableArray = _toConsumableArray;
+exports.buildDefaultFilters = buildDefaultFilters;
+exports.buildFilterColumnsFromFields = buildFilterColumnsFromFields;
+exports.buildFilteredColumns = buildFilteredColumns;
+exports.buildFiltersFromSearchParams = buildFiltersFromSearchParams;
+exports.buildFiltersFromURL = buildFiltersFromURL;
+exports.buildFiltersPayload = buildFiltersPayload;
+exports.buildRuleOptions = buildRuleOptions;
+exports.buildSegmentsPayload = buildSegmentsPayload;
+exports.buildSelectorsFromURL = buildSelectorsFromURL;
+exports.buildUpdatedFilter = buildUpdatedFilter;
+exports.buildUrlFromFilters = buildUrlFromFilters;
+exports.buildUrlFromSegment = buildUrlFromSegment;
+exports.compareFilters = compareFilters;
+exports.getColumnsWithStandardizedType = getColumnsWithStandardizedType;
+exports.getLabelFromBool = getLabelFromBool;
+exports.getSearchTermFromUrl = getSearchTermFromUrl;
+exports.getSnakeCasedQueryParams = getSnakeCasedQueryParams;
+exports.isBoolean = isBoolean;
+exports.isCheckbox = isCheckbox;
+exports.isCustomDateRange = isCustomDateRange;
+exports.isCustomTimeRange = isCustomTimeRange;
+exports.isDate = isDate;
+exports.isDigit = isDigit;
+exports.isKeywordFilterPresent = isKeywordFilterPresent;
+exports.isMulti = isMulti;
+exports.isSingle = isSingle;
+exports.isSingleDate = isSingleDate;
+exports.isSingleTime = isSingleTime;
+exports.isText = isText;
+exports.isTime = isTime;
+exports.isTreeSelect = isTreeSelect;
+exports.isUndefinedOrEmpty = isUndefinedOrEmpty;
+//# sourceMappingURL=utils-61b4223d.js.map