@refinitiv-ui/efx-grid 6.0.0-next.0

package/lib/tr-grid-row-filtering/es6/RowFiltering.js

@@ -0,0 +1,1884 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+import { Ext } from '../../tr-grid-util/es6/Ext.js';
+import { GridPlugin } from '../../tr-grid-util/es6/GridPlugin.js';
+import { FilterBuilder } from '../../tr-grid-util/es6/FilterBuilder.js';
+import { ElfUtil } from '../../tr-grid-util/es6/ElfUtil.js';
+/** @event RowFilteringPlugin#click
+* @description click event is dispatched when a user clicks the column filter icon.
+*/
+
+/** @event RowFilteringPlugin#iconCreated
+* @description iconCreated event is dispatched when a new column filter icon is created.
+* @property {Element} icon Filter icon element
+* @property {number} colIndex Column index
+* @property {Object} grid Core grid instance
+*/
+
+/** @event RowFilteringPlugin#filterChanged
+* @description Fired whenever global or column filter is changed by either adding or removing. The change will not immediately applied to grid's data view
+* @property {string} filterType This can be either "global" or "column"
+* @property {string} changeType This can be either "add" or "remove"
+* @property {number} colIndex Column index
+* @property {string} field specified by the current column
+*/
+
+/** @event RowFilteringPlugin#refreshed
+* @description Fired after new filter is applied to grid's data view
+*/
+
+/** @callback RowFilteringPlugin~FilterLogic
+* @description Logic used to filter in or out on each row
+* @param {Object.<string, *>} rowData Row data is an object with field as key and user data as value
+* @param {string} rid Row Id used in DataView
+* @param {*} ctx Context object contains context/states given by user
+* @return {boolean}
+*/
+
+/** @typedef {*} RowFilteringPlugin~Expression
+* @description An expression that can be parsed into RowFilteringPlugin~FilterLogic. The expression is intended for saving and restoring filters, so it is serializable by JSON.stringify.
+The expression can take various forms:<br>
+* 1. String for free style text input e.g., "[col1] > 10", "[field] == 20"<br>
+* 2. 2D-Array for predefined filter operators e.g., [["GT", 10, "AND"], ["EQ", "text"]]<br>
+* 3. Object map for value filters e.g., {"value": true, "10": true}<br>
+* 4. Function for RowFilteringPlugin~FilterLogic
+*/
+
+/** @typedef {Object} RowFilteringPlugin~FilterExpression
+* @description FilterExpression contains all data used for saving and restoring filter in a column
+* @property {string} field
+* @property {RowFilteringPlugin~Expression} expression Expression representing filter function
+* @property {*} context Context object contains context/states given by user
+*/
+
+/** @typedef {Object} RowFilteringPlugin~ColumnOptions
+* @description Extension column options that can be specified on each individual grid's column option:
+* @property {RowFilteringPlugin~Expression=} filter An expression string or Function
+* @property {*=} filterState Context object that will be passed as the third parameter for the filter logic
+*/
+
+/** @typedef {Object} RowFilteringPlugin~FilterDialogOptions
+* @description Options that specific UI of filter dialog
+* @property {boolean=} sortUI show/hide sort UI
+* @property {boolean=} filterUI show/hide filter UI
+* @property {string=} fieldDataType data type of column
+* @property {string=} lang dialog language
+* @property {Function=} rawDataAccessor In case you have custom data type for the specified field, data getter is needed to retrieve raw value for filtering
+* @property {Function=} formattedDataAccessor In case you have custom data type for the specified field, data getter is needed to retrieve formatted value for display
+* @property {Function=} sortLogic sorting function for sort autosuggest list in filter dialog, the values for comparison are raw value not a formatted value
+*/
+
+/** @typedef {Object} RowFilteringPlugin~Options
+* @description The options can be specified by `rowFiltering` property of the main grid's options
+* @property {boolean=} disabledUI=false If enabled, filter icon will not be created/shown.
+* @property {Function=} click=null Event handler dispatched when a user clicks the column filter icon.
+* @property {Function=} clicked=null Alias to `click` event handler
+* @property {Function=} iconCreated=null Event handler dispatched when a new column filter icon is created.
+* @property {Function=} filterChanged=null Event handler dispatched whenever global or column filter is changed by either adding or removing.
+*/
+
+/** @private
+* @function
+* @param {Object} cfo
+* @return {!RowFilteringPlugin~FilterExpression}
+*/
+
+var toFilterExpression = function toFilterExpression(cfo) {
+  var ctx = cfo._context[0]; // TODO: Handle rawDataAccessor and formattedDataAccessor (saving and loading of functions)
+
+  return {
+    field: cfo._field || "",
+    expression: cfo._expressions[0],
+    context: ctx != null && !ctx._autoGenerated ? ctx : null
+  };
+};
+/** @constructor
+* @extends {GridPlugin}
+*/
+
+
+var RowFilteringPlugin = function RowFilteringPlugin() {
+  var t = this;
+  t._onPreSectionRender = t._onPreSectionRender.bind(t);
+  t._onColumnAdded = t._onColumnAdded.bind(t);
+  t._onColumnRemoved = t._onColumnRemoved.bind(t);
+  t._onIconClick = t._onIconClick.bind(t);
+  t._filterLogic = t._filterLogic.bind(t);
+  t._updateAllColumnIcons = t._updateAllColumnIcons.bind(t);
+  t.refresh = t.refresh.bind(t);
+  t._requestFilterRefresh = t._requestFilterRefresh.bind(t);
+  t._globalFilters = [];
+  t._globalContexts = [];
+  t._columnFilters = [];
+  t._hosts = [];
+  t._dvs = [];
+  t._funcMap = {};
+  t._nameMap = {};
+};
+
+Ext.inherits(RowFilteringPlugin, GridPlugin);
+/** @type {!Object.<string, Function>}
+* @private
+*/
+
+RowFilteringPlugin.prototype._funcMap = null; // For preventing repetition of resolving the same expression
+
+/** @type {!Object.<string, Function>}
+* @private
+*/
+
+RowFilteringPlugin.prototype._nameMap; // Mapping name to filter function for referencing
+
+/** @type {boolean}
+* @private
+*/
+
+RowFilteringPlugin.prototype._disabled = false;
+/** @type {boolean}
+* @private
+*/
+
+RowFilteringPlugin.prototype._disabledUI = false;
+/** @type {Object.<string, boolean>}
+* @private
+*/
+
+RowFilteringPlugin.prototype._disablingIds = null; // For nested disabling
+
+/** @type {!Array.<Function>}
+* @private
+*/
+
+RowFilteringPlugin.prototype._globalFilters;
+/** @type {!Array.<Object>}
+* @private
+*/
+
+RowFilteringPlugin.prototype._globalContexts;
+/** @type {!Array.<Object>}
+* @private
+*/
+
+RowFilteringPlugin.prototype._columnFilters;
+/** @type {Array.<Object>}
+* @private
+*/
+
+RowFilteringPlugin.prototype._activeColFilters = null;
+/** @type {number}
+* @private
+*/
+
+RowFilteringPlugin.prototype._filterId = 0;
+/** @type {number}
+* @private
+*/
+
+RowFilteringPlugin.prototype._uiTimerId = 0;
+/** @type {number}
+* @private
+*/
+
+RowFilteringPlugin.prototype._dvTimerId = 0;
+/** @type {Function}
+* @private
+*/
+
+RowFilteringPlugin.prototype._overridingFilter = null;
+/** @type {Function}
+* @private
+*/
+
+RowFilteringPlugin.prototype._preTransform = null;
+/** @type {Function}
+* @private
+*/
+
+RowFilteringPlugin.prototype._rowTransform = null;
+/** @type {Element}
+* @private
+*/
+
+RowFilteringPlugin.prototype._filterDialog = null;
+/** @type {FilterBuilder}
+* @private
+*/
+
+RowFilteringPlugin._filterBuilder = null;
+/** Array of DataView objects
+* @type {!Array.<Object>}
+* @private
+*/
+
+RowFilteringPlugin.prototype._dvs;
+/** @public
+* @return {string}
+*/
+
+RowFilteringPlugin.prototype.getName = function () {
+  return "RowFilteringPlugin"; // Read Only
+};
+/** @public
+* @param {Object} host core grid instance
+* @param {Object=} options
+*/
+
+
+RowFilteringPlugin.prototype.initialize = function (host, options) {
+  if (this._hosts.indexOf(host) >= 0) {
+    return;
+  }
+
+  this._hosts.push(host);
+
+  host.unloadPlugin("ColumnFilterPlugin");
+  host.listen("preSectionRender", this._onPreSectionRender);
+  host.listen("postDataSourceChanged", this._requestFilterRefresh); // TODO: Check if this is necessary
+
+  host.listen("columnAdded", this._onColumnAdded);
+  host.listen("columnRemoved", this._onColumnRemoved);
+  this.config(options); // In case of lazy loading
+  // TODO
+};
+/** @public
+* @param {Object} host core grid instance
+*/
+
+
+RowFilteringPlugin.prototype.unload = function (host) {
+  var at = this._hosts.indexOf(host);
+
+  if (at < 0) {
+    return;
+  }
+
+  this._hosts.splice(at, 1);
+
+  host.unlisten("preSectionRender", this._onPreSectionRender);
+  host.unlisten("postDataSourceChanged", this._requestFilterRefresh);
+  host.unlisten("columnAdded", this._onColumnAdded);
+  host.unlisten("columnRemoved", this._onColumnRemoved);
+
+  this._dispose();
+};
+/** @public
+* @param {Object=} options
+*/
+
+
+RowFilteringPlugin.prototype.config = function (options) {
+  if (!options) {
+    return;
+  }
+
+  var rowFiltering = options["rowFiltering"];
+
+  if (rowFiltering) {
+    if (rowFiltering["disabledUI"] || rowFiltering["uiDisabled"]) {
+      this._disabledUI = true;
+    }
+
+    if (rowFiltering["clicked"]) {
+      rowFiltering["click"] = rowFiltering["clicked"];
+    }
+
+    this.addListener(rowFiltering, "click");
+    this.addListener(rowFiltering, "iconCreated");
+    this.addListener(rowFiltering, "filterChanged");
+    this.addListener(rowFiltering, "refreshed");
+  }
+
+  var columns = options["columns"];
+
+  if (!columns) {
+    return;
+  } // var host = this._hosts[0];
+
+
+  var len = columns.length;
+
+  for (var i = 0; i < len; ++i) {
+    var column = columns[i];
+
+    this._setColumnOptions(i, column);
+  }
+};
+/** @public
+* @param {Object=} gridOptions
+* @return {!Object}
+*/
+
+
+RowFilteringPlugin.prototype.getConfigObject = function (gridOptions) {
+  var obj = gridOptions || {};
+  var columns = obj.columns;
+
+  if (!columns) {
+    columns = obj.columns = [];
+  }
+
+  var len = this.getColumnCount();
+
+  for (var i = 0; i < len; ++i) {
+    var column = columns[i];
+
+    if (!column) {
+      column = columns[i] = {};
+    }
+
+    var colOptions = this._getColumnFilterOption(i);
+
+    if (colOptions) {
+      var exp = colOptions._expressions[0];
+
+      if (exp && typeof exp !== "function") {
+        // TODO: Accept function type
+        column.filter = exp; // This could be string, array, or object
+      }
+
+      var ctx = colOptions._context[0];
+
+      if (ctx != null) {
+        if (_typeof(ctx) !== "object" || !ctx._autoGenerated) {
+          column.filterState = ctx;
+        }
+      }
+    }
+  }
+
+  var extOptions = obj.rowFiltering;
+
+  if (!extOptions) {
+    extOptions = obj.rowFiltering = {};
+  }
+
+  extOptions.disabledUI = this._disabledUI;
+  return obj;
+};
+/** All filter logics in DataView will be temporarily removed until re-enabling. This is useful when trying to insert an item at the specified index. After re-enabling, both logics and icons will be restored.
+* @public
+* @param {boolean=} opt_disabled
+* @param {string=} opt_id For handling nested called
+*/
+
+
+RowFilteringPlugin.prototype.disable = function (opt_disabled, opt_id) {
+  var disabled = opt_disabled !== false;
+
+  if (!this._disablingIds) {
+    this._disablingIds = {};
+  }
+
+  if (!opt_id) {
+    opt_id = "_";
+  }
+
+  this._disablingIds[opt_id] = disabled;
+  disabled = false;
+
+  for (var key in this._disablingIds) {
+    // Find cumulative state
+    if (this._disablingIds[key]) {
+      disabled = true;
+      break;
+    }
+  }
+
+  if (this._disabled !== disabled) {
+    this._disabled = disabled;
+
+    if (disabled) {
+      this.refresh(); // Take an effect immediately
+
+      this._updateAllColumnIcons();
+    } else {
+      this._requestFilterRefresh(); // Take an effect later
+
+
+      this._setTimerForUpdatingIcons();
+    }
+  }
+};
+/** Add a global filter that is not related to any column. No filter icon is created in this way
+* @public
+* @param {RowFilteringPlugin~Expression} exp Expression or Function
+* @param {string=} funcName Optional function name for referencing the given function
+* @param {*=} ctx Context that will be passed as the third parameter for the filter logic
+* @return {string} If success, function name is returned, otherwise empty string
+* @fires RowFilteringPlugin#filterChanged
+*/
+
+
+RowFilteringPlugin.prototype.addFilter = function (exp, funcName, ctx) {
+  var func = this._parseFilter(exp, -1);
+
+  if (!func) {
+    return "";
+  }
+
+  if (!funcName) {
+    funcName = "_" + this._filterId++;
+  }
+
+  if (this._nameMap[funcName] || this._globalFilters.indexOf(func) >= 0) {
+    return ""; // Function is already exists
+  }
+
+  ctx = ctx != null ? ctx : null;
+  this._nameMap[funcName] = func;
+
+  this._globalFilters.push(func);
+
+  this._globalContexts.push(ctx);
+
+  this._dispatch("filterChanged", {
+    "filterType": "global",
+    "changeType": "add",
+    "colIndex": -1,
+    "field": null
+  });
+
+  this._requestFilterRefresh();
+
+  return funcName;
+};
+/** Add a global filter that is not related to any column. No filter icon is created in this way
+* @public
+* @param {RowFilteringPlugin~Expression} exp Expression or Function
+* @param {*=} ctx Context that will be passed as the third parameter for the filter logic
+* @return {string} If success, function name is returned, otherwise empty string
+* @fires RowFilteringPlugin#filterChanged
+*/
+
+
+RowFilteringPlugin.prototype.addGridFilter = function (exp, ctx) {
+  return this.addFilter(exp, null, ctx);
+};
+/** @private
+* @param {RowFilteringPlugin~Expression} exp
+* @param {number=} colIndex
+* @param {*=} ctx
+* @return {Function}
+*/
+
+
+RowFilteringPlugin.prototype._parseFilter = function (exp, colIndex, ctx) {
+  if (!exp) {
+    return null;
+  }
+
+  if (typeof exp === "function") {
+    return exp;
+  }
+
+  var filterBuilder = RowFilteringPlugin._getFilterBuilder();
+
+  var validIdx = colIndex || colIndex === 0;
+  var field = validIdx ? this._getField(colIndex) : "";
+  var formatter = validIdx ? this._getFormatter(colIndex) : null;
+  var func = null;
+
+  if (typeof exp === "string") {
+    // Free text does not need data accessors
+    func = this._funcMap[exp];
+
+    if (func == null) {
+      func = this._funcMap[exp] = filterBuilder.parse(exp, field, formatter, field);
+    }
+  } else {
+    var rawDataAccessor = null;
+    var formattedDataAccessor = null;
+
+    if (ctx) {
+      rawDataAccessor = ctx.rawDataAccessor || null;
+      formattedDataAccessor = ctx.formattedDataAccessor || null;
+    }
+
+    func = filterBuilder.parse(exp, field, formatter, field, rawDataAccessor, formattedDataAccessor);
+  }
+
+  return func;
+};
+/** If you want the column to always have one single filter, please use {@link RowFilteringPlugin#setColumnFilter} instead. This method allow a single column to have multiple filters.
+* @public
+* @param {number} colIndex
+* @param {RowFilteringPlugin~Expression} exp Expression can be string, Array, Object, or Function
+* @param {(Object|string)=} ctx Context object that will be passed as the third parameter for the filter logic
+* @return {boolean} True if success
+* @fires RowFilteringPlugin#filterChanged
+*/
+
+
+RowFilteringPlugin.prototype.addColumnFilter = function (colIndex, exp, ctx) {
+  var func = null;
+
+  if (typeof exp === "function") {
+    func =
+    /** @type{Function} */
+    exp;
+    exp = ctx && typeof ctx === "string" ? ctx : null; // for saving. TODO: Support saving for function type
+  } else {
+    func = this._parseFilter(exp, colIndex, ctx);
+  }
+
+  if (!func) {
+    return false;
+  }
+
+  if (ctx == null) {
+    ctx = {
+      "_autoGenerated": true
+    };
+  }
+
+  var field = this._getField(colIndex);
+
+  if (ctx && _typeof(ctx) === "object") {
+    ctx["field"] = field;
+  }
+
+  var cfo = this._initColumnFilterOption(colIndex);
+
+  cfo._field = field; // TODO: Handle fieldDataType
+
+  cfo._filters.push(func);
+
+  cfo._expressions.push(exp);
+
+  cfo._context.push(ctx);
+
+  cfo._rawDataAccessor = ctx.rawDataAccessor || null;
+  cfo._formattedDataAccessor = ctx.formattedDataAccessor || null;
+
+  this._columnFilters.push(cfo);
+
+  this._dispatch("filterChanged", {
+    "filterType": "column",
+    "changeType": "add",
+    "colIndex": colIndex,
+    "field": field
+  }); // UI
+
+
+  this._requestFilterRefresh();
+
+  this._updateColumnIcon(colIndex);
+
+  return true;
+};
+/** This method guarantees that the column can have at most one filter at the time. It performs {@link RowFilteringPlugin#removeColumnFilters} before {@link RowFilteringPlugin#addColumnFilter}
+* @public
+* @param {number} colIndex
+* @param {RowFilteringPlugin~Expression} exp Expression can be string, Array, Object, or Function
+* @param {(Object|string)=} ctx Context object that will be passed as the third parameter for the filter logic
+* @return {boolean} True If there is any change
+* @fires RowFilteringPlugin#filterChanged
+*/
+
+
+RowFilteringPlugin.prototype.setColumnFilter = function (colIndex, exp, ctx) {
+  var removed = this._removeColumnFilters(colIndex);
+
+  var added = this.addColumnFilter(colIndex, exp, ctx);
+
+  if (!added && removed) {
+    this._updateColumnIcon(colIndex);
+  }
+
+  return removed || added;
+};
+/** @private
+* @param {number} colIndex
+* @param {RowFilteringPlugin~ColumnOptions} columnOptions
+* @example
+* var colDef = {
+*   "filter": "gt♦0♣"
+* };
+* var colDef2 = {
+*   "filter": "[PCTCHNG] > 0"
+* };
+* var colDef3 = {
+*   "filter": function() { }
+* };
+*/
+
+
+RowFilteringPlugin.prototype._setColumnOptions = function (colIndex, columnOptions) {
+  var fieldDataType = columnOptions["fieldDataType"]; // TODO: This should not be set here
+
+  if (fieldDataType) {
+    var colOptions = this._newExtColumnOptions(colIndex);
+
+    colOptions.fieldDataType = fieldDataType; // TODO: This should not be set here
+  }
+
+  var exp = columnOptions["filter"];
+
+  if (exp) {
+    this.addColumnFilter(colIndex, exp, columnOptions["filterState"]);
+  }
+};
+/** @private
+ * @param {number} colIndex
+ * @return {Object|null}
+ */
+
+
+RowFilteringPlugin.prototype._getExtColumnOptions = function (colIndex) {
+  return this._getColumnOption(colIndex, "rowFiltering");
+};
+/** @private
+ * @param {number} colIndex
+ * @return {!Object} Newly created extension column option or the existing one
+ */
+
+
+RowFilteringPlugin.prototype._newExtColumnOptions = function (colIndex) {
+  var colDef = this._newColumnData(colIndex);
+
+  var colExtOptions = colDef["rowFiltering"];
+
+  if (!colExtOptions) {
+    colExtOptions = colDef["rowFiltering"] = {};
+  }
+
+  return colExtOptions;
+};
+/** @private
+* @param {number} colIndex
+* @return {Object|null}
+*/
+
+
+RowFilteringPlugin.prototype._getColumnFilterOption = function (colIndex) {
+  var colOptions = this._getExtColumnOptions(colIndex);
+
+  if (colOptions) {
+    return colOptions["filterOption"] || null;
+  } else {
+    return null;
+  }
+};
+/** @private
+* @param {number} colIndex
+* @param {Object} filterOption
+*/
+
+
+RowFilteringPlugin.prototype._setColumnFilterOption = function (colIndex, filterOption) {
+  var colOptions = this._newExtColumnOptions(colIndex);
+
+  if (filterOption) {
+    colOptions["filterOption"] = filterOption;
+  } else {
+    var cfo = colOptions["filterOption"];
+
+    if (cfo) {
+      colOptions["filterOption"] = null;
+
+      if (cfo._filters.length) {
+        this._dispatch("filterChanged", {
+          "filterType": "column",
+          "changeType": "remove",
+          "colIndex": colIndex,
+          "field": this._getField(colIndex)
+        });
+      }
+    }
+  }
+};
+/** @private
+* @param {number} colIndex
+* @return {!Object}
+*/
+
+
+RowFilteringPlugin.prototype._initColumnFilterOption = function (colIndex) {
+  var cfo = this._getColumnFilterOption(colIndex);
+
+  if (!cfo) {
+    cfo = {};
+    cfo._filters = [];
+    cfo._expressions = [];
+    cfo._context = [];
+
+    this._setColumnFilterOption(colIndex, cfo);
+  }
+
+  return cfo;
+};
+/** Remove the registered global filter. The column filter cannot be removed
+* @public
+* @param {Function|string} funcRef Function object or the function name can be used to remove
+* @return {boolean} True if success
+*/
+
+
+RowFilteringPlugin.prototype.removeFilter = function (funcRef) {
+  var func = null;
+  var funcName = "";
+  var funcIndex = -1;
+
+  if (typeof funcRef === "string") {
+    funcName =
+    /** @type{string} */
+    funcRef;
+    func = this._nameMap[funcRef];
+    funcIndex = this._globalFilters.indexOf(func);
+  } else {
+    func =
+    /** @type{Function} */
+    funcRef;
+    funcIndex = this._globalFilters.indexOf(func);
+
+    if (funcIndex >= 0) {
+      for (var key in this._nameMap) {
+        if (this._nameMap[key] === func) {
+          funcName = key;
+        }
+      }
+    }
+  }
+
+  if (funcIndex < 0) {
+    return false;
+  }
+
+  delete this._nameMap[funcName];
+
+  this._globalFilters.splice(funcIndex, 1);
+
+  this._globalContexts.splice(funcIndex, 1);
+
+  this._requestFilterRefresh();
+
+  return true;
+};
+/** Remove all filters in from the specified column
+* @public
+* @param {number} colIndex
+* @return {boolean} True if there is any change
+*/
+
+
+RowFilteringPlugin.prototype.removeColumnFilters = function (colIndex) {
+  if (colIndex == null) {
+    // Prevent user mistake
+    return this.removeAllColumnFilters();
+  }
+
+  var dirty = this._removeColumnFilters(colIndex);
+
+  if (dirty) {
+    this._updateColumnIcon(colIndex);
+  }
+
+  return dirty;
+};
+/** @private
+* @param {number} colIndex
+* @return {boolean} True if there is any change
+*/
+
+
+RowFilteringPlugin.prototype._removeColumnFilters = function (colIndex) {
+  var cfo = this._getColumnFilterOption(colIndex);
+
+  if (cfo) {
+    var funcIndex = this._columnFilters.indexOf(cfo);
+
+    if (funcIndex >= 0) {
+      this._columnFilters.splice(funcIndex, 1);
+    }
+
+    this._setColumnFilterOption(colIndex, null); // filterChanged fired
+
+
+    var inputExt = this._getPlugin('FilterInputPlugin'); // TODO: Use the event instead
+
+
+    inputExt && inputExt.updateUI(colIndex, '');
+
+    this._requestFilterRefresh();
+  }
+
+  return cfo ? true : false;
+};
+/** Alias to {@link RowFilteringPlugin#removeColumnFilters} Remove all filters from the specified column
+* @public
+* @function
+* @param {number} colIndex
+* @return {boolean} True if there is any change
+*/
+
+
+RowFilteringPlugin.prototype.removeColumnFilter = RowFilteringPlugin.prototype.removeColumnFilters;
+/** Remove all column filters from all columns, excluding global filters
+* @public
+* @return {boolean} Return true if there is any change
+*/
+
+RowFilteringPlugin.prototype.removeAllColumnFilters = function () {
+  if (this._columnFilters.length) {
+    this._columnFilters.length = 0;
+
+    var inputExt = this._getPlugin('FilterInputPlugin');
+
+    var colCount = this._getColumnCount();
+
+    for (var i = 0; i < colCount; ++i) {
+      this._setColumnFilterOption(i, null); // filterChanged fired
+
+
+      inputExt && inputExt.updateUI(i, ''); // TODO: Use the event instead
+    }
+
+    this._updateAllColumnIcons();
+
+    this._requestFilterRefresh();
+
+    return true;
+  }
+
+  return false;
+};
+/** Remove all column and global filters. OverridingFilters are not removed by this method
+* @public
+*/
+
+
+RowFilteringPlugin.prototype.removeAllFilters = function () {
+  var totalFilter = this._globalFilters.length + this._columnFilters.length;
+
+  if (totalFilter <= 0) {
+    return;
+  }
+
+  if (this._globalFilters.length) {
+    this._globalFilters.length = 0;
+    this._nameMap = {};
+
+    this._dispatch("filterChanged", {
+      "filterType": "global",
+      "changeType": "remove",
+      "colIndex": -1,
+      "field": ""
+    });
+  }
+
+  this.removeAllColumnFilters();
+
+  this._requestFilterRefresh();
+};
+/** Column overriding function is processed before column filters and after global filters. If it returns non-zero, the result will override all other column filter results. If it returns 1, the row will be always included. If it returns -1, the row will be always excluded. If it returns 0, the column filters will be used as normal.
+* @public
+* @param {Function} func
+*/
+
+
+RowFilteringPlugin.prototype.setOverridingFilter = function (func) {
+  this._overridingFilter = func;
+};
+/** PreTransform is used to minimize the same data transformation on multiple filters. Output from the given method will be used on all subsequent filters. Note that it will be used for every existing row, so performance should be critical in here. This is optional setting.
+* @public
+* @param {Function} func This function must return object with key and value pairs
+*/
+
+
+RowFilteringPlugin.prototype.setPreTransform = function (func) {
+  this._preTransform = func;
+};
+/** This is the same as preTransform, only it is executed just before column filters and after the global filters. This is optional setting.
+* @public
+* @param {Function} func This function must return object with key and value pairs
+*/
+
+
+RowFilteringPlugin.prototype.setRowTransform = function (func) {
+  this._rowTransform = func;
+};
+/** @public
+* @return {!Array.<Function>} All global filters
+*/
+
+
+RowFilteringPlugin.prototype.getFilters = function () {
+  return this._globalFilters;
+};
+/** Return filter functions. Use getFilterExpressions for saving and loading instead of this function
+* @public
+* @return {!Array.<Function>} All column filters
+* @see {@link RowFilteringPlugin.getFilterExpressions}
+*/
+
+
+RowFilteringPlugin.prototype.getAllColumnFilters = function () {
+  var filters = [];
+  var len = this._columnFilters.length;
+
+  for (var i = 0; i < len; ++i) {
+    var cfo = this._columnFilters[i];
+    var jLen = cfo._filters.length;
+
+    for (var j = 0; j < jLen; ++j) {
+      filters.push(cfo._filters[j]);
+    }
+  }
+
+  return filters;
+};
+/** Get existing filter expressions for saving and restoring.
+* @public
+* @return {Array.<RowFilteringPlugin~FilterExpression>} Return null if there is no column filter
+* @see {@link RowFilteringPlugin.setFilterExpressions}
+*/
+
+
+RowFilteringPlugin.prototype.getFilterExpressions = function () {
+  if (this._columnFilters.length) {
+    return this._columnFilters.map(toFilterExpression);
+  }
+
+  return null;
+};
+/** Clear all existing column filters and restore column filters from the given valid filter expressions. If the parameter is null, the result is equivalent to calling removeAllColumnFilters();
+* @public
+* @param {Array.<RowFilteringPlugin~FilterExpression>} filterExps
+*/
+
+
+RowFilteringPlugin.prototype.setFilterExpressions = function (filterExps) {
+  this.removeAllColumnFilters();
+
+  if (Array.isArray(filterExps)) {
+    var api = this.getGridApi();
+    var fields = api.getColumnFields();
+    var len = filterExps.length;
+
+    for (var i = 0; i < len; ++i) {
+      var filterExp = filterExps[i];
+      var field = filterExp.field;
+      var colIndex = fields.indexOf(field);
+
+      if (colIndex >= 0) {
+        this.addColumnFilter(colIndex, filterExp.expression, filterExp.context);
+      }
+    }
+  }
+};
+/** @public
+* @return {boolean}
+*/
+
+
+RowFilteringPlugin.prototype.hasColumnFilter = function () {
+  return this._columnFilters.length > 0;
+};
+/** @public
+* @param {number} colIndex
+* @return {Array.<Element>} icons
+*/
+
+
+RowFilteringPlugin.prototype.getColumnFilterIcons = function (colIndex) {
+  var icons = [];
+
+  for (var i = this._hosts.length; --i >= 0;) {
+    var host = this._hosts[i];
+    var tsect = host.getSection("title");
+
+    if (!tsect) {
+      continue;
+    }
+
+    var rCount = tsect.getRowCount();
+    var cell = tsect.getCell(colIndex, rCount - 1, true); // Get bottom cell
+
+    if (cell && cell._filterIcon) {
+      icons.push(cell._filterIcon);
+    }
+  }
+
+  return icons;
+};
+/** @public */
+
+
+RowFilteringPlugin.prototype.updateAllColumnIcons = function () {
+  if (this._uiTimerId) {
+    clearTimeout(this._uiTimerId);
+    this._uiTimerId = 0;
+  }
+
+  this._updateAllColumnIcons();
+};
+/** Specify a list of data views to be filtered, excluding default data views used by UI. <br>
+* This is useful when multiple shared or nested data views are employed.
+* @public
+* @param {Object} dv DataView
+*/
+
+
+RowFilteringPlugin.prototype.addDataView = function (dv) {
+  var at = this._dvs.indexOf(dv);
+
+  if (at < 0) {
+    this._dvs.push(dv);
+
+    this._requestFilterRefresh();
+  }
+};
+/** @public
+* @param {Object} dv DataView
+*/
+
+
+RowFilteringPlugin.prototype.removeDataView = function (dv) {
+  var at = this._dvs.indexOf(dv);
+
+  if (at >= 0) {
+    this._dvs.splice(at, 1);
+
+    this._requestFilterRefresh(); // This could be unnecessary
+
+  }
+};
+/** @private
+* @param {Object} e
+*/
+
+
+RowFilteringPlugin.prototype._onPreSectionRender = function (e) {
+  if (e["sectionType"] !== "title") {
+    return;
+  }
+
+  this._setTimerForUpdatingIcons();
+};
+/** @private
+* @param {Event} e
+*/
+
+
+RowFilteringPlugin.prototype._onIconClick = function (e) {
+  var host = this._hosts[0];
+
+  if (!host) {
+    return;
+  }
+
+  var pos = host.getRelativePosition(e); // TODO: Support reopenning with fieldDataType
+
+  this.openDialog(pos.colIndex);
+  e.stopPropagation();
+  e.preventDefault();
+
+  this._dispatch("click", e);
+};
+/** @private
+* @param {string} rid
+* @param {Object} rowData
+* @return {boolean}
+*/
+
+
+RowFilteringPlugin.prototype._filterLogic = function (rid, rowData) {
+  if (rowData) {
+    if (this._rowGetter) {
+      rowData = this._rowGetter(rowData);
+    }
+
+    if (this._preTransform) {
+      rowData = this._preTransform(rowData);
+    }
+
+    var i;
+    var len = this._globalFilters.length;
+
+    for (i = 0; i < len; ++i) {
+      if (!this._globalFilters[i](rowData, rid, this._globalContexts[i])) {
+        return false;
+      }
+    }
+
+    len = this._activeColFilters.length;
+
+    if (len) {
+      if (this._overridingFilter) {
+        var ret = this._overridingFilter(rowData, rid);
+
+        if (ret) {
+          return ret > 0;
+        }
+      }
+
+      if (this._rowTransform) {
+        rowData = this._rowTransform(rowData);
+      }
+
+      for (i = 0; i < len; ++i) {
+        var cfo = this._activeColFilters[i];
+        var jLen = cfo._filters.length;
+
+        for (var j = 0; j < jLen; ++j) {
+          if (!cfo._filters[j](rowData, rid, cfo._context[j])) {
+            return false;
+          }
+        }
+      }
+    }
+  }
+
+  return true;
+};
+/** @private */
+
+
+RowFilteringPlugin.prototype._requestFilterRefresh = function () {
+  if (!this._dvTimerId) {
+    this._dvTimerId = setTimeout(this.refresh, 10);
+  }
+};
+/** @private */
+
+
+RowFilteringPlugin.prototype._setTimerForUpdatingIcons = function () {
+  if (this._disabledUI) {
+    return;
+  }
+
+  if (!this._uiTimerId) {
+    this._uiTimerId = setTimeout(this._updateAllColumnIcons, 10);
+  }
+};
+/** Perform filtering with the same parameters. Do not call this method repeatedly as the operation is quite expensive.
+* @public
+* @suppress {checkTypes}
+* @fires RowFilteringPlugin#refreshed
+*/
+
+
+RowFilteringPlugin.prototype.refresh = function () {
+  this._dvTimerId = 0;
+
+  var cstkp = this._getPlugin("ColumnStackingPlugin");
+
+  this._activeColFilters = this._columnFilters;
+
+  if (cstkp && this._activeColFilters.length) {
+    var colIndex, cfo;
+
+    var colCount = this._getColumnCount();
+
+    var hasInactiveColumn = false;
+
+    for (colIndex = 0; colIndex < colCount; ++colIndex) {
+      cfo = this._getColumnFilterOption(colIndex);
+
+      if (cfo) {
+        if (cstkp.isInactiveStackedColumn(colIndex)) {
+          hasInactiveColumn = true;
+          break;
+        }
+      }
+    }
+
+    if (hasInactiveColumn) {
+      this._activeColFilters = [];
+
+      for (colIndex = 0; colIndex < colCount; ++colIndex) {
+        cfo = this._getColumnFilterOption(colIndex);
+
+        if (cfo && !cstkp.isInactiveStackedColumn(colIndex)) {
+          this._activeColFilters.push(cfo);
+        }
+      }
+    }
+  }
+
+  var totalFilter = this._globalFilters.length + this._activeColFilters.length;
+  var logic = !this._disabled && totalFilter ? this._filterLogic : null;
+  var dirty = 0;
+
+  var dvs = this._getAvailableDataViews();
+
+  for (var i = dvs.length; --i >= 0;) {
+    dirty |= dvs[i].filterIn(logic);
+  }
+
+  if (dirty) {
+    this._dispatch("refreshed", {});
+  }
+};
+/** @private
+* @param {number} colIndex
+*/
+
+
+RowFilteringPlugin.prototype._updateColumnIcon = function (colIndex) {
+  if (this._disabledUI) {
+    return;
+  }
+
+  var cfo = this._getColumnFilterOption(colIndex);
+
+  var hasFilter = cfo ? cfo._filters.length : 0;
+
+  for (var i = this._hosts.length; --i >= 0;) {
+    var host = this._hosts[i];
+    var tsect = host.getSection("title");
+
+    if (!tsect) {
+      continue;
+    }
+
+    var rCount = tsect.getRowCount();
+    var cell = tsect.getCell(colIndex, rCount - 1, true); // Get bottom cell
+
+    if (!cell) {
+      continue;
+    } // HACK: Update cell padding for all type of icons (sorting and column grouping icons)
+
+
+    if (cell["updatePadding"]) {
+      cell["updatePadding"]();
+    }
+
+    if (!this._disabled && hasFilter) {
+      if (!cell._filterIcon) {
+        cell.addClass("filtering");
+        var filterIcon;
+
+        if (ElfUtil.hasComponent("ef-icon") >= 3) {
+          filterIcon = document.createElement("ef-icon");
+          filterIcon.setAttribute("icon", "filter");
+        } else {
+          filterIcon = document.createElement("div");
+          filterIcon.className = "filter-symbol icon-filter ef-icon";
+        }
+
+        filterIcon.addEventListener("click", this._onIconClick, false);
+
+        this._dispatch("iconCreated", {
+          "icon": filterIcon,
+          "colIndex": colIndex,
+          "grid": host
+        });
+
+        cell.insertFloatingIcon(filterIcon, 10);
+        cell._filterIcon = filterIcon;
+      }
+    } else {
+      if (cell._filterIcon) {
+        cell.removeFloatingIcon(cell._filterIcon);
+        cell._filterIcon = null;
+        cell.removeClass("filtering");
+      }
+    }
+  }
+};
+/** @private */
+
+
+RowFilteringPlugin.prototype._updateAllColumnIcons = function () {
+  this._uiTimerId = 0;
+
+  var colCount = this._getColumnCount();
+
+  for (var i = 0; i < colCount; ++i) {
+    this._updateColumnIcon(i);
+  }
+};
+/** @private
+* @return {number}
+*/
+
+
+RowFilteringPlugin.prototype._getColumnCount = function () {
+  var grid = this._hosts[0];
+
+  if (grid) {
+    return grid.getColumnCount();
+  }
+
+  return 0;
+};
+/** Update existing filter state by replacing the old one. Note that filtering will be performed asynchronously after executing this method.
+* @public
+* @param {number} colIndex
+* @param {*} ctx Context object that will be passed as the third parameter for the filter logic
+* @return {boolean} Returns true if there is any change
+*/
+
+
+RowFilteringPlugin.prototype.setColumnFilterState = function (colIndex, ctx) {
+  var cfo = this._getColumnFilterOption(colIndex);
+
+  if (cfo) {
+    cfo._context[0] = ctx;
+
+    this._requestFilterRefresh();
+
+    return true;
+  }
+
+  return false;
+};
+/** Get the stored user context from the specified column
+* @public
+* @param {number} colIndex
+* @return {*} Context object that is passed as the third parameter for the filter logic
+*/
+
+
+RowFilteringPlugin.prototype.getColumnFilterState = function (colIndex) {
+  var cfo = this._getColumnFilterOption(colIndex);
+
+  if (cfo) {
+    return cfo._context[0];
+  }
+
+  return null;
+};
+/** Get the stored user context from all columns. The column with no filter will return null value
+* @public
+* @return {!Array} Array of context objects
+* @see {@link RowFilteringPlugin.getFilterExpressions}
+*/
+
+
+RowFilteringPlugin.prototype.getColumnFilterStates = function () {
+  var colCount = this._hosts[0] ? this._hosts[0].getColumnCount() : 0;
+  var states = new Array(colCount);
+
+  for (var c = 0; c < colCount; ++c) {
+    states[c] = this.getColumnFilterState(c);
+  }
+
+  return states;
+};
+/** @private
+* @return {!Array.<Object>} array of DataView
+*/
+
+
+RowFilteringPlugin.prototype._getAvailableDataViews = function () {
+  if (this._dvs.length) {
+    return this._dvs;
+  } else {
+    var len = this._hosts.length;
+    var ary = [];
+
+    for (var i = 0; i < len; ++i) {
+      var host = this._hosts[i];
+      var dv = host.getDataSource();
+
+      if (dv) {
+        ary.push(dv);
+      }
+    }
+
+    return ary;
+  }
+};
+/** @private
+* @param {Object} dv DataView
+* @return {Object} DataTable
+*/
+
+
+RowFilteringPlugin.prototype._getDataTable = function (dv) {
+  var dt = dv ? dv.getDataSource() : null;
+
+  while (dt && dt.getDataSource()) {
+    dt = dt.getDataSource();
+  }
+
+  return dt;
+};
+/** @public
+* @param {string} field A field name for getting raw value from row data
+* @param {Function=} formatter A formatter that takes row data, retrieves data, and modified the data for display.
+* @param {string=} fmtField A field name to be used instead of formatter for getting formatted value
+* @param {Function=} rawDataAccessor Data getter to retrieve raw value
+* @param {Function=} formattedDataAccessor Data getter to retrieve formatted value. This paramter will override formatted and fmtField parameters
+* @return {Object} Object that maps formatted value to array of raw values
+*/
+
+
+RowFilteringPlugin.prototype.getUniqueValues = function (field, formatter, fmtField, rawDataAccessor, formattedDataAccessor) {
+  if (!field) {
+    return null;
+  }
+
+  var dvs = this._getAvailableDataViews();
+
+  var dts = dvs.map(this._getDataTable);
+  var tblCount = dts.length;
+  var uniqueValues = {};
+
+  for (var t = 0; t < tblCount; ++t) {
+    var rows = dts[t].getAllRowData();
+    var rowCount = rows.length;
+
+    for (var r = 0; r < rowCount; ++r) {
+      var row = rows[r];
+
+      if (this._rowGetter) {
+        row = this._rowGetter(row);
+      }
+
+      if (this._rowTransform) {
+        row = this._rowTransform(row);
+      }
+
+      var fieldVal = row[field];
+      var rawVal = fieldVal;
+
+      if (rawDataAccessor) {
+        rawVal = rawDataAccessor(rawVal);
+      }
+
+      if (!rawVal) {
+        // Only valid values are accepted
+        if (rawVal !== 0 && rawVal !== false) {
+          continue;
+        }
+      }
+
+      var formattedVal = rawVal;
+
+      if (formattedDataAccessor) {
+        formattedVal = formattedDataAccessor(fieldVal); // The function takes data value
+      } else if (formatter) {
+        formattedVal = formatter(row); // The function takes row data
+      } else if (fmtField) {
+        formattedVal = row[fmtField];
+      }
+
+      if (typeof formattedVal != "string") {
+        if (formattedVal) {
+          if (_typeof(formattedVal) != "object") {
+            formattedVal = rawVal + "";
+          } else if (formattedVal instanceof Date) {
+            formattedVal = formattedVal.toLocaleString("en-GB");
+          } else {
+            // Object type cannot be converted to string
+            formattedVal = "";
+          }
+        } else if (formattedVal === 0) {
+          formattedVal = "0";
+        } else if (formattedVal === false) {
+          formattedVal = "false";
+        }
+      }
+
+      if (!formattedVal) {
+        continue;
+      }
+
+      var rawValues = uniqueValues[formattedVal];
+
+      if (rawValues) {
+        if (rawValues.indexOf(rawVal) < 0) {
+          // Check for unique raw values
+          rawValues.push(rawVal);
+        }
+      } else {
+        // The first unique formatted value detected
+        uniqueValues[formattedVal] = [rawVal];
+      }
+    }
+  }
+
+  return uniqueValues;
+};
+/** @public
+* @param {number} colIndex
+* @param {RowFilteringPlugin~FilterDialogOptions=} options
+*/
+
+
+RowFilteringPlugin.prototype.openDialog = function (colIndex, options) {
+  var stp = this._getPlugin("SortableTitlePlugin");
+
+  if (!this._filterDialog) {
+    // Check if dialog is filter v1 or v3
+    var dialogVersion = ElfUtil.hasComponent('filter-dialog');
+
+    if (!dialogVersion) {
+      console.log("Filter dialog doesn't exist");
+      return;
+    }
+
+    if (dialogVersion >= 3) {
+      this._filterDialog = document.createElement("filter-dialog");
+    } else if (dialogVersion < 2) {
+      this._filterDialog = document.createElement("tr-grid-filter-dialog");
+    }
+
+    if (!stp) {
+      this._filterDialog.hideSortUI();
+    } else {
+      this._filterDialog.addEventListener("sortChanged", this._onDialogSortChanged.bind(this));
+    }
+
+    this._filterDialog.addEventListener("filterChanged", this._onDialogFilterChanged.bind(this));
+  }
+
+  if (this._filterDialog.isShown) {
+    this._filterDialog.hide(); // Hide previously openned dialog
+
+
+    if (this._filterDialog._colIndex === colIndex) {
+      // The dialog is already openned
+      return; // Toggle open state
+    }
+  }
+
+  var host = this._hosts[0];
+
+  if (!host) {
+    return;
+  } // Find target cell for positioning filter dialog
+
+
+  var tsect = host.getSection("title");
+
+  if (!tsect) {
+    return;
+  }
+
+  var rCount = tsect.getRowCount();
+  var cell = tsect.getCell(colIndex, rCount - 1, true); // Get bottom cell
+
+  if (!cell || !cell.getElement()) {
+    return;
+  } // TODO: Handle newly inserted/added columns
+
+
+  var field = this._getField(colIndex);
+
+  if (!field) {
+    return; // The specified column has no field
+  }
+
+  if (stp) {
+    this._filterDialog.setSortState(stp.getSortOrder(colIndex)); // This is for ELF v3
+
+  } // TODO: _initColumnFilterOption is just a lazy (bad) way to populate the non-existing object.
+
+
+  var cfo = this._initColumnFilterOption(colIndex);
+
+  var rawDataAccessor = cfo._rawDataAccessor || null;
+  var formattedDataAccessor = cfo._formattedDataAccessor || null;
+
+  if (options && _typeof(options) === "object") {
+    if (options.rawDataAccessor != null) {
+      rawDataAccessor = cfo._rawDataAccessor = options.rawDataAccessor || null;
+    }
+
+    if (options.formattedDataAccessor != null) {
+      formattedDataAccessor = cfo._formattedDataAccessor = options.formattedDataAccessor || null;
+    }
+  } // Populate data for filter dialog based on existing states
+
+
+  var customFilter = cfo._expressions[0] || "";
+  var ctx = cfo._context[0];
+  var selectedItems = ctx ? ctx.selectedItems : null;
+
+  if (selectedItems) {
+    customFilter = "";
+  } else {
+    selectedItems = {};
+  }
+
+  var uniqueValues = cfo.uniqueValues = this.getUniqueValues(field, this._getFormatter(colIndex), "", rawDataAccessor, formattedDataAccessor);
+  var keys = Object.keys(uniqueValues);
+
+  if (options && options.sortLogic) {
+    var sortLogic = options.sortLogic;
+    keys.sort(function (a, b) {
+      var rawValueA = uniqueValues[a][0];
+      var rawValueB = uniqueValues[b][0];
+      return sortLogic(rawValueA, rawValueB); // Compare with rawValue
+    });
+  }
+
+  var items = keys.map(function (formattedVal, idx) {
+    return {
+      id: idx,
+      title: formattedVal,
+      nodes: [],
+      checked: selectedItems[formattedVal] ? true : false
+    };
+  });
+
+  var colOptions = this._getExtColumnOptions(colIndex);
+
+  var fdt = "";
+
+  if (colOptions && colOptions.fieldDataType) {
+    // TODO: Retrieve data type from Composite/Realtime Grid instead
+    fdt = colOptions.fieldDataType;
+  }
+
+  var dialogConfig = {
+    sortUI: true,
+    filterUI: true,
+    fieldDataType: fdt
+  };
+
+  if (options && _typeof(options) === "object") {
+    if (options.sortUI === false) {
+      dialogConfig.sortUI = options.sortUI;
+    }
+
+    if (options.filterUI === false) {
+      dialogConfig.filterUI = options.filterUI;
+    }
+
+    if (options.fieldDataType != null) {
+      dialogConfig.fieldDataType = options.fieldDataType;
+    }
+
+    if (options.lang != null) {
+      dialogConfig.lang = options.lang;
+    }
+  }
+
+  if (this._filterDialog.init) {
+    // TODO: support initiailization in v1
+    this._filterDialog.init(dialogConfig);
+  }
+
+  this._filterDialog.target = cell.getElement();
+  this._filterDialog._colIndex = colIndex;
+  this._filterDialog.data = items; // TODO: Move all settings to configuration object
+
+  this._filterDialog.filterMode = customFilter ? "advanced" : ""; // this._filterDialog.customFilter = customFilter;
+
+  this._filterDialog.conditions = customFilter; // WARNING: This must be 2D Array
+
+  this._filterDialog.show();
+};
+/** @private
+* @param {number} colIndex
+* @return {Function}
+*/
+
+
+RowFilteringPlugin.prototype._getFormatter = function (colIndex) {
+  var tfp = this._getPlugin("TextFormattingPlugin");
+
+  if (tfp) {
+    var formatter = tfp.getFormatter(colIndex);
+
+    if (formatter) {
+      return formatter.format || null;
+    }
+  }
+
+  return null;
+};
+/** @private
+* @return {!FilterBuilder}
+*/
+
+
+RowFilteringPlugin._getFilterBuilder = function () {
+  if (!RowFilteringPlugin._filterBuilder) {
+    RowFilteringPlugin._filterBuilder = new FilterBuilder();
+  }
+
+  return RowFilteringPlugin._filterBuilder;
+};
+/** @private
+* @param {Object} e
+*/
+
+
+RowFilteringPlugin.prototype._onDialogFilterChanged = function (e) {
+  var colIndex = this._filterDialog._colIndex;
+
+  var cfo = this._getColumnFilterOption(colIndex);
+
+  var uniqueValues = cfo.uniqueValues; // Unique values have to be stored before the removal of the filter
+
+  var rawDataAccessor = cfo._rawDataAccessor;
+  var formattedDataAccessor = cfo._formattedDataAccessor;
+  var ctx = null;
+
+  if (rawDataAccessor || formattedDataAccessor) {
+    ctx = {
+      "rawDataAccessor": rawDataAccessor || null,
+      "formattedDataAccessor": formattedDataAccessor || null
+    };
+  }
+
+  this.removeColumnFilters(colIndex); // Check inputs from advanced filter UIs
+
+  var conditions = e.detail.conditions;
+
+  if (Array.isArray(conditions)) {
+    // Advanced condition filtering. Expecting 2D-Array
+    // Ensure rawValue input for number field data type
+    var condCount = conditions.length;
+
+    for (var m = 0; m < condCount; ++m) {
+      var cond = conditions[m];
+      var inputVal = cond[1]; // inputVal is hardcoded at index 1
+
+      var rawValues = uniqueValues[inputVal];
+
+      if (rawValues) {
+        cond[1] = rawValues[0];
+      }
+    }
+
+    if (ctx) {
+      ctx["_autoGenerated"] = true;
+    }
+
+    this.addColumnFilter(colIndex, conditions, ctx);
+    return;
+  } // Check input from free text input
+
+
+  var selVal = e.detail.value;
+  var selAry = null;
+
+  if (selVal) {
+    if (typeof selVal === "string") {
+      // Custom filter mode (free style text).
+      // WARNING: Free style text is no longer available anymore from the newer dialog
+      this.addColumnFilter(colIndex, selVal);
+      return;
+    } else {
+      selAry =
+      /** @type{Array} */
+      selVal; // Expecting Array of object
+    }
+  }
+
+  var selCount = selAry ? selAry.length : 0;
+
+  if (!selCount) {
+    return;
+  } // The given input is from simple text filter selector
+  // Validate if the input is correct and prepare selected items for building filter
+
+
+  var itemMap = {};
+  var selectedItems = {};
+  var atLeastOne = false;
+
+  for (var i = 0; i < selCount; ++i) {
+    var formattedVal = selAry[i].title; // title is defined by the multi-select element
+    // var selIdx = selAry[i].index; // index cannot be used due to filtering
+
+    var rawVals = uniqueValues[formattedVal];
+
+    if (!rawVals) {
+      continue;
+    }
+
+    atLeastOne = true;
+    selectedItems[formattedVal] = true;
+    var jLen = rawVals.length;
+
+    for (var j = 0; j < jLen; ++j) {
+      itemMap[rawVals[j]] = true;
+    }
+  }
+
+  if (atLeastOne) {
+    if (!ctx) {
+      ctx = {};
+    }
+
+    if (ctx) {
+      ctx["selectedItems"] = selectedItems; // For restore item in the dialog
+    }
+
+    this.addColumnFilter(colIndex, itemMap, ctx);
+  }
+
+  this._dispatch("dialogCommitted", {
+    "value": e.detail.value,
+    "fieldDataType": e.detail.fieldDataType,
+    "colIndex": colIndex
+  });
+};
+/** @private
+* @param {Object} e
+*/
+
+
+RowFilteringPlugin.prototype._onDialogSortChanged = function (e) {
+  var stp = this._getPlugin("SortableTitlePlugin");
+
+  if (stp) {
+    var colIndex = this._filterDialog._colIndex;
+    var eDetail = e.detail.value ? e.detail.value : e.detail;
+
+    if (stp.getSortOrder(colIndex) === eDetail) {
+      stp.sortColumn(colIndex, "n");
+    } else {
+      stp.sortColumn(colIndex, eDetail);
+    }
+
+    this._dispatch("dialogCommitted", {
+      "sortOrder": e.detail.value,
+      "colIndex": colIndex
+    });
+  }
+};
+/** @private
+* @param {Object} e
+*/
+
+
+RowFilteringPlugin.prototype._onColumnAdded = function (e) {
+  if (e["context"]) {
+    this._setColumnOptions(e["colIndex"], e["context"]);
+  }
+};
+/** @private
+* @param {Object} e
+*/
+
+
+RowFilteringPlugin.prototype._onColumnRemoved = function (e) {
+  var colData =
+  /** @type{Object} */
+  e.columnData;
+
+  if (!colData) {
+    return;
+  }
+
+  var cfo = colData["filterOption"];
+
+  if (cfo) {
+    var funcIndex = this._columnFilters.indexOf(cfo);
+
+    if (funcIndex >= 0) {
+      this._columnFilters.splice(funcIndex, 1);
+    }
+
+    this._dispatch("filterChanged", {
+      "filterType": "column",
+      "changeType": "remove",
+      "colIndex": e.colIndex,
+      "field": cfo._field || ""
+    });
+
+    this._requestFilterRefresh();
+  }
+};
+
+export default RowFilteringPlugin;
+export { RowFilteringPlugin, RowFilteringPlugin as RowFiltering, RowFilteringPlugin as RowFilteringExtension };