/** * This class provides a flexible means to control the * `{@link Ext.util.Collection#cfg!filters filters}` of a * `{@link Ext.util.Collection Collection}`. Instances of this class are created * automatically when filters are added to added to Collections. * * This collection can be directly manipulated by application code to gain full * control over the filters of the owner collection. Be aware that some components * create filters internally (such as `Ext.form.field.ComboBox` and the * `Ext.grid.filters.Filters` plugin) so be careful in such cases to not disturb * these additional filters. * * Items in this collection are `Ext.util.Filter` instances and can be managed * individually by their `id`. This is the recommended way to manage application * filters while preserving filters applied from other sources. * * Bulk changes to this collection should be wrapped in * `{@link Ext.util.Collection#method!beginUpdate beginUpdate}` and * `{@link Ext.util.Collection#method!endUpdate endUpdate}` (as with any collection). * During these bulk updates all reactions to filter changes will be suspended. */Ext.define('Ext.util.FilterCollection', { extend: 'Ext.util.Collection', requires: [ 'Ext.util.Filter' ], isFilterCollection: true, /** * @property {Ext.util.Collection} $filterable * The owning filterable instance. The filterable's configuration governs this * collection. * @private * @readonly */ $filterable: null, /** * @property filterFn * This is the cached filter function. * @readonly */ filterFn: null, constructor: function(config) { var me = this; // Because this closure operates on the collection, we are able to use it for as // long as we have the Collection instance. me.filterFn = Ext.util.Filter.createFilterFn(me); me.callParent([config]); me.setDecoder(me.decodeFilter); }, /** * This method will filter an array based on the currently configured `filters`. * @param {Array} data The array you want to have filtered. * @return {Array} The array you passed after it is filtered. */ filterData: function(data) { return this.filtered ? Ext.Array.filter(data, this.filterFn) : data; }, /** * Returns the filter function. * @return {Function} The filter function. */ getFilterFn: function() { return this.filterFn; }, isItemFiltered: function(item) { return !this.filterFn(item); }, /** * returns the number of *enabled* filters in this `FilterCollection` * @returns {Number} */ getFilterCount: function() { var filters = this.items, len = filters.length, i; for (i = len - 1; i >= 0; i--) { if (filters[i].getDisabled()) { len--; } } return len; }, //------------------------------------------------------------------------- // Private decodeFilter: function(filter) { var options = this.getOptions(), filterRoot = options.getRootProperty(), filterConfig; if (filter.isFilter) { if (filter.setRoot && !filter.getRoot()) { filter.setRoot(filterRoot); } } else { filterConfig = { root: filterRoot }; if (Ext.isFunction(filter)) { filterConfig.filterFn = filter; } // If we are dealing with an object, we assume its a Filter configuration. In // this case we create an instance of Ext.util.Filter passing the config. else { // Finally we get to the point where it has to be invalid //<debug> if (!Ext.isObject(filter)) { Ext.raise('Invalid filter specified: ' + filter); } //</debug> filterConfig = Ext.apply(filterConfig, filter); if (filterConfig.fn) { filterConfig.filterFn = filterConfig.fn; delete filterConfig.fn; } if (Ext.util.Filter.isInvalid(filterConfig)) { return false; } } filter = new Ext.util.Filter(filterConfig); } return filter; }, decodeRemoveItems: function(args, index) { var me = this, ret = (index === undefined) ? args : args[index]; if (!ret.$cloned) { if (args.length > index + 1 || !Ext.isIterable(ret)) { ret = Ext.Array.slice(args, index); } // eslint-disable-next-line vars-on-top var currentFilters = me.items, ln = ret.length, remove = [], filter, i, isFunction, isProp, isString, item, match, n, type; for (i = 0; i < ln; i++) { filter = ret[i]; if (filter && filter.isFilter) { remove.push(filter); } else { type = typeof filter; isFunction = type === 'function'; isProp = filter.property !== undefined && filter.value !== undefined; isString = type === 'string'; //<debug> if (!isFunction && !isProp && !isString) { Ext.raise('Invalid filter specification: ' + filter); } //</debug> for (n = currentFilters.length; n-- > 0;) { item = currentFilters[n]; match = false; if (isString) { match = item.getProperty() === filter; } else if (isFunction) { match = item.getFilterFn() === filter; } else if (isProp) { match = item.getProperty() === filter.property && item.getValue() === filter.value; } if (match) { remove.push(item); } } } } ret = remove; ret.$cloned = true; } return ret; }, getOptions: function() { // Odd thing this. We need a Filterable to know how to manage our collection, but // we may not have one. Of course as a Collection, we *are* one as well... just // that is not really useful to filter the filters themselves, but we do have the // default options for Filterable baked in, so we'll do. return this.$filterable || this; }});