1 var _typeof = typeof Symbol ===
"function" && typeof Symbol.iterator ===
"symbol" ?
function (obj) {
return typeof obj; } :
function (obj) {
return obj && typeof Symbol ===
"function" && obj.constructor === Symbol && obj !== Symbol.prototype ?
"symbol" : typeof obj; };
5 var Filter =
function Filter(table) {
10 this.headerFilters = {};
11 this.headerFilterColumns = [];
17 Filter.prototype.initializeColumn =
function (column, value) {
19 field = column.getField(),
23 function success(value) {
24 var filterType = column.modules.filter.tagType ==
"input" && column.modules.filter.attrType ==
"text" || column.modules.filter.tagType ==
"textarea" ?
"partial" :
"match",
28 if (typeof column.modules.filter.prevSuccess ===
"undefined" || column.modules.filter.prevSuccess !== value) {
30 column.modules.filter.prevSuccess = value;
32 if (!column.modules.filter.emptyFunc(value)) {
33 column.modules.filter.value = value;
35 switch (_typeof(column.definition.headerFilterFunc)) {
37 if (
self.filters[column.definition.headerFilterFunc]) {
38 type = column.definition.headerFilterFunc;
39 filterFunc =
function filterFunc(data) {
40 var params = column.definition.headerFilterFuncParams || {};
41 var fieldVal = column.getFieldValue(data);
43 params = typeof params ===
"function" ? params(value, fieldVal, data) : params;
45 return self.filters[column.definition.headerFilterFunc](value, fieldVal, data, params);
48 console.warn(
"Header Filter Error - Matching filter function not found: ", column.definition.headerFilterFunc);
53 filterFunc =
function filterFunc(data) {
54 var params = column.definition.headerFilterFuncParams || {};
55 var fieldVal = column.getFieldValue(data);
57 params = typeof params ===
"function" ? params(value, fieldVal, data) : params;
59 return column.definition.headerFilterFunc(value, fieldVal, data, params);
69 filterFunc =
function filterFunc(data) {
70 var colVal = column.getFieldValue(data);
72 if (typeof colVal !==
'undefined' && colVal !== null) {
73 return String(colVal).toLowerCase().indexOf(String(value).toLowerCase()) > -1;
82 filterFunc =
function filterFunc(data) {
83 return column.getFieldValue(data) == value;
89 self.headerFilters[field] = { value: value, func: filterFunc, type: type };
91 delete self.headerFilters[field];
96 self.table.rowManager.filterRefresh();
102 column.modules.filter = {
109 this.generateHeaderFilterElement(column);
112 Filter.prototype.generateHeaderFilterElement =
function (column, initialValue, reinitialize) {
116 success = column.modules.filter.success,
117 field = column.getField(),
129 if (column.modules.filter.headerElement && column.modules.filter.headerElement.parentNode) {
130 column.contentElement.removeChild(column.modules.filter.headerElement.parentNode);
136 column.modules.filter.emptyFunc = column.definition.headerFilterEmptyCheck ||
function (value) {
137 return !value && value !==
"0";
140 filterElement = document.createElement(
"div");
141 filterElement.classList.add(
"tabulator-header-filter");
144 switch (_typeof(column.definition.headerFilter)) {
146 if (
self.table.modules.edit.editors[column.definition.headerFilter]) {
147 editor =
self.table.modules.edit.editors[column.definition.headerFilter];
149 if ((column.definition.headerFilter ===
"tick" || column.definition.headerFilter ===
"tickCross") && !column.definition.headerFilterEmptyCheck) {
150 column.modules.filter.emptyFunc =
function (value) {
151 return value !==
true && value !==
false;
155 console.warn(
"Filter Error - Cannot build header filter, No such editor found: ", column.definition.editor);
160 editor = column.definition.headerFilter;
164 if (column.modules.edit && column.modules.edit.editor) {
165 editor = column.modules.edit.editor;
167 if (column.definition.formatter &&
self.table.modules.edit.editors[column.definition.formatter]) {
168 editor =
self.table.modules.edit.editors[column.definition.formatter];
170 if ((column.definition.formatter ===
"tick" || column.definition.formatter ===
"tickCross") && !column.definition.headerFilterEmptyCheck) {
171 column.modules.filter.emptyFunc =
function (value) {
172 return value !==
true && value !==
false;
176 editor =
self.table.modules.edit.editors[
"input"];
185 getValue:
function getValue() {
186 return typeof initialValue !==
"undefined" ? initialValue :
"";
188 getField:
function getField() {
189 return column.definition.field;
191 getElement:
function getElement() {
192 return filterElement;
194 getColumn:
function getColumn() {
195 return column.getComponent();
197 getRow:
function getRow() {
199 normalizeHeight:
function normalizeHeight() {}
204 params = column.definition.headerFilterParams || {};
206 params = typeof params ===
"function" ? params.call(
self.table) : params;
208 editorElement = editor.call(this.table.modules.edit, cellWrapper, function () {}, success, cancel, params);
210 if (!editorElement) {
211 console.warn(
"Filter Error - Cannot add filter to " + field +
" column, editor returned a value of false");
215 if (!(editorElement instanceof Node)) {
216 console.warn(
"Filter Error - Cannot add filter to " + field +
" column, editor should return an instance of Node, the editor returned:", editorElement);
222 self.table.modules.localize.bind(
"headerFilters|columns|" + column.definition.field, function (value) {
223 editorElement.setAttribute(
"placeholder", typeof value !==
"undefined" && value ? value :
self.table.modules.localize.getText(
"headerFilters|default"));
226 self.table.modules.localize.bind(
"headerFilters|default",
function (value) {
227 editorElement.setAttribute(
"placeholder", typeof
self.column.definition.headerFilterPlaceholder !==
"undefined" &&
self.column.definition.headerFilterPlaceholder ?
self.column.definition.headerFilterPlaceholder : value);
232 editorElement.addEventListener(
"click",
function (e) {
234 editorElement.focus();
237 editorElement.addEventListener(
"focus",
function (e) {
238 var left = _this.table.columnManager.element.scrollLeft;
240 if (left !== _this.table.rowManager.element.scrollLeft) {
241 _this.table.rowManager.scrollHorizontal(left);
242 _this.table.columnManager.scrollHorizontal(left);
249 searchTrigger =
function searchTrigger(e) {
251 clearTimeout(typingTimer);
254 typingTimer = setTimeout(
function () {
255 success(editorElement.value);
259 column.modules.filter.headerElement = editorElement;
260 column.modules.filter.attrType = editorElement.hasAttribute(
"type") ? editorElement.getAttribute(
"type").toLowerCase() :
"";
261 column.modules.filter.tagType = editorElement.tagName.toLowerCase();
263 if (column.definition.headerFilterLiveFilter !==
false) {
265 if (!(column.definition.headerFilter ===
'autocomplete' || column.definition.headerFilter ===
'tickCross' || (column.definition.editor ===
'autocomplete' || column.definition.editor ===
'tickCross') && column.definition.headerFilter ===
true)) {
266 editorElement.addEventListener(
"keyup", searchTrigger);
267 editorElement.addEventListener(
"search", searchTrigger);
270 if (column.modules.filter.attrType ==
"number") {
271 editorElement.addEventListener(
"change",
function (e) {
272 success(editorElement.value);
277 if (column.modules.filter.attrType ==
"text" &&
this.table.browser !==
"ie") {
278 editorElement.setAttribute(
"type",
"search");
284 if (column.modules.filter.tagType ==
"input" || column.modules.filter.tagType ==
"select" || column.modules.filter.tagType ==
"textarea") {
285 editorElement.addEventListener(
"mousedown",
function (e) {
291 filterElement.appendChild(editorElement);
293 column.contentElement.appendChild(filterElement);
296 self.headerFilterColumns.push(column);
300 console.warn(
"Filter Error - Cannot add header filter, column has no field set:", column.definition.title);
305 Filter.prototype.hideHeaderFilterElements =
function () {
306 this.headerFilterColumns.forEach(
function (column) {
307 if (column.modules.filter && column.modules.filter.headerElement) {
308 column.modules.filter.headerElement.style.display =
'none';
314 Filter.prototype.showHeaderFilterElements =
function () {
315 this.headerFilterColumns.forEach(
function (column) {
316 if (column.modules.filter && column.modules.filter.headerElement) {
317 column.modules.filter.headerElement.style.display =
'';
323 Filter.prototype.setHeaderFilterFocus =
function (column) {
324 if (column.modules.filter && column.modules.filter.headerElement) {
325 column.modules.filter.headerElement.focus();
327 console.warn(
"Column Filter Focus Error - No header filter set on column:", column.getField());
332 Filter.prototype.setHeaderFilterValue =
function (column, value) {
334 if (column.modules.filter && column.modules.filter.headerElement) {
335 this.generateHeaderFilterElement(column, value,
true);
336 column.modules.filter.success(value);
338 console.warn(
"Column Filter Error - No header filter set on column:", column.getField());
343 Filter.prototype.reloadHeaderFilter =
function (column) {
345 if (column.modules.filter && column.modules.filter.headerElement) {
346 this.generateHeaderFilterElement(column, column.modules.filter.value,
true);
348 console.warn(
"Column Filter Error - No header filter set on column:", column.getField());
354 Filter.prototype.hasChanged =
function () {
355 var changed = this.changed;
356 this.changed =
false;
361 Filter.prototype.setFilter =
function (field, type, value) {
364 self.filterList = [];
366 if (!Array.isArray(field)) {
367 field = [{ field: field, type: type, value: value }];
370 self.addFilter(field);
374 Filter.prototype.addFilter =
function (field, type, value) {
377 if (!Array.isArray(field)) {
378 field = [{ field: field, type: type, value: value }];
381 field.forEach(
function (filter) {
383 filter =
self.findFilter(filter);
386 self.filterList.push(filter);
392 if (this.table.options.persistence &&
this.table.modExists(
"persistence",
true) && this.table.modules.persistence.config.filter) {
393 this.table.modules.persistence.save(
"filter");
397 Filter.prototype.findFilter =
function (filter) {
401 if (Array.isArray(filter)) {
402 return this.findSubFilters(filter);
405 var filterFunc =
false;
407 if (typeof filter.field ==
"function") {
408 filterFunc =
function filterFunc(data) {
409 return filter.field(data, filter.type || {});
413 if (
self.filters[filter.type]) {
415 column =
self.table.columnManager.getColumnByField(filter.field);
418 filterFunc =
function filterFunc(data) {
419 return self.filters[filter.type](filter.value, column.getFieldValue(data));
422 filterFunc =
function filterFunc(data) {
423 return self.filters[filter.type](filter.value, data[filter.field]);
427 console.warn(
"Filter Error - No such filter type found, ignoring: ", filter.type);
431 filter.func = filterFunc;
433 return filter.func ? filter :
false;
436 Filter.prototype.findSubFilters =
function (filters) {
440 filters.forEach(
function (filter) {
441 filter =
self.findFilter(filter);
448 return output.length ? output :
false;
452 Filter.prototype.getFilters =
function (all, ajax) {
456 output = this.getHeaderFilters();
460 output.forEach(
function (item) {
461 if (typeof item.type ==
"function") {
462 item.type =
"function";
467 output = output.concat(this.filtersToArray(this.filterList, ajax));
473 Filter.prototype.filtersToArray =
function (filterList, ajax) {
478 filterList.forEach(
function (filter) {
481 if (Array.isArray(filter)) {
482 output.push(_this2.filtersToArray(filter, ajax));
484 item = { field: filter.field, type: filter.type, value: filter.value };
487 if (typeof item.type ==
"function") {
488 item.type =
"function";
500 Filter.prototype.getHeaderFilters =
function () {
504 for (var key in this.headerFilters) {
505 output.push({ field: key, type: this.headerFilters[key].type, value: this.headerFilters[key].value });
512 Filter.prototype.removeFilter =
function (field, type, value) {
515 if (!Array.isArray(field)) {
516 field = [{ field: field, type: type, value: value }];
519 field.forEach(
function (filter) {
522 if (_typeof(filter.field) ==
"object") {
523 index =
self.filterList.findIndex(function (element) {
524 return filter === element;
527 index =
self.filterList.findIndex(
function (element) {
528 return filter.field === element.field && filter.type === element.type && filter.value === element.value;
533 self.filterList.splice(index, 1);
536 console.warn(
"Filter Error - No matching filter type found, ignoring: ", filter.type);
540 if (this.table.options.persistence &&
this.table.modExists(
"persistence",
true) && this.table.modules.persistence.config.filter) {
541 this.table.modules.persistence.save(
"filter");
546 Filter.prototype.clearFilter =
function (all) {
547 this.filterList = [];
550 this.clearHeaderFilter();
555 if (this.table.options.persistence &&
this.table.modExists(
"persistence",
true) && this.table.modules.persistence.config.filter) {
556 this.table.modules.persistence.save(
"filter");
561 Filter.prototype.clearHeaderFilter =
function () {
564 this.headerFilters = {};
566 this.headerFilterColumns.forEach(
function (column) {
567 column.modules.filter.value = null;
568 column.modules.filter.prevSuccess = undefined;
569 self.reloadHeaderFilter(column);
576 Filter.prototype.search =
function (searchType, field, type, value) {
581 if (!Array.isArray(field)) {
582 field = [{ field: field, type: type, value: value }];
585 field.forEach(
function (filter) {
586 filter =
self.findFilter(filter);
589 filterList.push(filter);
593 this.table.rowManager.rows.forEach(
function (row) {
596 filterList.forEach(
function (filter) {
597 if (!
self.filterRecurse(filter, row.getData())) {
603 activeRows.push(searchType ===
"data" ? row.getData(
"data") : row.getComponent());
611 Filter.prototype.filter =
function (rowList, filters) {
614 activeRowComponents = [];
616 if (
self.table.options.dataFiltering) {
617 self.table.options.dataFiltering.call(
self.table,
self.getFilters());
620 if (!
self.table.options.ajaxFiltering && (
self.filterList.length || Object.keys(
self.headerFilters).length)) {
622 rowList.forEach(
function (row) {
623 if (
self.filterRow(row)) {
624 activeRows.push(row);
628 activeRows = rowList.slice(0);
631 if (
self.table.options.dataFiltered) {
633 activeRows.forEach(
function (row) {
634 activeRowComponents.push(row.getComponent());
637 self.table.options.dataFiltered.call(
self.table,
self.getFilters(), activeRowComponents);
644 Filter.prototype.filterRow =
function (row, filters) {
647 data = row.getData();
649 self.filterList.forEach(
function (filter) {
650 if (!
self.filterRecurse(filter, data)) {
655 for (var field in
self.headerFilters) {
656 if (!
self.headerFilters[field].func(data)) {
664 Filter.prototype.filterRecurse =
function (filter, data) {
668 if (Array.isArray(filter)) {
669 filter.forEach(
function (subFilter) {
670 if (
self.filterRecurse(subFilter, data)) {
675 match = filter.func(data);
682 Filter.prototype.filters = {
685 "=":
function _(filterVal, rowVal, rowData, filterParams) {
686 return rowVal == filterVal ?
true :
false;
690 "<":
function _(filterVal, rowVal, rowData, filterParams) {
691 return rowVal < filterVal ?
true :
false;
695 "<=":
function _(filterVal, rowVal, rowData, filterParams) {
696 return rowVal <= filterVal ?
true :
false;
700 ">":
function _(filterVal, rowVal, rowData, filterParams) {
701 return rowVal > filterVal ?
true :
false;
705 ">=":
function _(filterVal, rowVal, rowData, filterParams) {
706 return rowVal >= filterVal ?
true :
false;
710 "!=":
function _(filterVal, rowVal, rowData, filterParams) {
711 return rowVal != filterVal ?
true :
false;
714 "regex":
function regex(filterVal, rowVal, rowData, filterParams) {
716 if (typeof filterVal ==
"string") {
717 filterVal =
new RegExp(filterVal);
720 return filterVal.test(rowVal);
724 "like":
function like(filterVal, rowVal, rowData, filterParams) {
725 if (filterVal === null || typeof filterVal ===
"undefined") {
726 return rowVal === filterVal ?
true :
false;
728 if (typeof rowVal !==
'undefined' && rowVal !== null) {
729 return String(rowVal).toLowerCase().indexOf(filterVal.toLowerCase()) > -1;
737 "in":
function _in(filterVal, rowVal, rowData, filterParams) {
738 if (Array.isArray(filterVal)) {
739 return filterVal.indexOf(rowVal) > -1;
741 console.warn(
"Filter Error - filter value is not an array:", filterVal);
747 Tabulator.prototype.registerModule(
"filter", Filter);