@elliemae/ds-query-builder 2.3.0-alpha.6 → 2.3.0-next.0

package/cjs/components/ToolBarAnimation/ToolBarAnimation.js

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.filter.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var React = require('react');
+var GrowRight = require('@elliemae/ds-shared/Animations/GrowRight');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var GrowRight__default = /*#__PURE__*/_interopDefaultLegacy(GrowRight);
+
+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 ToolBarAnimation = props => /*#__PURE__*/React.createElement(GrowRight__default["default"], _objectSpread(_objectSpread({}, props), {}, {
+  key: "popper-animation-key",
+  from: 0.5,
+  to: 1
+}));
+
+exports.ToolBarAnimation = ToolBarAnimation;

package/cjs/components/format/format.js

@@ -0,0 +1,33 @@
+'use strict';
+
+var sqlFormat = require('./sqlFormat.js');
+var xmlFormat = require('./xmlFormat.js');
+var sqlSafeFormat = require('./sqlSafeFormat.js');
+
+class QueryBuilderFormat {
+  constructor() {
+    this.format = {
+      defaultFormat: query => query,
+      sqlFormat: sqlFormat.sqlFormat,
+      xmlFormat: xmlFormat.xmlFormat,
+      sqlSafeFormat: sqlSafeFormat.sqlSafeFormat
+    };
+    this.currentFormat = 'sqlFormat';
+
+    this.setDefaultFormat = formatName => {
+      if (this.format[formatName]) this.currentFormat = formatName;
+    };
+
+    this.addFormat = (formatName, format) => this.format[formatName] = format;
+
+    this.run = (query, formatName) => {
+      if (this.format[formatName]) return this.format[formatName](query);
+      return this.format[this.currentFormat](query);
+    };
+  }
+
+}
+
+var QueryBuilderFormat$1 = new QueryBuilderFormat();
+
+module.exports = QueryBuilderFormat$1;

package/cjs/components/format/sqlFormat.js

@@ -0,0 +1,73 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('core-js/modules/esnext.async-iterator.map.js');
+require('core-js/modules/esnext.iterator.map.js');
+var types = require('../helpers/types.js');
+
+const conditionSql = (condition, value) => {
+  const {
+    EQUAL,
+    NOT_EQUAL,
+    GREATER_THAN,
+    LESS_THAN,
+    CONTAINS,
+    NOT_CONTAINS,
+    BETWEEN,
+    GREATER_THAN_OR_EQUAL,
+    LESS_THAN_OR_EQUAL,
+    START_WITH
+  } = types.QB_OPERATOR_TYPES;
+  if (condition === EQUAL) return " = '".concat(value, "'");
+  if (condition === NOT_EQUAL) return " <> '".concat(value, "'");
+  if (condition === GREATER_THAN) return " > ".concat(value);
+  if (condition === LESS_THAN) return " < ".concat(value);
+  if (condition === CONTAINS) return " LIKE '%".concat(value, "%'");
+  if (condition === NOT_CONTAINS) return " NOT LIKE '%".concat(value, "%'");
+  if (condition === BETWEEN) return " BETWEEN ".concat(value[0], " AND ").concat(value[1], " ");
+  if (condition === GREATER_THAN_OR_EQUAL) return " >= ".concat(value);
+  if (condition === LESS_THAN_OR_EQUAL) return " <= ".concat(value);
+  if (condition === START_WITH) return " LIKE '".concat(value, "%'");
+  return condition;
+};
+
+const renderFilterSQl = filter => {
+  const {
+    field,
+    operator,
+    value
+  } = filter.element;
+  return "".concat(field, " ").concat(conditionSql(operator, value) || '');
+};
+
+const sqlFormat = _ref => {
+  let {
+    main,
+    mapGroups,
+    items
+  } = _ref;
+
+  const groupSql = (item, idGroup) => {
+    if (idGroup === main) {
+      const groupCondition = mapGroups[idGroup].condition === true ? 'AND' : 'OR';
+      return " ( ".concat(filterSql(item, groupCondition), " ) "); // eslint-disable-line
+    }
+
+    const groupCondition = item.element.condition === true ? 'AND' : 'OR';
+    return " ( ".concat(filterSql(item.children, groupCondition), " ) "); // eslint-disable-line
+  };
+
+  const filterSql = (filters, groupCondition) => {
+    const filterGroup = filters.map(filter => {
+      if (filter.element.type === 'filter') return " ".concat(renderFilterSQl(filter), " ");
+      return " ".concat(groupSql(filter) || '', " ");
+    });
+    return filterGroup.join(groupCondition);
+  };
+
+  const sql = " FROM [TABLE_NAME] WHERE ".concat(groupSql(items, main) || '', " ");
+  return sql;
+};
+
+exports.sqlFormat = sqlFormat;

package/cjs/components/format/sqlSafeFormat.js

@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('core-js/modules/esnext.async-iterator.map.js');
+require('core-js/modules/esnext.iterator.map.js');
+var types = require('../helpers/types.js');
+
+const specialChar = /[ !@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]/;
+
+const conditionSql = (condition, value) => {
+  const {
+    EQUAL,
+    NOT_EQUAL,
+    GREATER_THAN,
+    LESS_THAN,
+    CONTAINS,
+    NOT_CONTAINS,
+    BETWEEN,
+    GREATER_THAN_OR_EQUAL,
+    LESS_THAN_OR_EQUAL,
+    START_WITH
+  } = types.QB_OPERATOR_TYPES; // eslint-disable-next-line no-restricted-globals
+
+  const valueDisplay = isNaN(value) ? "'".concat(value, "'") : value;
+  if (condition === EQUAL) return " = ".concat(valueDisplay);
+  if (condition === NOT_EQUAL) return " <> ".concat(valueDisplay);
+  if (condition === GREATER_THAN) return " > ".concat(valueDisplay);
+  if (condition === LESS_THAN) return " < ".concat(valueDisplay);
+  if (condition === CONTAINS) return " LIKE '%".concat(value, "%'");
+  if (condition === NOT_CONTAINS) return " NOT LIKE '%".concat(value, "%'");
+  if (condition === BETWEEN) return " BETWEEN ".concat(value[0], " AND ").concat(value[1], " ");
+  if (condition === GREATER_THAN_OR_EQUAL) return " >= ".concat(value);
+  if (condition === LESS_THAN_OR_EQUAL) return " <= ".concat(value);
+  if (condition === START_WITH) return " LIKE '".concat(value, "%'");
+  return condition;
+};
+
+const renderFilterSQl = filter => {
+  const {
+    field,
+    operator,
+    value
+  } = filter.element; // eslint-disable-next-line no-restricted-globals
+
+  const fieldDisplay = // eslint-disable-next-line no-restricted-globals
+  /[.]/.test(field) || !isNaN(field) ? "\\\"".concat(field, "\\\"") : field;
+  return "".concat(fieldDisplay, " ").concat(conditionSql(operator, value) || '');
+};
+
+const sqlSafeFormat = _ref => {
+  let {
+    main,
+    mapGroups,
+    items
+  } = _ref;
+
+  const groupSql = (item, idGroup) => {
+    if (idGroup === main) {
+      const groupCondition = mapGroups[idGroup].condition === true ? 'AND' : 'OR';
+      return " ( ".concat(filterSql(item, groupCondition), " ) "); // eslint-disable-line
+    }
+
+    const groupCondition = item.element.condition === true ? 'AND' : 'OR';
+    return " ( ".concat(filterSql(item.children, groupCondition), " ) "); // eslint-disable-line
+  };
+
+  const filterSql = (filters, groupCondition) => {
+    const filterGroup = filters.map(filter => {
+      if (filter.element.type === 'filter') return " ".concat(renderFilterSQl(filter), " ");
+      return " ".concat(groupSql(filter) || '', " ");
+    });
+    return filterGroup.join(groupCondition);
+  };
+
+  const sql = " FROM [TABLE_NAME] WHERE ".concat(groupSql(items, main) || '', " ");
+  return sql;
+};
+
+exports.specialChar = specialChar;
+exports.sqlSafeFormat = sqlSafeFormat;

package/cjs/components/format/xmlFormat.js

@@ -0,0 +1,73 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('core-js/modules/esnext.async-iterator.map.js');
+require('core-js/modules/esnext.iterator.map.js');
+var types = require('../helpers/types.js');
+
+const conditionSql = (condition, value) => {
+  const {
+    EQUAL,
+    NOT_EQUAL,
+    GREATER_THAN,
+    LESS_THAN,
+    CONTAINS,
+    NOT_CONTAINS,
+    BETWEEN,
+    GREATER_THAN_OR_EQUAL,
+    LESS_THAN_OR_EQUAL,
+    START_WITH
+  } = types.QB_OPERATOR_TYPES;
+  if (condition === EQUAL) return "<condition>EQUAL</condition><value>".concat(value, "</value>");
+  if (condition === NOT_EQUAL) return "<condition>NOT_EQUAL</condition><value>".concat(value, "</value>");
+  if (condition === GREATER_THAN) return "<condition>GREATER_THAN</condition><value>".concat(value, "</value>");
+  if (condition === LESS_THAN) return "<condition>LESS_THAN</condition><value>".concat(value, "</value>");
+  if (condition === CONTAINS) return "<condition>LIKE</condition><value>".concat(value, "</value>");
+  if (condition === NOT_CONTAINS) return "<condition>NOT_LIKE</condition><value>".concat(value, "</value>");
+  if (condition === BETWEEN) return "<condition>NOT_LIKE</condition><value><from>".concat(value[0], "</from><to>").concat(value[1], "</to></value>");
+  if (condition === GREATER_THAN_OR_EQUAL) return "<condition>GREATER_THAN_OR_EQUAL</condition><value>".concat(value, "</value>");
+  if (condition === LESS_THAN_OR_EQUAL) return "<condition>LESS_THAN_OR_EQUAL</condition><value>".concat(value, "</value>");
+  if (condition === START_WITH) return "<condition>GREATER_THAN</condition><value>".concat(value, "</value>");
+  return condition;
+};
+
+const renderFilterSQl = filter => {
+  const {
+    field,
+    operator,
+    value
+  } = filter.element;
+  return "<filter><field>".concat(field, "</field>").concat(conditionSql(operator, value) || '', "</filter>");
+};
+
+const xmlFormat = _ref => {
+  let {
+    main,
+    mapGroups,
+    items
+  } = _ref;
+
+  const groupXML = (item, idGroup) => {
+    if (idGroup === main) {
+      const groupCondition = mapGroups[idGroup].condition === true ? 'AND' : 'OR';
+      return "<group value=\"".concat(groupCondition, "\">").concat(filterXML(item), "</group>"); // eslint-disable-line
+    }
+
+    const groupCondition = item.element.condition === true ? 'AND' : 'OR';
+    return "<group value=\"".concat(groupCondition, "\">").concat(filterXML(item.children), "</group>"); // eslint-disable-line
+  };
+
+  const filterXML = filters => {
+    const filterGroup = filters.map(filter => {
+      if (filter.element.type === 'filter') return "".concat(renderFilterSQl(filter) || '', " ");
+      return " ".concat(groupXML(filter), " ");
+    });
+    return filterGroup.join('');
+  };
+
+  const xml = "<xml><query>".concat(groupXML(items, main) || '', "</query></xml>");
+  return xml;
+};
+
+exports.xmlFormat = xmlFormat;

package/cjs/components/helpers/actions.js

@@ -0,0 +1,277 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+require('core-js/modules/esnext.async-iterator.find.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.find.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');
+require('core-js/modules/esnext.async-iterator.map.js');
+require('core-js/modules/esnext.iterator.map.js');
+var types = require('./types.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; }
+/**
+ * this is injected. instance of QBStore
+ *
+ * @param {*} idGroup: UUID
+ * @param idGroup
+ */
+
+const createNewFilter = function (idGroup) {
+  const idFilter = "filter_".concat(new Date().getTime(), "_").concat(Math.random().toString(36).substring(7));
+  return {
+    idGroup,
+    field: '',
+    condition: '',
+    value: '',
+    idFilter,
+    type: types.QB_DRAG_TYPES.FILTER
+  };
+};
+/**
+ * this is injected. instance of QBStore
+ *
+ * @param {*} parentIdGroup: UUID
+ * @param parentIdGroup
+ */
+
+const createNewGroup = function (parentIdGroup) {
+  const idGroup = "group_".concat(new Date().getTime(), "_").concat(Math.random().toString(36).substring(7));
+  return {
+    parentIdGroup,
+    idGroup,
+    condition: types.QB_GROUP_CONDITION_TYPES.AND,
+    type: types.QB_DRAG_TYPES.GROUP
+  };
+};
+/**
+ * this is injected. instance of QBStore
+ *
+ * @param {*} newFilter
+ */
+
+const addFilterToMap = function (newFilter) {
+  this.mapFilters = _objectSpread(_objectSpread({}, this.mapFilters), {}, {
+    [newFilter.idFilter]: newFilter
+  });
+};
+/**
+ * this is injected. instance of QBStore
+ *
+ * @param {*} newFilter
+ * @param newGroup
+ */
+
+const addGroupToMap = function (newGroup) {
+  this.mapGroups = _objectSpread(_objectSpread({}, this.mapGroups), {}, {
+    [newGroup.idGroup]: _objectSpread({}, newGroup)
+  });
+};
+const addFilterToItem = function (item, newFilter) {
+  item.children.push({
+    id: newFilter.idFilter,
+    element: newFilter,
+    children: []
+  });
+};
+const addFilterToMainItem = function (items, newFilter) {
+  items.push({
+    id: newFilter.idFilter,
+    element: newFilter,
+    children: []
+  });
+};
+const findInChilds = function (childs, filterId) {
+  const found = childs.find(_ref => {
+    let {
+      id
+    } = _ref;
+    return id === filterId;
+  });
+
+  if (!found) {
+    let findInChild;
+    childs.forEach(item => {
+      if (!findInChild) findInChild = findInChilds(item.children, filterId);
+    });
+    if (findInChild) return findInChild;
+  }
+
+  return found;
+};
+const findItemFilterById = function (filterId) {
+  return findInChilds(this.items, filterId);
+};
+const findParentWithFilterId = function (childs, filterId) {
+  const found = childs.find(_ref2 => {
+    let {
+      id
+    } = _ref2;
+    return id === filterId;
+  });
+
+  if (!found) {
+    let findInChild;
+    childs.forEach(item => {
+      if (!findInChild) findInChild = findParentWithFilterId(item.children, filterId);
+    });
+    if (findInChild) return findInChild;
+  }
+
+  return childs;
+};
+const findParentFilterById = function (filterId) {
+  return findParentWithFilterId(this.items, filterId);
+};
+const filterInChildren = function (childs, filterId, mainId) {
+  if (childs.children) {
+    childs.children = childs.children.filter(_ref3 => {
+      let {
+        id
+      } = _ref3;
+      return id !== filterId;
+    });
+    childs.children = childs.children.forEach(item => filterInChildren(item.children, filterId));
+    return childs;
+  } // main
+
+
+  if (childs.length > 1) childs = childs.filter(_ref4 => {
+    let {
+      id
+    } = _ref4;
+    return id !== filterId;
+  }); // https://jira.elliemae.io/browse/PUI-1252
+
+  if (childs.length === 0 && mainId) {
+    const emptyFilter = createNewFilter.call(this, mainId);
+    addFilterToMainItem.call(this, childs, emptyFilter);
+  }
+
+  childs.forEach(item => item.children = filterInChildren(item.children, filterId));
+  return childs;
+};
+const removeFilterItem = function (filterId) {
+  this.items = filterInChildren(this.items, filterId, this.main);
+};
+const addGroupFilterToItem = function (idGroup, idFilter, newGroup) {
+  const child = findItemFilterById.call(this, idFilter);
+
+  const copy = _objectSpread({}, child);
+
+  if (copy.element.type === 'group') {
+    copy.element.parentIdGroup = newGroup.idGroup;
+  } else {
+    copy.element.idGroup = newGroup.idGroup;
+  }
+
+  child.id = newGroup.idGroup;
+  child.element = newGroup;
+  child.children = [copy];
+};
+const unGroupFilterToItem = function (idGroup) {
+  const group = findItemFilterById.call(this, idGroup);
+
+  if (group.element.parentIdGroup === this.main) {
+    const index = this.items.map(item => item.id).indexOf(idGroup);
+    const tmp = [];
+    tmp.splice.apply(this.items, [index, 1].concat(group.children));
+    this.items.forEach(item => {
+      if (item.element.type === 'group') {
+        item.element.parentIdGroup = this.main;
+      } else {
+        item.element.idGroup = this.main;
+      }
+    });
+  } else {
+    const parent = findItemFilterById.call(this, group.element.parentIdGroup);
+    const index = parent.children.map(item => item.id).indexOf(idGroup);
+    const tmp = [];
+    tmp.splice.apply(parent.children, [index, 1].concat(group.children));
+    parent.children.forEach(item => {
+      if (item.element.type === 'group') {
+        item.element.parentIdGroup = parent.id;
+      } else {
+        item.element.idGroup = parent.id;
+      }
+    });
+  }
+};
+const changeGroupOperator = function (idGroup, value) {
+  const group = findItemFilterById.call(this, idGroup);
+
+  if (idGroup !== this.main) {
+    group.element.condition = value;
+  }
+};
+const changeFilterItem = function (_ref5) {
+  let {
+    idFilter,
+    field,
+    value,
+    operator,
+    additionalInfo,
+    target,
+    fieldsSharedActions: {
+      onFieldChange,
+      onOperatorChange,
+      onValueChange
+    }
+  } = _ref5;
+  const child = findItemFilterById.call(this, idFilter);
+  if (field || field === '' || typeof field === 'boolean') child.element.field = field;
+  if (operator) child.element.operator = operator;
+  if (value || value === '' || typeof value === 'boolean') child.element.value = value;
+  if (additionalInfo) child.element.additionalInfo = additionalInfo; // shared fields actions
+
+  if (target === 'field') {
+    onFieldChange.forEach(_ref6 => {
+      let {
+        action
+      } = _ref6;
+      if (action === types.QB_FIELD_SHARED_ACTIONS.RESET_FIELD) child.element.field = null;else if (action === types.QB_FIELD_SHARED_ACTIONS.RESET_OPERATOR) child.element.operator = null;else if (action === types.QB_FIELD_SHARED_ACTIONS.RESET_VALUE) child.element.value = null;
+    });
+  } else if (target === 'operator') {
+    onOperatorChange.forEach(_ref7 => {
+      let {
+        action
+      } = _ref7;
+      if (action === types.QB_FIELD_SHARED_ACTIONS.RESET_FIELD) child.element.field = null;else if (action === types.QB_FIELD_SHARED_ACTIONS.RESET_OPERATOR) child.element.operator = null;else if (action === types.QB_FIELD_SHARED_ACTIONS.RESET_VALUE) child.element.value = null;
+    });
+  } else if (target === 'value') {
+    onValueChange.forEach(_ref8 => {
+      let {
+        action
+      } = _ref8;
+      if (action === types.QB_FIELD_SHARED_ACTIONS.RESET_FIELD) child.element.field = null;else if (action === types.QB_FIELD_SHARED_ACTIONS.RESET_OPERATOR) child.element.operator = null;else if (action === types.QB_FIELD_SHARED_ACTIONS.RESET_VALUE) child.element.value = null;
+    });
+  }
+};
+
+exports.addFilterToItem = addFilterToItem;
+exports.addFilterToMainItem = addFilterToMainItem;
+exports.addFilterToMap = addFilterToMap;
+exports.addGroupFilterToItem = addGroupFilterToItem;
+exports.addGroupToMap = addGroupToMap;
+exports.changeFilterItem = changeFilterItem;
+exports.changeGroupOperator = changeGroupOperator;
+exports.createNewFilter = createNewFilter;
+exports.createNewGroup = createNewGroup;
+exports.filterInChildren = filterInChildren;
+exports.findInChilds = findInChilds;
+exports.findItemFilterById = findItemFilterById;
+exports.findParentFilterById = findParentFilterById;
+exports.findParentWithFilterId = findParentWithFilterId;
+exports.removeFilterItem = removeFilterItem;
+exports.unGroupFilterToItem = unGroupFilterToItem;

package/cjs/components/helpers/constants.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const DELAY_CLOSE = 0.1;
+const DELAY_OPEN = 0.1;
+const TOOLBAR_ANIMATION_DURATION = 50;
+
+exports.DELAY_CLOSE = DELAY_CLOSE;
+exports.DELAY_OPEN = DELAY_OPEN;
+exports.TOOLBAR_ANIMATION_DURATION = TOOLBAR_ANIMATION_DURATION;

package/cjs/components/helpers/dependencies.js

@@ -0,0 +1,84 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('core-js/modules/esnext.async-iterator.every.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.every.js');
+require('core-js/modules/esnext.async-iterator.some.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');
+var lodash = require('lodash');
+var operators = require('@elliemae/ds-utilities/operators');
+var types = require('./types.js');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var operators__namespace = /*#__PURE__*/_interopNamespace(operators);
+
+const resolveCondition = function (condition, state) {
+  let resolveBy = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : types.QB_GROUP_CONDITION_TYPES.AND;
+  if (condition.length === 0 || !condition) return true; // resolve by AND: all the conditions must be true
+
+  if (resolveBy) {
+    return condition.every(rule => {
+      const {
+        source: sourceRule,
+        operator: operatorRule,
+        value: valueRule
+      } = rule;
+      if (typeof operatorRule === "function") return operatorRule(lodash.get(state, sourceRule), valueRule);
+      return operators__namespace[operatorRule](lodash.get(state, sourceRule), valueRule);
+    });
+  } // resolve by OR: at least one condition must be true
+
+
+  return condition.some(rule => {
+    const {
+      source: sourceRule,
+      operator: operatorRule,
+      value: valueRule
+    } = rule;
+    return operators__namespace[operatorRule](state[sourceRule], valueRule);
+  });
+};
+
+const resolveDependencies = (state, fields) => {
+  const fieldsToRender = fields.reduce((result, _ref) => {
+    let {
+      target,
+      component,
+      condition,
+      resolveBy,
+      validation,
+      handleWidth
+    } = _ref;
+    if (resolveCondition(condition, state, resolveBy)) result.push({
+      target,
+      component,
+      validation,
+      handleWidth
+    });
+    return result;
+  }, []);
+  return fieldsToRender;
+};
+
+exports.resolveDependencies = resolveDependencies;