devextreme 23.1.2-beta.2 → 23.1.3

package/esm/ui/grid_core/ui.grid_core.filter_row.js

@@ -1,873 +1,9 @@
 /**
  * DevExtreme (esm/ui/grid_core/ui.grid_core.filter_row.js)
- * Version: 23.1.2
- * Build date: Fri May 26 2023
+ * Version: 23.1.3
+ * Build date: Fri Jun 09 2023
  *
  * Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
  * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
  */
-import _extends from "@babel/runtime/helpers/esm/extends";
-import {
-    getOuterWidth
-} from "../../core/utils/size";
-import $ from "../../core/renderer";
-import eventsEngine from "../../events/core/events_engine";
-import {
-    isDefined
-} from "../../core/utils/type";
-import {
-    extend
-} from "../../core/utils/extend";
-import {
-    normalizeKeyName
-} from "../../events/utils/index";
-import {
-    each,
-    map
-} from "../../core/utils/iterator";
-import modules from "./ui.grid_core.modules";
-import gridCoreUtils from "./ui.grid_core.utils";
-import messageLocalization from "../../localization/message";
-import Editor from "../editor/editor";
-import Overlay from "../overlay/ui.overlay";
-import Menu from "../menu";
-import {
-    selectView
-} from "../shared/accessibility";
-import {
-    equalByValue
-} from "../../core/utils/common";
-var OPERATION_ICONS = {
-    "=": "filter-operation-equals",
-    "<>": "filter-operation-not-equals",
-    "<": "filter-operation-less",
-    "<=": "filter-operation-less-equal",
-    ">": "filter-operation-greater",
-    ">=": "filter-operation-greater-equal",
-    default: "filter-operation-default",
-    notcontains: "filter-operation-not-contains",
-    contains: "filter-operation-contains",
-    startswith: "filter-operation-starts-with",
-    endswith: "filter-operation-ends-with",
-    between: "filter-operation-between"
-};
-var OPERATION_DESCRIPTORS = {
-    "=": "equal",
-    "<>": "notEqual",
-    "<": "lessThan",
-    "<=": "lessThanOrEqual",
-    ">": "greaterThan",
-    ">=": "greaterThanOrEqual",
-    startswith: "startsWith",
-    contains: "contains",
-    notcontains: "notContains",
-    endswith: "endsWith",
-    between: "between"
-};
-var FILTERING_TIMEOUT = 700;
-var CORRECT_FILTER_RANGE_OVERLAY_WIDTH = 1;
-var FILTER_ROW_CLASS = "filter-row";
-var FILTER_RANGE_OVERLAY_CLASS = "filter-range-overlay";
-var FILTER_RANGE_START_CLASS = "filter-range-start";
-var FILTER_RANGE_END_CLASS = "filter-range-end";
-var MENU_CLASS = "dx-menu";
-var EDITOR_WITH_MENU_CLASS = "dx-editor-with-menu";
-var EDITOR_CONTAINER_CLASS = "dx-editor-container";
-var EDITOR_CELL_CLASS = "dx-editor-cell";
-var FILTER_MENU = "dx-filter-menu";
-var APPLY_BUTTON_CLASS = "dx-apply-button";
-var HIGHLIGHT_OUTLINE_CLASS = "dx-highlight-outline";
-var FOCUSED_CLASS = "dx-focused";
-var CELL_FOCUS_DISABLED_CLASS = "dx-cell-focus-disabled";
-var FILTER_RANGE_CONTENT_CLASS = "dx-filter-range-content";
-var FILTER_MODIFIED_CLASS = "dx-filter-modified";
-var EDITORS_INPUT_SELECTOR = "input:not([type='hidden'])";
-var BETWEEN_OPERATION_DATA_TYPES = ["date", "datetime", "number"];
-var ARIA_SEARCH_BOX = messageLocalization.format("dxDataGrid-ariaSearchBox");
-
-function isOnClickApplyFilterMode(that) {
-    return "onClick" === that.option("filterRow.applyFilter")
-}
-var getEditorInstance = function($editorContainer) {
-    var $editor = $editorContainer && $editorContainer.children();
-    var componentNames = $editor && $editor.data("dxComponents");
-    var editor = componentNames && componentNames.length && $editor.data(componentNames[0]);
-    if (editor instanceof Editor) {
-        return editor
-    }
-};
-var ColumnHeadersViewFilterRowExtender = function() {
-    var getRangeTextByFilterValue = function(that, column) {
-        var result = "";
-        var rangeEnd = "";
-        var filterValue = getColumnFilterValue(that, column);
-        var formatOptions = gridCoreUtils.getFormatOptionsByColumn(column, "filterRow");
-        if (Array.isArray(filterValue)) {
-            result = gridCoreUtils.formatValue(filterValue[0], formatOptions);
-            rangeEnd = gridCoreUtils.formatValue(filterValue[1], formatOptions);
-            if ("" !== rangeEnd) {
-                result += " - " + rangeEnd
-            }
-        } else if (isDefined(filterValue)) {
-            result = gridCoreUtils.formatValue(filterValue, formatOptions)
-        }
-        return result
-    };
-
-    function getColumnFilterValue(that, column) {
-        if (column) {
-            return isOnClickApplyFilterMode(that) && void 0 !== column.bufferedFilterValue ? column.bufferedFilterValue : column.filterValue
-        }
-    }
-    var getColumnSelectedFilterOperation = function(that, column) {
-        if (column) {
-            return isOnClickApplyFilterMode(that) && void 0 !== column.bufferedSelectedFilterOperation ? column.bufferedSelectedFilterOperation : column.selectedFilterOperation
-        }
-    };
-    var getFilterValue = function(that, columnIndex, $editorContainer) {
-        var column = that._columnsController.columnOption(columnIndex);
-        var filterValue = getColumnFilterValue(that, column);
-        var isFilterRange = $editorContainer.closest("." + that.addWidgetPrefix(FILTER_RANGE_OVERLAY_CLASS)).length;
-        var isRangeStart = $editorContainer.hasClass(that.addWidgetPrefix(FILTER_RANGE_START_CLASS));
-        if (filterValue && Array.isArray(filterValue) && "between" === getColumnSelectedFilterOperation(that, column)) {
-            if (isRangeStart) {
-                return filterValue[0]
-            } else {
-                return filterValue[1]
-            }
-        }
-        return !isFilterRange && function(filterValue, column) {
-            if (column && BETWEEN_OPERATION_DATA_TYPES.indexOf(column.dataType) >= 0 && Array.isArray(filterValue)) {
-                return false
-            }
-            return void 0 !== filterValue
-        }(filterValue, column) ? filterValue : null
-    };
-    var updateFilterValue = function(that, options) {
-        var value = "" === options.value ? null : options.value;
-        var $editorContainer = options.container;
-        var column = that._columnsController.columnOption(options.column.index);
-        var filterValue = getFilterValue(that, column.index, $editorContainer);
-        if (!isDefined(filterValue) && !isDefined(value)) {
-            return
-        }
-        that._applyFilterViewController.setHighLight($editorContainer, filterValue !== value);
-        var columnOptionName = isOnClickApplyFilterMode(that) ? "bufferedFilterValue" : "filterValue";
-        var normalizedValue = function(that, filterValue, column, $editorContainer) {
-            if ("between" === getColumnSelectedFilterOperation(that, column)) {
-                var columnFilterValue = getColumnFilterValue(that, column);
-                if ($editorContainer.hasClass(that.addWidgetPrefix(FILTER_RANGE_START_CLASS))) {
-                    return [filterValue, Array.isArray(columnFilterValue) ? columnFilterValue[1] : void 0]
-                } else {
-                    return [Array.isArray(columnFilterValue) ? columnFilterValue[0] : columnFilterValue, filterValue]
-                }
-            }
-            return filterValue
-        }(that, value, column, $editorContainer);
-        var isBetween = "between" === getColumnSelectedFilterOperation(that, column);
-        var notFireEvent = options.notFireEvent || isBetween && Array.isArray(normalizedValue) && normalizedValue.indexOf(void 0) >= 0;
-        that._columnsController.columnOption(column.index, columnOptionName, normalizedValue, notFireEvent)
-    };
-    return {
-        _updateEditorValue: function(column, $editorContainer) {
-            var editor = getEditorInstance($editorContainer);
-            editor && editor.option("value", getFilterValue(this, column.index, $editorContainer))
-        },
-        _columnOptionChanged: function(e) {
-            var optionNames = e.optionNames;
-            var $cell;
-            var $editorContainer;
-            var $editorRangeElements;
-            var $menu;
-            if (gridCoreUtils.checkChanges(optionNames, ["filterValue", "bufferedFilterValue", "selectedFilterOperation", "bufferedSelectedFilterOperation", "filterValues", "filterType"]) && void 0 !== e.columnIndex) {
-                var visibleIndex = this._columnsController.getVisibleIndex(e.columnIndex);
-                var column = this._columnsController.columnOption(e.columnIndex);
-                $cell = this._getCellElement(this.element().find("." + this.addWidgetPrefix(FILTER_ROW_CLASS)).index(), visibleIndex) || $();
-                $editorContainer = $cell.find("." + EDITOR_CONTAINER_CLASS).first();
-                if (optionNames.filterValue || optionNames.bufferedFilterValue) {
-                    this._updateEditorValue(column, $editorContainer);
-                    var overlayInstance = $cell.find("." + this.addWidgetPrefix(FILTER_RANGE_OVERLAY_CLASS)).data("dxOverlay");
-                    if (overlayInstance) {
-                        $editorRangeElements = overlayInstance.$content().find("." + EDITOR_CONTAINER_CLASS);
-                        this._updateEditorValue(column, $editorRangeElements.first());
-                        this._updateEditorValue(column, $editorRangeElements.last())
-                    }
-                    if (!overlayInstance || !overlayInstance.option("visible")) {
-                        this._updateFilterRangeContent($cell, getRangeTextByFilterValue(this, column))
-                    }
-                }
-                if (optionNames.selectedFilterOperation || optionNames.bufferedSelectedFilterOperation) {
-                    if (visibleIndex >= 0 && column) {
-                        $menu = $cell.find("." + MENU_CLASS);
-                        if ($menu.length) {
-                            this._updateFilterOperationChooser($menu, column, $editorContainer);
-                            if ("between" === getColumnSelectedFilterOperation(this, column)) {
-                                this._renderFilterRangeContent($cell, column)
-                            } else if ($editorContainer.find("." + FILTER_RANGE_CONTENT_CLASS).length) {
-                                this._renderEditor($editorContainer, this._getEditorOptions($editorContainer, column));
-                                this._hideFilterRange()
-                            }
-                        }
-                    }
-                }
-                return
-            }
-            this.callBase(e)
-        },
-        _renderCore: function() {
-            this._filterRangeOverlayInstance = null;
-            return this.callBase.apply(this, arguments)
-        },
-        _resizeCore: function() {
-            this.callBase.apply(this, arguments);
-            this._filterRangeOverlayInstance && this._filterRangeOverlayInstance.repaint()
-        },
-        isFilterRowVisible: function() {
-            return this._isElementVisible(this.option("filterRow"))
-        },
-        isVisible: function() {
-            return this.callBase() || this.isFilterRowVisible()
-        },
-        init: function() {
-            this.callBase();
-            this._applyFilterViewController = this.getController("applyFilter")
-        },
-        _initFilterRangeOverlay: function($cell, column) {
-            var that = this;
-            var sharedData = {};
-            var $editorContainer = $cell.find(".dx-editor-container");
-            var filterRangeOverlayClass = that.addWidgetPrefix(FILTER_RANGE_OVERLAY_CLASS);
-            var $overlay = $("<div>").addClass(filterRangeOverlayClass).appendTo($cell);
-            return that._createComponent($overlay, Overlay, {
-                height: "auto",
-                shading: false,
-                showTitle: false,
-                focusStateEnabled: false,
-                hideOnOutsideClick: true,
-                wrapperAttr: {
-                    class: filterRangeOverlayClass
-                },
-                animation: false,
-                position: {
-                    my: "top",
-                    at: "top",
-                    of: $editorContainer.length && $editorContainer || $cell,
-                    offset: "0 -1"
-                },
-                contentTemplate: function(contentElement) {
-                    var editorOptions;
-                    var $editor = $("<div>").addClass(EDITOR_CONTAINER_CLASS + " " + that.addWidgetPrefix(FILTER_RANGE_START_CLASS)).appendTo(contentElement);
-                    column = that._columnsController.columnOption(column.index);
-                    editorOptions = that._getEditorOptions($editor, column);
-                    editorOptions.sharedData = sharedData;
-                    that._renderEditor($editor, editorOptions);
-                    eventsEngine.on($editor.find(EDITORS_INPUT_SELECTOR), "keydown", (function(e) {
-                        var $prevElement = $cell.find("[tabindex]").not(e.target).first();
-                        if ("tab" === normalizeKeyName(e) && e.shiftKey) {
-                            e.preventDefault();
-                            that._hideFilterRange();
-                            if (!$prevElement.length) {
-                                $prevElement = $cell.prev().find("[tabindex]").last()
-                            }
-                            eventsEngine.trigger($prevElement, "focus")
-                        }
-                    }));
-                    $editor = $("<div>").addClass(EDITOR_CONTAINER_CLASS + " " + that.addWidgetPrefix(FILTER_RANGE_END_CLASS)).appendTo(contentElement);
-                    editorOptions = that._getEditorOptions($editor, column);
-                    editorOptions.sharedData = sharedData;
-                    that._renderEditor($editor, editorOptions);
-                    eventsEngine.on($editor.find(EDITORS_INPUT_SELECTOR), "keydown", (function(e) {
-                        if ("tab" === normalizeKeyName(e) && !e.shiftKey) {
-                            e.preventDefault();
-                            that._hideFilterRange();
-                            eventsEngine.trigger($cell.next().find("[tabindex]").first(), "focus")
-                        }
-                    }));
-                    return $(contentElement).addClass(that.getWidgetContainerClass())
-                },
-                onShown: function(e) {
-                    var $editor = e.component.$content().find("." + EDITOR_CONTAINER_CLASS).first();
-                    eventsEngine.trigger($editor.find(EDITORS_INPUT_SELECTOR), "focus")
-                },
-                onHidden: function() {
-                    column = that._columnsController.columnOption(column.index);
-                    $cell.find("." + MENU_CLASS).parent().addClass(EDITOR_WITH_MENU_CLASS);
-                    if ("between" === getColumnSelectedFilterOperation(that, column)) {
-                        that._updateFilterRangeContent($cell, getRangeTextByFilterValue(that, column));
-                        that.component.updateDimensions()
-                    }
-                }
-            })
-        },
-        _updateFilterRangeOverlay: function(options) {
-            var overlayInstance = this._filterRangeOverlayInstance;
-            overlayInstance && overlayInstance.option(options)
-        },
-        _showFilterRange: function($cell, column) {
-            var $overlay = $cell.children("." + this.addWidgetPrefix(FILTER_RANGE_OVERLAY_CLASS));
-            var overlayInstance = $overlay.length && $overlay.data("dxOverlay");
-            if (!overlayInstance && column) {
-                overlayInstance = this._initFilterRangeOverlay($cell, column)
-            }
-            if (!overlayInstance.option("visible")) {
-                this._filterRangeOverlayInstance && this._filterRangeOverlayInstance.hide();
-                this._filterRangeOverlayInstance = overlayInstance;
-                this._updateFilterRangeOverlay({
-                    width: getOuterWidth($cell, true) + CORRECT_FILTER_RANGE_OVERLAY_WIDTH
-                });
-                this._filterRangeOverlayInstance && this._filterRangeOverlayInstance.show()
-            }
-        },
-        _hideFilterRange: function() {
-            var overlayInstance = this._filterRangeOverlayInstance;
-            overlayInstance && overlayInstance.hide()
-        },
-        getFilterRangeOverlayInstance: function() {
-            return this._filterRangeOverlayInstance
-        },
-        _createRow: function(row) {
-            var $row = this.callBase(row);
-            if ("filter" === row.rowType) {
-                $row.addClass(this.addWidgetPrefix(FILTER_ROW_CLASS));
-                if (!this.option("useLegacyKeyboardNavigation")) {
-                    eventsEngine.on($row, "keydown", event => selectView("filterRow", this, event))
-                }
-            }
-            return $row
-        },
-        _getRows: function() {
-            var result = this.callBase();
-            if (this.isFilterRowVisible()) {
-                result.push({
-                    rowType: "filter"
-                })
-            }
-            return result
-        },
-        _renderFilterCell: function(cell, options) {
-            var column = options.column;
-            var $cell = $(cell);
-            if (this.component.option("showColumnHeaders")) {
-                this.setAria("describedby", column.headerId, $cell)
-            }
-            this.setAria("label", messageLocalization.format("dxDataGrid-ariaFilterCell"), $cell);
-            $cell.addClass(EDITOR_CELL_CLASS);
-            var $container = $("<div>").appendTo($cell);
-            var $editorContainer = $("<div>").addClass(EDITOR_CONTAINER_CLASS).appendTo($container);
-            if ("between" === getColumnSelectedFilterOperation(this, column)) {
-                this._renderFilterRangeContent($cell, column)
-            } else {
-                var editorOptions = this._getEditorOptions($editorContainer, column);
-                this._renderEditor($editorContainer, editorOptions)
-            }
-            var alignment = column.alignment;
-            if (alignment && "center" !== alignment) {
-                $cell.find(EDITORS_INPUT_SELECTOR).first().css("textAlign", column.alignment)
-            }
-            if (column.filterOperations && column.filterOperations.length) {
-                this._renderFilterOperationChooser($container, column, $editorContainer)
-            }
-        },
-        _renderCellContent: function($cell, options) {
-            var that = this;
-            var column = options.column;
-            if ("filter" === options.rowType) {
-                if (column.command) {
-                    $cell.html("&nbsp;")
-                } else if (column.allowFiltering) {
-                    that.renderTemplate($cell, that._renderFilterCell.bind(that), options).done(() => {
-                        that._updateCell($cell, options)
-                    });
-                    return
-                }
-            }
-            this.callBase.apply(this, arguments)
-        },
-        _getEditorOptions: function($editorContainer, column) {
-            var that = this;
-            var accessibilityOptions = {
-                editorOptions: {
-                    inputAttr: that._getFilterInputAccessibilityAttributes(column)
-                }
-            };
-            var result = extend(accessibilityOptions, column, {
-                value: getFilterValue(that, column.index, $editorContainer),
-                parentType: "filterRow",
-                showAllText: that.option("filterRow.showAllText"),
-                updateValueTimeout: "onClick" === that.option("filterRow.applyFilter") ? 0 : FILTERING_TIMEOUT,
-                width: null,
-                setValue: function(value, notFireEvent) {
-                    updateFilterValue(that, {
-                        column: column,
-                        value: value,
-                        container: $editorContainer,
-                        notFireEvent: notFireEvent
-                    })
-                }
-            });
-            if ("between" === getColumnSelectedFilterOperation(that, column)) {
-                if ($editorContainer.hasClass(that.addWidgetPrefix(FILTER_RANGE_START_CLASS))) {
-                    result.placeholder = that.option("filterRow.betweenStartText")
-                } else {
-                    result.placeholder = that.option("filterRow.betweenEndText")
-                }
-            }
-            return result
-        },
-        _getFilterInputAccessibilityAttributes: function(column) {
-            var columnAriaLabel = messageLocalization.format("dxDataGrid-ariaFilterCell");
-            if (this.component.option("showColumnHeaders")) {
-                return {
-                    "aria-label": columnAriaLabel,
-                    "aria-describedby": column.headerId
-                }
-            }
-            return {
-                "aria-label": columnAriaLabel
-            }
-        },
-        _renderEditor: function($editorContainer, options) {
-            $editorContainer.empty();
-            var $element = $("<div>").appendTo($editorContainer);
-            var editorController = this.getController("editorFactory");
-            var dataSource = this.getController("data").dataSource();
-            var filterRowController = this.getController("applyFilter");
-            if (options.lookup && this.option("syncLookupFilterValues")) {
-                filterRowController.setCurrentColumnForFiltering(options);
-                var filter = this.getController("data").getCombinedFilter();
-                filterRowController.setCurrentColumnForFiltering(null);
-                var lookupDataSource = gridCoreUtils.getWrappedLookupDataSource(options, dataSource, filter);
-                var lookupOptions = _extends({}, options, {
-                    lookup: _extends({}, options.lookup, {
-                        dataSource: lookupDataSource
-                    })
-                });
-                return editorController.createEditor($element, lookupOptions)
-            } else {
-                return editorController.createEditor($element, options)
-            }
-        },
-        _renderFilterRangeContent: function($cell, column) {
-            var that = this;
-            var $editorContainer = $cell.find("." + EDITOR_CONTAINER_CLASS).first();
-            $editorContainer.empty();
-            var $filterRangeContent = $("<div>").addClass(FILTER_RANGE_CONTENT_CLASS).attr("tabindex", this.option("tabIndex"));
-            eventsEngine.on($filterRangeContent, "focusin", (function() {
-                that._showFilterRange($cell, column)
-            }));
-            $filterRangeContent.appendTo($editorContainer);
-            that._updateFilterRangeContent($cell, getRangeTextByFilterValue(that, column))
-        },
-        _updateFilterRangeContent: function($cell, value) {
-            var $filterRangeContent = $cell.find("." + FILTER_RANGE_CONTENT_CLASS);
-            if ($filterRangeContent.length) {
-                if ("" === value) {
-                    $filterRangeContent.html("&nbsp;")
-                } else {
-                    $filterRangeContent.text(value)
-                }
-            }
-        },
-        _updateFilterOperationChooser: function($menu, column, $editorContainer) {
-            var that = this;
-            var isCellWasFocused;
-            var restoreFocus = function() {
-                var menu = Menu.getInstance($menu);
-                menu && menu.option("focusedElement", null);
-                isCellWasFocused && that._focusEditor($editorContainer)
-            };
-            that._createComponent($menu, Menu, {
-                integrationOptions: {},
-                activeStateEnabled: false,
-                selectionMode: "single",
-                cssClass: that.getWidgetContainerClass() + " " + CELL_FOCUS_DISABLED_CLASS + " " + FILTER_MENU,
-                showFirstSubmenuMode: "onHover",
-                hideSubmenuOnMouseLeave: true,
-                elementAttr: {
-                    "aria-label": ARIA_SEARCH_BOX
-                },
-                items: [{
-                    disabled: column.filterOperations && column.filterOperations.length ? false : true,
-                    icon: OPERATION_ICONS[getColumnSelectedFilterOperation(that, column) || "default"],
-                    selectable: false,
-                    items: that._getFilterOperationMenuItems(column)
-                }],
-                onItemClick: function(properties) {
-                    var selectedFilterOperation = properties.itemData.name;
-                    var columnSelectedFilterOperation = getColumnSelectedFilterOperation(that, column);
-                    var notFocusEditor = false;
-                    var isOnClickMode = isOnClickApplyFilterMode(that);
-                    var options = {};
-                    if (properties.itemData.items || selectedFilterOperation && selectedFilterOperation === columnSelectedFilterOperation) {
-                        return
-                    }
-                    if (selectedFilterOperation) {
-                        options[isOnClickMode ? "bufferedSelectedFilterOperation" : "selectedFilterOperation"] = selectedFilterOperation;
-                        if ("between" === selectedFilterOperation || "between" === columnSelectedFilterOperation) {
-                            notFocusEditor = "between" === selectedFilterOperation;
-                            options[isOnClickMode ? "bufferedFilterValue" : "filterValue"] = null
-                        }
-                    } else {
-                        options[isOnClickMode ? "bufferedFilterValue" : "filterValue"] = null;
-                        options[isOnClickMode ? "bufferedSelectedFilterOperation" : "selectedFilterOperation"] = column.defaultSelectedFilterOperation || null
-                    }
-                    that._columnsController.columnOption(column.index, options);
-                    that._applyFilterViewController.setHighLight($editorContainer, true);
-                    if (!selectedFilterOperation) {
-                        var editor = getEditorInstance($editorContainer);
-                        if (editor && "dxDateBox" === editor.NAME && !editor.option("isValid")) {
-                            editor.reset();
-                            editor.option("isValid", true)
-                        }
-                    }
-                    if (!notFocusEditor) {
-                        that._focusEditor($editorContainer)
-                    } else {
-                        that._showFilterRange($editorContainer.closest("." + EDITOR_CELL_CLASS), column)
-                    }
-                },
-                onSubmenuShowing: function() {
-                    isCellWasFocused = that._isEditorFocused($editorContainer);
-                    that.getController("editorFactory").loseFocus()
-                },
-                onSubmenuHiding: function() {
-                    eventsEngine.trigger($menu, "blur");
-                    restoreFocus()
-                },
-                onContentReady: function(e) {
-                    eventsEngine.on($menu, "blur", () => {
-                        var menu = e.component;
-                        menu._hideSubmenuAfterTimeout();
-                        restoreFocus()
-                    })
-                },
-                rtlEnabled: that.option("rtlEnabled")
-            })
-        },
-        _isEditorFocused: function($container) {
-            return $container.hasClass(FOCUSED_CLASS) || $container.parents("." + FOCUSED_CLASS).length
-        },
-        _focusEditor: function($container) {
-            this.getController("editorFactory").focus($container);
-            eventsEngine.trigger($container.find(EDITORS_INPUT_SELECTOR), "focus")
-        },
-        _renderFilterOperationChooser: function($container, column, $editorContainer) {
-            var $menu;
-            if (this.option("filterRow.showOperationChooser")) {
-                $container.addClass(EDITOR_WITH_MENU_CLASS);
-                $menu = $("<div>").prependTo($container);
-                this._updateFilterOperationChooser($menu, column, $editorContainer)
-            }
-        },
-        _getFilterOperationMenuItems: function(column) {
-            var that = this;
-            var result = [{}];
-            var filterRowOptions = that.option("filterRow");
-            var operationDescriptions = filterRowOptions && filterRowOptions.operationDescriptions || {};
-            if (column.filterOperations && column.filterOperations.length) {
-                var availableFilterOperations = column.filterOperations.filter((function(value) {
-                    return isDefined(OPERATION_DESCRIPTORS[value])
-                }));
-                result = map(availableFilterOperations, (function(value) {
-                    var descriptionName = OPERATION_DESCRIPTORS[value];
-                    return {
-                        name: value,
-                        selected: (getColumnSelectedFilterOperation(that, column) || column.defaultFilterOperation) === value,
-                        text: operationDescriptions[descriptionName],
-                        icon: OPERATION_ICONS[value]
-                    }
-                }));
-                result.push({
-                    name: null,
-                    text: filterRowOptions && filterRowOptions.resetOperationText,
-                    icon: OPERATION_ICONS.default
-                })
-            }
-            return result
-        },
-        _handleDataChanged: function(e) {
-            var _e$operationTypes, _e$operationTypes2;
-            this.callBase.apply(this, arguments);
-            if (null !== (_e$operationTypes = e.operationTypes) && void 0 !== _e$operationTypes && _e$operationTypes.filtering || null !== (_e$operationTypes2 = e.operationTypes) && void 0 !== _e$operationTypes2 && _e$operationTypes2.fullReload) {
-                var _e$operationTypes3;
-                this.updateLookupDataSource(null === (_e$operationTypes3 = e.operationTypes) || void 0 === _e$operationTypes3 ? void 0 : _e$operationTypes3.filtering)
-            }
-        },
-        updateLookupDataSource: function(filterChanged) {
-            if (!this.option("syncLookupFilterValues")) {
-                return
-            }
-            if (!this.element()) {
-                return
-            }
-            var columns = this._columnsController.getVisibleColumns();
-            var dataSource = this._dataController.dataSource();
-            var applyFilterViewController = this._applyFilterViewController;
-            var rowIndex = this.element().find("." + this.addWidgetPrefix(FILTER_ROW_CLASS)).index();
-            if (-1 === rowIndex) {
-                return
-            }
-            columns.forEach((column, index) => {
-                if (!column.lookup || column.calculateCellValue !== column.defaultCalculateCellValue) {
-                    return
-                }
-                var $cell = this._getCellElement(rowIndex, index);
-                var editor = getEditorInstance(null === $cell || void 0 === $cell ? void 0 : $cell.find(".dx-editor-container"));
-                if (editor) {
-                    applyFilterViewController.setCurrentColumnForFiltering(column);
-                    var filter = this._dataController.getCombinedFilter() || null;
-                    applyFilterViewController.setCurrentColumnForFiltering(null);
-                    var editorDataSource = editor.option("dataSource");
-                    var shouldUpdateFilter = !filterChanged || !equalByValue(editorDataSource.__dataGridSourceFilter, filter);
-                    if (shouldUpdateFilter) {
-                        var lookupDataSource = gridCoreUtils.getWrappedLookupDataSource(column, dataSource, filter);
-                        editor.option("dataSource", lookupDataSource)
-                    }
-                }
-            })
-        },
-        optionChanged: function(args) {
-            switch (args.name) {
-                case "filterRow":
-                case "showColumnLines":
-                    this._invalidate(true, true);
-                    args.handled = true;
-                    break;
-                case "syncLookupFilterValues":
-                    if (args.value) {
-                        this.updateLookupDataSource()
-                    } else {
-                        this.render()
-                    }
-                    args.handled = true;
-                    break;
-                default:
-                    this.callBase(args)
-            }
-        }
-    }
-}();
-var DataControllerFilterRowExtender = {
-    skipCalculateColumnFilters: function() {
-        return false
-    },
-    _calculateAdditionalFilter: function() {
-        if (this.skipCalculateColumnFilters()) {
-            return this.callBase()
-        }
-        var filters = [this.callBase()];
-        var columns = this._columnsController.getVisibleColumns(null, true);
-        var filterRowController = this.getController("applyFilter");
-        each(columns, (function() {
-            var _filterRowController$;
-            var shouldSkip = (null === (_filterRowController$ = filterRowController.getCurrentColumnForFiltering()) || void 0 === _filterRowController$ ? void 0 : _filterRowController$.index) === this.index;
-            if (this.allowFiltering && this.calculateFilterExpression && isDefined(this.filterValue) && !shouldSkip) {
-                var filter = this.createFilterExpression(this.filterValue, this.selectedFilterOperation || this.defaultFilterOperation, "filterRow");
-                filters.push(filter)
-            }
-        }));
-        return gridCoreUtils.combineFilters(filters)
-    }
-};
-var ApplyFilterViewController = modules.ViewController.inherit({
-    _getHeaderPanel: function() {
-        if (!this._headerPanel) {
-            this._headerPanel = this.getView("headerPanel")
-        }
-        return this._headerPanel
-    },
-    setHighLight: function($element, value) {
-        if (isOnClickApplyFilterMode(this)) {
-            $element && $element.toggleClass(HIGHLIGHT_OUTLINE_CLASS, value) && $element.closest("." + EDITOR_CELL_CLASS).toggleClass(FILTER_MODIFIED_CLASS, value);
-            this._getHeaderPanel().enableApplyButton(value)
-        }
-    },
-    applyFilter: function() {
-        var columnsController = this.getController("columns");
-        var columns = columnsController.getColumns();
-        columnsController.beginUpdate();
-        for (var i = 0; i < columns.length; i++) {
-            var column = columns[i];
-            if (void 0 !== column.bufferedFilterValue) {
-                columnsController.columnOption(i, "filterValue", column.bufferedFilterValue);
-                column.bufferedFilterValue = void 0
-            }
-            if (void 0 !== column.bufferedSelectedFilterOperation) {
-                columnsController.columnOption(i, "selectedFilterOperation", column.bufferedSelectedFilterOperation);
-                column.bufferedSelectedFilterOperation = void 0
-            }
-        }
-        columnsController.endUpdate();
-        this.removeHighLights()
-    },
-    removeHighLights: function() {
-        if (isOnClickApplyFilterMode(this)) {
-            var columnHeadersViewElement = this.getView("columnHeadersView").element();
-            columnHeadersViewElement.find("." + this.addWidgetPrefix(FILTER_ROW_CLASS) + " ." + HIGHLIGHT_OUTLINE_CLASS).removeClass(HIGHLIGHT_OUTLINE_CLASS);
-            columnHeadersViewElement.find("." + this.addWidgetPrefix(FILTER_ROW_CLASS) + " ." + FILTER_MODIFIED_CLASS).removeClass(FILTER_MODIFIED_CLASS);
-            this._getHeaderPanel().enableApplyButton(false)
-        }
-    },
-    setCurrentColumnForFiltering: function(column) {
-        this._currentColumn = column
-    },
-    getCurrentColumnForFiltering: function() {
-        return this._currentColumn
-    }
-});
-export var filterRowModule = {
-    defaultOptions: function() {
-        return {
-            syncLookupFilterValues: true,
-            filterRow: {
-                visible: false,
-                showOperationChooser: true,
-                showAllText: messageLocalization.format("dxDataGrid-filterRowShowAllText"),
-                resetOperationText: messageLocalization.format("dxDataGrid-filterRowResetOperationText"),
-                applyFilter: "auto",
-                applyFilterText: messageLocalization.format("dxDataGrid-applyFilterText"),
-                operationDescriptions: {
-                    equal: messageLocalization.format("dxDataGrid-filterRowOperationEquals"),
-                    notEqual: messageLocalization.format("dxDataGrid-filterRowOperationNotEquals"),
-                    lessThan: messageLocalization.format("dxDataGrid-filterRowOperationLess"),
-                    lessThanOrEqual: messageLocalization.format("dxDataGrid-filterRowOperationLessOrEquals"),
-                    greaterThan: messageLocalization.format("dxDataGrid-filterRowOperationGreater"),
-                    greaterThanOrEqual: messageLocalization.format("dxDataGrid-filterRowOperationGreaterOrEquals"),
-                    startsWith: messageLocalization.format("dxDataGrid-filterRowOperationStartsWith"),
-                    contains: messageLocalization.format("dxDataGrid-filterRowOperationContains"),
-                    notContains: messageLocalization.format("dxDataGrid-filterRowOperationNotContains"),
-                    endsWith: messageLocalization.format("dxDataGrid-filterRowOperationEndsWith"),
-                    between: messageLocalization.format("dxDataGrid-filterRowOperationBetween"),
-                    isBlank: messageLocalization.format("dxFilterBuilder-filterOperationIsBlank"),
-                    isNotBlank: messageLocalization.format("dxFilterBuilder-filterOperationIsNotBlank")
-                },
-                betweenStartText: messageLocalization.format("dxDataGrid-filterRowOperationBetweenStartText"),
-                betweenEndText: messageLocalization.format("dxDataGrid-filterRowOperationBetweenEndText")
-            }
-        }
-    },
-    controllers: {
-        applyFilter: ApplyFilterViewController
-    },
-    extenders: {
-        controllers: {
-            data: DataControllerFilterRowExtender,
-            columnsResizer: {
-                _startResizing: function() {
-                    var that = this;
-                    that.callBase.apply(that, arguments);
-                    if (that.isResizing()) {
-                        var overlayInstance = that._columnHeadersView.getFilterRangeOverlayInstance();
-                        if (overlayInstance) {
-                            var cellIndex = overlayInstance.$element().closest("td").index();
-                            if (cellIndex === that._targetPoint.columnIndex || cellIndex === that._targetPoint.columnIndex + 1) {
-                                overlayInstance.$content().hide()
-                            }
-                        }
-                    }
-                },
-                _endResizing: function() {
-                    var that = this;
-                    var $cell;
-                    if (that.isResizing()) {
-                        var overlayInstance = that._columnHeadersView.getFilterRangeOverlayInstance();
-                        if (overlayInstance) {
-                            $cell = overlayInstance.$element().closest("td");
-                            that._columnHeadersView._updateFilterRangeOverlay({
-                                width: getOuterWidth($cell, true) + CORRECT_FILTER_RANGE_OVERLAY_WIDTH
-                            });
-                            overlayInstance.$content().show()
-                        }
-                    }
-                    that.callBase.apply(that, arguments)
-                }
-            },
-            editing: {
-                updateFieldValue(options) {
-                    if (options.column.lookup) {
-                        this._needUpdateLookupDataSource = true
-                    }
-                    return this.callBase.apply(this, arguments)
-                },
-                _afterSaveEditData(cancel) {
-                    if (this._needUpdateLookupDataSource && !cancel) {
-                        var _this$getView;
-                        null === (_this$getView = this.getView("columnHeadersView")) || void 0 === _this$getView ? void 0 : _this$getView.updateLookupDataSource()
-                    }
-                    this._needUpdateLookupDataSource = false;
-                    return this.callBase.apply(this, arguments)
-                },
-                _afterCancelEditData() {
-                    this._needUpdateLookupDataSource = false;
-                    return this.callBase.apply(this, arguments)
-                }
-            }
-        },
-        views: {
-            columnHeadersView: ColumnHeadersViewFilterRowExtender,
-            headerPanel: {
-                _getToolbarItems: function() {
-                    var items = this.callBase();
-                    var filterItem = this._prepareFilterItem(items);
-                    return filterItem.concat(items)
-                },
-                _prepareFilterItem: function() {
-                    var that = this;
-                    var filterItem = [];
-                    if (that._isShowApplyFilterButton()) {
-                        var hintText = that.option("filterRow.applyFilterText");
-                        var columns = that._columnsController.getColumns();
-                        var disabled = !columns.filter((function(column) {
-                            return void 0 !== column.bufferedFilterValue
-                        })).length;
-                        var toolbarItem = {
-                            widget: "dxButton",
-                            options: {
-                                icon: "apply-filter",
-                                disabled: disabled,
-                                onClick: function() {
-                                    that._applyFilterViewController.applyFilter()
-                                },
-                                hint: hintText,
-                                text: hintText,
-                                onInitialized: function(e) {
-                                    $(e.element).addClass(that._getToolbarButtonClass(APPLY_BUTTON_CLASS))
-                                }
-                            },
-                            showText: "inMenu",
-                            name: "applyFilterButton",
-                            location: "after",
-                            locateInMenu: "auto",
-                            sortIndex: 10
-                        };
-                        filterItem.push(toolbarItem)
-                    }
-                    return filterItem
-                },
-                _isShowApplyFilterButton: function() {
-                    var filterRowOptions = this.option("filterRow");
-                    return filterRowOptions && filterRowOptions.visible && "onClick" === filterRowOptions.applyFilter
-                },
-                init: function() {
-                    this.callBase();
-                    this._dataController = this.getController("data");
-                    this._applyFilterViewController = this.getController("applyFilter")
-                },
-                enableApplyButton: function(value) {
-                    this.setToolbarItemDisabled("applyFilterButton", !value)
-                },
-                isVisible: function() {
-                    return this.callBase() || this._isShowApplyFilterButton()
-                },
-                optionChanged: function(args) {
-                    if ("filterRow" === args.name) {
-                        this._invalidate();
-                        args.handled = true
-                    } else {
-                        this.callBase(args)
-                    }
-                }
-            }
-        }
-    }
-};
+export * from "../../__internal/grids/grid_core/filter_row/module";