@mui/x-data-grid 5.4.0 → 5.6.0

package/node/hooks/features/export/useGridPrintExport.js

@@ -0,0 +1,251 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridPrintExport = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _utils = require("@mui/material/utils");
+
+var _useGridLogger = require("../../utils/useGridLogger");
+
+var _gridFilterSelector = require("../filter/gridFilterSelector");
+
+var _gridColumnsSelector = require("../columns/gridColumnsSelector");
+
+var _densitySelector = require("../density/densitySelector");
+
+var _gridClasses = require("../../../constants/gridClasses");
+
+var _useGridApiMethod = require("../../utils/useGridApiMethod");
+
+var _gridRowsMetaSelector = require("../rows/gridRowsMetaSelector");
+
+var _utils2 = require("./utils");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/**
+ * @requires useGridColumns (state)
+ * @requires useGridFilter (state)
+ * @requires useGridSorting (state)
+ * @requires useGridParamsApi (method)
+ */
+const useGridPrintExport = (apiRef, props) => {
+  const logger = (0, _useGridLogger.useGridLogger)(apiRef, 'useGridPrintExport');
+  const doc = React.useRef(null);
+  const previousGridState = React.useRef(null);
+  const previousColumnVisibility = React.useRef({});
+  React.useEffect(() => {
+    doc.current = (0, _utils.ownerDocument)(apiRef.current.rootElementRef.current);
+  }, [apiRef]); // Returns a promise because updateColumns triggers state update and
+  // the new state needs to be in place before the grid can be sized correctly
+
+  const updateGridColumnsForPrint = React.useCallback((fields, allColumns) => new Promise(resolve => {
+    if (!fields && !allColumns) {
+      resolve();
+      return;
+    }
+
+    const exportedColumnFields = (0, _utils2.getColumnsToExport)({
+      apiRef,
+      options: {
+        fields,
+        allColumns
+      }
+    }).map(column => column.field);
+    const columns = (0, _gridColumnsSelector.gridColumnDefinitionsSelector)(apiRef);
+    const newColumnVisibilityModel = {};
+    columns.forEach(column => {
+      newColumnVisibilityModel[column.field] = exportedColumnFields.includes(column.field);
+    });
+    apiRef.current.setColumnVisibilityModel(newColumnVisibilityModel);
+    resolve();
+  }), [apiRef]);
+  const buildPrintWindow = React.useCallback(title => {
+    const iframeEl = document.createElement('iframe');
+    iframeEl.id = 'grid-print-window'; // Without this 'onload' event won't fire in some browsers
+
+    iframeEl.src = window.location.href;
+    iframeEl.style.position = 'absolute';
+    iframeEl.style.width = '0px';
+    iframeEl.style.height = '0px';
+    iframeEl.title = title || document.title;
+    return iframeEl;
+  }, []);
+  const handlePrintWindowLoad = React.useCallback((printWindow, options) => {
+    var _printWindow$contentW, _querySelector, _querySelector2;
+
+    const normalizeOptions = (0, _extends2.default)({
+      copyStyles: true,
+      hideToolbar: false,
+      hideFooter: false
+    }, options); // Some agents, such as IE11 and Enzyme (as of 2 Jun 2020) continuously call the
+    // `onload` callback. This ensures that it is only called once.
+
+    printWindow.onload = null;
+    const printDoc = printWindow.contentDocument || ((_printWindow$contentW = printWindow.contentWindow) == null ? void 0 : _printWindow$contentW.document);
+
+    if (!printDoc) {
+      return;
+    }
+
+    const headerHeight = (0, _densitySelector.gridDensityHeaderHeightSelector)(apiRef);
+    const rowsMeta = (0, _gridRowsMetaSelector.gridRowsMetaSelector)(apiRef.current.state);
+    const gridRootElement = apiRef.current.rootElementRef.current;
+    const gridClone = gridRootElement.cloneNode(true);
+    const gridCloneViewport = gridClone.querySelector(`.${_gridClasses.gridClasses.virtualScroller}`); // Expand the viewport window to prevent clipping
+
+    gridCloneViewport.style.height = 'auto';
+    gridCloneViewport.style.width = 'auto';
+    gridCloneViewport.parentElement.style.width = 'auto';
+    gridCloneViewport.parentElement.style.height = 'auto'; // Allow to overflow to not hide the border of the last row
+
+    const gridMain = gridClone.querySelector(`.${_gridClasses.gridClasses.main}`);
+    gridMain.style.overflow = 'visible';
+    const columnHeaders = gridClone.querySelector(`.${_gridClasses.gridClasses.columnHeaders}`);
+    const columnHeadersInner = columnHeaders.querySelector(`.${_gridClasses.gridClasses.columnHeadersInner}`);
+    columnHeadersInner.style.width = '100%';
+    let gridToolbarElementHeight = ((_querySelector = gridRootElement.querySelector(`.${_gridClasses.gridClasses.toolbarContainer}`)) == null ? void 0 : _querySelector.clientHeight) || 0;
+    let gridFooterElementHeight = ((_querySelector2 = gridRootElement.querySelector(`.${_gridClasses.gridClasses.footerContainer}`)) == null ? void 0 : _querySelector2.clientHeight) || 0;
+
+    if (normalizeOptions.hideToolbar) {
+      var _gridClone$querySelec;
+
+      (_gridClone$querySelec = gridClone.querySelector(`.${_gridClasses.gridClasses.toolbarContainer}`)) == null ? void 0 : _gridClone$querySelec.remove();
+      gridToolbarElementHeight = 0;
+    }
+
+    if (normalizeOptions.hideFooter) {
+      var _gridClone$querySelec2;
+
+      (_gridClone$querySelec2 = gridClone.querySelector(`.${_gridClasses.gridClasses.footerContainer}`)) == null ? void 0 : _gridClone$querySelec2.remove();
+      gridFooterElementHeight = 0;
+    } // Expand container height to accommodate all rows
+
+
+    gridClone.style.height = `${rowsMeta.currentPageTotalHeight + headerHeight + gridToolbarElementHeight + gridFooterElementHeight}px`; // Remove all loaded elements from the current host
+
+    printDoc.body.innerHTML = '';
+    printDoc.body.appendChild(gridClone);
+    const defaultPageStyle = typeof normalizeOptions.pageStyle === 'function' ? normalizeOptions.pageStyle() : normalizeOptions.pageStyle;
+
+    if (typeof defaultPageStyle === 'string') {
+      // TODO custom styles should always win
+      const styleElement = printDoc.createElement('style');
+      styleElement.appendChild(printDoc.createTextNode(defaultPageStyle));
+      printDoc.head.appendChild(styleElement);
+    }
+
+    if (normalizeOptions.bodyClassName) {
+      printDoc.body.classList.add(...normalizeOptions.bodyClassName.split(' '));
+    }
+
+    if (normalizeOptions.copyStyles) {
+      const headStyleElements = doc.current.querySelectorAll("style, link[rel='stylesheet']");
+
+      for (let i = 0; i < headStyleElements.length; i += 1) {
+        const node = headStyleElements[i];
+
+        if (node.tagName === 'STYLE') {
+          const newHeadStyleElements = printDoc.createElement(node.tagName);
+          const sheet = node.sheet;
+
+          if (sheet) {
+            let styleCSS = ''; // NOTE: for-of is not supported by IE
+
+            for (let j = 0; j < sheet.cssRules.length; j += 1) {
+              if (typeof sheet.cssRules[j].cssText === 'string') {
+                styleCSS += `${sheet.cssRules[j].cssText}\r\n`;
+              }
+            }
+
+            newHeadStyleElements.appendChild(printDoc.createTextNode(styleCSS));
+            printDoc.head.appendChild(newHeadStyleElements);
+          }
+        } else if (node.getAttribute('href')) {
+          // If `href` tag is empty, avoid loading these links
+          const newHeadStyleElements = printDoc.createElement(node.tagName);
+
+          for (let j = 0; j < node.attributes.length; j += 1) {
+            const attr = node.attributes[j];
+
+            if (attr) {
+              newHeadStyleElements.setAttribute(attr.nodeName, attr.nodeValue || '');
+            }
+          }
+
+          printDoc.head.appendChild(newHeadStyleElements);
+        }
+      }
+    } // Trigger print
+
+
+    if (process.env.NODE_ENV !== 'test') {
+      printWindow.contentWindow.print();
+    }
+  }, [apiRef, doc]);
+  const handlePrintWindowAfterPrint = React.useCallback(printWindow => {
+    var _previousGridState$cu, _previousGridState$cu2;
+
+    // Remove the print iframe
+    doc.current.body.removeChild(printWindow); // Revert grid to previous state
+
+    apiRef.current.restoreState(previousGridState.current || {});
+
+    if (!((_previousGridState$cu = previousGridState.current) != null && (_previousGridState$cu2 = _previousGridState$cu.columns) != null && _previousGridState$cu2.columnVisibilityModel)) {
+      // if the apiRef.current.exportState(); did not exported the column visibility, we update it
+      apiRef.current.setColumnVisibilityModel(previousColumnVisibility.current);
+    }
+
+    apiRef.current.unstable_enableVirtualization(); // Clear local state
+
+    previousGridState.current = null;
+    previousColumnVisibility.current = {};
+  }, [apiRef]);
+  const exportDataAsPrint = React.useCallback(async options => {
+    logger.debug(`Export data as Print`);
+
+    if (!apiRef.current.rootElementRef.current) {
+      throw new Error('MUI: No grid root element available.');
+    }
+
+    previousGridState.current = apiRef.current.exportState(); // It appends that the visibility model is not exported, especially if columnVisibility is not controlled
+
+    previousColumnVisibility.current = (0, _gridColumnsSelector.gridColumnVisibilityModelSelector)(apiRef);
+
+    if (props.pagination) {
+      const visibleRowCount = (0, _gridFilterSelector.gridVisibleRowCountSelector)(apiRef);
+      apiRef.current.setPageSize(visibleRowCount);
+    }
+
+    await updateGridColumnsForPrint(options == null ? void 0 : options.fields, options == null ? void 0 : options.allColumns);
+    apiRef.current.unstable_disableVirtualization();
+    const printWindow = buildPrintWindow(options == null ? void 0 : options.fileName);
+    doc.current.body.appendChild(printWindow);
+
+    if (process.env.NODE_ENV === 'test') {
+      // In test env, run the all pipeline without waiting for loading
+      handlePrintWindowLoad(printWindow, options);
+      handlePrintWindowAfterPrint(printWindow);
+    } else {
+      printWindow.onload = () => handlePrintWindowLoad(printWindow, options);
+
+      printWindow.contentWindow.onafterprint = () => handlePrintWindowAfterPrint(printWindow);
+    }
+  }, [props, logger, apiRef, buildPrintWindow, handlePrintWindowLoad, handlePrintWindowAfterPrint, updateGridColumnsForPrint]);
+  const printExportApi = {
+    exportDataAsPrint
+  };
+  (0, _useGridApiMethod.useGridApiMethod)(apiRef, printExportApi, 'GridPrintExportApi');
+};
+
+exports.useGridPrintExport = useGridPrintExport;

package/node/hooks/features/export/utils.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getColumnsToExport = void 0;
+
+var _columns = require("../columns");
+
+const getColumnsToExport = ({
+  apiRef,
+  options
+}) => {
+  const columns = (0, _columns.gridColumnDefinitionsSelector)(apiRef);
+
+  if (options.fields) {
+    return options.fields.map(field => columns.find(column => column.field === field)).filter(column => !!column);
+  }
+
+  const validColumns = options.allColumns ? columns : (0, _columns.gridVisibleColumnDefinitionsSelector)(apiRef);
+  return validColumns.filter(column => !column.disableExport);
+};
+
+exports.getColumnsToExport = getColumnsToExport;

package/node/hooks/features/filter/gridFilterSelector.js

@@ -0,0 +1,169 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.gridVisibleTopLevelRowCountSelector = exports.gridVisibleSortedTopLevelRowEntriesSelector = exports.gridVisibleSortedRowIdsSelector = exports.gridVisibleSortedRowEntriesSelector = exports.gridVisibleRowsSelector = exports.gridVisibleRowsLookupSelector = exports.gridVisibleRowCountSelector = exports.gridFilteredSortedRowIdsSelector = exports.gridFilteredSortedRowEntriesSelector = exports.gridFilteredRowsLookupSelector = exports.gridFilteredDescendantCountLookupSelector = exports.gridFilterStateSelector = exports.gridFilterModelSelector = exports.gridFilterActiveItemsSelector = exports.gridFilterActiveItemsLookupSelector = void 0;
+
+var _createSelector = require("../../../utils/createSelector");
+
+var _gridSortingSelector = require("../sorting/gridSortingSelector");
+
+var _gridColumnsSelector = require("../columns/gridColumnsSelector");
+
+var _gridRowsSelector = require("../rows/gridRowsSelector");
+
+/**
+ * @category Filtering
+ */
+const gridFilterStateSelector = state => state.filter;
+/**
+ * Get the current filter model.
+ * @category Filtering
+ */
+
+
+exports.gridFilterStateSelector = gridFilterStateSelector;
+const gridFilterModelSelector = (0, _createSelector.createSelector)(gridFilterStateSelector, filterState => filterState.filterModel);
+/**
+ * @category Filtering
+ * @ignore - do not document.
+ */
+
+exports.gridFilterModelSelector = gridFilterModelSelector;
+const gridVisibleRowsLookupSelector = (0, _createSelector.createSelector)(gridFilterStateSelector, filterState => filterState.visibleRowsLookup);
+/**
+ * @category Filtering
+ * @ignore - do not document.
+ */
+
+exports.gridVisibleRowsLookupSelector = gridVisibleRowsLookupSelector;
+const gridFilteredRowsLookupSelector = (0, _createSelector.createSelector)(gridFilterStateSelector, filterState => filterState.filteredRowsLookup);
+/**
+ * @category Filtering
+ * @ignore - do not document.
+ */
+
+exports.gridFilteredRowsLookupSelector = gridFilteredRowsLookupSelector;
+const gridFilteredDescendantCountLookupSelector = (0, _createSelector.createSelector)(gridFilterStateSelector, filterState => filterState.filteredDescendantCountLookup);
+/**
+ * Get the id and the model of the rows accessible after the filtering process.
+ * Does not contain the collapsed children.
+ * @category Filtering
+ */
+
+exports.gridFilteredDescendantCountLookupSelector = gridFilteredDescendantCountLookupSelector;
+const gridVisibleSortedRowEntriesSelector = (0, _createSelector.createSelector)(gridVisibleRowsLookupSelector, _gridSortingSelector.gridSortedRowEntriesSelector, (visibleRowsLookup, sortedRows) => sortedRows.filter(row => visibleRowsLookup[row.id] !== false));
+/**
+ * Get the id of the rows accessible after the filtering process.
+ * Does not contain the collapsed children.
+ * @category Filtering
+ */
+
+exports.gridVisibleSortedRowEntriesSelector = gridVisibleSortedRowEntriesSelector;
+const gridVisibleSortedRowIdsSelector = (0, _createSelector.createSelector)(gridVisibleSortedRowEntriesSelector, visibleSortedRowEntries => visibleSortedRowEntries.map(row => row.id));
+/**
+ * Get the id and the model of the rows accessible after the filtering process.
+ * Contains the collapsed children.
+ * @category Filtering
+ */
+
+exports.gridVisibleSortedRowIdsSelector = gridVisibleSortedRowIdsSelector;
+const gridFilteredSortedRowEntriesSelector = (0, _createSelector.createSelector)(gridFilteredRowsLookupSelector, _gridSortingSelector.gridSortedRowEntriesSelector, (filteredRowsLookup, sortedRows) => sortedRows.filter(row => filteredRowsLookup[row.id] !== false));
+/**
+ * Get the id of the rows accessible after the filtering process.
+ * Contains the collapsed children.
+ * @category Filtering
+ */
+
+exports.gridFilteredSortedRowEntriesSelector = gridFilteredSortedRowEntriesSelector;
+const gridFilteredSortedRowIdsSelector = (0, _createSelector.createSelector)(gridFilteredSortedRowEntriesSelector, filteredSortedRowEntries => filteredSortedRowEntries.map(row => row.id));
+/**
+ * @category Filtering
+ * @deprecated Use `gridVisibleSortedRowIdsSelector` instead
+ * @ignore - do not document.
+ */
+
+exports.gridFilteredSortedRowIdsSelector = gridFilteredSortedRowIdsSelector;
+const gridVisibleRowsSelector = gridVisibleSortedRowIdsSelector;
+/**
+ * Get the id and the model of the top level rows accessible after the filtering process.
+ * @category Filtering
+ */
+
+exports.gridVisibleRowsSelector = gridVisibleRowsSelector;
+const gridVisibleSortedTopLevelRowEntriesSelector = (0, _createSelector.createSelector)(gridVisibleSortedRowEntriesSelector, _gridRowsSelector.gridRowTreeSelector, _gridRowsSelector.gridRowTreeDepthSelector, (visibleSortedRows, rowTree, rowTreeDepth) => {
+  if (rowTreeDepth < 2) {
+    return visibleSortedRows;
+  }
+
+  return visibleSortedRows.filter(row => {
+    var _rowTree$row$id;
+
+    return ((_rowTree$row$id = rowTree[row.id]) == null ? void 0 : _rowTree$row$id.depth) === 0;
+  });
+});
+/**
+ * Get the amount of rows accessible after the filtering process.
+ * @category Filtering
+ */
+
+exports.gridVisibleSortedTopLevelRowEntriesSelector = gridVisibleSortedTopLevelRowEntriesSelector;
+const gridVisibleRowCountSelector = (0, _createSelector.createSelector)(gridVisibleSortedRowEntriesSelector, visibleSortedRows => visibleSortedRows.length);
+/**
+ * Get the amount of top level rows accessible after the filtering process.
+ * @category Filtering
+ */
+
+exports.gridVisibleRowCountSelector = gridVisibleRowCountSelector;
+const gridVisibleTopLevelRowCountSelector = (0, _createSelector.createSelector)(gridVisibleSortedTopLevelRowEntriesSelector, visibleSortedTopLevelRows => visibleSortedTopLevelRows.length);
+/**
+ * @category Filtering
+ * @ignore - do not document.
+ */
+
+exports.gridVisibleTopLevelRowCountSelector = gridVisibleTopLevelRowCountSelector;
+const gridFilterActiveItemsSelector = (0, _createSelector.createSelector)(gridFilterModelSelector, _gridColumnsSelector.gridColumnLookupSelector, (filterModel, columnLookup) => {
+  var _filterModel$items;
+
+  return (_filterModel$items = filterModel.items) == null ? void 0 : _filterModel$items.filter(item => {
+    var _column$filterOperato, _item$value;
+
+    if (!item.columnField) {
+      return false;
+    }
+
+    const column = columnLookup[item.columnField];
+
+    if (!(column != null && column.filterOperators) || (column == null ? void 0 : (_column$filterOperato = column.filterOperators) == null ? void 0 : _column$filterOperato.length) === 0) {
+      return false;
+    }
+
+    const filterOperator = column.filterOperators.find(operator => operator.value === item.operatorValue);
+
+    if (!filterOperator) {
+      return false;
+    }
+
+    return !filterOperator.InputComponent || item.value != null && ((_item$value = item.value) == null ? void 0 : _item$value.toString()) !== '';
+  });
+});
+exports.gridFilterActiveItemsSelector = gridFilterActiveItemsSelector;
+
+/**
+ * @category Filtering
+ * @ignore - do not document.
+ */
+const gridFilterActiveItemsLookupSelector = (0, _createSelector.createSelector)(gridFilterActiveItemsSelector, activeFilters => {
+  const result = activeFilters.reduce((res, filterItem) => {
+    if (!res[filterItem.columnField]) {
+      res[filterItem.columnField] = [filterItem];
+    } else {
+      res[filterItem.columnField].push(filterItem);
+    }
+
+    return res;
+  }, {});
+  return result;
+});
+exports.gridFilterActiveItemsLookupSelector = gridFilterActiveItemsLookupSelector;

package/node/hooks/features/filter/gridFilterState.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDefaultGridFilterModel = void 0;
+
+var _gridFilterItem = require("../../../models/gridFilterItem");
+
+const getDefaultGridFilterModel = () => ({
+  items: [],
+  linkOperator: _gridFilterItem.GridLinkOperator.And
+});
+
+exports.getDefaultGridFilterModel = getDefaultGridFilterModel;

package/node/hooks/features/filter/gridFilterUtils.js

@@ -0,0 +1,175 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sanitizeFilterModel = exports.mergeStateWithFilterModel = exports.buildAggregatedFilterApplier = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _models = require("../../../models");
+
+var _warning = require("../../../utils/warning");
+
+/**
+ * Adds default values to the optional fields of a filter items.
+ * @param {GridFilterItem} item The raw filter item.
+ * @param {React.MutableRefObject<GridApiCommunity>} apiRef The API of the grid.
+ * @return {GridFilterItem} The clean filter item with an uniq ID and an always-defined operatorValue.
+ * TODO: Make the typing reflect the different between GridFilterInputItem and GridFilterItem.
+ */
+const cleanFilterItem = (item, apiRef) => {
+  const cleanItem = (0, _extends2.default)({}, item);
+
+  if (cleanItem.id == null) {
+    cleanItem.id = Math.round(Math.random() * 1e5);
+  }
+
+  if (cleanItem.operatorValue == null) {
+    // we select a default operator
+    const column = apiRef.current.getColumn(cleanItem.columnField);
+    cleanItem.operatorValue = column && column.filterOperators[0].value;
+  }
+
+  return cleanItem;
+};
+
+const filterModelDisableMultiColumnsFilteringWarning = (0, _warning.buildWarning)(['MUI: The `filterModel` can only contain a single item when the `disableMultipleColumnsFiltering` prop is set to `true`.', 'If you are using the community version of the `DataGrid`, this prop is always `true`.'], 'error');
+const filterModelMissingItemIdWarning = (0, _warning.buildWarning)("MUI: The 'id' field is required on `filterModel.items` when you use multiple filters.", 'error');
+const filterModelMissingItemOperatorWarning = (0, _warning.buildWarning)(['MUI: One of your filtering item have no `operatorValue` provided.', 'This property will become required on `@mui/x-data-grid@6.X`.']);
+
+const sanitizeFilterModel = (model, disableMultipleColumnsFiltering, apiRef) => {
+  const hasSeveralItems = model.items.length > 1;
+  let items;
+
+  if (hasSeveralItems && disableMultipleColumnsFiltering) {
+    filterModelDisableMultiColumnsFilteringWarning();
+    items = [model.items[0]];
+  } else {
+    items = model.items;
+  }
+
+  const hasItemsWithoutIds = hasSeveralItems && items.some(item => item.id == null);
+  const hasItemWithoutOperator = items.some(item => item.operatorValue == null);
+
+  if (hasItemsWithoutIds) {
+    filterModelMissingItemIdWarning();
+  }
+
+  if (hasItemWithoutOperator) {
+    filterModelMissingItemOperatorWarning();
+  }
+
+  if (hasItemWithoutOperator || hasItemsWithoutIds) {
+    return (0, _extends2.default)({}, model, {
+      items: items.map(item => cleanFilterItem(item, apiRef))
+    });
+  }
+
+  if (model.items !== items) {
+    return (0, _extends2.default)({}, model, {
+      items
+    });
+  }
+
+  return model;
+};
+
+exports.sanitizeFilterModel = sanitizeFilterModel;
+
+const mergeStateWithFilterModel = (filterModel, disableMultipleColumnsFiltering, apiRef) => state => (0, _extends2.default)({}, state, {
+  filter: (0, _extends2.default)({}, state.filter, {
+    filterModel: sanitizeFilterModel(filterModel, disableMultipleColumnsFiltering, apiRef)
+  })
+});
+/**
+ * Generates a method to easily check if a row is matching the current filter model.
+ * @param {GridFilterModel} filterModel The model with which we want to filter the rows.
+ * @param {React.MutableRefObject<GridApiCommunity>} apiRef The API of the grid.
+ * @returns {GridAggregatedFilterItemApplier | null} A method that checks if a row is matching the current filter model. If `null`, we consider that all the rows are matching the filters.
+ */
+
+
+exports.mergeStateWithFilterModel = mergeStateWithFilterModel;
+
+const buildAggregatedFilterApplier = (filterModel, apiRef) => {
+  const {
+    items,
+    linkOperator = _models.GridLinkOperator.And
+  } = filterModel;
+
+  const getFilterCallbackFromItem = filterItem => {
+    if (!filterItem.columnField || !filterItem.operatorValue) {
+      return null;
+    }
+
+    const column = apiRef.current.getColumn(filterItem.columnField);
+
+    if (!column) {
+      return null;
+    }
+
+    let parsedValue;
+
+    if (column.valueParser) {
+      var _filterItem$value;
+
+      const parser = column.valueParser;
+      parsedValue = Array.isArray(filterItem.value) ? (_filterItem$value = filterItem.value) == null ? void 0 : _filterItem$value.map(x => parser(x)) : parser(filterItem.value);
+    } else {
+      parsedValue = filterItem.value;
+    }
+
+    const newFilterItem = (0, _extends2.default)({}, filterItem, {
+      value: parsedValue
+    });
+    const filterOperators = column.filterOperators;
+
+    if (!(filterOperators != null && filterOperators.length)) {
+      throw new Error(`MUI: No filter operators found for column '${column.field}'.`);
+    }
+
+    const filterOperator = filterOperators.find(operator => operator.value === newFilterItem.operatorValue);
+
+    if (!filterOperator) {
+      throw new Error(`MUI: No filter operator found for column '${column.field}' and operator value '${newFilterItem.operatorValue}'.`);
+    }
+
+    const applyFilterOnRow = filterOperator.getApplyFilterFn(newFilterItem, column);
+
+    if (typeof applyFilterOnRow !== 'function') {
+      return null;
+    }
+
+    const fn = rowId => {
+      const cellParams = apiRef.current.getCellParams(rowId, newFilterItem.columnField);
+      return applyFilterOnRow(cellParams);
+    };
+
+    return {
+      fn,
+      item: newFilterItem
+    };
+  };
+
+  const appliers = items.map(getFilterCallbackFromItem).filter(callback => !!callback);
+
+  if (appliers.length === 0) {
+    return null;
+  }
+
+  return (rowId, shouldApplyFilter) => {
+    const filteredAppliers = shouldApplyFilter ? appliers.filter(applier => shouldApplyFilter(applier.item)) : appliers; // Return `false` as soon as we have a failing filter
+
+    if (linkOperator === _models.GridLinkOperator.And) {
+      return filteredAppliers.every(applier => applier.fn(rowId));
+    } // Return `true` as soon as we have a passing filter
+
+
+    return filteredAppliers.some(applier => applier.fn(rowId));
+  };
+};
+
+exports.buildAggregatedFilterApplier = buildAggregatedFilterApplier;

package/node/hooks/features/filter/index.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  getDefaultGridFilterModel: true
+};
+Object.defineProperty(exports, "getDefaultGridFilterModel", {
+  enumerable: true,
+  get: function () {
+    return _gridFilterState.getDefaultGridFilterModel;
+  }
+});
+
+var _gridFilterState = require("./gridFilterState");
+
+var _gridFilterSelector = require("./gridFilterSelector");
+
+Object.keys(_gridFilterSelector).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _gridFilterSelector[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _gridFilterSelector[key];
+    }
+  });
+});