@mui/x-data-grid 7.17.0 → 7.19.0

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

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCellValue = void 0;
+exports.getUnprocessedRange = getUnprocessedRange;
+exports.isRowContextInitialized = isRowContextInitialized;
+exports.isRowRangeUpdated = isRowRangeUpdated;
+function getUnprocessedRange(testRange, processedRange) {
+  if (testRange.firstRowIndex >= processedRange.firstRowIndex && testRange.lastRowIndex <= processedRange.lastRowIndex) {
+    return null;
+  }
+  // Overflowing at the end
+  // Example: testRange={ firstRowIndex: 10, lastRowIndex: 20 }, processedRange={ firstRowIndex: 0, lastRowIndex: 15 }
+  // Unprocessed Range={ firstRowIndex: 16, lastRowIndex: 20 }
+  if (testRange.firstRowIndex >= processedRange.firstRowIndex && testRange.lastRowIndex > processedRange.lastRowIndex) {
+    return {
+      firstRowIndex: processedRange.lastRowIndex,
+      lastRowIndex: testRange.lastRowIndex
+    };
+  }
+  // Overflowing at the beginning
+  // Example: testRange={ firstRowIndex: 0, lastRowIndex: 20 }, processedRange={ firstRowIndex: 16, lastRowIndex: 30 }
+  // Unprocessed Range={ firstRowIndex: 0, lastRowIndex: 15 }
+  if (testRange.firstRowIndex < processedRange.firstRowIndex && testRange.lastRowIndex <= processedRange.lastRowIndex) {
+    return {
+      firstRowIndex: testRange.firstRowIndex,
+      lastRowIndex: processedRange.firstRowIndex - 1
+    };
+  }
+  // TODO: Should return two ranges handle overflowing at both ends ?
+  return testRange;
+}
+function isRowContextInitialized(renderContext) {
+  return renderContext.firstRowIndex !== 0 || renderContext.lastRowIndex !== 0;
+}
+function isRowRangeUpdated(range1, range2) {
+  return range1.firstRowIndex !== range2.firstRowIndex || range1.lastRowIndex !== range2.lastRowIndex;
+}
+const getCellValue = (row, colDef, apiRef) => {
+  if (!row) {
+    return null;
+  }
+  let cellValue = row[colDef.field];
+  const valueGetter = colDef.rowSpanValueGetter ?? colDef.valueGetter;
+  if (valueGetter) {
+    cellValue = valueGetter(cellValue, row, colDef, apiRef);
+  }
+  return cellValue;
+};
+exports.getCellValue = getCellValue;

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/rows/useGridRows.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.useGridRows = exports.rowsStateInitializer = void 0;
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var React = _interopRequireWildcard(require("react"));
+var _useLazyRef = _interopRequireDefault(require("@mui/utils/useLazyRef"));
 var _useGridApiMethod = require("../../utils/useGridApiMethod");
 var _useGridLogger = require("../../utils/useGridLogger");
 var _gridRowsSelector = require("./gridRowsSelector");
@@ -376,11 +377,16 @@ const useGridRows = (apiRef, props) => {
       throttle: false
     });
   }, [logger, apiRef, props.rows, props.getRowId, props.loading, props.rowCount, throttledRowsChange]);
+  const previousDataSource = (0, _useLazyRef.default)(() => 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/node/hooks/features/scroll/useGridScroll.js

@@ -20,22 +20,22 @@ var _dimensions = require("../dimensions");
 // 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;
 }
@@ -79,10 +79,10 @@ 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) {
@@ -92,10 +92,10 @@ 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/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.19.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,
@@ -78,6 +80,7 @@ var _exportNames = {
   EMPTY_DETAIL_PANELS: true,
   useGridColumnResize: true,
   columnResizeStateInitializer: true,
+  ROW_SELECTION_PROPAGATION_DEFAULT: true,
   useTimeout: true,
   useGridVisibleRows: true,
   getVisibleRows: true,
@@ -152,6 +155,12 @@ Object.defineProperty(exports, "GridVirtualScrollerRenderZone", {
     return _GridVirtualScrollerRenderZone.GridVirtualScrollerRenderZone;
   }
 });
+Object.defineProperty(exports, "ROW_SELECTION_PROPAGATION_DEFAULT", {
+  enumerable: true,
+  get: function () {
+    return _utils.ROW_SELECTION_PROPAGATION_DEFAULT;
+  }
+});
 Object.defineProperty(exports, "buildRootGroup", {
   enumerable: true,
   get: function () {
@@ -215,7 +224,7 @@ Object.defineProperty(exports, "createSelectorV8", {
 Object.defineProperty(exports, "defaultGetRowsToExport", {
   enumerable: true,
   get: function () {
-    return _utils.defaultGetRowsToExport;
+    return _utils2.defaultGetRowsToExport;
   }
 });
 Object.defineProperty(exports, "densityStateInitializer", {
@@ -269,7 +278,7 @@ Object.defineProperty(exports, "getActiveElement", {
 Object.defineProperty(exports, "getColumnsToExport", {
   enumerable: true,
   get: function () {
-    return _utils.getColumnsToExport;
+    return _utils2.getColumnsToExport;
   }
 });
 Object.defineProperty(exports, "getGridFilter", {
@@ -398,6 +407,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 +611,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 +744,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");
@@ -752,10 +774,11 @@ Object.keys(_virtualization).forEach(function (key) {
   });
 });
 var _useGridColumnResize = require("../hooks/features/columnResize/useGridColumnResize");
+var _utils = require("../hooks/features/rowSelection/utils");
 var _useTimeout = require("../hooks/utils/useTimeout");
 var _useGridVisibleRows = require("../hooks/utils/useGridVisibleRows");
 var _useGridInitializeState = require("../hooks/utils/useGridInitializeState");
-var _utils = require("../hooks/features/export/utils");
+var _utils2 = require("../hooks/features/export/utils");
 var _createControllablePromise = require("../utils/createControllablePromise");
 Object.keys(_createControllablePromise).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -772,15 +795,15 @@ var _createSelector = require("../utils/createSelector");
 var _useGridSelector = require("../hooks/utils/useGridSelector");
 var _domUtils = require("../utils/domUtils");
 var _keyboardUtils = require("../utils/keyboardUtils");
-var _utils2 = require("../utils/utils");
-Object.keys(_utils2).forEach(function (key) {
+var _utils3 = require("../utils/utils");
+Object.keys(_utils3).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _utils2[key]) return;
+  if (key in exports && exports[key] === _utils3[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _utils2[key];
+      return _utils3[key];
     }
   });
 });
@@ -810,28 +833,28 @@ Object.keys(_cellBorderUtils).forEach(function (key) {
   });
 });
 var _useGridPrivateApiContext = require("../hooks/utils/useGridPrivateApiContext");
-var _utils3 = require("../hooks/utils");
-Object.keys(_utils3).forEach(function (key) {
+var _utils4 = require("../hooks/utils");
+Object.keys(_utils4).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _utils3[key]) return;
+  if (key in exports && exports[key] === _utils4[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _utils3[key];
+      return _utils4[key];
     }
   });
 });
 var _csvSerializer = require("../hooks/features/export/serializers/csvSerializer");
-var _utils4 = require("./utils");
-Object.keys(_utils4).forEach(function (key) {
+var _utils5 = require("./utils");
+Object.keys(_utils5).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _utils4[key]) return;
+  if (key in exports && exports[key] === _utils5[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _utils4[key];
+      return _utils5[key];
     }
   });
 });