@mui/x-data-grid 7.16.0 → 7.18.0

package/hooks/features/rows/useGridRowSpanning.js

@@ -0,0 +1,257 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import useLazyRef from '@mui/utils/useLazyRef';
+import { gridVisibleColumnDefinitionsSelector } from "../columns/gridColumnsSelector.js";
+import { useGridVisibleRows } from "../../utils/useGridVisibleRows.js";
+import { gridRenderContextSelector } from "../virtualization/gridVirtualizationSelectors.js";
+import { useGridSelector } from "../../utils/useGridSelector.js";
+import { getUnprocessedRange, isRowRangeUpdated, isRowContextInitialized, getCellValue } from "./gridRowSpanningUtils.js";
+const EMPTY_STATE = {
+  spannedCells: {},
+  hiddenCells: {},
+  hiddenCellOriginMap: {}
+};
+const EMPTY_RANGE = {
+  firstRowIndex: 0,
+  lastRowIndex: 0
+};
+const skippedFields = new Set(['__check__', '__reorder__', '__detail_panel_toggle__']);
+/**
+ * Default number of rows to process during state initialization to avoid flickering.
+ * Number `20` is arbitrarily chosen to be large enough to cover most of the cases without
+ * compromising performance.
+ */
+const DEFAULT_ROWS_TO_PROCESS = 20;
+const computeRowSpanningState = (apiRef, colDefs, visibleRows, range, rangeToProcess, resetState, processedRange) => {
+  const spannedCells = resetState ? {} : _extends({}, apiRef.current.state.rowSpanning.spannedCells);
+  const hiddenCells = resetState ? {} : _extends({}, apiRef.current.state.rowSpanning.hiddenCells);
+  const hiddenCellOriginMap = resetState ? {} : _extends({}, apiRef.current.state.rowSpanning.hiddenCellOriginMap);
+  if (resetState) {
+    processedRange = EMPTY_RANGE;
+  }
+  colDefs.forEach(colDef => {
+    if (skippedFields.has(colDef.field)) {
+      return;
+    }
+    for (let index = rangeToProcess.firstRowIndex; index <= rangeToProcess.lastRowIndex; index += 1) {
+      const row = visibleRows[index];
+      if (hiddenCells[row.id]?.[colDef.field]) {
+        continue;
+      }
+      const cellValue = getCellValue(row.model, colDef, apiRef);
+      if (cellValue == null) {
+        continue;
+      }
+      let spannedRowId = row.id;
+      let spannedRowIndex = index;
+      let rowSpan = 0;
+
+      // For first index, also scan in the previous rows to handle the reset state case e.g by sorting
+      const backwardsHiddenCells = [];
+      if (index === rangeToProcess.firstRowIndex) {
+        let prevIndex = index - 1;
+        const prevRowEntry = visibleRows[prevIndex];
+        while (prevIndex >= range.firstRowIndex && getCellValue(prevRowEntry.model, colDef, apiRef) === cellValue) {
+          const currentRow = visibleRows[prevIndex + 1];
+          if (hiddenCells[currentRow.id]) {
+            hiddenCells[currentRow.id][colDef.field] = true;
+          } else {
+            hiddenCells[currentRow.id] = {
+              [colDef.field]: true
+            };
+          }
+          backwardsHiddenCells.push(index);
+          rowSpan += 1;
+          spannedRowId = prevRowEntry.id;
+          spannedRowIndex = prevIndex;
+          prevIndex -= 1;
+        }
+      }
+      backwardsHiddenCells.forEach(hiddenCellIndex => {
+        if (hiddenCellOriginMap[hiddenCellIndex]) {
+          hiddenCellOriginMap[hiddenCellIndex][colDef.field] = spannedRowIndex;
+        } else {
+          hiddenCellOriginMap[hiddenCellIndex] = {
+            [colDef.field]: spannedRowIndex
+          };
+        }
+      });
+
+      // Scan the next rows
+      let relativeIndex = index + 1;
+      while (relativeIndex <= range.lastRowIndex && visibleRows[relativeIndex] && getCellValue(visibleRows[relativeIndex].model, colDef, apiRef) === cellValue) {
+        const currentRow = visibleRows[relativeIndex];
+        if (hiddenCells[currentRow.id]) {
+          hiddenCells[currentRow.id][colDef.field] = true;
+        } else {
+          hiddenCells[currentRow.id] = {
+            [colDef.field]: true
+          };
+        }
+        if (hiddenCellOriginMap[relativeIndex]) {
+          hiddenCellOriginMap[relativeIndex][colDef.field] = spannedRowIndex;
+        } else {
+          hiddenCellOriginMap[relativeIndex] = {
+            [colDef.field]: spannedRowIndex
+          };
+        }
+        relativeIndex += 1;
+        rowSpan += 1;
+      }
+      if (rowSpan > 0) {
+        if (spannedCells[spannedRowId]) {
+          spannedCells[spannedRowId][colDef.field] = rowSpan + 1;
+        } else {
+          spannedCells[spannedRowId] = {
+            [colDef.field]: rowSpan + 1
+          };
+        }
+      }
+    }
+    processedRange = {
+      firstRowIndex: Math.min(processedRange.firstRowIndex, rangeToProcess.firstRowIndex),
+      lastRowIndex: Math.max(processedRange.lastRowIndex, rangeToProcess.lastRowIndex)
+    };
+  });
+  return {
+    spannedCells,
+    hiddenCells,
+    hiddenCellOriginMap,
+    processedRange
+  };
+};
+
+/**
+ * @requires columnsStateInitializer (method) - should be initialized before
+ * @requires rowsStateInitializer (method) - should be initialized before
+ * @requires filterStateInitializer (method) - should be initialized before
+ */
+export const rowSpanningStateInitializer = (state, props, apiRef) => {
+  if (props.unstable_rowSpanning) {
+    const rowIds = state.rows.dataRowIds || [];
+    const orderedFields = state.columns.orderedFields || [];
+    const dataRowIdToModelLookup = state.rows.dataRowIdToModelLookup;
+    const columnsLookup = state.columns.lookup;
+    const isFilteringPending = Boolean(state.filter.filterModel.items.length) || Boolean(state.filter.filterModel.quickFilterValues?.length);
+    if (!rowIds.length || !orderedFields.length || !dataRowIdToModelLookup || !columnsLookup || isFilteringPending) {
+      return _extends({}, state, {
+        rowSpanning: EMPTY_STATE
+      });
+    }
+    const rangeToProcess = {
+      firstRowIndex: 0,
+      lastRowIndex: Math.min(DEFAULT_ROWS_TO_PROCESS - 1, Math.max(rowIds.length - 1, 0))
+    };
+    const rows = rowIds.map(id => ({
+      id,
+      model: dataRowIdToModelLookup[id]
+    }));
+    const colDefs = orderedFields.map(field => columnsLookup[field]);
+    const {
+      spannedCells,
+      hiddenCells,
+      hiddenCellOriginMap
+    } = computeRowSpanningState(apiRef, colDefs, rows, rangeToProcess, rangeToProcess, true, EMPTY_RANGE);
+    return _extends({}, state, {
+      rowSpanning: {
+        spannedCells,
+        hiddenCells,
+        hiddenCellOriginMap
+      }
+    });
+  }
+  return _extends({}, state, {
+    rowSpanning: EMPTY_STATE
+  });
+};
+export const useGridRowSpanning = (apiRef, props) => {
+  const {
+    range,
+    rows: visibleRows
+  } = useGridVisibleRows(apiRef, props);
+  const renderContext = useGridSelector(apiRef, gridRenderContextSelector);
+  const colDefs = useGridSelector(apiRef, gridVisibleColumnDefinitionsSelector);
+  const processedRange = useLazyRef(() => {
+    return Object.keys(apiRef.current.state.rowSpanning.spannedCells).length > 0 ? {
+      firstRowIndex: 0,
+      lastRowIndex: Math.min(DEFAULT_ROWS_TO_PROCESS - 1, Math.max(apiRef.current.state.rows.dataRowIds.length - 1, 0))
+    } : EMPTY_RANGE;
+  });
+  const lastRange = React.useRef(EMPTY_RANGE);
+  const updateRowSpanningState = React.useCallback(
+  // A reset needs to occur when:
+  // - The `unstable_rowSpanning` prop is updated (feature flag)
+  // - The filtering is applied
+  // - The sorting is applied
+  // - The `paginationModel` is updated
+  // - The rows are updated
+  (resetState = true) => {
+    if (!props.unstable_rowSpanning) {
+      if (apiRef.current.state.rowSpanning !== EMPTY_STATE) {
+        apiRef.current.setState(state => _extends({}, state, {
+          rowSpanning: EMPTY_STATE
+        }));
+      }
+      return;
+    }
+    if (range === null || !isRowContextInitialized(renderContext)) {
+      return;
+    }
+    if (resetState) {
+      processedRange.current = EMPTY_RANGE;
+    }
+    const rangeToProcess = getUnprocessedRange({
+      firstRowIndex: renderContext.firstRowIndex,
+      lastRowIndex: renderContext.lastRowIndex - 1
+    }, processedRange.current);
+    if (rangeToProcess === null) {
+      return;
+    }
+    const {
+      spannedCells,
+      hiddenCells,
+      hiddenCellOriginMap,
+      processedRange: newProcessedRange
+    } = computeRowSpanningState(apiRef, colDefs, visibleRows, range, rangeToProcess, resetState, processedRange.current);
+    processedRange.current = newProcessedRange;
+    const newSpannedCellsCount = Object.keys(spannedCells).length;
+    const newHiddenCellsCount = Object.keys(hiddenCells).length;
+    const currentSpannedCellsCount = Object.keys(apiRef.current.state.rowSpanning.spannedCells).length;
+    const currentHiddenCellsCount = Object.keys(apiRef.current.state.rowSpanning.hiddenCells).length;
+    const shouldUpdateState = resetState || newSpannedCellsCount !== currentSpannedCellsCount || newHiddenCellsCount !== currentHiddenCellsCount;
+    if (!shouldUpdateState) {
+      return;
+    }
+    apiRef.current.setState(state => {
+      return _extends({}, state, {
+        rowSpanning: {
+          spannedCells,
+          hiddenCells,
+          hiddenCellOriginMap
+        }
+      });
+    });
+  }, [apiRef, props.unstable_rowSpanning, range, renderContext, visibleRows, colDefs, processedRange]);
+  const prevRenderContext = React.useRef(renderContext);
+  const isFirstRender = React.useRef(true);
+  const shouldResetState = React.useRef(false);
+  React.useEffect(() => {
+    const firstRender = isFirstRender.current;
+    if (isFirstRender.current) {
+      isFirstRender.current = false;
+    }
+    if (range && lastRange.current && isRowRangeUpdated(range, lastRange.current)) {
+      lastRange.current = range;
+      shouldResetState.current = true;
+    }
+    if (!firstRender && prevRenderContext.current !== renderContext) {
+      if (isRowRangeUpdated(prevRenderContext.current, renderContext)) {
+        updateRowSpanningState(shouldResetState.current);
+        shouldResetState.current = false;
+      }
+      prevRenderContext.current = renderContext;
+      return;
+    }
+    updateRowSpanningState();
+  }, [updateRowSpanningState, renderContext, range, lastRange]);
+};

package/hooks/features/sorting/gridSortingUtils.js

@@ -1,5 +1,5 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
-import { warnOnce } from "../../../internals/utils/warning.js";
+import { warnOnce } from '@mui/x-internals/warning';
 export const sanitizeSortModel = (model, disableMultipleColumnsSorting) => {
   if (disableMultipleColumnsSorting && model.length > 1) {
     if (process.env.NODE_ENV !== 'production') {

package/hooks/features/virtualization/useGridVirtualScroller.d.ts

@@ -40,4 +40,4 @@ export declare const useGridVirtualScroller: () => {
     };
 };
 export declare function areRenderContextsEqual(context1: GridRenderContext, context2: GridRenderContext): boolean;
-export declare function computeOffsetLeft(columnPositions: number[], renderContext: GridColumnsRenderContext, isRtl: boolean, pinnedLeftLength: number): number;
+export declare function computeOffsetLeft(columnPositions: number[], renderContext: GridColumnsRenderContext, pinnedLeftLength: number): number;

package/hooks/features/virtualization/useGridVirtualScroller.js

@@ -24,6 +24,7 @@ import { getFirstNonSpannedColumnToRender } from "../columns/gridColumnsUtils.js
 import { getMinimalContentHeight } from "../rows/gridRowsUtils.js";
 import { gridRenderContextSelector, gridVirtualizationRowEnabledSelector, gridVirtualizationColumnEnabledSelector } from "./gridVirtualizationSelectors.js";
 import { EMPTY_RENDER_CONTEXT } from "./useGridVirtualization.js";
+import { gridRowSpanningHiddenCellsOriginMapSelector } from "../rows/gridRowSpanningSelectors.js";
 import { jsx as _jsx } from "react/jsx-runtime";
 const MINIMUM_COLUMN_WIDTH = 50;
 var ScrollDirection = /*#__PURE__*/function (ScrollDirection) {
@@ -325,7 +326,7 @@ export const useGridVirtualScroller = () => {
       if (!isPinnedSection && frozenContext.current && rowIndexInPage >= frozenContext.current.firstRowIndex && rowIndexInPage < frozenContext.current.lastRowIndex) {
         currentRenderContext = frozenContext.current;
       }
-      const offsetLeft = computeOffsetLeft(columnPositions, currentRenderContext, isRtl, pinnedColumns.left.length);
+      const offsetLeft = computeOffsetLeft(columnPositions, currentRenderContext, pinnedColumns.left.length);
       const showBottomBorder = isLastVisibleInSection && params.position === 'top';
       rows.push(/*#__PURE__*/_jsx(rootProps.slots.row, _extends({
         row: model,
@@ -353,7 +354,7 @@ export const useGridVirtualScroller = () => {
       if (panel) {
         rows.push(panel);
       }
-      if (isLastVisible) {
+      if (params.position === undefined && isLastVisibleInSection) {
         rows.push(apiRef.current.getInfiniteLoadingTriggerElement?.({
           lastRowId: id
         }));
@@ -447,6 +448,7 @@ function inputsSelector(apiRef, rootProps, enabledForRows, enabledForColumns) {
   const dimensions = gridDimensionsSelector(apiRef.current.state);
   const currentPage = getVisibleRows(apiRef, rootProps);
   const visibleColumns = gridVisibleColumnDefinitionsSelector(apiRef);
+  const hiddenCellsOriginMap = gridRowSpanningHiddenCellsOriginMapSelector(apiRef);
   const lastRowId = apiRef.current.state.rows.dataRowIds.at(-1);
   const lastColumn = visibleColumns.at(-1);
   return {
@@ -467,7 +469,8 @@ function inputsSelector(apiRef, rootProps, enabledForRows, enabledForColumns) {
     rows: currentPage.rows,
     range: currentPage.range,
     pinnedColumns: gridVisiblePinnedColumnDefinitionsSelector(apiRef),
-    visibleColumns
+    visibleColumns,
+    hiddenCellsOriginMap
   };
 }
 function computeRenderContext(inputs, scrollPosition, scrollCache) {
@@ -485,10 +488,18 @@ function computeRenderContext(inputs, scrollPosition, scrollCache) {
   if (inputs.enabledForRows) {
     // Clamp the value because the search may return an index out of bounds.
     // In the last index, this is not needed because Array.slice doesn't include it.
-    const firstRowIndex = Math.min(getNearestIndexToRender(inputs, top, {
+    let firstRowIndex = Math.min(getNearestIndexToRender(inputs, top, {
       atStart: true,
       lastPosition: inputs.rowsMeta.positions[inputs.rowsMeta.positions.length - 1] + inputs.lastRowHeight
     }), inputs.rowsMeta.positions.length - 1);
+
+    // If any of the cells in the `firstRowIndex` is hidden due to an extended row span,
+    // Make sure the row from where the rowSpan is originated is visible.
+    const rowSpanHiddenCellOrigin = inputs.hiddenCellsOriginMap[firstRowIndex];
+    if (rowSpanHiddenCellOrigin) {
+      const minSpannedRowIndex = Math.min(...Object.values(rowSpanHiddenCellOrigin));
+      firstRowIndex = Math.min(firstRowIndex, minSpannedRowIndex);
+    }
     const lastRowIndex = inputs.autoHeight ? firstRowIndex + inputs.rows.length : getNearestIndexToRender(inputs, top + inputs.viewportInnerHeight);
     renderContext.firstRowIndex = firstRowIndex;
     renderContext.lastRowIndex = lastRowIndex;
@@ -642,9 +653,8 @@ export function areRenderContextsEqual(context1, context2) {
   }
   return context1.firstRowIndex === context2.firstRowIndex && context1.lastRowIndex === context2.lastRowIndex && context1.firstColumnIndex === context2.firstColumnIndex && context1.lastColumnIndex === context2.lastColumnIndex;
 }
-export function computeOffsetLeft(columnPositions, renderContext, isRtl, pinnedLeftLength) {
-  const factor = isRtl ? -1 : 1;
-  const left = factor * (columnPositions[renderContext.firstColumnIndex] ?? 0) - (columnPositions[pinnedLeftLength] ?? 0);
+export function computeOffsetLeft(columnPositions, renderContext, pinnedLeftLength) {
+  const left = (columnPositions[renderContext.firstColumnIndex] ?? 0) - (columnPositions[pinnedLeftLength] ?? 0);
   return Math.abs(left);
 }
 function directionForDelta(dx, dy) {

package/hooks/utils/useGridApiEventHandler.js

@@ -90,7 +90,6 @@ const optionsSubscriberOptions = {
   isFirst: true
 };
 export function useGridApiOptionHandler(apiRef, eventName, handler) {
-  // Validate that only one per event name?
   useGridApiEventHandler(apiRef, eventName, handler, optionsSubscriberOptions);
 }
 export { GridSignature };

package/hooks/utils/useGridSelector.js

@@ -1,8 +1,8 @@
 import * as React from 'react';
 import { fastObjectShallowCompare } from '@mui/x-internals/fastObjectShallowCompare';
+import { warnOnce } from '@mui/x-internals/warning';
 import { useLazyRef } from "./useLazyRef.js";
 import { useOnMount } from "./useOnMount.js";
-import { warnOnce } from "../../internals/utils/warning.js";
 function isOutputSelector(selector) {
   return selector.acceptsApiRef;
 }

package/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-data-grid v7.16.0
+ * @mui/x-data-grid v7.18.0
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the

package/internals/index.d.ts

@@ -41,6 +41,7 @@ export { useGridPreferencesPanel, preferencePanelStateInitializer, } from '../ho
 export { useGridEditing, editingStateInitializer } from '../hooks/features/editing/useGridEditing';
 export { gridEditRowsStateSelector } from '../hooks/features/editing/gridEditingSelectors';
 export { useGridRows, rowsStateInitializer } from '../hooks/features/rows/useGridRows';
+export { useGridRowSpanning, rowSpanningStateInitializer, } from '../hooks/features/rows/useGridRowSpanning';
 export { useGridAriaAttributes } from '../hooks/utils/useGridAriaAttributes';
 export { useGridRowAriaAttributes } from '../hooks/features/rows/useGridRowAriaAttributes';
 export { useGridRowsPreProcessors } from '../hooks/features/rows/useGridRowsPreProcessors';

package/internals/index.js

@@ -32,6 +32,7 @@ export { useGridPreferencesPanel, preferencePanelStateInitializer } from "../hoo
 export { useGridEditing, editingStateInitializer } from "../hooks/features/editing/useGridEditing.js";
 export { gridEditRowsStateSelector } from "../hooks/features/editing/gridEditingSelectors.js";
 export { useGridRows, rowsStateInitializer } from "../hooks/features/rows/useGridRows.js";
+export { useGridRowSpanning, rowSpanningStateInitializer } from "../hooks/features/rows/useGridRowSpanning.js";
 export { useGridAriaAttributes } from "../hooks/utils/useGridAriaAttributes.js";
 export { useGridRowAriaAttributes } from "../hooks/features/rows/useGridRowAriaAttributes.js";
 export { useGridRowsPreProcessors } from "../hooks/features/rows/useGridRowsPreProcessors.js";

package/internals/utils/index.d.ts

@@ -1,4 +1,3 @@
 export * from './computeSlots';
 export * from './useProps';
 export * from './propValidation';
-export * from './warning';

package/internals/utils/index.js

@@ -1,4 +1,3 @@
 export * from "./computeSlots.js";
 export * from "./useProps.js";
-export * from "./propValidation.js";
-export * from "./warning.js";
+export * from "./propValidation.js";

package/internals/utils/propValidation.js

@@ -1,4 +1,4 @@
-import { warnOnce } from "./warning.js";
+import { warnOnce } from '@mui/x-internals/warning';
 import { isNumber } from "../../utils/utils.js";
 import { GridSignature } from "../../hooks/utils/useGridApiEventHandler.js";
 export const propValidatorsDataGrid = [props => props.autoPageSize && props.autoHeight && ['MUI X: `<DataGrid autoPageSize={true} autoHeight={true} />` are not valid props.', 'You cannot use both the `autoPageSize` and `autoHeight` props at the same time because `autoHeight` scales the height of the Data Grid according to the `pageSize`.', '', 'Please remove one of these two props.'].join('\n') || undefined, props => props.paginationMode === 'client' && props.paginationMeta != null && ['MUI X: Usage of the `paginationMeta` prop with client-side pagination (`paginationMode="client"`) has no effect.', '`paginationMeta` is only meant to be used with `paginationMode="server"`.'].join('\n') || undefined, props => props.signature === GridSignature.DataGrid && props.paginationMode === 'client' && isNumber(props.rowCount) && ['MUI X: Usage of the `rowCount` prop with client side pagination (`paginationMode="client"`) has no effect.', '`rowCount` is only meant to be used with `paginationMode="server"`.'].join('\n') || undefined, props => props.paginationMode === 'server' && props.rowCount == null && !props.unstable_dataSource && ["MUI X: The `rowCount` prop must be passed using `paginationMode='server'`", 'For more detail, see http://mui.com/components/data-grid/pagination/#index-based-pagination'].join('\n') || undefined];

package/locales/arSD.js

@@ -48,7 +48,9 @@ const arSDGrid = {
   filterPanelInputPlaceholder: 'ترشِيح قيمة',
   // Filter operators text
   filterOperatorContains: 'يحتوي',
+  // filterOperatorDoesNotContain: 'does not contain',
   filterOperatorEquals: 'يساوي',
+  // filterOperatorDoesNotEqual: 'does not equal',
   filterOperatorStartsWith: 'يبدأ بـ',
   filterOperatorEndsWith: 'ينتهي بـ',
   filterOperatorIs: 'يكون',
@@ -68,7 +70,9 @@ const arSDGrid = {
   'filterOperator<=': '<=',
   // Header filter operators text
   headerFilterOperatorContains: 'يحتوي على',
+  // headerFilterOperatorDoesNotContain: 'Does not contain',
   headerFilterOperatorEquals: 'يساوي',
+  // headerFilterOperatorDoesNotEqual: 'Does not equal',
   headerFilterOperatorStartsWith: 'يبدأ ب',
   headerFilterOperatorEndsWith: 'ينتهي ب',
   headerFilterOperatorIs: 'هو',

package/locales/beBY.js

@@ -62,7 +62,9 @@ const beBYGrid = {
   filterPanelInputPlaceholder: 'Значэнне фільтра',
   // Filter operators text
   filterOperatorContains: 'змяшчае',
+  // filterOperatorDoesNotContain: 'does not contain',
   filterOperatorEquals: 'роўны',
+  // filterOperatorDoesNotEqual: 'does not equal',
   filterOperatorStartsWith: 'пачынаецца з',
   filterOperatorEndsWith: 'скончваецца на',
   filterOperatorIs: 'роўны',
@@ -83,7 +85,9 @@ const beBYGrid = {
 
   // Header filter operators text
   // headerFilterOperatorContains: 'Contains',
+  // headerFilterOperatorDoesNotContain: 'Does not contain',
   // headerFilterOperatorEquals: 'Equals',
+  // headerFilterOperatorDoesNotEqual: 'Does not equal',
   // headerFilterOperatorStartsWith: 'Starts with',
   // headerFilterOperatorEndsWith: 'Ends with',
   // headerFilterOperatorIs: 'Is',

package/locales/bgBG.js

@@ -48,7 +48,9 @@ const bgBGGrid = {
   filterPanelInputPlaceholder: 'Стойност на филтъра',
   // Filter operators text
   filterOperatorContains: 'съдържа',
+  // filterOperatorDoesNotContain: 'does not contain',
   filterOperatorEquals: 'равно',
+  // filterOperatorDoesNotEqual: 'does not equal',
   filterOperatorStartsWith: 'започва с',
   filterOperatorEndsWith: 'завършва с',
   filterOperatorIs: 'е',
@@ -68,7 +70,9 @@ const bgBGGrid = {
   'filterOperator<=': '<=',
   // Header filter operators text
   headerFilterOperatorContains: 'Съдържа',
+  // headerFilterOperatorDoesNotContain: 'Does not contain',
   headerFilterOperatorEquals: 'Равнo',
+  // headerFilterOperatorDoesNotEqual: 'Does not equal',
   headerFilterOperatorStartsWith: 'Започва с',
   headerFilterOperatorEndsWith: 'Завършва с',
   headerFilterOperatorIs: 'Равно е на',

package/locales/csCZ.js

@@ -55,7 +55,9 @@ const csCZGrid = {
   filterPanelInputPlaceholder: 'Hodnota filtru',
   // Filter operators text
   filterOperatorContains: 'obsahuje',
+  // filterOperatorDoesNotContain: 'does not contain',
   filterOperatorEquals: 'rovná se',
+  // filterOperatorDoesNotEqual: 'does not equal',
   filterOperatorStartsWith: 'začíná na',
   filterOperatorEndsWith: 'končí na',
   filterOperatorIs: 'je',
@@ -75,7 +77,9 @@ const csCZGrid = {
   'filterOperator<=': '<=',
   // Header filter operators text
   headerFilterOperatorContains: 'Obsahuje',
+  // headerFilterOperatorDoesNotContain: 'Does not contain',
   headerFilterOperatorEquals: 'Rovná se',
+  // headerFilterOperatorDoesNotEqual: 'Does not equal',
   headerFilterOperatorStartsWith: 'Začíná na',
   headerFilterOperatorEndsWith: 'Končí na',
   headerFilterOperatorIs: 'Je',

package/locales/daDK.js

@@ -48,7 +48,9 @@ const daDKGrid = {
   filterPanelInputPlaceholder: 'Filterværdi',
   // Filter operators text
   filterOperatorContains: 'indeholder',
+  // filterOperatorDoesNotContain: 'does not contain',
   filterOperatorEquals: 'lig med',
+  // filterOperatorDoesNotEqual: 'does not equal',
   filterOperatorStartsWith: 'begynder med',
   filterOperatorEndsWith: 'ender med',
   filterOperatorIs: 'er lig med',
@@ -68,7 +70,9 @@ const daDKGrid = {
   'filterOperator<=': '<=',
   // Header filter operators text
   headerFilterOperatorContains: 'Indeholder',
+  // headerFilterOperatorDoesNotContain: 'Does not contain',
   headerFilterOperatorEquals: 'Lig med',
+  // headerFilterOperatorDoesNotEqual: 'Does not equal',
   headerFilterOperatorStartsWith: 'Begynder med',
   headerFilterOperatorEndsWith: 'Ender med',
   headerFilterOperatorIs: 'Er lig med',

package/locales/deDE.js

@@ -47,7 +47,9 @@ const deDEGrid = {
   filterPanelInputPlaceholder: 'Wert filtern',
   // Filter operators text
   filterOperatorContains: 'enthält',
+  // filterOperatorDoesNotContain: 'does not contain',
   filterOperatorEquals: 'ist gleich',
+  // filterOperatorDoesNotEqual: 'does not equal',
   filterOperatorStartsWith: 'beginnt mit',
   filterOperatorEndsWith: 'endet mit',
   filterOperatorIs: 'ist',
@@ -67,7 +69,9 @@ const deDEGrid = {
   'filterOperator<=': '<=',
   // Header filter operators text
   headerFilterOperatorContains: 'Enthält',
+  // headerFilterOperatorDoesNotContain: 'Does not contain',
   headerFilterOperatorEquals: 'Gleich',
+  // headerFilterOperatorDoesNotEqual: 'Does not equal',
   headerFilterOperatorStartsWith: 'Beginnt mit',
   headerFilterOperatorEndsWith: 'Endet mit',
   headerFilterOperatorIs: 'Ist',

package/locales/elGR.js

@@ -48,7 +48,9 @@ const elGRGrid = {
   filterPanelInputPlaceholder: 'Τιμή φίλτρου',
   // Filter operators text
   filterOperatorContains: 'περιέχει',
+  // filterOperatorDoesNotContain: 'does not contain',
   filterOperatorEquals: 'ισούται',
+  // filterOperatorDoesNotEqual: 'does not equal',
   filterOperatorStartsWith: 'ξεκινάει με',
   filterOperatorEndsWith: 'τελειώνει με',
   filterOperatorIs: 'είναι',
@@ -68,7 +70,9 @@ const elGRGrid = {
   'filterOperator<=': '<=',
   // Header filter operators text
   headerFilterOperatorContains: 'Περιέχει',
+  // headerFilterOperatorDoesNotContain: 'Does not contain',
   headerFilterOperatorEquals: 'Ισούται',
+  // headerFilterOperatorDoesNotEqual: 'Does not equal',
   headerFilterOperatorStartsWith: 'Ξεκινάει με',
   headerFilterOperatorEndsWith: 'Τελειώνει με',
   headerFilterOperatorIs: 'Είναι',

package/locales/esES.js

@@ -47,7 +47,9 @@ const esESGrid = {
   filterPanelInputPlaceholder: 'Valor de filtro',
   // Filter operators text
   filterOperatorContains: 'contiene',
+  // filterOperatorDoesNotContain: 'does not contain',
   filterOperatorEquals: 'es igual',
+  // filterOperatorDoesNotEqual: 'does not equal',
   filterOperatorStartsWith: 'comienza con',
   filterOperatorEndsWith: 'termina con',
   filterOperatorIs: 'es',
@@ -67,7 +69,9 @@ const esESGrid = {
   'filterOperator<=': '<=',
   // Header filter operators text
   headerFilterOperatorContains: 'Contiene',
+  // headerFilterOperatorDoesNotContain: 'Does not contain',
   headerFilterOperatorEquals: 'Es igual a',
+  // headerFilterOperatorDoesNotEqual: 'Does not equal',
   headerFilterOperatorStartsWith: 'Comienza con',
   headerFilterOperatorEndsWith: 'Termina con',
   headerFilterOperatorIs: 'Es',

package/locales/faIR.js

@@ -47,7 +47,9 @@ const faIRGrid = {
   filterPanelInputPlaceholder: 'فیلتر مقدار',
   // Filter operators text
   filterOperatorContains: 'شامل',
+  // filterOperatorDoesNotContain: 'does not contain',
   filterOperatorEquals: 'مساوی',
+  // filterOperatorDoesNotEqual: 'does not equal',
   filterOperatorStartsWith: 'شروع با',
   filterOperatorEndsWith: 'پایان با',
   filterOperatorIs: 'هست',
@@ -67,7 +69,9 @@ const faIRGrid = {
   'filterOperator<=': '<=',
   // Header filter operators text
   headerFilterOperatorContains: 'شامل',
+  // headerFilterOperatorDoesNotContain: 'Does not contain',
   headerFilterOperatorEquals: 'مساوی',
+  // headerFilterOperatorDoesNotEqual: 'Does not equal',
   headerFilterOperatorStartsWith: 'شروع با',
   headerFilterOperatorEndsWith: 'پایان با',
   headerFilterOperatorIs: 'هست',

package/locales/fiFI.js

@@ -47,7 +47,9 @@ const fiFIGrid = {
   filterPanelInputPlaceholder: 'Suodattimen arvo',
   // Filter operators text
   filterOperatorContains: 'sisältää',
+  // filterOperatorDoesNotContain: 'does not contain',
   filterOperatorEquals: 'on yhtä suuri kuin',
+  // filterOperatorDoesNotEqual: 'does not equal',
   filterOperatorStartsWith: 'alkaa',
   filterOperatorEndsWith: 'päättyy',
   filterOperatorIs: 'on',
@@ -67,7 +69,9 @@ const fiFIGrid = {
   'filterOperator<=': '<=',
   // Header filter operators text
   headerFilterOperatorContains: 'Sisältää',
+  // headerFilterOperatorDoesNotContain: 'Does not contain',
   headerFilterOperatorEquals: 'On yhtä suuri kuin',
+  // headerFilterOperatorDoesNotEqual: 'Does not equal',
   headerFilterOperatorStartsWith: 'Alkaa',
   headerFilterOperatorEndsWith: 'Päättyy',
   headerFilterOperatorIs: 'On',

package/locales/frFR.js

@@ -47,7 +47,9 @@ const frFRGrid = {
   filterPanelInputPlaceholder: 'Filtrer la valeur',
   // Filter operators text
   filterOperatorContains: 'contient',
+  // filterOperatorDoesNotContain: 'does not contain',
   filterOperatorEquals: 'est égal à',
+  // filterOperatorDoesNotEqual: 'does not equal',
   filterOperatorStartsWith: 'commence par',
   filterOperatorEndsWith: 'se termine par',
   filterOperatorIs: 'est',
@@ -67,7 +69,9 @@ const frFRGrid = {
   'filterOperator<=': '<=',
   // Header filter operators text
   headerFilterOperatorContains: 'Contient',
+  // headerFilterOperatorDoesNotContain: 'Does not contain',
   headerFilterOperatorEquals: 'Est égal à',
+  // headerFilterOperatorDoesNotEqual: 'Does not equal',
   headerFilterOperatorStartsWith: 'Commence par',
   headerFilterOperatorEndsWith: 'Se termine par',
   headerFilterOperatorIs: 'Est',