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

package/esm/components/format/format.js

@@ -0,0 +1,31 @@
+import { sqlFormat } from './sqlFormat.js';
+import { xmlFormat } from './xmlFormat.js';
+import { sqlSafeFormat } from './sqlSafeFormat.js';
+
+class QueryBuilderFormat {
+  constructor() {
+    this.format = {
+      defaultFormat: query => query,
+      sqlFormat,
+      xmlFormat,
+      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();
+
+export { QueryBuilderFormat$1 as default };

package/esm/components/format/sqlFormat.js

@@ -0,0 +1,69 @@
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import { QB_OPERATOR_TYPES } from '../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
+  } = 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;
+};
+
+export { sqlFormat };

package/esm/components/format/sqlSafeFormat.js

@@ -0,0 +1,76 @@
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import { QB_OPERATOR_TYPES } from '../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
+  } = 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;
+};
+
+export { specialChar, sqlSafeFormat };

package/esm/components/format/xmlFormat.js

@@ -0,0 +1,69 @@
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import { QB_OPERATOR_TYPES } from '../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
+  } = 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;
+};
+
+export { xmlFormat };

package/esm/components/helpers/actions.js

@@ -0,0 +1,254 @@
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import 'core-js/modules/esnext.async-iterator.find.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.find.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 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import { QB_DRAG_TYPES, QB_GROUP_CONDITION_TYPES, QB_FIELD_SHARED_ACTIONS } from './types.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; }
+/**
+ * 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: 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: QB_GROUP_CONDITION_TYPES.AND,
+    type: 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 === QB_FIELD_SHARED_ACTIONS.RESET_FIELD) child.element.field = null;else if (action === QB_FIELD_SHARED_ACTIONS.RESET_OPERATOR) child.element.operator = null;else if (action === QB_FIELD_SHARED_ACTIONS.RESET_VALUE) child.element.value = null;
+    });
+  } else if (target === 'operator') {
+    onOperatorChange.forEach(_ref7 => {
+      let {
+        action
+      } = _ref7;
+      if (action === QB_FIELD_SHARED_ACTIONS.RESET_FIELD) child.element.field = null;else if (action === QB_FIELD_SHARED_ACTIONS.RESET_OPERATOR) child.element.operator = null;else if (action === QB_FIELD_SHARED_ACTIONS.RESET_VALUE) child.element.value = null;
+    });
+  } else if (target === 'value') {
+    onValueChange.forEach(_ref8 => {
+      let {
+        action
+      } = _ref8;
+      if (action === QB_FIELD_SHARED_ACTIONS.RESET_FIELD) child.element.field = null;else if (action === QB_FIELD_SHARED_ACTIONS.RESET_OPERATOR) child.element.operator = null;else if (action === QB_FIELD_SHARED_ACTIONS.RESET_VALUE) child.element.value = null;
+    });
+  }
+};
+
+export { addFilterToItem, addFilterToMainItem, addFilterToMap, addGroupFilterToItem, addGroupToMap, changeFilterItem, changeGroupOperator, createNewFilter, createNewGroup, filterInChildren, findInChilds, findItemFilterById, findParentFilterById, findParentWithFilterId, removeFilterItem, unGroupFilterToItem };

package/esm/components/helpers/constants.js

@@ -0,0 +1,5 @@
+const DELAY_CLOSE = 0.1;
+const DELAY_OPEN = 0.1;
+const TOOLBAR_ANIMATION_DURATION = 50;
+
+export { DELAY_CLOSE, DELAY_OPEN, TOOLBAR_ANIMATION_DURATION };

package/esm/components/helpers/dependencies.js

@@ -0,0 +1,60 @@
+import 'core-js/modules/esnext.async-iterator.every.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.every.js';
+import 'core-js/modules/esnext.async-iterator.some.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 { get } from 'lodash';
+import * as operators from '@elliemae/ds-utilities/operators';
+import { QB_GROUP_CONDITION_TYPES } from './types.js';
+
+const resolveCondition = function (condition, state) {
+  let resolveBy = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 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(get(state, sourceRule), valueRule);
+      return operators[operatorRule](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[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;
+};
+
+export { resolveDependencies };

package/esm/components/helpers/selectors.js

@@ -0,0 +1,93 @@
+import { QB_FIELD_TYPES, QB_OPERATOR_TYPES } from './types.js';
+
+const QB_DEFAULT_VALUES_OPTIONS = [{
+  label: 'Choose a Field',
+  value: ''
+}];
+const QB_SUBJECT_VALUES_OPTIONS = [{
+  label: 'Condominium',
+  value: 'Condominium'
+}, {
+  label: 'Single Family Home',
+  value: 'Single Family Home'
+}, {
+  label: 'Co-Operative',
+  value: 'Co-Operative'
+}, {
+  label: 'Detached',
+  value: 'Detached'
+}, {
+  label: 'High Rise Condominium',
+  value: 'High Rise Condominium'
+}, {
+  label: 'Manufactured Housing',
+  value: 'Manufactured Housing'
+}, {
+  label: 'Other',
+  value: 'Other'
+}];
+const QB_LOAN_VALUES_OPTIONS = [{
+  label: 'Conventional',
+  value: 'Conventional'
+}, {
+  label: 'VA',
+  value: 'VA'
+}, {
+  label: 'FHA',
+  value: 'FHA'
+}, {
+  label: 'USAD-RHS',
+  value: 'USAD-RHS'
+}, {
+  label: 'HELOC',
+  value: 'HELOC'
+}, {
+  label: 'Other',
+  value: 'Other'
+}];
+const QB_FIELD_OPTIONS = [{
+  label: 'Select',
+  value: ''
+}, {
+  label: 'Loan Type',
+  value: QB_FIELD_TYPES.LOAN_VALUES
+}, {
+  label: 'Loan To Value (LTV)',
+  value: QB_FIELD_TYPES.LTV_VALUES
+}, {
+  label: 'Subject Property Type',
+  value: QB_FIELD_TYPES.SUBJECT_VALUES
+}, {
+  label: 'Last Finished Milestone',
+  value: QB_FIELD_TYPES.LAST_VALUES
+}, {
+  label: 'Credit Score',
+  value: QB_FIELD_TYPES.CREDIT_VALUES
+}];
+const QB_OPERATOR_OPTIONS = [{
+  label: 'Select',
+  value: ''
+}, {
+  label: 'Is',
+  value: QB_OPERATOR_TYPES.EQUAL
+}, {
+  label: 'Is not',
+  value: QB_OPERATOR_TYPES.NOT_EQUAL
+}, {
+  label: 'Greater than',
+  value: QB_OPERATOR_TYPES.GREATER_THAN
+}, {
+  label: 'Less than',
+  value: QB_OPERATOR_TYPES.LESS_THAN
+}, {
+  label: 'Contains',
+  value: QB_OPERATOR_TYPES.CONTAINS
+}, {
+  label: "Doesn't Contain",
+  value: QB_OPERATOR_TYPES.NOT_CONTAINS
+}, {
+  label: 'Between',
+  value: QB_OPERATOR_TYPES.BETWEEN
+}];
+
+export { QB_DEFAULT_VALUES_OPTIONS, QB_FIELD_OPTIONS, QB_LOAN_VALUES_OPTIONS, QB_OPERATOR_OPTIONS, QB_SUBJECT_VALUES_OPTIONS };