@wavemaker-ai/app-ng-runtime 1.0.0-rc.647469

package/components/data/table/esm2022/table-filter.directive.mjs

@@ -0,0 +1,706 @@
+import { Directive, Inject, Self } from '@angular/core';
+import { $appDigest, adjustContainerRightEdges, DataSource, DataType, FormWidgetType, getClonedObject, isDefined, isNumberType } from '@wm/core';
+import { getMatchModeMsgs, getMatchModeTypesMap, isDataSetWidget, refreshDataSource, unsupportedStatePersistenceTypes } from '@wm/components/base';
+import { TableComponent } from './table.component';
+import { endsWith, filter, find, forEach, get, head, includes, isArray, isEmpty, isEqual, isNull, isObject, orderBy, range, split, startsWith, toLower, toNumber, toString } from "lodash-es";
+import * as momentLib from 'moment';
+import * as i0 from "@angular/core";
+const moment = momentLib.default || window['moment'];
+const emptyMatchModes = ['null', 'empty', 'nullorempty', 'isnotnull', 'isnotempty'];
+// Get search value based on the time
+const getSearchValue = (value, type) => {
+    if (!isDefined(value) || value === '') {
+        return undefined;
+    }
+    if (isNumberType(type)) {
+        return toNumber(value);
+    }
+    if (type === DataType.DATETIME) {
+        return moment(value).valueOf();
+    }
+    return toString(value).toLowerCase();
+};
+// Filter the data based on the search value and conditions
+const getFilteredData = (data, searchObj, visibleCols = []) => {
+    const searchVal = getSearchValue(searchObj.value, searchObj.type);
+    let currentVal;
+    // Return whole data if
+    // - search value is undefined and matchmode is not an empty matchmode type
+    // - search value is null and datatype is number. Null can not be compared with numeric values[WMS-19275].
+    if ((!isDefined(searchVal) && !includes(emptyMatchModes, searchObj.matchMode)) || (isNumberType(searchObj.type) && isNull(searchObj.value))) {
+        return data;
+    }
+    data = data.filter((obj) => {
+        let isExists;
+        if (searchObj.field) {
+            currentVal = getSearchValue(get(obj, searchObj.field), searchObj.type);
+        }
+        else {
+            currentVal = [];
+            forEach(obj, (val, key) => {
+                if ((includes(visibleCols, key))) {
+                    currentVal.push(val);
+                }
+                else {
+                    // WMS-22271 If the key is in nested key format (dot format)
+                    // Find all the indexes of the key in visiblecols and extract their values from obj
+                    const colIndex = filter(range(visibleCols.length), (i) => visibleCols[i].includes(key));
+                    forEach(colIndex, (index) => {
+                        // @ts-ignore
+                        const value = get(obj, visibleCols[index]);
+                        if (currentVal.indexOf(value) < 0) {
+                            currentVal.push(value);
+                        }
+                    });
+                }
+            });
+            currentVal = currentVal.join(' ').toLowerCase(); // If field is not there, search on all the columns
+        }
+        switch (searchObj.matchMode) {
+            case 'start':
+                isExists = startsWith(currentVal, searchVal);
+                break;
+            case 'end':
+                isExists = endsWith(currentVal, searchVal);
+                break;
+            case 'exact':
+                isExists = isEqual(currentVal, searchVal);
+                break;
+            case 'notequals':
+                isExists = !isEqual(currentVal, searchVal);
+                break;
+            case 'null':
+                isExists = isNull(currentVal);
+                break;
+            case 'isnotnull':
+                isExists = !isNull(currentVal);
+                break;
+            case 'empty':
+                isExists = isEmpty(currentVal);
+                break;
+            case 'isnotempty':
+                isExists = !isEmpty(currentVal);
+                break;
+            case 'nullorempty':
+                isExists = isNull(currentVal) || isEmpty(currentVal);
+                break;
+            case 'lessthan':
+                isExists = currentVal < searchVal;
+                break;
+            case 'lessthanequal':
+                isExists = currentVal <= searchVal;
+                break;
+            case 'greaterthan':
+                isExists = currentVal > searchVal;
+                break;
+            case 'greaterthanequal':
+                isExists = currentVal >= searchVal;
+                break;
+            default:
+                isExists = isNumberType(searchObj.type) ? isEqual(currentVal, searchVal) : includes(currentVal, searchVal);
+                break;
+        }
+        return isExists;
+    });
+    return data;
+};
+// Set the filter fields when the search value is specified and field is not selected
+const setAllFilterFields = function (filterFields, searchObj, visibleCols) {
+    visibleCols.forEach(function (field) {
+        filterFields[field] = {
+            'value': searchObj.value,
+            'type': searchObj.value.type,
+            'logicalOp': 'OR'
+        };
+        if (searchObj.matchMode) {
+            filterFields[field].matchMode = searchObj.matchMode;
+        }
+    });
+};
+// Set the filter fields as required by datasource
+const setFilterFields = (filterFields, searchObj, visibleCols = []) => {
+    const field = searchObj && searchObj.field;
+    /*Set the filter options when a field/column has been selected.*/
+    if (field) {
+        filterFields[field] = {
+            'value': searchObj.value,
+            'logicalOp': 'AND'
+        };
+        if (searchObj.matchMode) {
+            filterFields[field].matchMode = searchObj.matchMode;
+        }
+    }
+    else {
+        /*Set the filter options when a field/column hasn't been selected.*/
+        setAllFilterFields(filterFields, searchObj, visibleCols);
+    }
+};
+// Transform filter fields from array to object having field names as keys
+const transformFilterField = (userFilters, filterField) => {
+    if (filterField.field) {
+        userFilters[filterField.field] = {
+            value: filterField.value,
+            matchMode: filterField.matchMode,
+            type: filterField.type
+        };
+    }
+};
+// Build a filter Fields object
+const addToFilterFields = (filterFields, searchObj) => {
+    filterFields.push({
+        field: (searchObj.key) ? searchObj.key : '',
+        matchMode: searchObj.matchMode,
+        type: searchObj.type,
+        value: searchObj.value
+    });
+};
+export class TableFilterSortDirective {
+    constructor(table) {
+        this.table = table;
+        table._searchSortHandler = this.searchSortHandler.bind(this);
+        table.getSearchResult = this.getSearchResult.bind(this);
+        table.getSortResult = this.getSortResult.bind(this);
+        table.checkFiltersApplied = this.checkFiltersApplied.bind(this);
+        table.getFilterFields = this.getFilterFields.bind(this);
+        table.onRowFilterChange = this.onRowFilterChange.bind(this);
+        table.onFilterConditionSelect = this.onFilterConditionSelect.bind(this);
+        table.showClearIcon = this.showClearIcon.bind(this);
+        table.clearRowFilter = this.clearRowFilter.bind(this);
+        table.matchModeTypesMap = getMatchModeTypesMap();
+        table.matchModeMsgs = getMatchModeMsgs(table.appLocale);
+        table.emptyMatchModes = emptyMatchModes;
+        table.getNavigationTargetBySortInfo = this.getNavigationTargetBySortInfo.bind(this);
+        table.refreshData = this.refreshData.bind(this);
+        table.clearFilter = this.clearFilter.bind(this);
+        table.adjustContainer = this.adjustContainer.bind(this);
+    }
+    adjustContainer(fieldName) {
+        setTimeout(() => {
+            adjustContainerRightEdges($('bs-dropdown-container'), this.table.rowFilterCompliedTl[fieldName], this.table, $('bs-dropdown-container .dropdown-menu'));
+        });
+    }
+    // Get first or last page based on sort info of primary key
+    getNavigationTargetBySortInfo() {
+        return this.table.sortInfo && this.table.sortInfo.direction === 'desc' &&
+            includes(this.table.primaryKey, this.table.sortInfo.field) ? 'first' : 'last';
+    }
+    // Returns all the columns of the table wherein, showinfilter is set to true
+    getTableVisibleCols() {
+        const visibleCols = [];
+        forEach(this.table.columns, (val, col) => {
+            if (toLower(toString(val.showinfilter)) === 'true' && col !== 'rowOperations' && val.searchable) {
+                visibleCols.push(col);
+            }
+        });
+        return visibleCols;
+    }
+    // call the set filter fields function based on the field selected or not
+    invokeSetFilterfieldBasedOnFieldval(searchObj, filterFields) {
+        if (searchObj.field) {
+            setFilterFields(filterFields, searchObj);
+        }
+        else if (!isEmpty(searchObj)) {
+            const visibleCols = this.getTableVisibleCols();
+            setFilterFields(filterFields, searchObj, visibleCols);
+        }
+    }
+    // Get the filter fields as required by datasource
+    getFilterFields(searchObj) {
+        searchObj = searchObj || {};
+        const filterFields = {};
+        if (isArray(searchObj)) {
+            forEach(searchObj, obj => {
+                this.invokeSetFilterfieldBasedOnFieldval(obj, filterFields);
+            });
+        }
+        else {
+            this.invokeSetFilterfieldBasedOnFieldval(searchObj, filterFields);
+        }
+        return filterFields;
+    }
+    // Get the logical operator for the search filter
+    getLogicalOperator(filterFields) {
+        let operator = '';
+        for (const field in filterFields) {
+            operator = filterFields[field]['logicalOp'] || '';
+            break;
+        }
+        return operator;
+    }
+    // Reset the sort based on sort returned by the call
+    resetSortStatus(variableSort) {
+        let gridSortString;
+        if (!isEmpty(this.table.sortInfo) && this.table.datasource) {
+            gridSortString = this.table.sortInfo.field + ' ' + this.table.sortInfo.direction;
+            variableSort = this.table.datasource.execute(DataSource.Operation.GET_OPTIONS).orderBy || variableSort;
+            if (variableSort) { // If multiple order by fields are present, compare with the first one
+                variableSort = head(split(variableSort, ','));
+            }
+            if (gridSortString !== variableSort) {
+                this.table.callDataGridMethod('resetSortIcons');
+                this.table.sortInfo = {};
+                this.table.setDataGridOption('sortInfo', {});
+            }
+        }
+    }
+    // Clear the all the filters applied
+    clearFilter(skipFilter) {
+        let $gridElement;
+        this.table.filterInfo = {};
+        if (this.table.filtermode === 'multicolumn') {
+            this.table.fieldDefs.forEach(col => {
+                if (col.resetFilter) {
+                    col.resetFilter();
+                }
+            });
+            if (!skipFilter) {
+                this.table.onRowFilterChange();
+            }
+        }
+        else if (this.table.filtermode === 'search') {
+            $gridElement = this.table.datagridElement;
+            $gridElement.find('[data-element="dgSearchText"]').val('');
+            $gridElement.find('[data-element="dgFilterValue"]').val('');
+            if (!skipFilter) {
+                $gridElement.find('.app-search-button').trigger('click');
+            }
+        }
+    }
+    // Check the filters applied and remove if dat does not contain any filters
+    checkFiltersApplied(variableSort) {
+        if (!this.table.datasource) {
+            return;
+        }
+        if (this.table.datasource.execute(DataSource.Operation.SUPPORTS_SERVER_FILTER)) {
+            if (isEmpty(this.table.datasource.execute(DataSource.Operation.GET_OPTIONS).filterFields)) {
+                this.clearFilter(true);
+            }
+            this.resetSortStatus(variableSort);
+            return;
+        }
+        if (this.table.datasource.execute(DataSource.Operation.IS_PAGEABLE)) {
+            this.resetSortStatus(variableSort);
+        }
+    }
+    // Returns data filtered using searchObj
+    getSearchResult(data, searchObj) {
+        const visibleCols = this.getTableVisibleCols();
+        if (!searchObj) {
+            return data;
+        }
+        if (isArray(searchObj)) {
+            searchObj.forEach((obj) => {
+                data = getFilteredData(data, obj, visibleCols);
+            });
+        }
+        else {
+            data = getFilteredData(data, searchObj, visibleCols);
+        }
+        return data;
+    }
+    // Function that checks if a given string is a valid date and returns the timestamp if it is, or NaN if it's not.
+    parseDateString(dateString) {
+        const timestamp = Date.parse(dateString);
+        // handling case when string starts with string and end with number
+        const trimmed = dateString.trim();
+        const monthRegex = /\b(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)\b/i;
+        if (/^[A-Za-z]+/.test(trimmed) && /\d+$/.test(trimmed) && !monthRegex.test(trimmed)) {
+            return NaN;
+        }
+        if (!isNaN(timestamp)) {
+            return timestamp;
+        }
+        else { // Since Date.parse() doesn't support all date formats, manually validating the date.
+            const parts = dateString?.split(/[-/\s]+/)?.map(Number) || [];
+            return new Date(parts[2], parts[1] - 1, parts[0]).getTime();
+        }
+        return NaN;
+    }
+    // Returns data sorted using sortObj
+    getSortResult(data, sortObj) {
+        if (sortObj && sortObj.direction) {
+            const fieldValue = get(find(data, sortObj.field), sortObj.field);
+            const isValidDateString = typeof fieldValue === 'string' ? this.parseDateString(fieldValue) : NaN;
+            if (!isNaN(isValidDateString)) { // if the field is a date string
+                data = orderBy(data, [(item) => this.parseDateString(get(item, sortObj.field))], [sortObj.direction]);
+            }
+            else if (sortObj.sortBy ? this.table.columns[sortObj.sortBy]?.caseinsensitive : this.table.columns[sortObj.field]?.caseinsensitive) {
+                //Fix for [WMS-27505]: Added case-insensitive sorting so that uppercase and lowercase letters are treated the same when sorting.
+                data = orderBy(data, [
+                    (item) => {
+                        const val = get(item, sortObj.field);
+                        return typeof val === 'string' ? val.toLowerCase() : val;
+                    },
+                    (item) => get(item, sortObj.field) // fallback to original value
+                ], [sortObj.direction, sortObj.direction]);
+            }
+            else {
+                data = orderBy(data, sortObj.field, sortObj.direction);
+            }
+        }
+        return data;
+    }
+    // This method handles the client side sort and search
+    handleClientSideSortSearch(searchSortObj, e, type) {
+        this.table._isClientSearch = true;
+        let data;
+        data = this.table.isNavigationEnabled() ? getClonedObject(this.table.__fullData) : getClonedObject(this.table.dataset);
+        if (type === 'search') {
+            this.table.filterInfo = searchSortObj;
+        }
+        else {
+            this.table.sortInfo = searchSortObj;
+        }
+        if (isObject(data) && !isArray(data)) {
+            data = [data];
+        }
+        /*Both the functions return same 'data' if arguments are undefined*/
+        data = this.getSearchResult(data, this.table.filterInfo);
+        data = this.getSortResult(data, this.table.sortInfo);
+        this.table.serverData = data;
+        if (type === 'sort') {
+            // Calling 'onSort' event
+            this.table.invokeEventCallback('sort', { $event: e, $data: {
+                    data: this.table.serverData,
+                    sortDirection: this.table.sortInfo.direction,
+                    colDef: this.table.columns[this.table.sortInfo.field]
+                } });
+        }
+        if (this.table.isNavigationEnabled()) {
+            // Reset the page number to 1
+            this.table.dataNavigator.dn.currentPage = 1;
+            this.table.dataNavigator.setPagingValues(data);
+        }
+        else {
+            this.table.setGridData(this.table.serverData);
+        }
+    }
+    // This method handles the search for pageable datasource
+    handleSinglePageSearch(searchObj) {
+        this.table._isPageSearch = true;
+        let data = getClonedObject(this.table.gridData);
+        const $rows = this.table.datagridElement.find('tbody tr.app-datagrid-row');
+        this.table.filterInfo = searchObj;
+        data = this.getSearchResult(data, searchObj);
+        // Compared the filtered data and original data, to show or hide the rows
+        forEach(this.table.gridData, (value, index) => {
+            const $row = $($rows[index]);
+            if (find(data, obj => isEqual(obj, value))) {
+                $row.show();
+            }
+            else {
+                $row.hide();
+            }
+        });
+        if (data && data.length) {
+            this.table.callDataGridMethod('setStatus', 'ready');
+            // Select the first row after the search for single select
+            if (this.table.gridfirstrowselect && !this.table.multiselect) {
+                this.table.callDataGridMethod('selectFirstRow', true, true);
+            }
+        }
+        else {
+            this.table.callDataGridMethod('setStatus', 'nodata', this.table.nodatamessage);
+            this.table.selecteditem = undefined;
+        }
+        this.table.callDataGridMethod('updateSelectAllCheckboxState');
+    }
+    // This method handles the search for server side variables
+    handleServerSideSearch(searchObj) {
+        this.table.filterInfo = searchObj;
+        if (!this.table.datasource) {
+            return;
+        }
+        const sortInfo = this.table.sortInfo;
+        const sortOptions = sortInfo && sortInfo.direction ? (sortInfo.field + ' ' + sortInfo.direction) : '';
+        const filterFields = this.getFilterFields(searchObj);
+        const logicalOp = this.getLogicalOperator(filterFields);
+        refreshDataSource(this.table.datasource, {
+            page: 1,
+            filterFields: filterFields,
+            orderBy: sortOptions,
+            condition: logicalOp
+        }).then(() => {
+            $appDigest();
+        }, () => {
+            this.table.toggleMessage(true, 'error', this.table.nodatamessage);
+        });
+    }
+    // This method handles the sort for server side variables
+    handleSeverSideSort(sortObj, e, statePersistenceTriggered) {
+        // Update the sort info for passing to datagrid
+        this.table.gridOptions.sortInfo.field = sortObj.field;
+        this.table.gridOptions.sortInfo.direction = sortObj.direction;
+        this.table.sortInfo = getClonedObject(sortObj);
+        const sortOptions = sortObj && sortObj.direction ? (sortObj.field + ' ' + sortObj.direction) : '';
+        const filterFields = this.getFilterFields(this.table.filterInfo);
+        const condition = this.getLogicalOperator(filterFields);
+        if (!statePersistenceTriggered && this.table.getConfiguredState() !== 'none') {
+            this.table.statePersistence.removeWidgetState(this.table, 'pagination');
+        }
+        refreshDataSource(this.table.datasource, {
+            page: 1,
+            filterFields: filterFields,
+            orderBy: sortOptions,
+            condition: condition
+        }).then((response) => {
+            $appDigest();
+            const data = (response && response.data) ? response.data : response;
+            this.table.invokeEventCallback('sort', { $event: e, $data: {
+                    data,
+                    sortDirection: sortObj.direction,
+                    colDef: this.table.columns[sortObj.field]
+                }
+            });
+        });
+    }
+    searchHandler(searchSortObj, e, type, statePersistenceTriggered) {
+        let obj;
+        if (isArray(searchSortObj)) {
+            obj = searchSortObj.filter(function (searchObject) {
+                return (searchObject.matchMode !== undefined && searchObject.value !== undefined) || (searchObject.value !== undefined && searchObject.field === '');
+            });
+        }
+        else {
+            obj = { field: searchSortObj.field, value: searchSortObj.value, type: searchSortObj.type };
+        }
+        if (this.table.getConfiguredState() !== 'none' && unsupportedStatePersistenceTypes.indexOf(this.table.navigation) < 0) {
+            if ((isArray(searchSortObj) && obj.length) || (searchSortObj.value)) {
+                this.table.statePersistence.removeWidgetState(this.table, 'search');
+                this.table.statePersistence.setWidgetState(this.table, { search: obj });
+            }
+            else {
+                this.table.statePersistence.removeWidgetState(this.table, 'search');
+            }
+            if (!statePersistenceTriggered) {
+                this.table.statePersistence.removeWidgetState(this.table, 'pagination');
+                this.table.statePersistence.removeWidgetState(this.table, 'selectedItem');
+            }
+        }
+        else {
+            console.warn('Retain State handling on Widget ' + this.table.name + ' is not supported for current pagination type.');
+        }
+        let filterFields = getClonedObject(searchSortObj);
+        const dataSource = this.table.datasource;
+        if (!dataSource && !this.table.dataset) {
+            return;
+        }
+        let output;
+        const userFilters = {};
+        // Transform filter fields from array to object having field names as keys
+        if (isArray(filterFields)) {
+            filterFields.forEach(filterField => {
+                transformFilterField(userFilters, filterField);
+            });
+        }
+        else {
+            transformFilterField(userFilters, filterFields);
+        }
+        output = this.table.invokeEventCallback('beforefilter', { $event: e, $data: userFilters, columns: userFilters });
+        // If callback returns false, don't trigger the filter call
+        if (output === false) {
+            return;
+        }
+        filterFields = [];
+        // if the field is not selected in search filter dropdown, building the filter fields object
+        if (isEmpty(userFilters) && !isEmpty(obj)) {
+            if (isArray(obj)) {
+                forEach(obj, searchObj => {
+                    addToFilterFields(filterFields, searchObj);
+                });
+            }
+            else {
+                addToFilterFields(filterFields, obj);
+            }
+        }
+        else {
+            // Transform back the filter fields from object to array
+            forEach(userFilters, (val, key) => {
+                // @ts-ignore
+                filterFields.push({ field: key, matchMode: val.matchMode, type: val.type, value: val.value });
+            });
+        }
+        if (dataSource && dataSource.execute(DataSource.Operation.SUPPORTS_SERVER_FILTER)) {
+            this.handleServerSideSearch(filterFields);
+            return;
+        }
+        if (dataSource && dataSource.execute(DataSource.Operation.IS_API_AWARE) && dataSource.execute(DataSource.Operation.IS_PAGEABLE)) {
+            this.handleSinglePageSearch(filterFields);
+        }
+        else {
+            this.handleClientSideSortSearch(filterFields, e, type);
+        }
+    }
+    sortHandler(searchSortObj, e, type, statePersistenceTriggered) {
+        const dataSource = this.table.datasource;
+        if (!dataSource && !this.table.dataset) {
+            return;
+        }
+        if (!statePersistenceTriggered && this.table.getConfiguredState() !== 'none' && unsupportedStatePersistenceTypes.indexOf(this.table.navigation) < 0) {
+            const obj = { direction: searchSortObj.direction, field: searchSortObj.field };
+            if (searchSortObj.direction) {
+                this.table.statePersistence.setWidgetState(this.table, { sort: obj });
+            }
+            else {
+                this.table.statePersistence.removeWidgetState(this.table, 'sort');
+            }
+            this.table.statePersistence.removeWidgetState(this.table, 'selectedItem');
+        }
+        else {
+            console.warn('Retain State handling on Widget ' + this.table.name + ' is not supported for current pagination type.');
+        }
+        // WMS-22387: For server side pagination, execute client side sorting
+        if (dataSource && dataSource.execute(DataSource.Operation.IS_SORTABLE)) {
+            this.handleSeverSideSort(searchSortObj, e, statePersistenceTriggered);
+        }
+        else {
+            this.handleClientSideSortSearch(searchSortObj, e, type);
+        }
+    }
+    // set the 'lastAction' performed on the table to 'search_or_sort'
+    setLastActionPerformedToSearchSort() {
+        this.table.gridOptions.setLastActionPerformed(this.table.gridOptions.ACTIONS.SEARCH_OR_SORT);
+        this.table.gridOptions.setIsSearchTrigerred(true);
+    }
+    // This method is triggered by jquery table
+    searchSortHandler(searchSortObj, e, type, statePersistenceTriggered) {
+        const event_type = e ? e.type : '';
+        if (event_type === 'change' && this.table.filtermode !== 'multicolumn') {
+            e.stopPropagation();
+        }
+        else {
+            this.setLastActionPerformedToSearchSort();
+            if (type === 'search') {
+                this.searchHandler(searchSortObj, e, type, statePersistenceTriggered);
+            }
+            else {
+                this.sortHandler(searchSortObj, e, type, statePersistenceTriggered);
+            }
+        }
+    }
+    // Method to show/hide clear icon in multi column filter
+    showClearIcon(fieldName) {
+        const value = this.table.rowFilter[fieldName] && this.table.rowFilter[fieldName].value;
+        return isDefined(value) && value !== '' && value !== null;
+    }
+    // Method clear the filter value in multi column filter
+    clearRowFilter(fieldName) {
+        if (this.table.rowFilter && this.table.rowFilter[fieldName]) {
+            this.table.columns[fieldName].resetFilter();
+            this.onRowFilterChange(fieldName);
+        }
+    }
+    // This method is triggered on select of condition in multi column filter
+    onFilterConditionSelect(fieldName, condition) {
+        this.table.rowFilter[fieldName] = this.table.rowFilter[fieldName] || {};
+        this.table.rowFilter[fieldName].matchMode = condition;
+        // For empty match modes, clear off the value and call filter
+        if (includes(this.table.emptyMatchModes, condition)) {
+            this.table.columns[fieldName].resetFilter();
+            this.table.onRowFilterChange();
+        }
+        else {
+            // If value is present, call the filter. Else, focus on the field
+            if (isDefined(this.table.rowFilter[fieldName].value) && this.table.rowFilter[fieldName].value !== '') {
+                this.table.onRowFilterChange();
+            }
+            else {
+                setTimeout(() => {
+                    this.table.columns[fieldName].filterInstance.focus();
+                });
+            }
+        }
+    }
+    // Method to get the updated values when filter on field is changed for multicolumn filter
+    getFilterOnFieldValues(filterDef) {
+        if (!this.table.datasource || !this.table.datasource.execute(DataSource.Operation.SUPPORTS_DISTINCT_API)) {
+            return;
+        }
+        const fieldName = filterDef.field;
+        const formFields = this.table.fullFieldDefs;
+        const filterOnFields = filter(formFields, { 'filteronfilter': fieldName });
+        const newVal = get(this.table.rowFilter, [fieldName, 'value']);
+        // Loop over the fields for which the current field is filter on field
+        forEach(filterOnFields, filterField => {
+            const filterOn = filterField.filteronfilter;
+            const filterKey = filterField.field;
+            const filterFields = {};
+            const filterWidget = filterField.filterwidget;
+            if (!isDataSetWidget(filterWidget) || filterOn === filterKey || filterField.isFilterDataSetBound) {
+                return;
+            }
+            filterFields[filterOn] = (isDefined(newVal) && newVal !== '' && newVal !== null) ? { 'value': newVal } : {};
+            if (filterWidget === FormWidgetType.AUTOCOMPLETE && filterField.filterInstance.dataoptions) {
+                filterField.filterInstance.dataoptions.filterFields = filterFields;
+            }
+            else {
+                this.table.datasource.execute(DataSource.Operation.GET_DISTINCT_DATA_BY_FIELDS, {
+                    'fields': filterKey,
+                    'filterFields': filterFields
+                }).then(data => {
+                    filterField.filterdataset = data.data;
+                });
+            }
+        });
+    }
+    // This method is triggered on value change in multi column filter
+    onRowFilterChange(fieldName) {
+        const searchObj = [];
+        const field = find(this.table.fullFieldDefs, { 'field': fieldName });
+        // Convert row filters to a search object and call search handler
+        forEach(this.table.rowFilter, (value, key) => {
+            if ((isDefined(value.value) && value.value !== '') || includes(this.table.emptyMatchModes, value.matchMode)) {
+                if (field && key === field.field) {
+                    value.type = value.type || field.type;
+                    value.matchMode = value.matchMode || get(this.table.matchModeTypesMap[value.type], 0);
+                }
+                searchObj.push({
+                    field: key,
+                    value: value.value,
+                    matchMode: value.matchMode,
+                    type: value.type
+                });
+            }
+        });
+        this.table.gridOptions.searchHandler(searchObj, undefined, 'search');
+        // If field is passed, update any filter on field values if present
+        if (field) {
+            this.getFilterOnFieldValues(field);
+        }
+    }
+    refreshData(isSamePage) {
+        if (!this.table.datasource) {
+            return;
+        }
+        const page = isSamePage ? this.table.dataNavigator.dn.currentPage : 1;
+        const sortInfo = this.table.sortInfo;
+        const sortOptions = sortInfo && sortInfo.direction ? (sortInfo.field + ' ' + sortInfo.direction) : '';
+        const filterFields = this.getFilterFields(this.table.filterInfo);
+        const logicalOp = this.getLogicalOperator(filterFields);
+        refreshDataSource(this.table.datasource, {
+            page: page,
+            filterFields: filterFields,
+            orderBy: sortOptions,
+            condition: logicalOp
+        });
+    }
+    ngOnDestroy() {
+        // MEMORY LEAK FIX: Clear table reference
+        this.table = null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TableFilterSortDirective, deps: [{ token: TableComponent, self: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: TableFilterSortDirective, isStandalone: true, selector: "[wmTableFilterSort]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TableFilterSortDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[wmTableFilterSort]'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Self
+                }, {
+                    type: Inject,
+                    args: [TableComponent]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-filter.directive.js","sourceRoot":"","sources":["../../../../../projects/components/widgets/data/table/src/table-filter.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {Directive, Inject, OnDestroy, Self} from '@angular/core';\n\nimport {\n    $appDigest,\n    adjustContainerRightEdges,\n    DataSource,\n    DataType,\n    FormWidgetType,\n    getClonedObject,\n    isDefined,\n    isNumberType\n} from '@wm/core';\nimport {\n    getMatchModeMsgs,\n    getMatchModeTypesMap,\n    isDataSetWidget,\n    refreshDataSource,\n    unsupportedStatePersistenceTypes\n} from '@wm/components/base';\n\nimport {TableComponent} from './table.component';\nimport {\n    endsWith,\n    filter,\n    find,\n    forEach,\n    get,\n    head,\n    includes,\n    isArray,\n    isEmpty,\n    isEqual,\n    isNull,\n    isObject,\n    orderBy,\n    range,\n    split,\n    startsWith,\n    toLower,\n    toNumber,\n    toString\n} from \"lodash-es\";\nimport * as momentLib from 'moment';\n\ndeclare const $;\nconst moment = momentLib.default || window['moment'];\n\nconst emptyMatchModes = ['null', 'empty', 'nullorempty', 'isnotnull', 'isnotempty'];\n\n// Get search value based on the time\nconst getSearchValue = (value, type) => {\n    if (!isDefined(value) || value === '') {\n        return undefined;\n    }\n    if (isNumberType(type)) {\n        return toNumber(value);\n    }\n    if (type === DataType.DATETIME) {\n        return moment(value).valueOf();\n    }\n    return toString(value).toLowerCase();\n};\n\n// Filter the data based on the search value and conditions\nconst getFilteredData = (data, searchObj, visibleCols = []) => {\n    const searchVal = getSearchValue(searchObj.value, searchObj.type);\n    let currentVal;\n    // Return whole data if\n    // - search value is undefined and matchmode is not an empty matchmode type\n    // - search value is null and datatype is number. Null can not be compared with numeric values[WMS-19275].\n    if ((!isDefined(searchVal) && !includes(emptyMatchModes, searchObj.matchMode)) || (isNumberType(searchObj.type) && isNull(searchObj.value))) {\n        return data;\n    }\n    data = data.filter((obj) => {\n        let isExists;\n        if (searchObj.field) {\n            currentVal = getSearchValue(get(obj, searchObj.field), searchObj.type);\n        } else {\n            currentVal = [];\n            forEach(obj, (val, key) => {\n                if ((includes(visibleCols, key))) {\n                    currentVal.push(val);\n                } else {\n                    // WMS-22271 If the key is in nested key format (dot format)\n                    // Find all the indexes of the key in visiblecols and extract their values from obj\n                    const colIndex = filter(range(visibleCols.length), (i) => visibleCols[i].includes(key));\n                    forEach(colIndex, (index) => {\n                        // @ts-ignore\n                        const value = get(obj, visibleCols[index]);\n                        if (currentVal.indexOf(value) < 0) {\n                            currentVal.push(value);\n                        }\n                    });\n                }\n            });\n            currentVal = currentVal.join(' ').toLowerCase(); // If field is not there, search on all the columns\n        }\n        switch (searchObj.matchMode) {\n            case 'start':\n                isExists = startsWith(currentVal, searchVal as string);\n                break;\n            case 'end':\n                isExists = endsWith(currentVal, searchVal as string);\n                break;\n            case 'exact':\n                isExists = isEqual(currentVal, searchVal);\n                break;\n            case 'notequals':\n                isExists = !isEqual(currentVal, searchVal);\n                break;\n            case 'null':\n                isExists = isNull(currentVal);\n                break;\n            case 'isnotnull':\n                isExists = !isNull(currentVal);\n                break;\n            case 'empty':\n                isExists = isEmpty(currentVal);\n                break;\n            case 'isnotempty':\n                isExists = !isEmpty(currentVal);\n                break;\n            case 'nullorempty':\n                isExists = isNull(currentVal) || isEmpty(currentVal);\n                break;\n            case 'lessthan':\n                isExists = currentVal < searchVal;\n                break;\n            case 'lessthanequal':\n                isExists = currentVal <= searchVal;\n                break;\n            case 'greaterthan':\n                isExists = currentVal > searchVal;\n                break;\n            case 'greaterthanequal':\n                isExists = currentVal >= searchVal;\n                break;\n            default:\n                isExists = isNumberType(searchObj.type) ? isEqual(currentVal, searchVal) : includes(currentVal, searchVal);\n                break;\n        }\n        return isExists;\n    });\n    return data;\n};\n\n// Set the filter fields when the search value is specified and field is not selected\nconst setAllFilterFields = function(filterFields, searchObj, visibleCols) {\n    visibleCols.forEach(function(field) {\n        filterFields[field] = {\n            'value': searchObj.value,\n            'type' : searchObj.value.type,\n            'logicalOp': 'OR'\n        };\n        if (searchObj.matchMode) {\n            filterFields[field].matchMode = searchObj.matchMode;\n        }\n    });\n};\n\n// Set the filter fields as required by datasource\nconst setFilterFields = (filterFields, searchObj, visibleCols = []) => {\n    const field = searchObj && searchObj.field;\n    /*Set the filter options when a field/column has been selected.*/\n    if (field) {\n        filterFields[field] = {\n            'value'     : searchObj.value,\n            'logicalOp' : 'AND'\n        };\n        if (searchObj.matchMode) {\n            filterFields[field].matchMode = searchObj.matchMode;\n        }\n    } else {\n        /*Set the filter options when a field/column hasn't been selected.*/\n        setAllFilterFields(filterFields, searchObj, visibleCols);\n    }\n};\n\n// Transform filter fields from array to object having field names as keys\nconst transformFilterField = (userFilters, filterField) => {\n    if (filterField.field) {\n        userFilters[filterField.field] = {\n            value: filterField.value,\n            matchMode: filterField.matchMode,\n            type: filterField.type\n        };\n    }\n};\n\n// Build a filter Fields object\nconst addToFilterFields = (filterFields, searchObj) => {\n    filterFields.push({\n        field: (searchObj.key) ? searchObj.key : '',\n        matchMode: searchObj.matchMode,\n        type: searchObj.type,\n        value: searchObj.value\n    });\n};\n\n@Directive({\n  standalone: true,\n    selector: '[wmTableFilterSort]'\n})\nexport class TableFilterSortDirective implements OnDestroy {\n\n    constructor(@Self() @Inject(TableComponent) private table) {\n        table._searchSortHandler = this.searchSortHandler.bind(this);\n        table.getSearchResult = this.getSearchResult.bind(this);\n        table.getSortResult = this.getSortResult.bind(this);\n        table.checkFiltersApplied = this.checkFiltersApplied.bind(this);\n        table.getFilterFields = this.getFilterFields.bind(this);\n        table.onRowFilterChange = this.onRowFilterChange.bind(this);\n        table.onFilterConditionSelect = this.onFilterConditionSelect.bind(this);\n        table.showClearIcon = this.showClearIcon.bind(this);\n        table.clearRowFilter = this.clearRowFilter.bind(this);\n        table.matchModeTypesMap = getMatchModeTypesMap();\n        table.matchModeMsgs = getMatchModeMsgs(table.appLocale);\n        table.emptyMatchModes = emptyMatchModes;\n        table.getNavigationTargetBySortInfo = this.getNavigationTargetBySortInfo.bind(this);\n        table.refreshData = this.refreshData.bind(this);\n        table.clearFilter = this.clearFilter.bind(this);\n        table.adjustContainer = this.adjustContainer.bind(this);\n    }\n\n    adjustContainer(fieldName) {\n        setTimeout(() => {\n            adjustContainerRightEdges($('bs-dropdown-container'), this.table.rowFilterCompliedTl[fieldName], this.table, $('bs-dropdown-container .dropdown-menu'));\n        });\n    }\n\n    // Get first or last page based on sort info of primary key\n    getNavigationTargetBySortInfo() {\n        return this.table.sortInfo && this.table.sortInfo.direction === 'desc' &&\n        includes(this.table.primaryKey, this.table.sortInfo.field) ? 'first' : 'last';\n    }\n\n    // Returns all the columns of the table wherein, showinfilter is set to true\n    getTableVisibleCols() {\n        const visibleCols = [];\n        forEach(this.table.columns, (val, col) => {\n            if (toLower(toString(val.showinfilter)) === 'true' && col !== 'rowOperations' && val.searchable) {\n                visibleCols.push(col);\n            }\n        });\n        return visibleCols;\n    }\n\n    // call the set filter fields function based on the field selected or not\n    invokeSetFilterfieldBasedOnFieldval(searchObj, filterFields) {\n        if (searchObj.field) {\n            setFilterFields(filterFields, searchObj);\n        } else if (!isEmpty(searchObj)) {\n           const visibleCols = this.getTableVisibleCols();\n            setFilterFields(filterFields, searchObj, visibleCols);\n        }\n    }\n\n    // Get the filter fields as required by datasource\n    getFilterFields(searchObj) {\n        searchObj = searchObj || {};\n        const filterFields = {};\n        if (isArray(searchObj)) {\n            forEach(searchObj, obj => {\n               this.invokeSetFilterfieldBasedOnFieldval(obj, filterFields);\n            });\n        } else {\n            this.invokeSetFilterfieldBasedOnFieldval(searchObj, filterFields);\n        }\n        return filterFields;\n    }\n\n    // Get the logical operator for the search filter\n    getLogicalOperator(filterFields) {\n        let operator = '';\n        for (const field in filterFields) {\n            operator = filterFields[field]['logicalOp'] || '';\n            break;\n        }\n        return operator;\n    }\n\n    // Reset the sort based on sort returned by the call\n    resetSortStatus(variableSort) {\n        let gridSortString;\n        if (!isEmpty(this.table.sortInfo) && this.table.datasource) {\n            gridSortString = this.table.sortInfo.field + ' ' + this.table.sortInfo.direction;\n            variableSort = this.table.datasource.execute(DataSource.Operation.GET_OPTIONS).orderBy || variableSort;\n            if (variableSort) { // If multiple order by fields are present, compare with the first one\n                variableSort = head(split(variableSort, ','));\n            }\n            if (gridSortString !== variableSort) {\n                this.table.callDataGridMethod('resetSortIcons');\n                this.table.sortInfo = {};\n                this.table.setDataGridOption('sortInfo', {});\n            }\n        }\n    }\n\n    // Clear the all the filters applied\n    clearFilter(skipFilter) {\n        let $gridElement;\n        this.table.filterInfo = {};\n        if (this.table.filtermode === 'multicolumn') {\n            this.table.fieldDefs.forEach(col => {\n                if (col.resetFilter) {\n                    col.resetFilter();\n                }\n            });\n            if (!skipFilter) {\n                this.table.onRowFilterChange();\n            }\n        } else if (this.table.filtermode === 'search') {\n            $gridElement = this.table.datagridElement;\n            $gridElement.find('[data-element=\"dgSearchText\"]').val('');\n            $gridElement.find('[data-element=\"dgFilterValue\"]').val('');\n            if (!skipFilter) {\n                $gridElement.find('.app-search-button').trigger('click');\n            }\n        }\n    }\n\n    // Check the filters applied and remove if dat does not contain any filters\n    checkFiltersApplied(variableSort) {\n        if (!this.table.datasource) {\n            return;\n        }\n        if (this.table.datasource.execute(DataSource.Operation.SUPPORTS_SERVER_FILTER)) {\n            if (isEmpty(this.table.datasource.execute(DataSource.Operation.GET_OPTIONS).filterFields)) {\n                this.clearFilter(true);\n            }\n            this.resetSortStatus(variableSort);\n            return;\n        }\n        if (this.table.datasource.execute(DataSource.Operation.IS_PAGEABLE)) {\n            this.resetSortStatus(variableSort);\n        }\n    }\n\n    // Returns data filtered using searchObj\n    getSearchResult(data, searchObj) {\n        const visibleCols = this.getTableVisibleCols();\n        if (!searchObj) {\n            return data;\n        }\n        if (isArray(searchObj)) {\n            searchObj.forEach((obj) => {\n                data = getFilteredData(data, obj, visibleCols);\n            });\n        } else {\n            data = getFilteredData(data, searchObj, visibleCols);\n        }\n        return data;\n    }\n    // Function that checks if a given string is a valid date and returns the timestamp if it is, or NaN if it's not.\n    parseDateString(dateString) {\n        const timestamp = Date.parse(dateString);\n        // handling case when string starts with string and end with number\n        const trimmed = dateString.trim();\n        const monthRegex = /\\b(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)\\b/i;\n        if (/^[A-Za-z]+/.test(trimmed) && /\\d+$/.test(trimmed)  && !monthRegex.test(trimmed)) {\n            return NaN;\n        }\n        if (!isNaN(timestamp)) {\n            return timestamp;\n        } else { // Since Date.parse() doesn't support all date formats, manually validating the date.\n            const parts = dateString?.split(/[-/\\s]+/)?.map(Number) || [];\n            return  new Date(parts[2], parts[1] - 1, parts[0]).getTime();\n        }\n        return NaN;\n    }\n\n    // Returns data sorted using sortObj\n    getSortResult(data, sortObj) {\n        if (sortObj && sortObj.direction) {\n            const fieldValue = get(find(data, sortObj.field), sortObj.field)\n            const isValidDateString = typeof fieldValue === 'string' ?  this.parseDateString(fieldValue) : NaN;\n            if (!isNaN(isValidDateString)) { // if the field is a date string\n                data = orderBy(data, [(item) => this.parseDateString(get(item, sortObj.field))], [sortObj.direction]);\n            } else if (sortObj.sortBy ? this.table.columns[sortObj.sortBy]?.caseinsensitive : this.table.columns[sortObj.field]?.caseinsensitive) {\n                //Fix for [WMS-27505]: Added case-insensitive sorting so that uppercase and lowercase letters are treated the same when sorting.\n                    data = orderBy(data, [\n                          (item) => {\n                            const val = get(item, sortObj.field);\n                            return typeof val === 'string' ? val.toLowerCase() : val;\n                          },\n                          (item) => get(item, sortObj.field) // fallback to original value\n                        ],\n                        [sortObj.direction, sortObj.direction]\n                      );\n            } else {\n                data = orderBy(data, sortObj.field, sortObj.direction);\n            }\n        }\n        return data;\n    }\n\n    // This method handles the client side sort and search\n    private handleClientSideSortSearch(searchSortObj, e, type) {\n        this.table._isClientSearch = true;\n\n        let data;\n        data = this.table.isNavigationEnabled() ? getClonedObject(this.table.__fullData) : getClonedObject(this.table.dataset);\n        if (type === 'search') {\n            this.table.filterInfo = searchSortObj;\n        } else {\n            this.table.sortInfo = searchSortObj;\n        }\n        if (isObject(data) && !isArray(data)) {\n            data = [data];\n        }\n        /*Both the functions return same 'data' if arguments are undefined*/\n        data = this.getSearchResult(data, this.table.filterInfo);\n        data = this.getSortResult(data, this.table.sortInfo);\n        this.table.serverData = data;\n\n        if (type === 'sort') {\n            // Calling 'onSort' event\n            this.table.invokeEventCallback('sort', {$event: e, $data: {\n                    data: this.table.serverData,\n                    sortDirection: this.table.sortInfo.direction,\n                    colDef: this.table.columns[this.table.sortInfo.field]\n                }});\n        }\n\n        if (this.table.isNavigationEnabled()) {\n            // Reset the page number to 1\n            this.table.dataNavigator.dn.currentPage = 1;\n            this.table.dataNavigator.setPagingValues(data);\n        } else {\n            this.table.setGridData(this.table.serverData);\n        }\n    }\n\n    // This method handles the search for pageable datasource\n    private handleSinglePageSearch(searchObj) {\n        this.table._isPageSearch = true;\n\n        let data  = getClonedObject(this.table.gridData);\n        const $rows = this.table.datagridElement.find('tbody tr.app-datagrid-row');\n        this.table.filterInfo = searchObj;\n        data = this.getSearchResult(data, searchObj);\n        // Compared the filtered data and original data, to show or hide the rows\n        forEach(this.table.gridData, (value, index) => {\n            const $row = $($rows[index]);\n            if (find(data, obj => isEqual(obj, value))) {\n                $row.show();\n            } else {\n                $row.hide();\n            }\n        });\n        if (data && data.length) {\n            this.table.callDataGridMethod('setStatus', 'ready');\n            // Select the first row after the search for single select\n            if (this.table.gridfirstrowselect && !this.table.multiselect) {\n                this.table.callDataGridMethod('selectFirstRow', true, true);\n            }\n        } else {\n            this.table.callDataGridMethod('setStatus', 'nodata', this.table.nodatamessage);\n            this.table.selecteditem = undefined;\n        }\n        this.table.callDataGridMethod('updateSelectAllCheckboxState');\n    }\n\n    // This method handles the search for server side variables\n    private handleServerSideSearch(searchObj) {\n        this.table.filterInfo = searchObj;\n\n        if (!this.table.datasource) {\n            return;\n        }\n\n        const sortInfo     = this.table.sortInfo;\n        const sortOptions  = sortInfo && sortInfo.direction ? (sortInfo.field + ' ' + sortInfo.direction) : '';\n        const filterFields = this.getFilterFields(searchObj);\n        const logicalOp = this.getLogicalOperator(filterFields);\n        refreshDataSource(this.table.datasource, {\n            page: 1,\n            filterFields : filterFields,\n            orderBy : sortOptions,\n            condition : logicalOp\n        }).then(() => {\n            $appDigest();\n        }, () => {\n            this.table.toggleMessage(true, 'error', this.table.nodatamessage);\n        });\n    }\n\n    // This method handles the sort for server side variables\n    private handleSeverSideSort(sortObj, e, statePersistenceTriggered?) {\n        // Update the sort info for passing to datagrid\n        this.table.gridOptions.sortInfo.field = sortObj.field;\n        this.table.gridOptions.sortInfo.direction = sortObj.direction;\n        this.table.sortInfo = getClonedObject(sortObj);\n\n        const sortOptions  = sortObj && sortObj.direction ? (sortObj.field + ' ' + sortObj.direction) : '';\n        const filterFields = this.getFilterFields(this.table.filterInfo);\n        const condition = this.getLogicalOperator(filterFields);\n        if (!statePersistenceTriggered && this.table.getConfiguredState() !== 'none') {\n            this.table.statePersistence.removeWidgetState(this.table, 'pagination');\n        }\n\n        refreshDataSource(this.table.datasource, {\n            page : 1,\n            filterFields : filterFields,\n            orderBy : sortOptions,\n            condition : condition\n        }).then((response) => {\n            $appDigest();\n            const data = (response && response.data) ? response.data : response;\n            this.table.invokeEventCallback('sort', {$event: e, $data: {\n                    data,\n                    sortDirection: sortObj.direction,\n                    colDef: this.table.columns[sortObj.field]\n\n                    }\n            });\n        });\n    }\n\n    private searchHandler(searchSortObj, e, type, statePersistenceTriggered?) {\n        let obj;\n        if (isArray(searchSortObj)) {\n            obj = searchSortObj.filter(function(searchObject) {\n                return (searchObject.matchMode !== undefined && searchObject.value !== undefined) || (searchObject.value !== undefined && searchObject.field === '');\n            });\n        } else {\n            obj = {field: searchSortObj.field, value: searchSortObj.value, type: searchSortObj.type};\n        }\n        if (this.table.getConfiguredState() !== 'none' && unsupportedStatePersistenceTypes.indexOf(this.table.navigation) < 0) {\n            if ((isArray(searchSortObj) && obj.length) || (searchSortObj.value)) {\n                this.table.statePersistence.removeWidgetState(this.table, 'search');\n                this.table.statePersistence.setWidgetState(this.table, {search: obj});\n            } else {\n                this.table.statePersistence.removeWidgetState(this.table, 'search');\n            }\n            if (!statePersistenceTriggered) {\n                this.table.statePersistence.removeWidgetState(this.table, 'pagination');\n                this.table.statePersistence.removeWidgetState(this.table, 'selectedItem');\n            }\n        } else {\n            console.warn('Retain State handling on Widget ' + this.table.name + ' is not supported for current pagination type.');\n        }\n        let filterFields = getClonedObject(searchSortObj);\n        const dataSource = this.table.datasource;\n        if (!dataSource && !this.table.dataset) {\n            return;\n        }\n        let output;\n        const userFilters = {};\n        // Transform filter fields from array to object having field names as keys\n        if (isArray(filterFields)) {\n            filterFields.forEach(filterField => {\n                transformFilterField(userFilters, filterField);\n            });\n        } else {\n            transformFilterField(userFilters, filterFields);\n        }\n        output = this.table.invokeEventCallback('beforefilter', {$event: e, $data: userFilters, columns: userFilters});\n        // If callback returns false, don't trigger the filter call\n        if (output === false) {\n            return;\n        }\n        filterFields = [];\n        // if the field is not selected in search filter dropdown, building the filter fields object\n        if (isEmpty(userFilters) && !isEmpty(obj)) {\n            if (isArray(obj)) {\n                forEach(obj, searchObj => {\n                    addToFilterFields(filterFields, searchObj);\n                });\n            } else {\n                addToFilterFields(filterFields, obj);\n            }\n        } else {\n            // Transform back the filter fields from object to array\n            forEach(userFilters, (val, key) => {\n                // @ts-ignore\n                filterFields.push({field: key, matchMode: val.matchMode, type: val.type, value: val.value});\n            });\n        }\n        if (dataSource && dataSource.execute(DataSource.Operation.SUPPORTS_SERVER_FILTER)) {\n            this.handleServerSideSearch(filterFields);\n            return;\n        }\n        if (dataSource && dataSource.execute(DataSource.Operation.IS_API_AWARE) && dataSource.execute(DataSource.Operation.IS_PAGEABLE)) {\n            this.handleSinglePageSearch(filterFields);\n        } else {\n            this.handleClientSideSortSearch(filterFields, e, type);\n        }\n    }\n\n    private sortHandler(searchSortObj, e, type, statePersistenceTriggered?) {\n        const dataSource = this.table.datasource;\n        if (!dataSource && !this.table.dataset) {\n            return;\n        }\n        if (!statePersistenceTriggered && this.table.getConfiguredState() !== 'none' && unsupportedStatePersistenceTypes.indexOf(this.table.navigation) < 0) {\n            const obj = {direction: searchSortObj.direction, field: searchSortObj.field};\n            if (searchSortObj.direction) {\n                this.table.statePersistence.setWidgetState(this.table, {sort: obj});\n            } else {\n                this.table.statePersistence.removeWidgetState(this.table, 'sort');\n            }\n            this.table.statePersistence.removeWidgetState(this.table, 'selectedItem');\n        } else {\n            console.warn('Retain State handling on Widget ' + this.table.name + ' is not supported for current pagination type.');\n        }\n\n        // WMS-22387: For server side pagination, execute client side sorting\n        if (dataSource && dataSource.execute(DataSource.Operation.IS_SORTABLE)) {\n            this.handleSeverSideSort(searchSortObj, e, statePersistenceTriggered);\n        } else {\n            this.handleClientSideSortSearch(searchSortObj, e, type);\n        }\n    }\n    // set the 'lastAction' performed on the table to 'search_or_sort'\n    setLastActionPerformedToSearchSort() {\n        this.table.gridOptions.setLastActionPerformed(this.table.gridOptions.ACTIONS.SEARCH_OR_SORT);\n        this.table.gridOptions.setIsSearchTrigerred(true);\n    }\n\n    // This method is triggered by jquery table\n    searchSortHandler(searchSortObj, e, type, statePersistenceTriggered?) {\n        const event_type = e ? e.type : '';\n        if (event_type === 'change' && this.table.filtermode !== 'multicolumn') {\n            e.stopPropagation();\n        } else {\n            this.setLastActionPerformedToSearchSort();\n            if (type === 'search') {\n                this.searchHandler(searchSortObj, e, type, statePersistenceTriggered);\n            } else {\n                this.sortHandler(searchSortObj, e, type, statePersistenceTriggered);\n            }\n        }\n    }\n\n    // Method to show/hide clear icon in multi column filter\n    showClearIcon(fieldName) {\n        const value = this.table.rowFilter[fieldName] && this.table.rowFilter[fieldName].value;\n        return isDefined(value) && value !== '' && value !== null;\n    }\n\n    // Method clear the filter value in multi column filter\n    clearRowFilter(fieldName) {\n        if (this.table.rowFilter && this.table.rowFilter[fieldName]) {\n            this.table.columns[fieldName].resetFilter();\n            this.onRowFilterChange(fieldName);\n        }\n    }\n\n    // This method is triggered on select of condition in multi column filter\n    onFilterConditionSelect(fieldName, condition) {\n        this.table.rowFilter[fieldName] = this.table.rowFilter[fieldName] || {};\n        this.table.rowFilter[fieldName].matchMode = condition;\n        // For empty match modes, clear off the value and call filter\n        if (includes(this.table.emptyMatchModes, condition)) {\n            this.table.columns[fieldName].resetFilter();\n            this.table.onRowFilterChange();\n        } else {\n            // If value is present, call the filter. Else, focus on the field\n            if (isDefined(this.table.rowFilter[fieldName].value) && this.table.rowFilter[fieldName].value !== '') {\n                this.table.onRowFilterChange();\n            } else {\n                setTimeout(() => {\n                    this.table.columns[fieldName].filterInstance.focus();\n                });\n            }\n        }\n    }\n\n    // Method to get the updated values when filter on field is changed for multicolumn filter\n    private getFilterOnFieldValues(filterDef) {\n        if (!this.table.datasource || !this.table.datasource.execute(DataSource.Operation.SUPPORTS_DISTINCT_API)) {\n            return;\n        }\n\n        const fieldName = filterDef.field;\n        const formFields = this.table.fullFieldDefs;\n        const filterOnFields = filter(formFields, {'filteronfilter': fieldName});\n        const newVal = get(this.table.rowFilter, [fieldName, 'value']);\n\n        // Loop over the fields for which the current field is filter on field\n        forEach(filterOnFields, filterField => {\n            const filterOn = filterField.filteronfilter;\n            const filterKey = filterField.field;\n            const filterFields = {};\n            const filterWidget = filterField.filterwidget;\n\n            if (!isDataSetWidget(filterWidget) || filterOn === filterKey || filterField.isFilterDataSetBound) {\n                return;\n            }\n\n            filterFields[filterOn] = (isDefined(newVal) && newVal !== '' && newVal !== null) ? {'value' : newVal} : {};\n\n            if (filterWidget === FormWidgetType.AUTOCOMPLETE && filterField.filterInstance.dataoptions) {\n                filterField.filterInstance.dataoptions.filterFields = filterFields;\n            } else {\n                this.table.datasource.execute(DataSource.Operation.GET_DISTINCT_DATA_BY_FIELDS, {\n                    'fields'         : filterKey,\n                    'filterFields'   : filterFields\n                }).then(data => {\n                    filterField.filterdataset = data.data;\n                });\n            }\n        });\n    }\n\n    // This method is triggered on value change in multi column filter\n    onRowFilterChange(fieldName) {\n        const searchObj = [];\n        const field = find(this.table.fullFieldDefs, {'field': fieldName});\n        // Convert row filters to a search object and call search handler\n        forEach(this.table.rowFilter, (value, key) => {\n            if ((isDefined(value.value) && value.value !== '') || includes(this.table.emptyMatchModes, value.matchMode)) {\n                if (field && key === field.field) {\n                    value.type      = value.type || field.type;\n                    value.matchMode = value.matchMode || get(this.table.matchModeTypesMap[value.type], 0);\n                }\n                searchObj.push({\n                    field: key,\n                    value: value.value,\n                    matchMode: value.matchMode,\n                    type: value.type\n                });\n            }\n        });\n        this.table.gridOptions.searchHandler(searchObj, undefined, 'search');\n\n        // If field is passed, update any filter on field values if present\n        if (field) {\n            this.getFilterOnFieldValues(field);\n        }\n    }\n\n    refreshData(isSamePage) {\n        if (!this.table.datasource) {\n            return;\n        }\n        const page = isSamePage ? this.table.dataNavigator.dn.currentPage : 1;\n        const sortInfo     = this.table.sortInfo;\n        const sortOptions  = sortInfo && sortInfo.direction ? (sortInfo.field + ' ' + sortInfo.direction) : '';\n        const filterFields = this.getFilterFields(this.table.filterInfo);\n        const logicalOp = this.getLogicalOperator(filterFields);\n        refreshDataSource(this.table.datasource, {\n            page: page,\n            filterFields : filterFields,\n            orderBy : sortOptions,\n            condition : logicalOp\n        });\n    }\n\n    ngOnDestroy() {\n        // MEMORY LEAK FIX: Clear table reference\n        this.table = null;\n    }\n}\n"]}