handsontable 0.0.0-next-9ec04ce-20221121

package/plugins/filters/conditionUpdateObserver.js

@@ -0,0 +1,248 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+require("core-js/modules/es.array.index-of.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.object.to-string.js");
+var _array = require("../../helpers/array");
+var _object = require("../../helpers/object");
+var _function = require("../../helpers/function");
+var _localHooks = _interopRequireDefault(require("../../mixins/localHooks"));
+var _conditionCollection = _interopRequireDefault(require("./conditionCollection"));
+var _dataFilter = _interopRequireDefault(require("./dataFilter"));
+var _utils = require("./utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+/**
+ * Class which is designed for observing changes in condition collection. When condition is changed by user at specified
+ * column it's necessary to update all conditions defined after this edited one.
+ *
+ * Object fires `update` hook for every column conditions change.
+ *
+ * @private
+ * @class ConditionUpdateObserver
+ */
+var ConditionUpdateObserver = /*#__PURE__*/function () {
+  function ConditionUpdateObserver(hot, conditionCollection) {
+    var _this = this;
+    var columnDataFactory = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {
+      return [];
+    };
+    _classCallCheck(this, ConditionUpdateObserver);
+    /**
+     * Handsontable instance.
+     *
+     * @type {Core}
+     */
+    this.hot = hot;
+    /**
+     * Reference to the instance of {@link ConditionCollection}.
+     *
+     * @type {ConditionCollection}
+     */
+    this.conditionCollection = conditionCollection;
+    /**
+     * Function which provide source data factory for specified column.
+     *
+     * @type {Function}
+     */
+    this.columnDataFactory = columnDataFactory;
+    /**
+     * Collected changes when grouping is enabled.
+     *
+     * @type {Array}
+     * @default []
+     */
+    this.changes = [];
+    /**
+     * Flag which determines if grouping events is enabled.
+     *
+     * @type {boolean}
+     */
+    this.grouping = false;
+    /**
+     * The latest known position of edited conditions at specified column index.
+     *
+     * @type {number}
+     * @default -1
+     */
+    this.latestEditedColumnPosition = -1;
+    /**
+     * The latest known order of conditions stack.
+     *
+     * @type {Array}
+     */
+    this.latestOrderStack = [];
+    this.conditionCollection.addLocalHook('beforeRemove', function (column) {
+      return _this._onConditionBeforeModify(column);
+    });
+    this.conditionCollection.addLocalHook('afterRemove', function (column) {
+      return _this.updateStatesAtColumn(column);
+    });
+    this.conditionCollection.addLocalHook('afterAdd', function (column) {
+      return _this.updateStatesAtColumn(column);
+    });
+    this.conditionCollection.addLocalHook('beforeClean', function () {
+      return _this._onConditionBeforeClean();
+    });
+    this.conditionCollection.addLocalHook('afterClean', function () {
+      return _this._onConditionAfterClean();
+    });
+  }
+
+  /**
+   * Enable grouping changes. Grouping is helpful in situations when a lot of conditions is added in one moment. Instead of
+   * trigger `update` hook for every condition by adding/removing you can group this changes and call `flush` method to trigger
+   * it once.
+   */
+  _createClass(ConditionUpdateObserver, [{
+    key: "groupChanges",
+    value: function groupChanges() {
+      this.grouping = true;
+    }
+
+    /**
+     * Flush all collected changes. This trigger `update` hook for every previously collected change from condition collection.
+     */
+  }, {
+    key: "flush",
+    value: function flush() {
+      var _this2 = this;
+      this.grouping = false;
+      (0, _array.arrayEach)(this.changes, function (column) {
+        _this2.updateStatesAtColumn(column);
+      });
+      this.changes.length = 0;
+    }
+
+    /**
+     * On before modify condition (add or remove from collection),.
+     *
+     * @param {number} column Column index.
+     * @private
+     */
+  }, {
+    key: "_onConditionBeforeModify",
+    value: function _onConditionBeforeModify(column) {
+      this.latestEditedColumnPosition = this.conditionCollection.getColumnStackPosition(column);
+    }
+
+    /**
+     * Update all related states which should be changed after invoking changes applied to current column.
+     *
+     * @param {number} column The column index.
+     * @param {object} conditionArgsChange Object describing condition changes which can be handled by filters on `update` hook.
+     * It contains keys `conditionKey` and `conditionValue` which refers to change specified key of condition to specified value
+     * based on referred keys.
+     */
+  }, {
+    key: "updateStatesAtColumn",
+    value: function updateStatesAtColumn(column, conditionArgsChange) {
+      var _this3 = this;
+      if (this.grouping) {
+        if (this.changes.indexOf(column) === -1) {
+          this.changes.push(column);
+        }
+        return;
+      }
+      var allConditions = this.conditionCollection.exportAllConditions();
+      var editedColumnPosition = this.conditionCollection.getColumnStackPosition(column);
+      if (editedColumnPosition === -1) {
+        editedColumnPosition = this.latestEditedColumnPosition;
+      }
+
+      // Collection of all conditions defined before currently edited `column` (without edited one)
+      var conditionsBefore = allConditions.slice(0, editedColumnPosition);
+      // Collection of all conditions defined after currently edited `column` (with edited one)
+      var conditionsAfter = allConditions.slice(editedColumnPosition);
+
+      // Make sure that conditionAfter doesn't contain edited column conditions
+      if (conditionsAfter.length && conditionsAfter[0].column === column) {
+        conditionsAfter.shift();
+      }
+      var visibleDataFactory = (0, _function.curry)(function (curriedConditionsBefore, curriedColumn) {
+        var conditionsStack = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+        var splitConditionCollection = new _conditionCollection.default(_this3.hot, false);
+        var curriedConditionsBeforeArray = [].concat(curriedConditionsBefore, conditionsStack);
+
+        // Create new condition collection to determine what rows should be visible in "filter by value" box
+        // in the next conditions in the chain
+        splitConditionCollection.importAllConditions(curriedConditionsBeforeArray);
+        var allRows = _this3.columnDataFactory(curriedColumn);
+        var visibleRows;
+        if (splitConditionCollection.isEmpty()) {
+          visibleRows = allRows;
+        } else {
+          visibleRows = new _dataFilter.default(splitConditionCollection, function (columnData) {
+            return _this3.columnDataFactory(columnData);
+          }).filter();
+        }
+        visibleRows = (0, _array.arrayMap)(visibleRows, function (rowData) {
+          return rowData.meta.visualRow;
+        });
+        var visibleRowsAssertion = (0, _utils.createArrayAssertion)(visibleRows);
+        splitConditionCollection.destroy();
+        return (0, _array.arrayFilter)(allRows, function (rowData) {
+          return visibleRowsAssertion(rowData.meta.visualRow);
+        });
+      })(conditionsBefore);
+      var editedConditions = [].concat(this.conditionCollection.getConditions(column));
+      this.runLocalHooks('update', {
+        editedConditionStack: {
+          column: column,
+          conditions: editedConditions
+        },
+        dependentConditionStacks: conditionsAfter,
+        filteredRowsFactory: visibleDataFactory,
+        conditionArgsChange: conditionArgsChange
+      });
+    }
+
+    /**
+     * On before conditions clean listener.
+     *
+     * @private
+     */
+  }, {
+    key: "_onConditionBeforeClean",
+    value: function _onConditionBeforeClean() {
+      this.latestOrderStack = this.conditionCollection.getFilteredColumns();
+    }
+
+    /**
+     * On after conditions clean listener.
+     *
+     * @private
+     */
+  }, {
+    key: "_onConditionAfterClean",
+    value: function _onConditionAfterClean() {
+      var _this4 = this;
+      (0, _array.arrayEach)(this.latestOrderStack, function (column) {
+        _this4.updateStatesAtColumn(column);
+      });
+    }
+
+    /**
+     * Destroy instance.
+     */
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      var _this5 = this;
+      this.clearLocalHooks();
+      (0, _object.objectEach)(this, function (value, property) {
+        _this5[property] = null;
+      });
+    }
+  }]);
+  return ConditionUpdateObserver;
+}();
+(0, _object.mixin)(ConditionUpdateObserver, _localHooks.default);
+var _default = ConditionUpdateObserver;
+exports.default = _default;

package/plugins/filters/conditionUpdateObserver.mjs

@@ -0,0 +1,242 @@
+import "core-js/modules/es.array.index-of.js";
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.array.concat.js";
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.object.to-string.js";
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+import { arrayEach, arrayMap, arrayFilter } from "../../helpers/array.mjs";
+import { mixin, objectEach } from "../../helpers/object.mjs";
+import { curry } from "../../helpers/function.mjs";
+import localHooks from "../../mixins/localHooks.mjs";
+import ConditionCollection from "./conditionCollection.mjs";
+import DataFilter from "./dataFilter.mjs";
+import { createArrayAssertion } from "./utils.mjs";
+/**
+ * Class which is designed for observing changes in condition collection. When condition is changed by user at specified
+ * column it's necessary to update all conditions defined after this edited one.
+ *
+ * Object fires `update` hook for every column conditions change.
+ *
+ * @private
+ * @class ConditionUpdateObserver
+ */
+var ConditionUpdateObserver = /*#__PURE__*/function () {
+  function ConditionUpdateObserver(hot, conditionCollection) {
+    var _this = this;
+    var columnDataFactory = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {
+      return [];
+    };
+    _classCallCheck(this, ConditionUpdateObserver);
+    /**
+     * Handsontable instance.
+     *
+     * @type {Core}
+     */
+    this.hot = hot;
+    /**
+     * Reference to the instance of {@link ConditionCollection}.
+     *
+     * @type {ConditionCollection}
+     */
+    this.conditionCollection = conditionCollection;
+    /**
+     * Function which provide source data factory for specified column.
+     *
+     * @type {Function}
+     */
+    this.columnDataFactory = columnDataFactory;
+    /**
+     * Collected changes when grouping is enabled.
+     *
+     * @type {Array}
+     * @default []
+     */
+    this.changes = [];
+    /**
+     * Flag which determines if grouping events is enabled.
+     *
+     * @type {boolean}
+     */
+    this.grouping = false;
+    /**
+     * The latest known position of edited conditions at specified column index.
+     *
+     * @type {number}
+     * @default -1
+     */
+    this.latestEditedColumnPosition = -1;
+    /**
+     * The latest known order of conditions stack.
+     *
+     * @type {Array}
+     */
+    this.latestOrderStack = [];
+    this.conditionCollection.addLocalHook('beforeRemove', function (column) {
+      return _this._onConditionBeforeModify(column);
+    });
+    this.conditionCollection.addLocalHook('afterRemove', function (column) {
+      return _this.updateStatesAtColumn(column);
+    });
+    this.conditionCollection.addLocalHook('afterAdd', function (column) {
+      return _this.updateStatesAtColumn(column);
+    });
+    this.conditionCollection.addLocalHook('beforeClean', function () {
+      return _this._onConditionBeforeClean();
+    });
+    this.conditionCollection.addLocalHook('afterClean', function () {
+      return _this._onConditionAfterClean();
+    });
+  }
+
+  /**
+   * Enable grouping changes. Grouping is helpful in situations when a lot of conditions is added in one moment. Instead of
+   * trigger `update` hook for every condition by adding/removing you can group this changes and call `flush` method to trigger
+   * it once.
+   */
+  _createClass(ConditionUpdateObserver, [{
+    key: "groupChanges",
+    value: function groupChanges() {
+      this.grouping = true;
+    }
+
+    /**
+     * Flush all collected changes. This trigger `update` hook for every previously collected change from condition collection.
+     */
+  }, {
+    key: "flush",
+    value: function flush() {
+      var _this2 = this;
+      this.grouping = false;
+      arrayEach(this.changes, function (column) {
+        _this2.updateStatesAtColumn(column);
+      });
+      this.changes.length = 0;
+    }
+
+    /**
+     * On before modify condition (add or remove from collection),.
+     *
+     * @param {number} column Column index.
+     * @private
+     */
+  }, {
+    key: "_onConditionBeforeModify",
+    value: function _onConditionBeforeModify(column) {
+      this.latestEditedColumnPosition = this.conditionCollection.getColumnStackPosition(column);
+    }
+
+    /**
+     * Update all related states which should be changed after invoking changes applied to current column.
+     *
+     * @param {number} column The column index.
+     * @param {object} conditionArgsChange Object describing condition changes which can be handled by filters on `update` hook.
+     * It contains keys `conditionKey` and `conditionValue` which refers to change specified key of condition to specified value
+     * based on referred keys.
+     */
+  }, {
+    key: "updateStatesAtColumn",
+    value: function updateStatesAtColumn(column, conditionArgsChange) {
+      var _this3 = this;
+      if (this.grouping) {
+        if (this.changes.indexOf(column) === -1) {
+          this.changes.push(column);
+        }
+        return;
+      }
+      var allConditions = this.conditionCollection.exportAllConditions();
+      var editedColumnPosition = this.conditionCollection.getColumnStackPosition(column);
+      if (editedColumnPosition === -1) {
+        editedColumnPosition = this.latestEditedColumnPosition;
+      }
+
+      // Collection of all conditions defined before currently edited `column` (without edited one)
+      var conditionsBefore = allConditions.slice(0, editedColumnPosition);
+      // Collection of all conditions defined after currently edited `column` (with edited one)
+      var conditionsAfter = allConditions.slice(editedColumnPosition);
+
+      // Make sure that conditionAfter doesn't contain edited column conditions
+      if (conditionsAfter.length && conditionsAfter[0].column === column) {
+        conditionsAfter.shift();
+      }
+      var visibleDataFactory = curry(function (curriedConditionsBefore, curriedColumn) {
+        var conditionsStack = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+        var splitConditionCollection = new ConditionCollection(_this3.hot, false);
+        var curriedConditionsBeforeArray = [].concat(curriedConditionsBefore, conditionsStack);
+
+        // Create new condition collection to determine what rows should be visible in "filter by value" box
+        // in the next conditions in the chain
+        splitConditionCollection.importAllConditions(curriedConditionsBeforeArray);
+        var allRows = _this3.columnDataFactory(curriedColumn);
+        var visibleRows;
+        if (splitConditionCollection.isEmpty()) {
+          visibleRows = allRows;
+        } else {
+          visibleRows = new DataFilter(splitConditionCollection, function (columnData) {
+            return _this3.columnDataFactory(columnData);
+          }).filter();
+        }
+        visibleRows = arrayMap(visibleRows, function (rowData) {
+          return rowData.meta.visualRow;
+        });
+        var visibleRowsAssertion = createArrayAssertion(visibleRows);
+        splitConditionCollection.destroy();
+        return arrayFilter(allRows, function (rowData) {
+          return visibleRowsAssertion(rowData.meta.visualRow);
+        });
+      })(conditionsBefore);
+      var editedConditions = [].concat(this.conditionCollection.getConditions(column));
+      this.runLocalHooks('update', {
+        editedConditionStack: {
+          column: column,
+          conditions: editedConditions
+        },
+        dependentConditionStacks: conditionsAfter,
+        filteredRowsFactory: visibleDataFactory,
+        conditionArgsChange: conditionArgsChange
+      });
+    }
+
+    /**
+     * On before conditions clean listener.
+     *
+     * @private
+     */
+  }, {
+    key: "_onConditionBeforeClean",
+    value: function _onConditionBeforeClean() {
+      this.latestOrderStack = this.conditionCollection.getFilteredColumns();
+    }
+
+    /**
+     * On after conditions clean listener.
+     *
+     * @private
+     */
+  }, {
+    key: "_onConditionAfterClean",
+    value: function _onConditionAfterClean() {
+      var _this4 = this;
+      arrayEach(this.latestOrderStack, function (column) {
+        _this4.updateStatesAtColumn(column);
+      });
+    }
+
+    /**
+     * Destroy instance.
+     */
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      var _this5 = this;
+      this.clearLocalHooks();
+      objectEach(this, function (value, property) {
+        _this5[property] = null;
+      });
+    }
+  }]);
+  return ConditionUpdateObserver;
+}();
+mixin(ConditionUpdateObserver, localHooks);
+export default ConditionUpdateObserver;

package/plugins/filters/constants.js

@@ -0,0 +1,103 @@
+"use strict";
+
+exports.__esModule = true;
+exports.TYPE_TEXT = exports.TYPE_NUMERIC = exports.TYPE_DATE = exports.TYPES = void 0;
+exports.default = getOptionsList;
+var _object = require("../../helpers/object");
+var _array = require("../../helpers/array");
+var _predefinedItems = require("../contextMenu/predefinedItems");
+var _conditionRegisterer = require("./conditionRegisterer");
+var _none = require("./condition/none");
+exports.CONDITION_NONE = _none.CONDITION_NAME;
+var _empty = require("./condition/empty");
+exports.CONDITION_EMPTY = _empty.CONDITION_NAME;
+var _notEmpty = require("./condition/notEmpty");
+exports.CONDITION_NOT_EMPTY = _notEmpty.CONDITION_NAME;
+var _equal = require("./condition/equal");
+exports.CONDITION_EQUAL = _equal.CONDITION_NAME;
+var _notEqual = require("./condition/notEqual");
+exports.CONDITION_NOT_EQUAL = _notEqual.CONDITION_NAME;
+var _greaterThan = require("./condition/greaterThan");
+exports.CONDITION_GREATER_THAN = _greaterThan.CONDITION_NAME;
+var _greaterThanOrEqual = require("./condition/greaterThanOrEqual");
+exports.CONDITION_GREATER_THAN_OR_EQUAL = _greaterThanOrEqual.CONDITION_NAME;
+var _lessThan = require("./condition/lessThan");
+exports.CONDITION_LESS_THAN = _lessThan.CONDITION_NAME;
+var _lessThanOrEqual = require("./condition/lessThanOrEqual");
+exports.CONDITION_LESS_THAN_OR_EQUAL = _lessThanOrEqual.CONDITION_NAME;
+var _between = require("./condition/between");
+exports.CONDITION_BETWEEN = _between.CONDITION_NAME;
+var _notBetween = require("./condition/notBetween");
+exports.CONDITION_NOT_BETWEEN = _notBetween.CONDITION_NAME;
+var _beginsWith = require("./condition/beginsWith");
+exports.CONDITION_BEGINS_WITH = _beginsWith.CONDITION_NAME;
+var _endsWith = require("./condition/endsWith");
+exports.CONDITION_ENDS_WITH = _endsWith.CONDITION_NAME;
+var _contains = require("./condition/contains");
+exports.CONDITION_CONTAINS = _contains.CONDITION_NAME;
+var _notContains = require("./condition/notContains");
+exports.CONDITION_NOT_CONTAINS = _notContains.CONDITION_NAME;
+var _before = require("./condition/date/before");
+exports.CONDITION_DATE_BEFORE = _before.CONDITION_NAME;
+var _after = require("./condition/date/after");
+exports.CONDITION_DATE_AFTER = _after.CONDITION_NAME;
+var _tomorrow = require("./condition/date/tomorrow");
+exports.CONDITION_TOMORROW = _tomorrow.CONDITION_NAME;
+var _today = require("./condition/date/today");
+exports.CONDITION_TODAY = _today.CONDITION_NAME;
+var _yesterday = require("./condition/date/yesterday");
+exports.CONDITION_YESTERDAY = _yesterday.CONDITION_NAME;
+var _byValue = require("./condition/byValue");
+exports.CONDITION_BY_VALUE = _byValue.CONDITION_NAME;
+var _true = require("./condition/true");
+exports.CONDITION_TRUE = _true.CONDITION_NAME;
+var _false = require("./condition/false");
+exports.CONDITION_FALSE = _false.CONDITION_NAME;
+var _conjunction = require("./logicalOperations/conjunction");
+exports.OPERATION_AND = _conjunction.OPERATION_ID;
+var _disjunction = require("./logicalOperations/disjunction");
+exports.OPERATION_OR = _disjunction.OPERATION_ID;
+var _disjunctionWithExtraCondition = require("./logicalOperations/disjunctionWithExtraCondition");
+exports.OPERATION_OR_THEN_VARIABLE = _disjunctionWithExtraCondition.OPERATION_ID;
+var _TYPES;
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+var TYPE_NUMERIC = 'numeric';
+exports.TYPE_NUMERIC = TYPE_NUMERIC;
+var TYPE_TEXT = 'text';
+exports.TYPE_TEXT = TYPE_TEXT;
+var TYPE_DATE = 'date';
+/**
+ * Default types and order for filter conditions.
+ *
+ * @type {object}
+ */
+exports.TYPE_DATE = TYPE_DATE;
+var TYPES = (_TYPES = {}, _defineProperty(_TYPES, TYPE_NUMERIC, [_none.CONDITION_NAME, _predefinedItems.SEPARATOR, _empty.CONDITION_NAME, _notEmpty.CONDITION_NAME, _predefinedItems.SEPARATOR, _equal.CONDITION_NAME, _notEqual.CONDITION_NAME, _predefinedItems.SEPARATOR, _greaterThan.CONDITION_NAME, _greaterThanOrEqual.CONDITION_NAME, _lessThan.CONDITION_NAME, _lessThanOrEqual.CONDITION_NAME, _between.CONDITION_NAME, _notBetween.CONDITION_NAME]), _defineProperty(_TYPES, TYPE_TEXT, [_none.CONDITION_NAME, _predefinedItems.SEPARATOR, _empty.CONDITION_NAME, _notEmpty.CONDITION_NAME, _predefinedItems.SEPARATOR, _equal.CONDITION_NAME, _notEqual.CONDITION_NAME, _predefinedItems.SEPARATOR, _beginsWith.CONDITION_NAME, _endsWith.CONDITION_NAME, _predefinedItems.SEPARATOR, _contains.CONDITION_NAME, _notContains.CONDITION_NAME]), _defineProperty(_TYPES, TYPE_DATE, [_none.CONDITION_NAME, _predefinedItems.SEPARATOR, _empty.CONDITION_NAME, _notEmpty.CONDITION_NAME, _predefinedItems.SEPARATOR, _equal.CONDITION_NAME, _notEqual.CONDITION_NAME, _predefinedItems.SEPARATOR, _before.CONDITION_NAME, _after.CONDITION_NAME, _between.CONDITION_NAME, _predefinedItems.SEPARATOR, _tomorrow.CONDITION_NAME, _today.CONDITION_NAME, _yesterday.CONDITION_NAME]), _TYPES);
+
+/**
+ * Get options list for conditional filter by data type (e.q: `'text'`, `'numeric'`, `'date'`).
+ *
+ * @private
+ * @param {string} type The data type.
+ * @returns {object}
+ */
+exports.TYPES = TYPES;
+function getOptionsList(type) {
+  var items = [];
+  var typeName = type;
+  if (!TYPES[typeName]) {
+    typeName = TYPE_TEXT;
+  }
+  (0, _array.arrayEach)(TYPES[typeName], function (typeValue) {
+    var option;
+    if (typeValue === _predefinedItems.SEPARATOR) {
+      option = {
+        name: _predefinedItems.SEPARATOR
+      };
+    } else {
+      option = (0, _object.clone)((0, _conditionRegisterer.getConditionDescriptor)(typeValue));
+    }
+    items.push(option);
+  });
+  return items;
+}

package/plugins/filters/constants.mjs

@@ -0,0 +1,69 @@
+var _TYPES;
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+import { clone } from "../../helpers/object.mjs";
+import { arrayEach } from "../../helpers/array.mjs";
+import { SEPARATOR } from "../contextMenu/predefinedItems.mjs";
+import { getConditionDescriptor } from "./conditionRegisterer.mjs";
+import { CONDITION_NAME as CONDITION_NONE } from "./condition/none.mjs";
+import { CONDITION_NAME as CONDITION_EMPTY } from "./condition/empty.mjs";
+import { CONDITION_NAME as CONDITION_NOT_EMPTY } from "./condition/notEmpty.mjs";
+import { CONDITION_NAME as CONDITION_EQUAL } from "./condition/equal.mjs";
+import { CONDITION_NAME as CONDITION_NOT_EQUAL } from "./condition/notEqual.mjs";
+import { CONDITION_NAME as CONDITION_GREATER_THAN } from "./condition/greaterThan.mjs";
+import { CONDITION_NAME as CONDITION_GREATER_THAN_OR_EQUAL } from "./condition/greaterThanOrEqual.mjs";
+import { CONDITION_NAME as CONDITION_LESS_THAN } from "./condition/lessThan.mjs";
+import { CONDITION_NAME as CONDITION_LESS_THAN_OR_EQUAL } from "./condition/lessThanOrEqual.mjs";
+import { CONDITION_NAME as CONDITION_BETWEEN } from "./condition/between.mjs";
+import { CONDITION_NAME as CONDITION_NOT_BETWEEN } from "./condition/notBetween.mjs";
+import { CONDITION_NAME as CONDITION_BEGINS_WITH } from "./condition/beginsWith.mjs";
+import { CONDITION_NAME as CONDITION_ENDS_WITH } from "./condition/endsWith.mjs";
+import { CONDITION_NAME as CONDITION_CONTAINS } from "./condition/contains.mjs";
+import { CONDITION_NAME as CONDITION_NOT_CONTAINS } from "./condition/notContains.mjs";
+import { CONDITION_NAME as CONDITION_DATE_BEFORE } from "./condition/date/before.mjs";
+import { CONDITION_NAME as CONDITION_DATE_AFTER } from "./condition/date/after.mjs";
+import { CONDITION_NAME as CONDITION_TOMORROW } from "./condition/date/tomorrow.mjs";
+import { CONDITION_NAME as CONDITION_TODAY } from "./condition/date/today.mjs";
+import { CONDITION_NAME as CONDITION_YESTERDAY } from "./condition/date/yesterday.mjs";
+import { CONDITION_NAME as CONDITION_BY_VALUE } from "./condition/byValue.mjs";
+import { CONDITION_NAME as CONDITION_TRUE } from "./condition/true.mjs";
+import { CONDITION_NAME as CONDITION_FALSE } from "./condition/false.mjs";
+import { OPERATION_ID as OPERATION_AND } from "./logicalOperations/conjunction.mjs";
+import { OPERATION_ID as OPERATION_OR } from "./logicalOperations/disjunction.mjs";
+import { OPERATION_ID as OPERATION_OR_THEN_VARIABLE } from "./logicalOperations/disjunctionWithExtraCondition.mjs";
+export { CONDITION_NONE, CONDITION_EMPTY, CONDITION_NOT_EMPTY, CONDITION_EQUAL, CONDITION_NOT_EQUAL, CONDITION_GREATER_THAN, CONDITION_GREATER_THAN_OR_EQUAL, CONDITION_LESS_THAN, CONDITION_LESS_THAN_OR_EQUAL, CONDITION_BETWEEN, CONDITION_NOT_BETWEEN, CONDITION_BEGINS_WITH, CONDITION_ENDS_WITH, CONDITION_CONTAINS, CONDITION_NOT_CONTAINS, CONDITION_DATE_BEFORE, CONDITION_DATE_AFTER, CONDITION_TOMORROW, CONDITION_TODAY, CONDITION_YESTERDAY, CONDITION_BY_VALUE, CONDITION_TRUE, CONDITION_FALSE, OPERATION_AND, OPERATION_OR, OPERATION_OR_THEN_VARIABLE };
+export var TYPE_NUMERIC = 'numeric';
+export var TYPE_TEXT = 'text';
+export var TYPE_DATE = 'date';
+/**
+ * Default types and order for filter conditions.
+ *
+ * @type {object}
+ */
+export var TYPES = (_TYPES = {}, _defineProperty(_TYPES, TYPE_NUMERIC, [CONDITION_NONE, SEPARATOR, CONDITION_EMPTY, CONDITION_NOT_EMPTY, SEPARATOR, CONDITION_EQUAL, CONDITION_NOT_EQUAL, SEPARATOR, CONDITION_GREATER_THAN, CONDITION_GREATER_THAN_OR_EQUAL, CONDITION_LESS_THAN, CONDITION_LESS_THAN_OR_EQUAL, CONDITION_BETWEEN, CONDITION_NOT_BETWEEN]), _defineProperty(_TYPES, TYPE_TEXT, [CONDITION_NONE, SEPARATOR, CONDITION_EMPTY, CONDITION_NOT_EMPTY, SEPARATOR, CONDITION_EQUAL, CONDITION_NOT_EQUAL, SEPARATOR, CONDITION_BEGINS_WITH, CONDITION_ENDS_WITH, SEPARATOR, CONDITION_CONTAINS, CONDITION_NOT_CONTAINS]), _defineProperty(_TYPES, TYPE_DATE, [CONDITION_NONE, SEPARATOR, CONDITION_EMPTY, CONDITION_NOT_EMPTY, SEPARATOR, CONDITION_EQUAL, CONDITION_NOT_EQUAL, SEPARATOR, CONDITION_DATE_BEFORE, CONDITION_DATE_AFTER, CONDITION_BETWEEN, SEPARATOR, CONDITION_TOMORROW, CONDITION_TODAY, CONDITION_YESTERDAY]), _TYPES);
+
+/**
+ * Get options list for conditional filter by data type (e.q: `'text'`, `'numeric'`, `'date'`).
+ *
+ * @private
+ * @param {string} type The data type.
+ * @returns {object}
+ */
+export default function getOptionsList(type) {
+  var items = [];
+  var typeName = type;
+  if (!TYPES[typeName]) {
+    typeName = TYPE_TEXT;
+  }
+  arrayEach(TYPES[typeName], function (typeValue) {
+    var option;
+    if (typeValue === SEPARATOR) {
+      option = {
+        name: SEPARATOR
+      };
+    } else {
+      option = clone(getConditionDescriptor(typeValue));
+    }
+    items.push(option);
+  });
+  return items;
+}