@mui/x-data-grid-premium 8.19.0 → 8.21.0

package/hooks/features/rowGrouping/useGridRowGrouping.d.ts

@@ -8,4 +8,4 @@ export declare const rowGroupingStateInitializer: GridStateInitializer<Pick<Data
  * @requires useGridRows (state, method) - can be after, async only
  * @requires useGridParamsApi (method) - can be after, async only
  */
-export declare const useGridRowGrouping: (apiRef: RefObject<GridPrivateApiPremium>, props: Pick<DataGridPremiumProcessedProps, "initialState" | "rowGroupingModel" | "onRowGroupingModelChange" | "isGroupExpandedByDefault" | "rowGroupingColumnMode" | "disableRowGrouping" | "slotProps" | "slots" | "dataSource" | "treeData">) => void;
+export declare const useGridRowGrouping: (apiRef: RefObject<GridPrivateApiPremium>, props: Pick<DataGridPremiumProcessedProps, "initialState" | "rowGroupingModel" | "onRowGroupingModelChange" | "isGroupExpandedByDefault" | "rowGroupingColumnMode" | "disableRowGrouping" | "slotProps" | "slots" | "dataSource" | "treeData" | "isValidRowReorder">) => void;

package/hooks/features/rowGrouping/useGridRowGrouping.js

@@ -13,7 +13,7 @@ var _xDataGridPro = require("@mui/x-data-grid-pro");
 var _internals = require("@mui/x-data-grid-pro/internals");
 var _gridRowGroupingSelector = require("./gridRowGroupingSelector");
 var _gridRowGroupingUtils = require("./gridRowGroupingUtils");
-var _reorderValidator = require("../rowReorder/reorderValidator");
+var _rowGroupingReorderValidator = require("../rowReorder/rowGroupingReorderValidator");
 const rowGroupingStateInitializer = (state, props, apiRef) => {
   apiRef.current.caches.rowGrouping = {
     rulesOnLastRowTreeCreation: []
@@ -177,7 +177,8 @@ const useGridRowGrouping = (apiRef, props) => {
       }
     }
   }, [apiRef, props.disableRowGrouping]);
-  const getRowReorderTargetIndex = React.useCallback((initialValue, {
+  const isValidRowReorderProp = props.isValidRowReorder;
+  const isRowReorderValid = React.useCallback((initialValue, {
     sourceRowId,
     targetRowId,
     dropPosition,
@@ -186,10 +187,9 @@ const useGridRowGrouping = (apiRef, props) => {
     if ((0, _xDataGridPro.gridRowMaximumTreeDepthSelector)(apiRef) === 1 || props.treeData) {
       return initialValue;
     }
-    const expandedSortedRowIndexLookup = (0, _internals.gridExpandedSortedRowIndexLookupSelector)(apiRef);
+    const expandedSortedRowIndexLookup = (0, _xDataGridPro.gridExpandedSortedRowIndexLookupSelector)(apiRef);
     const expandedSortedRowIds = (0, _xDataGridPro.gridExpandedSortedRowIdsSelector)(apiRef);
     const rowTree = (0, _xDataGridPro.gridRowTreeSelector)(apiRef);
-    const sourceRowIndex = expandedSortedRowIndexLookup[sourceRowId];
     const targetRowIndex = expandedSortedRowIndexLookup[targetRowId];
     const sourceNode = rowTree[sourceRowId];
     const targetNode = rowTree[targetRowId];
@@ -198,30 +198,34 @@ const useGridRowGrouping = (apiRef, props) => {
 
     // Basic validity checks
     if (!sourceNode || !targetNode) {
-      return -1;
+      return false;
     }
 
     // Create context object
     const context = {
+      apiRef,
       sourceNode,
       targetNode,
       prevNode,
       nextNode,
-      rowTree,
       dropPosition,
-      dragDirection,
-      targetRowIndex,
-      sourceRowIndex,
-      expandedSortedRowIndexLookup
+      dragDirection
     };
 
-    // Check if the reorder is valid
-    if (_reorderValidator.rowGroupingReorderValidator.validate(context)) {
-      return dropPosition === 'below' ? targetRowIndex + 1 : targetRowIndex;
+    // First apply internal validation
+    let isValid = _rowGroupingReorderValidator.rowGroupingReorderValidator.validate(context);
+
+    // If internal validation passes AND user provided additional validation
+    if (isValid && isValidRowReorderProp) {
+      // Apply additional user restrictions
+      isValid = isValidRowReorderProp(context);
+    }
+    if (isValid) {
+      return true;
     }
-    return -1;
-  }, [apiRef, props.treeData]);
-  (0, _internals.useGridRegisterPipeProcessor)(apiRef, 'getRowReorderTargetIndex', getRowReorderTargetIndex);
+    return false;
+  }, [apiRef, props.treeData, isValidRowReorderProp]);
+  (0, _internals.useGridRegisterPipeProcessor)(apiRef, 'isRowReorderValid', isRowReorderValid);
   (0, _xDataGridPro.useGridEvent)(apiRef, 'cellKeyDown', handleCellKeyDown);
   (0, _xDataGridPro.useGridEvent)(apiRef, 'columnsChange', checkGroupingColumnsModelDiff);
   (0, _xDataGridPro.useGridEvent)(apiRef, 'rowGroupingModelChange', checkGroupingColumnsModelDiff);

package/hooks/features/rowReorder/operations.d.ts

@@ -1,34 +1,13 @@
-import type { ReorderOperation, ReorderExecutionContext } from "./types.js";
-/**
- * Base class for all reorder operations.
- * Provides abstract methods for operation detection and execution.
- */
-export declare abstract class BaseReorderOperation {
-  abstract readonly operationType: string;
-  /**
-   * Detects if this operation can handle the given context.
-   */
-  abstract detectOperation(ctx: ReorderExecutionContext): ReorderOperation | null;
-  /**
-   * Executes the detected operation.
-   */
-  abstract executeOperation(operation: ReorderOperation, ctx: ReorderExecutionContext): Promise<void> | void;
-}
-/**
- * Handles reordering of items within the same parent group.
- */
-export declare class SameParentSwapOperation extends BaseReorderOperation {
-  readonly operationType = "same-parent-swap";
-  detectOperation(ctx: ReorderExecutionContext): ReorderOperation | null;
-  executeOperation(operation: ReorderOperation, ctx: ReorderExecutionContext): void;
-}
+import { BaseReorderOperation, type ReorderOperation, type ReorderExecutionContext } from '@mui/x-data-grid-pro/internals';
+import { GridPrivateApiPremium } from "../../../models/gridApiPremium.js";
+type ReorderExecutionContextType = ReorderExecutionContext<GridPrivateApiPremium>;
 /**
  * Handles moving leaf nodes between different parent groups.
  */
 export declare class CrossParentLeafOperation extends BaseReorderOperation {
   readonly operationType = "cross-parent-leaf";
   detectOperation(ctx: ReorderExecutionContext): ReorderOperation | null;
-  executeOperation(operation: ReorderOperation, ctx: ReorderExecutionContext): Promise<void>;
+  executeOperation(operation: ReorderOperation, ctx: ReorderExecutionContextType): Promise<void>;
 }
 /**
  * Handles moving entire groups between different parents.
@@ -36,5 +15,6 @@ export declare class CrossParentLeafOperation extends BaseReorderOperation {
 export declare class CrossParentGroupOperation extends BaseReorderOperation {
   readonly operationType = "cross-parent-group";
   detectOperation(ctx: ReorderExecutionContext): ReorderOperation | null;
-  executeOperation(operation: ReorderOperation, ctx: ReorderExecutionContext): Promise<void>;
-}
+  executeOperation(operation: ReorderOperation, ctx: ReorderExecutionContextType): Promise<void>;
+}
+export {};

package/hooks/features/rowReorder/operations.js

@@ -4,138 +4,16 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.SameParentSwapOperation = exports.CrossParentLeafOperation = exports.CrossParentGroupOperation = exports.BaseReorderOperation = void 0;
+exports.CrossParentLeafOperation = exports.CrossParentGroupOperation = void 0;
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var _xDataGridPro = require("@mui/x-data-grid-pro");
-var _warning = require("@mui/x-internals/warning");
-var _isDeepEqual = require("@mui/x-internals/isDeepEqual");
+var _internals = require("@mui/x-data-grid-pro/internals");
 var _rowGrouping = require("../rowGrouping");
 var _gridRowGroupingUtils = require("../rowGrouping/gridRowGroupingUtils");
-var _utils = require("./utils");
-/**
- * Base class for all reorder operations.
- * Provides abstract methods for operation detection and execution.
- */
-class BaseReorderOperation {}
-
-/**
- * Handles reordering of items within the same parent group.
- */
-exports.BaseReorderOperation = BaseReorderOperation;
-class SameParentSwapOperation extends BaseReorderOperation {
-  operationType = 'same-parent-swap';
-  detectOperation(ctx) {
-    const {
-      sourceRowId,
-      placeholderIndex,
-      sortedFilteredRowIds,
-      sortedFilteredRowIndexLookup,
-      rowTree,
-      apiRef
-    } = ctx;
-    const sourceNode = (0, _xDataGridPro.gridRowNodeSelector)(apiRef, sourceRowId);
-    if (!sourceNode || sourceNode.type === 'footer') {
-      return null;
-    }
-    let targetIndex = placeholderIndex;
-    const sourceIndex = sortedFilteredRowIndexLookup[sourceRowId];
-    if (targetIndex === sortedFilteredRowIds.length && sortedFilteredRowIds.length > 0) {
-      targetIndex -= 1;
-    }
-    let targetNode = (0, _xDataGridPro.gridRowNodeSelector)(apiRef, sortedFilteredRowIds[targetIndex]);
-    if (placeholderIndex > sourceIndex && sourceNode.parent === targetNode.parent) {
-      targetIndex = placeholderIndex - 1;
-      targetNode = (0, _xDataGridPro.gridRowNodeSelector)(apiRef, sortedFilteredRowIds[targetIndex]);
-      if (targetNode && targetNode.depth !== sourceNode.depth) {
-        while (targetNode.depth > sourceNode.depth && targetIndex >= 0) {
-          targetIndex -= 1;
-          targetNode = (0, _xDataGridPro.gridRowNodeSelector)(apiRef, sortedFilteredRowIds[targetIndex]);
-        }
-      }
-      if (targetIndex === -1) {
-        return null;
-      }
-    }
-    let isLastChild = false;
-    if (!targetNode) {
-      if (placeholderIndex >= sortedFilteredRowIds.length && sortedFilteredRowIds.length > 0) {
-        targetNode = (0, _xDataGridPro.gridRowNodeSelector)(apiRef, sortedFilteredRowIds[sortedFilteredRowIds.length - 1]);
-        isLastChild = true;
-      } else {
-        return null;
-      }
-    }
-    let adjustedTargetNode = targetNode;
-
-    // Case A and B adjustment
-    if (targetNode.type === 'group' && sourceNode.parent !== targetNode.parent && sourceNode.depth > targetNode.depth) {
-      let i = targetIndex - 1;
-      while (i >= 0) {
-        const node = (0, _xDataGridPro.gridRowNodeSelector)(apiRef, sortedFilteredRowIds[i]);
-        if (node && node.depth < sourceNode.depth) {
-          return null;
-        }
-        if (node && node.depth === sourceNode.depth) {
-          targetIndex = i;
-          adjustedTargetNode = node;
-          break;
-        }
-        i -= 1;
-      }
-    }
-    const operationType = (0, _utils.determineOperationType)(sourceNode, adjustedTargetNode);
-    if (operationType !== 'same-parent-swap') {
-      return null;
-    }
-    const actualTargetIndex = (0, _utils.calculateTargetIndex)(sourceNode, adjustedTargetNode, isLastChild, rowTree);
-    targetNode = adjustedTargetNode;
-    if (sourceNode.type !== targetNode.type) {
-      return null;
-    }
-    return {
-      sourceNode,
-      targetNode,
-      actualTargetIndex,
-      isLastChild,
-      operationType
-    };
-  }
-  executeOperation(operation, ctx) {
-    const {
-      sourceNode,
-      actualTargetIndex
-    } = operation;
-    const {
-      apiRef,
-      sourceRowId
-    } = ctx;
-    apiRef.current.setState(state => {
-      const group = (0, _xDataGridPro.gridRowTreeSelector)(apiRef)[sourceNode.parent];
-      const currentChildren = [...group.children];
-      const oldIndex = currentChildren.findIndex(row => row === sourceRowId);
-      if (oldIndex === -1 || actualTargetIndex === -1 || oldIndex === actualTargetIndex) {
-        return state;
-      }
-      currentChildren.splice(actualTargetIndex, 0, currentChildren.splice(oldIndex, 1)[0]);
-      return (0, _extends2.default)({}, state, {
-        rows: (0, _extends2.default)({}, state.rows, {
-          tree: (0, _extends2.default)({}, state.rows.tree, {
-            [sourceNode.parent]: (0, _extends2.default)({}, group, {
-              children: currentChildren
-            })
-          })
-        })
-      });
-    });
-    apiRef.current.publishEvent('rowsSet');
-  }
-}
-
 /**
  * Handles moving leaf nodes between different parent groups.
  */
-exports.SameParentSwapOperation = SameParentSwapOperation;
-class CrossParentLeafOperation extends BaseReorderOperation {
+class CrossParentLeafOperation extends _internals.BaseReorderOperation {
   operationType = 'cross-parent-leaf';
   detectOperation(ctx) {
     const {
@@ -173,11 +51,11 @@ class CrossParentLeafOperation extends BaseReorderOperation {
         }
       }
     }
-    const operationType = (0, _utils.determineOperationType)(sourceNode, adjustedTargetNode);
+    const operationType = _internals.rowReorderUtils.determineOperationType(sourceNode, adjustedTargetNode);
     if (operationType !== 'cross-parent-leaf') {
       return null;
     }
-    const actualTargetIndex = (0, _utils.calculateTargetIndex)(sourceNode, adjustedTargetNode, isLastChild, rowTree);
+    const actualTargetIndex = _internals.rowReorderUtils.calculateTargetIndex(sourceNode, adjustedTargetNode, isLastChild, rowTree);
     targetNode = adjustedTargetNode;
 
     // Validate depth constraints
@@ -255,72 +133,56 @@ class CrossParentLeafOperation extends BaseReorderOperation {
         updatedSourceRow[groupingRule.field] = targetRow[groupingRule.field];
       }
     }
-    const commitStateUpdate = finalSourceRow => {
-      apiRef.current.setState(state => {
-        const updatedSourceChildren = sourceChildren.filter(rowId => rowId !== sourceRowId);
-        const updatedTree = (0, _extends2.default)({}, state.rows.tree);
-        const removedGroups = new Set();
-        let rootLevelRemovals = 0;
-        if (updatedSourceChildren.length === 0) {
-          removedGroups.add(sourceGroup.id);
-          rootLevelRemovals = (0, _utils.removeEmptyAncestors)(sourceGroup.parent, updatedTree, removedGroups);
-        }
-        removedGroups.forEach(groupId => {
-          const group = updatedTree[groupId];
-          if (group && group.parent && updatedTree[group.parent]) {
-            const parent = updatedTree[group.parent];
-            updatedTree[group.parent] = (0, _extends2.default)({}, parent, {
-              children: parent.children.filter(childId => childId !== groupId)
-            });
-          }
-          delete updatedTree[groupId];
-        });
-        if (!removedGroups.has(sourceGroup.id)) {
-          updatedTree[sourceNode.parent] = (0, _extends2.default)({}, sourceGroup, {
-            children: updatedSourceChildren
+    const updater = new _internals.rowReorderUtils.BatchRowUpdater(apiRef, processRowUpdate, onProcessRowUpdateError);
+    updater.queueUpdate(sourceRowId, originalSourceRow, updatedSourceRow);
+    const {
+      successful,
+      updates
+    } = await updater.executeAll();
+    if (successful.length === 0) {
+      return;
+    }
+    const finalSourceRow = updates[0];
+    apiRef.current.setState(state => {
+      const updatedSourceChildren = sourceChildren.filter(rowId => rowId !== sourceRowId);
+      const updatedTree = (0, _extends2.default)({}, state.rows.tree);
+      const removedGroups = new Set();
+      let rootLevelRemovals = 0;
+      if (updatedSourceChildren.length === 0) {
+        removedGroups.add(sourceGroup.id);
+        rootLevelRemovals = _internals.rowReorderUtils.removeEmptyAncestors(sourceGroup.parent, updatedTree, removedGroups);
+      }
+      removedGroups.forEach(groupId => {
+        const group = updatedTree[groupId];
+        if (group && group.parent && updatedTree[group.parent]) {
+          const parent = updatedTree[group.parent];
+          updatedTree[group.parent] = (0, _extends2.default)({}, parent, {
+            children: parent.children.filter(childId => childId !== groupId)
           });
         }
-        const updatedTargetChildren = isLastChild ? [...targetChildren, sourceRowId] : [...targetChildren.slice(0, targetIndex), sourceRowId, ...targetChildren.slice(targetIndex)];
-        updatedTree[target.parent] = (0, _extends2.default)({}, targetGroup, {
-          children: updatedTargetChildren
-        });
-        updatedTree[sourceNode.id] = (0, _extends2.default)({}, sourceNode, {
-          parent: target.parent
-        });
-        return (0, _extends2.default)({}, state, {
-          rows: (0, _extends2.default)({}, state.rows, {
-            totalTopLevelRowCount: state.rows.totalTopLevelRowCount - rootLevelRemovals,
-            tree: updatedTree
-          })
-        });
+        delete updatedTree[groupId];
       });
-      apiRef.current.updateRows([finalSourceRow]);
-      apiRef.current.publishEvent('rowsSet');
-    };
-    if (processRowUpdate && !(0, _isDeepEqual.isDeepEqual)(originalSourceRow, updatedSourceRow)) {
-      const params = {
-        rowId: sourceRowId,
-        previousRow: originalSourceRow,
-        updatedRow: updatedSourceRow
-      };
-      apiRef.current.setLoading(true);
-      try {
-        const processedRow = await processRowUpdate(updatedSourceRow, originalSourceRow, params);
-        const finalRow = processedRow || updatedSourceRow;
-        commitStateUpdate(finalRow);
-      } catch (error) {
-        apiRef.current.setLoading(false);
-        if (onProcessRowUpdateError) {
-          onProcessRowUpdateError(error);
-        } else if (process.env.NODE_ENV !== 'production') {
-          (0, _warning.warnOnce)(['MUI X: A call to `processRowUpdate()` threw an error which was not handled because `onProcessRowUpdateError()` is missing.', 'To handle the error pass a callback to the `onProcessRowUpdateError()` prop, for example `<DataGrid onProcessRowUpdateError={(error) => ...} />`.', 'For more detail, see https://mui.com/x/react-data-grid/editing/persistence/.'], 'error');
-        }
-      } finally {
-        apiRef.current.setLoading(false);
+      if (!removedGroups.has(sourceGroup.id)) {
+        updatedTree[sourceNode.parent] = (0, _extends2.default)({}, sourceGroup, {
+          children: updatedSourceChildren
+        });
       }
-    } else {
-      commitStateUpdate(updatedSourceRow);
-    }
+      const updatedTargetChildren = isLastChild ? [...targetChildren, sourceRowId] : [...targetChildren.slice(0, targetIndex), sourceRowId, ...targetChildren.slice(targetIndex)];
+      updatedTree[target.parent] = (0, _extends2.default)({}, targetGroup, {
+        children: updatedTargetChildren
+      });
+      updatedTree[sourceNode.id] = (0, _extends2.default)({}, sourceNode, {
+        parent: target.parent
+      });
+      return (0, _extends2.default)({}, state, {
+        rows: (0, _extends2.default)({}, state.rows, {
+          totalTopLevelRowCount: state.rows.totalTopLevelRowCount - rootLevelRemovals,
+          tree: updatedTree
+        })
+      });
+    });
+    apiRef.current.updateRows([finalSourceRow]);
+    apiRef.current.publishEvent('rowsSet');
   }
 }
 
@@ -328,7 +190,7 @@ class CrossParentLeafOperation extends BaseReorderOperation {
  * Handles moving entire groups between different parents.
  */
 exports.CrossParentLeafOperation = CrossParentLeafOperation;
-class CrossParentGroupOperation extends BaseReorderOperation {
+class CrossParentGroupOperation extends _internals.BaseReorderOperation {
   operationType = 'cross-parent-group';
   detectOperation(ctx) {
     const {
@@ -375,11 +237,11 @@ class CrossParentGroupOperation extends BaseReorderOperation {
       isLastChild = true;
       adjustedTargetNode = prevNode;
     }
-    const operationType = (0, _utils.determineOperationType)(sourceNode, adjustedTargetNode);
+    const operationType = _internals.rowReorderUtils.determineOperationType(sourceNode, adjustedTargetNode);
     if (operationType !== 'cross-parent-group') {
       return null;
     }
-    const actualTargetIndex = (0, _utils.calculateTargetIndex)(sourceNode, adjustedTargetNode, isLastChild, rowTree);
+    const actualTargetIndex = _internals.rowReorderUtils.calculateTargetIndex(sourceNode, adjustedTargetNode, isLastChild, rowTree);
     const operation = {
       sourceNode,
       targetNode: adjustedTargetNode,
@@ -408,16 +270,16 @@ class CrossParentGroupOperation extends BaseReorderOperation {
     const dataRowIdToModelLookup = (0, _xDataGridPro.gridRowsLookupSelector)(apiRef);
     const columnsLookup = (0, _xDataGridPro.gridColumnLookupSelector)(apiRef);
     const sanitizedRowGroupingModel = (0, _rowGrouping.gridRowGroupingSanitizedModelSelector)(apiRef);
-    const allLeafIds = (0, _utils.collectAllLeafDescendants)(sourceNode, tree);
+    const allLeafIds = _internals.rowReorderUtils.collectAllLeafDescendants(sourceNode, tree);
     if (allLeafIds.length === 0) {
       return;
     }
-    const updater = new _utils.BatchRowUpdater(processRowUpdate, onProcessRowUpdateError);
+    const updater = new _internals.rowReorderUtils.BatchRowUpdater(apiRef, processRowUpdate, onProcessRowUpdateError);
     const groupingRules = (0, _gridRowGroupingUtils.getGroupingRules)({
       sanitizedRowGroupingModel,
       columnsLookup
     });
-    const targetParentPath = (0, _utils.getNodePathInTree)({
+    const targetParentPath = _internals.rowReorderUtils.getNodePathInTree({
       id: targetNode.parent,
       tree
     });
@@ -440,22 +302,75 @@ class CrossParentGroupOperation extends BaseReorderOperation {
       }
       updater.queueUpdate(leafId, originalRow, updatedRow);
     }
-    apiRef.current.setLoading(true);
-    try {
-      const {
-        successful,
-        failed,
-        updates
-      } = await updater.executeAll();
-      if (successful.length > 0) {
-        apiRef.current.setState(state => {
-          const updatedTree = (0, _extends2.default)({}, state.rows.tree);
-          const treeDepths = (0, _extends2.default)({}, state.rows.treeDepths);
-          let rootLevelRemovals = 0;
-          if (failed.length === 0) {
-            const sourceParentNode = updatedTree[sourceNode.parent];
-            if (!sourceParentNode) {
-              const targetParentNode = updatedTree[targetNode.parent];
+    const {
+      successful,
+      failed,
+      updates
+    } = await updater.executeAll();
+    if (successful.length > 0) {
+      apiRef.current.setState(state => {
+        const updatedTree = (0, _extends2.default)({}, state.rows.tree);
+        const treeDepths = (0, _extends2.default)({}, state.rows.treeDepths);
+        let rootLevelRemovals = 0;
+        if (failed.length === 0) {
+          const sourceParentNode = updatedTree[sourceNode.parent];
+          if (!sourceParentNode) {
+            const targetParentNode = updatedTree[targetNode.parent];
+            const targetIndex = targetParentNode.children.indexOf(targetNode.id);
+            const newTargetChildren = [...targetParentNode.children];
+            if (isLastChild) {
+              newTargetChildren.push(sourceNode.id);
+            } else {
+              newTargetChildren.splice(targetIndex, 0, sourceNode.id);
+            }
+            updatedTree[targetNode.parent] = (0, _extends2.default)({}, targetParentNode, {
+              children: newTargetChildren
+            });
+            updatedTree[sourceNode.id] = (0, _extends2.default)({}, sourceNode, {
+              parent: targetNode.parent
+            });
+          } else {
+            const updatedSourceParentChildren = sourceParentNode.children.filter(id => id !== sourceNode.id);
+            if (updatedSourceParentChildren.length === 0) {
+              const removedGroups = new Set();
+              removedGroups.add(sourceNode.parent);
+              const parentOfSourceParent = updatedTree[sourceNode.parent].parent;
+              if (parentOfSourceParent) {
+                rootLevelRemovals = _internals.rowReorderUtils.removeEmptyAncestors(parentOfSourceParent, updatedTree, removedGroups);
+              }
+              removedGroups.forEach(groupId => {
+                const group = updatedTree[groupId];
+                if (group && group.parent && updatedTree[group.parent]) {
+                  const parent = updatedTree[group.parent];
+                  updatedTree[group.parent] = (0, _extends2.default)({}, parent, {
+                    children: parent.children.filter(childId => childId !== groupId)
+                  });
+                }
+                delete updatedTree[groupId];
+              });
+            } else {
+              updatedTree[sourceNode.parent] = (0, _extends2.default)({}, sourceParentNode, {
+                children: updatedSourceParentChildren
+              });
+            }
+            const targetParentNode = updatedTree[targetNode.parent];
+            const sourceGroupNode = sourceNode;
+            const existingGroup = sourceGroupNode.groupingKey !== null && sourceGroupNode.groupingField !== null ? _internals.rowReorderUtils.findExistingGroupWithSameKey(targetParentNode, sourceGroupNode.groupingKey, sourceGroupNode.groupingField, updatedTree) : null;
+            if (existingGroup) {
+              const updatedExistingGroup = (0, _extends2.default)({}, existingGroup, {
+                children: [...existingGroup.children, ...sourceGroupNode.children]
+              });
+              updatedTree[existingGroup.id] = updatedExistingGroup;
+              sourceGroupNode.children.forEach(childId => {
+                const childNode = updatedTree[childId];
+                if (childNode) {
+                  updatedTree[childId] = (0, _extends2.default)({}, childNode, {
+                    parent: existingGroup.id
+                  });
+                }
+              });
+              delete updatedTree[sourceNode.id];
+            } else {
               const targetIndex = targetParentNode.children.indexOf(targetNode.id);
               const newTargetChildren = [...targetParentNode.children];
               if (isLastChild) {
@@ -469,77 +384,19 @@ class CrossParentGroupOperation extends BaseReorderOperation {
               updatedTree[sourceNode.id] = (0, _extends2.default)({}, sourceNode, {
                 parent: targetNode.parent
               });
-            } else {
-              const updatedSourceParentChildren = sourceParentNode.children.filter(id => id !== sourceNode.id);
-              if (updatedSourceParentChildren.length === 0) {
-                const removedGroups = new Set();
-                removedGroups.add(sourceNode.parent);
-                const parentOfSourceParent = updatedTree[sourceNode.parent].parent;
-                if (parentOfSourceParent) {
-                  rootLevelRemovals = (0, _utils.removeEmptyAncestors)(parentOfSourceParent, updatedTree, removedGroups);
-                }
-                removedGroups.forEach(groupId => {
-                  const group = updatedTree[groupId];
-                  if (group && group.parent && updatedTree[group.parent]) {
-                    const parent = updatedTree[group.parent];
-                    updatedTree[group.parent] = (0, _extends2.default)({}, parent, {
-                      children: parent.children.filter(childId => childId !== groupId)
-                    });
-                  }
-                  delete updatedTree[groupId];
-                });
-              } else {
-                updatedTree[sourceNode.parent] = (0, _extends2.default)({}, sourceParentNode, {
-                  children: updatedSourceParentChildren
-                });
-              }
-              const targetParentNode = updatedTree[targetNode.parent];
-              const sourceGroupNode = sourceNode;
-              const existingGroup = sourceGroupNode.groupingKey !== null && sourceGroupNode.groupingField !== null ? (0, _utils.findExistingGroupWithSameKey)(targetParentNode, sourceGroupNode.groupingKey, sourceGroupNode.groupingField, updatedTree) : null;
-              if (existingGroup) {
-                const updatedExistingGroup = (0, _extends2.default)({}, existingGroup, {
-                  children: [...existingGroup.children, ...sourceGroupNode.children]
-                });
-                updatedTree[existingGroup.id] = updatedExistingGroup;
-                sourceGroupNode.children.forEach(childId => {
-                  const childNode = updatedTree[childId];
-                  if (childNode) {
-                    updatedTree[childId] = (0, _extends2.default)({}, childNode, {
-                      parent: existingGroup.id
-                    });
-                  }
-                });
-                delete updatedTree[sourceNode.id];
-              } else {
-                const targetIndex = targetParentNode.children.indexOf(targetNode.id);
-                const newTargetChildren = [...targetParentNode.children];
-                if (isLastChild) {
-                  newTargetChildren.push(sourceNode.id);
-                } else {
-                  newTargetChildren.splice(targetIndex, 0, sourceNode.id);
-                }
-                updatedTree[targetNode.parent] = (0, _extends2.default)({}, targetParentNode, {
-                  children: newTargetChildren
-                });
-                updatedTree[sourceNode.id] = (0, _extends2.default)({}, sourceNode, {
-                  parent: targetNode.parent
-                });
-              }
             }
           }
-          return (0, _extends2.default)({}, state, {
-            rows: (0, _extends2.default)({}, state.rows, {
-              totalTopLevelRowCount: state.rows.totalTopLevelRowCount - rootLevelRemovals,
-              tree: updatedTree,
-              treeDepths
-            })
-          });
+        }
+        return (0, _extends2.default)({}, state, {
+          rows: (0, _extends2.default)({}, state.rows, {
+            totalTopLevelRowCount: state.rows.totalTopLevelRowCount - rootLevelRemovals,
+            tree: updatedTree,
+            treeDepths
+          })
         });
-        apiRef.current.updateRows(updates);
-        apiRef.current.publishEvent('rowsSet');
-      }
-    } finally {
-      apiRef.current.setLoading(false);
+      });
+      apiRef.current.updateRows(updates);
+      apiRef.current.publishEvent('rowsSet');
     }
   }
 }

package/hooks/features/rowReorder/rowGroupingReorderExecutor.d.ts

@@ -0,0 +1,2 @@
+import { RowReorderExecutor } from '@mui/x-data-grid-pro/internals';
+export declare const rowGroupingReorderExecutor: RowReorderExecutor;

package/hooks/features/rowReorder/rowGroupingReorderExecutor.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.rowGroupingReorderExecutor = void 0;
+var _internals = require("@mui/x-data-grid-pro/internals");
+var _operations = require("./operations");
+const rowGroupingReorderExecutor = exports.rowGroupingReorderExecutor = new _internals.RowReorderExecutor([new _internals.SameParentSwapOperation(), new _operations.CrossParentLeafOperation(), new _operations.CrossParentGroupOperation()]);

package/hooks/features/rowReorder/rowGroupingReorderValidator.d.ts

@@ -0,0 +1,2 @@
+import { RowReorderValidator } from '@mui/x-data-grid-pro/internals';
+export declare const rowGroupingReorderValidator: RowReorderValidator;