@mui/x-data-grid 7.17.0 → 7.18.0

package/node/hooks/features/rows/useGridRowSpanning.js

@@ -0,0 +1,267 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridRowSpanning = exports.rowSpanningStateInitializer = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
+var _useLazyRef = _interopRequireDefault(require("@mui/utils/useLazyRef"));
+var _gridColumnsSelector = require("../columns/gridColumnsSelector");
+var _useGridVisibleRows = require("../../utils/useGridVisibleRows");
+var _gridVirtualizationSelectors = require("../virtualization/gridVirtualizationSelectors");
+var _useGridSelector = require("../../utils/useGridSelector");
+var _gridRowSpanningUtils = require("./gridRowSpanningUtils");
+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 ? {} : (0, _extends2.default)({}, apiRef.current.state.rowSpanning.spannedCells);
+  const hiddenCells = resetState ? {} : (0, _extends2.default)({}, apiRef.current.state.rowSpanning.hiddenCells);
+  const hiddenCellOriginMap = resetState ? {} : (0, _extends2.default)({}, 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 = (0, _gridRowSpanningUtils.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 && (0, _gridRowSpanningUtils.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] && (0, _gridRowSpanningUtils.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
+ */
+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 (0, _extends2.default)({}, 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 (0, _extends2.default)({}, state, {
+      rowSpanning: {
+        spannedCells,
+        hiddenCells,
+        hiddenCellOriginMap
+      }
+    });
+  }
+  return (0, _extends2.default)({}, state, {
+    rowSpanning: EMPTY_STATE
+  });
+};
+exports.rowSpanningStateInitializer = rowSpanningStateInitializer;
+const useGridRowSpanning = (apiRef, props) => {
+  const {
+    range,
+    rows: visibleRows
+  } = (0, _useGridVisibleRows.useGridVisibleRows)(apiRef, props);
+  const renderContext = (0, _useGridSelector.useGridSelector)(apiRef, _gridVirtualizationSelectors.gridRenderContextSelector);
+  const colDefs = (0, _useGridSelector.useGridSelector)(apiRef, _gridColumnsSelector.gridVisibleColumnDefinitionsSelector);
+  const processedRange = (0, _useLazyRef.default)(() => {
+    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 => (0, _extends2.default)({}, state, {
+          rowSpanning: EMPTY_STATE
+        }));
+      }
+      return;
+    }
+    if (range === null || !(0, _gridRowSpanningUtils.isRowContextInitialized)(renderContext)) {
+      return;
+    }
+    if (resetState) {
+      processedRange.current = EMPTY_RANGE;
+    }
+    const rangeToProcess = (0, _gridRowSpanningUtils.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 (0, _extends2.default)({}, 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 && (0, _gridRowSpanningUtils.isRowRangeUpdated)(range, lastRange.current)) {
+      lastRange.current = range;
+      shouldResetState.current = true;
+    }
+    if (!firstRender && prevRenderContext.current !== renderContext) {
+      if ((0, _gridRowSpanningUtils.isRowRangeUpdated)(prevRenderContext.current, renderContext)) {
+        updateRowSpanningState(shouldResetState.current);
+        shouldResetState.current = false;
+      }
+      prevRenderContext.current = renderContext;
+      return;
+    }
+    updateRowSpanningState();
+  }, [updateRowSpanningState, renderContext, range, lastRange]);
+};
+exports.useGridRowSpanning = useGridRowSpanning;

package/node/hooks/features/virtualization/useGridVirtualScroller.js

@@ -35,6 +35,7 @@ var _gridColumnsUtils = require("../columns/gridColumnsUtils");
 var _gridRowsUtils = require("../rows/gridRowsUtils");
 var _gridVirtualizationSelectors = require("./gridVirtualizationSelectors");
 var _useGridVirtualization = require("./useGridVirtualization");
+var _gridRowSpanningSelectors = require("../rows/gridRowSpanningSelectors");
 var _jsxRuntime = require("react/jsx-runtime");
 const MINIMUM_COLUMN_WIDTH = 50;
 var ScrollDirection = /*#__PURE__*/function (ScrollDirection) {
@@ -336,7 +337,7 @@ 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__*/(0, _jsxRuntime.jsx)(rootProps.slots.row, (0, _extends2.default)({
         row: model,
@@ -364,7 +365,7 @@ const useGridVirtualScroller = () => {
       if (panel) {
         rows.push(panel);
       }
-      if (isLastVisible) {
+      if (params.position === undefined && isLastVisibleInSection) {
         rows.push(apiRef.current.getInfiniteLoadingTriggerElement?.({
           lastRowId: id
         }));
@@ -459,6 +460,7 @@ function inputsSelector(apiRef, rootProps, enabledForRows, enabledForColumns) {
   const dimensions = (0, _gridDimensionsSelectors.gridDimensionsSelector)(apiRef.current.state);
   const currentPage = (0, _useGridVisibleRows.getVisibleRows)(apiRef, rootProps);
   const visibleColumns = (0, _gridColumnsSelector.gridVisibleColumnDefinitionsSelector)(apiRef);
+  const hiddenCellsOriginMap = (0, _gridRowSpanningSelectors.gridRowSpanningHiddenCellsOriginMapSelector)(apiRef);
   const lastRowId = apiRef.current.state.rows.dataRowIds.at(-1);
   const lastColumn = visibleColumns.at(-1);
   return {
@@ -479,7 +481,8 @@ function inputsSelector(apiRef, rootProps, enabledForRows, enabledForColumns) {
     rows: currentPage.rows,
     range: currentPage.range,
     pinnedColumns: (0, _gridColumnsSelector.gridVisiblePinnedColumnDefinitionsSelector)(apiRef),
-    visibleColumns
+    visibleColumns,
+    hiddenCellsOriginMap
   };
 }
 function computeRenderContext(inputs, scrollPosition, scrollCache) {
@@ -497,10 +500,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;
@@ -654,9 +665,8 @@ function areRenderContextsEqual(context1, context2) {
   }
   return context1.firstRowIndex === context2.firstRowIndex && context1.lastRowIndex === context2.lastRowIndex && context1.firstColumnIndex === context2.firstColumnIndex && context1.lastColumnIndex === context2.lastColumnIndex;
 }
-function computeOffsetLeft(columnPositions, renderContext, isRtl, pinnedLeftLength) {
-  const factor = isRtl ? -1 : 1;
-  const left = factor * (columnPositions[renderContext.firstColumnIndex] ?? 0) - (columnPositions[pinnedLeftLength] ?? 0);
+function computeOffsetLeft(columnPositions, renderContext, pinnedLeftLength) {
+  const left = (columnPositions[renderContext.firstColumnIndex] ?? 0) - (columnPositions[pinnedLeftLength] ?? 0);
   return Math.abs(left);
 }
 function directionForDelta(dx, dy) {

package/node/hooks/utils/useGridApiEventHandler.js

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

package/node/index.js

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

package/node/internals/index.js

@@ -48,6 +48,8 @@ var _exportNames = {
   gridEditRowsStateSelector: true,
   useGridRows: true,
   rowsStateInitializer: true,
+  useGridRowSpanning: true,
+  rowSpanningStateInitializer: true,
   useGridAriaAttributes: true,
   useGridRowAriaAttributes: true,
   useGridRowsPreProcessors: true,
@@ -398,6 +400,12 @@ Object.defineProperty(exports, "rowSelectionStateInitializer", {
     return _useGridRowSelection.rowSelectionStateInitializer;
   }
 });
+Object.defineProperty(exports, "rowSpanningStateInitializer", {
+  enumerable: true,
+  get: function () {
+    return _useGridRowSpanning.rowSpanningStateInitializer;
+  }
+});
 Object.defineProperty(exports, "rowsMetaStateInitializer", {
   enumerable: true,
   get: function () {
@@ -596,6 +604,12 @@ Object.defineProperty(exports, "useGridRowSelectionPreProcessors", {
     return _useGridRowSelectionPreProcessors.useGridRowSelectionPreProcessors;
   }
 });
+Object.defineProperty(exports, "useGridRowSpanning", {
+  enumerable: true,
+  get: function () {
+    return _useGridRowSpanning.useGridRowSpanning;
+  }
+});
 Object.defineProperty(exports, "useGridRows", {
   enumerable: true,
   get: function () {
@@ -723,6 +737,7 @@ var _useGridPreferencesPanel = require("../hooks/features/preferencesPanel/useGr
 var _useGridEditing = require("../hooks/features/editing/useGridEditing");
 var _gridEditingSelectors = require("../hooks/features/editing/gridEditingSelectors");
 var _useGridRows = require("../hooks/features/rows/useGridRows");
+var _useGridRowSpanning = require("../hooks/features/rows/useGridRowSpanning");
 var _useGridAriaAttributes = require("../hooks/utils/useGridAriaAttributes");
 var _useGridRowAriaAttributes = require("../hooks/features/rows/useGridRowAriaAttributes");
 var _useGridRowsPreProcessors = require("../hooks/features/rows/useGridRowsPreProcessors");

package/node/utils/domUtils.js

@@ -146,22 +146,22 @@ const findPinnedCells = ({
   });
   return cells;
 };
-function findLeftPinnedCellsAfterCol(api, col) {
+function findLeftPinnedCellsAfterCol(api, col, isRtl) {
   const colIndex = parseCellColIndex(col);
   return findPinnedCells({
     api,
     colIndex,
-    position: 'left',
-    filterFn: index => index > colIndex
+    position: isRtl ? 'right' : 'left',
+    filterFn: index => isRtl ? index < colIndex : index > colIndex
   });
 }
-function findRightPinnedCellsBeforeCol(api, col) {
+function findRightPinnedCellsBeforeCol(api, col, isRtl) {
   const colIndex = parseCellColIndex(col);
   return findPinnedCells({
     api,
     colIndex,
-    position: 'right',
-    filterFn: index => index < colIndex
+    position: isRtl ? 'left' : 'right',
+    filterFn: index => isRtl ? index > colIndex : index < colIndex
   });
 }
 const findPinnedHeaders = ({
@@ -185,22 +185,22 @@ const findPinnedHeaders = ({
   });
   return elements;
 };
-function findLeftPinnedHeadersAfterCol(api, col) {
+function findLeftPinnedHeadersAfterCol(api, col, isRtl) {
   const colIndex = parseCellColIndex(col);
   return findPinnedHeaders({
     api,
-    position: 'left',
+    position: isRtl ? 'right' : 'left',
     colIndex,
-    filterFn: index => index > colIndex
+    filterFn: index => isRtl ? index < colIndex : index > colIndex
   });
 }
-function findRightPinnedHeadersBeforeCol(api, col) {
+function findRightPinnedHeadersBeforeCol(api, col, isRtl) {
   const colIndex = parseCellColIndex(col);
   return findPinnedHeaders({
     api,
-    position: 'right',
+    position: isRtl ? 'left' : 'right',
     colIndex,
-    filterFn: index => index < colIndex
+    filterFn: index => isRtl ? index > colIndex : index < colIndex
   });
 }
 function findGridHeader(api, field) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/x-data-grid",
-  "version": "7.17.0",
+  "version": "7.18.0",
   "description": "The Community plan edition of the Data Grid components (MUI X).",
   "author": "MUI Team",
   "main": "./node/index.js",
@@ -33,7 +33,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/mui/mui-x.git",
+    "url": "git+https://github.com/mui/mui-x.git",
     "directory": "packages/x-data-grid"
   },
   "dependencies": {
@@ -42,7 +42,7 @@
     "clsx": "^2.1.1",
     "prop-types": "^15.8.1",
     "reselect": "^5.1.1",
-    "@mui/x-internals": "7.17.0"
+    "@mui/x-internals": "7.18.0"
   },
   "peerDependencies": {
     "@emotion/react": "^11.9.0",

package/utils/domUtils.d.ts

@@ -18,9 +18,9 @@ export declare function getFieldsFromGroupHeaderElem(colCellEl: Element): string
 export declare function findGroupHeaderElementsFromField(elem: Element, field: string): Element[];
 export declare function findGridCellElementsFromCol(col: HTMLElement, api: GridPrivateApiCommunity): Element[];
 export declare function findGridElement(api: GridPrivateApiCommunity, klass: keyof typeof gridClasses): HTMLElement;
-export declare function findLeftPinnedCellsAfterCol(api: GridPrivateApiCommunity, col: HTMLElement): HTMLElement[];
-export declare function findRightPinnedCellsBeforeCol(api: GridPrivateApiCommunity, col: HTMLElement): HTMLElement[];
-export declare function findLeftPinnedHeadersAfterCol(api: GridPrivateApiCommunity, col: HTMLElement): HTMLElement[];
-export declare function findRightPinnedHeadersBeforeCol(api: GridPrivateApiCommunity, col: HTMLElement): HTMLElement[];
+export declare function findLeftPinnedCellsAfterCol(api: GridPrivateApiCommunity, col: HTMLElement, isRtl: boolean): HTMLElement[];
+export declare function findRightPinnedCellsBeforeCol(api: GridPrivateApiCommunity, col: HTMLElement, isRtl: boolean): HTMLElement[];
+export declare function findLeftPinnedHeadersAfterCol(api: GridPrivateApiCommunity, col: HTMLElement, isRtl: boolean): HTMLElement[];
+export declare function findRightPinnedHeadersBeforeCol(api: GridPrivateApiCommunity, col: HTMLElement, isRtl: boolean): HTMLElement[];
 export declare function findGridHeader(api: GridPrivateApiCommunity, field: string): Element | null;
 export declare function findGridCells(api: GridPrivateApiCommunity, field: string): Element[];

package/utils/domUtils.js

@@ -120,22 +120,22 @@ const findPinnedCells = ({
   });
   return cells;
 };
-export function findLeftPinnedCellsAfterCol(api, col) {
+export function findLeftPinnedCellsAfterCol(api, col, isRtl) {
   const colIndex = parseCellColIndex(col);
   return findPinnedCells({
     api,
     colIndex,
-    position: 'left',
-    filterFn: index => index > colIndex
+    position: isRtl ? 'right' : 'left',
+    filterFn: index => isRtl ? index < colIndex : index > colIndex
   });
 }
-export function findRightPinnedCellsBeforeCol(api, col) {
+export function findRightPinnedCellsBeforeCol(api, col, isRtl) {
   const colIndex = parseCellColIndex(col);
   return findPinnedCells({
     api,
     colIndex,
-    position: 'right',
-    filterFn: index => index < colIndex
+    position: isRtl ? 'left' : 'right',
+    filterFn: index => isRtl ? index > colIndex : index < colIndex
   });
 }
 const findPinnedHeaders = ({
@@ -159,22 +159,22 @@ const findPinnedHeaders = ({
   });
   return elements;
 };
-export function findLeftPinnedHeadersAfterCol(api, col) {
+export function findLeftPinnedHeadersAfterCol(api, col, isRtl) {
   const colIndex = parseCellColIndex(col);
   return findPinnedHeaders({
     api,
-    position: 'left',
+    position: isRtl ? 'right' : 'left',
     colIndex,
-    filterFn: index => index > colIndex
+    filterFn: index => isRtl ? index < colIndex : index > colIndex
   });
 }
-export function findRightPinnedHeadersBeforeCol(api, col) {
+export function findRightPinnedHeadersBeforeCol(api, col, isRtl) {
   const colIndex = parseCellColIndex(col);
   return findPinnedHeaders({
     api,
-    position: 'right',
+    position: isRtl ? 'left' : 'right',
     colIndex,
-    filterFn: index => index < colIndex
+    filterFn: index => isRtl ? index > colIndex : index < colIndex
   });
 }
 export function findGridHeader(api, field) {