@mui/x-data-grid 7.17.0 → 7.19.0

package/modern/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/modern/hooks/features/rows/useGridRows.js

@@ -1,5 +1,6 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
+import useLazyRef from '@mui/utils/useLazyRef';
 import { useGridApiMethod } from "../../utils/useGridApiMethod.js";
 import { useGridLogger } from "../../utils/useGridLogger.js";
 import { gridRowCountSelector, gridRowsLookupSelector, gridRowTreeSelector, gridRowGroupingNameSelector, gridRowTreeDepthsSelector, gridDataRowIdsSelector, gridRowsDataRowIdToIdLookupSelector, gridRowMaximumTreeDepthSelector, gridRowGroupsToFetchSelector } from "./gridRowsSelector.js";
@@ -367,11 +368,16 @@ export const useGridRows = (apiRef, props) => {
       throttle: false
     });
   }, [logger, apiRef, props.rows, props.getRowId, props.loading, props.rowCount, throttledRowsChange]);
+  const previousDataSource = useLazyRef(() => props.unstable_dataSource);
   const handleStrategyProcessorChange = React.useCallback(methodName => {
+    if (props.unstable_dataSource && props.unstable_dataSource !== previousDataSource.current) {
+      previousDataSource.current = props.unstable_dataSource;
+      return;
+    }
     if (methodName === 'rowTreeCreation') {
       groupRows();
     }
-  }, [groupRows]);
+  }, [groupRows, previousDataSource, props.unstable_dataSource]);
   const handleStrategyActivityChange = React.useCallback(() => {
     // `rowTreeCreation` is the only processor ran when `strategyAvailabilityChange` is fired.
     // All the other processors listen to `rowsSet` which will be published by the `groupRows` method below.

package/modern/hooks/features/scroll/useGridScroll.js

@@ -14,22 +14,22 @@ import { gridDimensionsSelector } from "../dimensions/index.js";
 // Similar to https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollIntoView
 function scrollIntoView(dimensions) {
   const {
-    clientHeight,
-    scrollTop,
-    offsetHeight,
-    offsetTop
+    containerSize,
+    scrollPosition,
+    elementSize,
+    elementOffset
   } = dimensions;
-  const elementBottom = offsetTop + offsetHeight;
+  const elementEnd = elementOffset + elementSize;
   // Always scroll to top when cell is higher than viewport to avoid scroll jump
   // See https://github.com/mui/mui-x/issues/4513 and https://github.com/mui/mui-x/issues/4514
-  if (offsetHeight > clientHeight) {
-    return offsetTop;
+  if (elementSize > containerSize) {
+    return elementOffset;
   }
-  if (elementBottom - clientHeight > scrollTop) {
-    return elementBottom - clientHeight;
+  if (elementEnd - containerSize > scrollPosition) {
+    return elementEnd - containerSize;
   }
-  if (offsetTop < scrollTop) {
-    return offsetTop;
+  if (elementOffset < scrollPosition) {
+    return elementOffset;
   }
   return undefined;
 }
@@ -73,10 +73,10 @@ export const useGridScroll = (apiRef, props) => {
       }
       // When using RTL, `scrollLeft` becomes negative, so we must ensure that we only compare values.
       scrollCoordinates.left = scrollIntoView({
-        clientHeight: dimensions.viewportInnerSize.width,
-        scrollTop: Math.abs(virtualScrollerRef.current.scrollLeft),
-        offsetHeight: cellWidth,
-        offsetTop: columnPositions[params.colIndex]
+        containerSize: dimensions.viewportOuterSize.width,
+        scrollPosition: Math.abs(virtualScrollerRef.current.scrollLeft),
+        elementSize: cellWidth,
+        elementOffset: columnPositions[params.colIndex]
       });
     }
     if (params.rowIndex !== undefined) {
@@ -86,10 +86,10 @@ export const useGridScroll = (apiRef, props) => {
       const elementIndex = !props.pagination ? params.rowIndex : params.rowIndex - page * pageSize;
       const targetOffsetHeight = rowsMeta.positions[elementIndex + 1] ? rowsMeta.positions[elementIndex + 1] - rowsMeta.positions[elementIndex] : rowsMeta.currentPageTotalHeight - rowsMeta.positions[elementIndex];
       scrollCoordinates.top = scrollIntoView({
-        clientHeight: dimensions.viewportInnerSize.height,
-        scrollTop: virtualScrollerRef.current.scrollTop,
-        offsetHeight: targetOffsetHeight,
-        offsetTop: rowsMeta.positions[elementIndex]
+        containerSize: dimensions.viewportInnerSize.height,
+        scrollPosition: virtualScrollerRef.current.scrollTop,
+        elementSize: targetOffsetHeight,
+        elementOffset: rowsMeta.positions[elementIndex]
       });
     }
     scrollCoordinates = apiRef.current.unstable_applyPipeProcessors('scrollToIndexes', scrollCoordinates, params);

package/modern/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/modern/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/modern/index.js

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

package/modern/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";
@@ -52,6 +53,7 @@ export { useGridStatePersistence } from "../hooks/features/statePersistence/useG
 export { useGridVirtualScroller, EMPTY_DETAIL_PANELS } from "../hooks/features/virtualization/useGridVirtualScroller.js";
 export * from "../hooks/features/virtualization/index.js";
 export { useGridColumnResize, columnResizeStateInitializer } from "../hooks/features/columnResize/useGridColumnResize.js";
+export { ROW_SELECTION_PROPAGATION_DEFAULT } from "../hooks/features/rowSelection/utils.js";
 export { useTimeout } from "../hooks/utils/useTimeout.js";
 export { useGridVisibleRows, getVisibleRows } from "../hooks/utils/useGridVisibleRows.js";
 export { useGridInitializeState } from "../hooks/utils/useGridInitializeState.js";

package/modern/locales/bgBG.js

@@ -30,11 +30,10 @@ const bgBGGrid = {
   toolbarExportPrint: 'Принтиране',
   toolbarExportExcel: 'Изтегли като Excel',
   // Columns management text
-  // columnsManagementSearchTitle: 'Search',
-  // columnsManagementNoColumns: 'No columns',
-  // columnsManagementShowHideAllText: 'Show/Hide All',
-  // columnsManagementReset: 'Reset',
-
+  columnsManagementSearchTitle: 'Търсене',
+  columnsManagementNoColumns: 'Няма колони',
+  columnsManagementShowHideAllText: 'Покажи/Скрий Всичко',
+  columnsManagementReset: 'Нулирай',
   // Filter panel text
   filterPanelAddFilter: 'Добави Филтър',
   filterPanelRemoveAll: 'Премахни всички',
@@ -48,9 +47,9 @@ const bgBGGrid = {
   filterPanelInputPlaceholder: 'Стойност на филтъра',
   // Filter operators text
   filterOperatorContains: 'съдържа',
-  // filterOperatorDoesNotContain: 'does not contain',
+  filterOperatorDoesNotContain: 'не съдържа',
   filterOperatorEquals: 'равно',
-  // filterOperatorDoesNotEqual: 'does not equal',
+  filterOperatorDoesNotEqual: 'не е равно',
   filterOperatorStartsWith: 'започва с',
   filterOperatorEndsWith: 'завършва с',
   filterOperatorIs: 'е',
@@ -70,9 +69,9 @@ const bgBGGrid = {
   'filterOperator<=': '<=',
   // Header filter operators text
   headerFilterOperatorContains: 'Съдържа',
-  // headerFilterOperatorDoesNotContain: 'Does not contain',
+  headerFilterOperatorDoesNotContain: 'Не съдържа',
   headerFilterOperatorEquals: 'Равнo',
-  // headerFilterOperatorDoesNotEqual: 'Does not equal',
+  headerFilterOperatorDoesNotEqual: 'Не е равно',
   headerFilterOperatorStartsWith: 'Започва с',
   headerFilterOperatorEndsWith: 'Завършва с',
   headerFilterOperatorIs: 'Равно е на',

package/modern/locales/deDE.js

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

package/modern/locales/frFR.js

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