@mui/x-data-grid-premium 8.18.0 → 8.20.0

package/esm/hooks/features/rowGrouping/useGridRowGrouping.js

@@ -2,11 +2,11 @@
 
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
-import { useGridEvent, useGridApiMethod, gridColumnLookupSelector, gridRowMaximumTreeDepthSelector, gridRowTreeSelector, gridExpandedSortedRowIdsSelector } from '@mui/x-data-grid-pro';
-import { useGridRegisterPipeProcessor, GridStrategyGroup, gridExpandedSortedRowIndexLookupSelector, RowGroupingStrategy } from '@mui/x-data-grid-pro/internals';
+import { useGridEvent, useGridApiMethod, gridColumnLookupSelector, gridRowMaximumTreeDepthSelector, gridRowTreeSelector, gridExpandedSortedRowIdsSelector, gridExpandedSortedRowIndexLookupSelector } from '@mui/x-data-grid-pro';
+import { useGridRegisterPipeProcessor, GridStrategyGroup, RowGroupingStrategy } from '@mui/x-data-grid-pro/internals';
 import { gridRowGroupingModelSelector, gridRowGroupingSanitizedModelSelector } from "./gridRowGroupingSelector.js";
 import { getRowGroupingFieldFromGroupingCriteria, isGroupingColumn, mergeStateWithRowGroupingModel, setStrategyAvailability, getGroupingRules, areGroupingRulesEqual } from "./gridRowGroupingUtils.js";
-import { rowGroupingReorderValidator } from "../rowReorder/reorderValidator.js";
+import { rowGroupingReorderValidator } from "../rowReorder/rowGroupingReorderValidator.js";
 export const rowGroupingStateInitializer = (state, props, apiRef) => {
   apiRef.current.caches.rowGrouping = {
     rulesOnLastRowTreeCreation: []
@@ -169,7 +169,8 @@ export const useGridRowGrouping = (apiRef, props) => {
       }
     }
   }, [apiRef, props.disableRowGrouping]);
-  const getRowReorderTargetIndex = React.useCallback((initialValue, {
+  const isValidRowReorderProp = props.isValidRowReorder;
+  const isRowReorderValid = React.useCallback((initialValue, {
     sourceRowId,
     targetRowId,
     dropPosition,
@@ -181,7 +182,6 @@ export const useGridRowGrouping = (apiRef, props) => {
     const expandedSortedRowIndexLookup = gridExpandedSortedRowIndexLookupSelector(apiRef);
     const expandedSortedRowIds = gridExpandedSortedRowIdsSelector(apiRef);
     const rowTree = gridRowTreeSelector(apiRef);
-    const sourceRowIndex = expandedSortedRowIndexLookup[sourceRowId];
     const targetRowIndex = expandedSortedRowIndexLookup[targetRowId];
     const sourceNode = rowTree[sourceRowId];
     const targetNode = rowTree[targetRowId];
@@ -190,30 +190,34 @@ export 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 (rowGroupingReorderValidator.validate(context)) {
-      return dropPosition === 'below' ? targetRowIndex + 1 : targetRowIndex;
+    // First apply internal validation
+    let isValid = 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]);
-  useGridRegisterPipeProcessor(apiRef, 'getRowReorderTargetIndex', getRowReorderTargetIndex);
+    return false;
+  }, [apiRef, props.treeData, isValidRowReorderProp]);
+  useGridRegisterPipeProcessor(apiRef, 'isRowReorderValid', isRowReorderValid);
   useGridEvent(apiRef, 'cellKeyDown', handleCellKeyDown);
   useGridEvent(apiRef, 'columnsChange', checkGroupingColumnsModelDiff);
   useGridEvent(apiRef, 'rowGroupingModelChange', checkGroupingColumnsModelDiff);

package/esm/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/esm/hooks/features/rowReorder/operations.js

@@ -1,128 +1,8 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import { gridRowNodeSelector, gridRowTreeSelector, gridRowsLookupSelector, gridColumnLookupSelector } from '@mui/x-data-grid-pro';
-import { warnOnce } from '@mui/x-internals/warning';
-import { isDeepEqual } from '@mui/x-internals/isDeepEqual';
+import { BaseReorderOperation, rowReorderUtils } from '@mui/x-data-grid-pro/internals';
 import { gridRowGroupingSanitizedModelSelector } from "../rowGrouping/index.js";
 import { getGroupingRules, getCellGroupingCriteria } from "../rowGrouping/gridRowGroupingUtils.js";
-import { determineOperationType, calculateTargetIndex, collectAllLeafDescendants, getNodePathInTree, removeEmptyAncestors, findExistingGroupWithSameKey, BatchRowUpdater } from "./utils.js";
-/**
- * Base class for all reorder operations.
- * Provides abstract methods for operation detection and execution.
- */
-export class BaseReorderOperation {}
-
-/**
- * Handles reordering of items within the same parent group.
- */
-export class SameParentSwapOperation extends BaseReorderOperation {
-  operationType = 'same-parent-swap';
-  detectOperation(ctx) {
-    const {
-      sourceRowId,
-      placeholderIndex,
-      sortedFilteredRowIds,
-      sortedFilteredRowIndexLookup,
-      rowTree,
-      apiRef
-    } = ctx;
-    const sourceNode = 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 = gridRowNodeSelector(apiRef, sortedFilteredRowIds[targetIndex]);
-    if (placeholderIndex > sourceIndex && sourceNode.parent === targetNode.parent) {
-      targetIndex = placeholderIndex - 1;
-      targetNode = gridRowNodeSelector(apiRef, sortedFilteredRowIds[targetIndex]);
-      if (targetNode && targetNode.depth !== sourceNode.depth) {
-        while (targetNode.depth > sourceNode.depth && targetIndex >= 0) {
-          targetIndex -= 1;
-          targetNode = gridRowNodeSelector(apiRef, sortedFilteredRowIds[targetIndex]);
-        }
-      }
-      if (targetIndex === -1) {
-        return null;
-      }
-    }
-    let isLastChild = false;
-    if (!targetNode) {
-      if (placeholderIndex >= sortedFilteredRowIds.length && sortedFilteredRowIds.length > 0) {
-        targetNode = 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 = 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 = determineOperationType(sourceNode, adjustedTargetNode);
-    if (operationType !== 'same-parent-swap') {
-      return null;
-    }
-    const actualTargetIndex = 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 = 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 _extends({}, state, {
-        rows: _extends({}, state.rows, {
-          tree: _extends({}, state.rows.tree, {
-            [sourceNode.parent]: _extends({}, group, {
-              children: currentChildren
-            })
-          })
-        })
-      });
-    });
-    apiRef.current.publishEvent('rowsSet');
-  }
-}
-
 /**
  * Handles moving leaf nodes between different parent groups.
  */
@@ -164,11 +44,11 @@ export class CrossParentLeafOperation extends BaseReorderOperation {
         }
       }
     }
-    const operationType = determineOperationType(sourceNode, adjustedTargetNode);
+    const operationType = rowReorderUtils.determineOperationType(sourceNode, adjustedTargetNode);
     if (operationType !== 'cross-parent-leaf') {
       return null;
     }
-    const actualTargetIndex = calculateTargetIndex(sourceNode, adjustedTargetNode, isLastChild, rowTree);
+    const actualTargetIndex = rowReorderUtils.calculateTargetIndex(sourceNode, adjustedTargetNode, isLastChild, rowTree);
     targetNode = adjustedTargetNode;
 
     // Validate depth constraints
@@ -246,72 +126,56 @@ export 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 = _extends({}, state.rows.tree);
-        const removedGroups = new Set();
-        let rootLevelRemovals = 0;
-        if (updatedSourceChildren.length === 0) {
-          removedGroups.add(sourceGroup.id);
-          rootLevelRemovals = 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] = _extends({}, parent, {
-              children: parent.children.filter(childId => childId !== groupId)
-            });
-          }
-          delete updatedTree[groupId];
-        });
-        if (!removedGroups.has(sourceGroup.id)) {
-          updatedTree[sourceNode.parent] = _extends({}, sourceGroup, {
-            children: updatedSourceChildren
+    const updater = new 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 = _extends({}, state.rows.tree);
+      const removedGroups = new Set();
+      let rootLevelRemovals = 0;
+      if (updatedSourceChildren.length === 0) {
+        removedGroups.add(sourceGroup.id);
+        rootLevelRemovals = 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] = _extends({}, parent, {
+            children: parent.children.filter(childId => childId !== groupId)
           });
         }
-        const updatedTargetChildren = isLastChild ? [...targetChildren, sourceRowId] : [...targetChildren.slice(0, targetIndex), sourceRowId, ...targetChildren.slice(targetIndex)];
-        updatedTree[target.parent] = _extends({}, targetGroup, {
-          children: updatedTargetChildren
-        });
-        updatedTree[sourceNode.id] = _extends({}, sourceNode, {
-          parent: target.parent
-        });
-        return _extends({}, state, {
-          rows: _extends({}, state.rows, {
-            totalTopLevelRowCount: state.rows.totalTopLevelRowCount - rootLevelRemovals,
-            tree: updatedTree
-          })
-        });
+        delete updatedTree[groupId];
       });
-      apiRef.current.updateRows([finalSourceRow]);
-      apiRef.current.publishEvent('rowsSet');
-    };
-    if (processRowUpdate && !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') {
-          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] = _extends({}, sourceGroup, {
+          children: updatedSourceChildren
+        });
       }
-    } else {
-      commitStateUpdate(updatedSourceRow);
-    }
+      const updatedTargetChildren = isLastChild ? [...targetChildren, sourceRowId] : [...targetChildren.slice(0, targetIndex), sourceRowId, ...targetChildren.slice(targetIndex)];
+      updatedTree[target.parent] = _extends({}, targetGroup, {
+        children: updatedTargetChildren
+      });
+      updatedTree[sourceNode.id] = _extends({}, sourceNode, {
+        parent: target.parent
+      });
+      return _extends({}, state, {
+        rows: _extends({}, state.rows, {
+          totalTopLevelRowCount: state.rows.totalTopLevelRowCount - rootLevelRemovals,
+          tree: updatedTree
+        })
+      });
+    });
+    apiRef.current.updateRows([finalSourceRow]);
+    apiRef.current.publishEvent('rowsSet');
   }
 }
 
@@ -365,11 +229,11 @@ export class CrossParentGroupOperation extends BaseReorderOperation {
       isLastChild = true;
       adjustedTargetNode = prevNode;
     }
-    const operationType = determineOperationType(sourceNode, adjustedTargetNode);
+    const operationType = rowReorderUtils.determineOperationType(sourceNode, adjustedTargetNode);
     if (operationType !== 'cross-parent-group') {
       return null;
     }
-    const actualTargetIndex = calculateTargetIndex(sourceNode, adjustedTargetNode, isLastChild, rowTree);
+    const actualTargetIndex = rowReorderUtils.calculateTargetIndex(sourceNode, adjustedTargetNode, isLastChild, rowTree);
     const operation = {
       sourceNode,
       targetNode: adjustedTargetNode,
@@ -398,16 +262,16 @@ export class CrossParentGroupOperation extends BaseReorderOperation {
     const dataRowIdToModelLookup = gridRowsLookupSelector(apiRef);
     const columnsLookup = gridColumnLookupSelector(apiRef);
     const sanitizedRowGroupingModel = gridRowGroupingSanitizedModelSelector(apiRef);
-    const allLeafIds = collectAllLeafDescendants(sourceNode, tree);
+    const allLeafIds = rowReorderUtils.collectAllLeafDescendants(sourceNode, tree);
     if (allLeafIds.length === 0) {
       return;
     }
-    const updater = new BatchRowUpdater(processRowUpdate, onProcessRowUpdateError);
+    const updater = new rowReorderUtils.BatchRowUpdater(apiRef, processRowUpdate, onProcessRowUpdateError);
     const groupingRules = getGroupingRules({
       sanitizedRowGroupingModel,
       columnsLookup
     });
-    const targetParentPath = getNodePathInTree({
+    const targetParentPath = rowReorderUtils.getNodePathInTree({
       id: targetNode.parent,
       tree
     });
@@ -430,22 +294,75 @@ export 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 = _extends({}, state.rows.tree);
-          const treeDepths = _extends({}, 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 = _extends({}, state.rows.tree);
+        const treeDepths = _extends({}, 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] = _extends({}, targetParentNode, {
+              children: newTargetChildren
+            });
+            updatedTree[sourceNode.id] = _extends({}, 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 = 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] = _extends({}, parent, {
+                    children: parent.children.filter(childId => childId !== groupId)
+                  });
+                }
+                delete updatedTree[groupId];
+              });
+            } else {
+              updatedTree[sourceNode.parent] = _extends({}, sourceParentNode, {
+                children: updatedSourceParentChildren
+              });
+            }
+            const targetParentNode = updatedTree[targetNode.parent];
+            const sourceGroupNode = sourceNode;
+            const existingGroup = sourceGroupNode.groupingKey !== null && sourceGroupNode.groupingField !== null ? rowReorderUtils.findExistingGroupWithSameKey(targetParentNode, sourceGroupNode.groupingKey, sourceGroupNode.groupingField, updatedTree) : null;
+            if (existingGroup) {
+              const updatedExistingGroup = _extends({}, existingGroup, {
+                children: [...existingGroup.children, ...sourceGroupNode.children]
+              });
+              updatedTree[existingGroup.id] = updatedExistingGroup;
+              sourceGroupNode.children.forEach(childId => {
+                const childNode = updatedTree[childId];
+                if (childNode) {
+                  updatedTree[childId] = _extends({}, childNode, {
+                    parent: existingGroup.id
+                  });
+                }
+              });
+              delete updatedTree[sourceNode.id];
+            } else {
               const targetIndex = targetParentNode.children.indexOf(targetNode.id);
               const newTargetChildren = [...targetParentNode.children];
               if (isLastChild) {
@@ -459,77 +376,19 @@ export class CrossParentGroupOperation extends BaseReorderOperation {
               updatedTree[sourceNode.id] = _extends({}, 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 = 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] = _extends({}, parent, {
-                      children: parent.children.filter(childId => childId !== groupId)
-                    });
-                  }
-                  delete updatedTree[groupId];
-                });
-              } else {
-                updatedTree[sourceNode.parent] = _extends({}, sourceParentNode, {
-                  children: updatedSourceParentChildren
-                });
-              }
-              const targetParentNode = updatedTree[targetNode.parent];
-              const sourceGroupNode = sourceNode;
-              const existingGroup = sourceGroupNode.groupingKey !== null && sourceGroupNode.groupingField !== null ? findExistingGroupWithSameKey(targetParentNode, sourceGroupNode.groupingKey, sourceGroupNode.groupingField, updatedTree) : null;
-              if (existingGroup) {
-                const updatedExistingGroup = _extends({}, existingGroup, {
-                  children: [...existingGroup.children, ...sourceGroupNode.children]
-                });
-                updatedTree[existingGroup.id] = updatedExistingGroup;
-                sourceGroupNode.children.forEach(childId => {
-                  const childNode = updatedTree[childId];
-                  if (childNode) {
-                    updatedTree[childId] = _extends({}, 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] = _extends({}, targetParentNode, {
-                  children: newTargetChildren
-                });
-                updatedTree[sourceNode.id] = _extends({}, sourceNode, {
-                  parent: targetNode.parent
-                });
-              }
             }
           }
-          return _extends({}, state, {
-            rows: _extends({}, state.rows, {
-              totalTopLevelRowCount: state.rows.totalTopLevelRowCount - rootLevelRemovals,
-              tree: updatedTree,
-              treeDepths
-            })
-          });
+        }
+        return _extends({}, state, {
+          rows: _extends({}, 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/esm/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/esm/hooks/features/rowReorder/rowGroupingReorderExecutor.js

@@ -0,0 +1,3 @@
+import { RowReorderExecutor, SameParentSwapOperation } from '@mui/x-data-grid-pro/internals';
+import { CrossParentLeafOperation, CrossParentGroupOperation } from "./operations.js";
+export const rowGroupingReorderExecutor = new RowReorderExecutor([new SameParentSwapOperation(), new CrossParentLeafOperation(), new CrossParentGroupOperation()]);

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

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

package/esm/hooks/features/rowReorder/{reorderValidator.js → rowGroupingReorderValidator.js}

@@ -1,9 +1,9 @@
-import { conditions } from "./utils.js";
+import { commonReorderConditions as conditions, RowReorderValidator } from '@mui/x-data-grid-pro/internals';
 const validationRules = [
 // ===== Basic invalid cases =====
 {
   name: 'same-position',
-  applies: ctx => ctx.sourceRowIndex === ctx.targetRowIndex,
+  applies: ctx => ctx.sourceNode.id === ctx.targetNode.id,
   isInvalid: () => true,
   message: 'Source and target are the same'
 }, {
@@ -93,24 +93,4 @@ const validationRules = [
   },
   message: 'Invalid depth configuration for leaf below group'
 }];
-class RowReorderValidator {
-  constructor(rules = validationRules) {
-    this.rules = rules;
-  }
-  addRule(rule) {
-    this.rules.push(rule);
-  }
-  removeRule(ruleName) {
-    this.rules = this.rules.filter(r => r.name !== ruleName);
-  }
-  validate(context) {
-    // Check all validation rules
-    for (const rule of this.rules) {
-      if (rule.applies(context) && rule.isInvalid(context)) {
-        return false;
-      }
-    }
-    return true;
-  }
-}
 export const rowGroupingReorderValidator = new RowReorderValidator(validationRules);

package/esm/hooks/features/rows/useGridRowsOverridableMethods.d.ts

@@ -1,7 +1,7 @@
-import { GridRowId } from '@mui/x-data-grid-pro';
 import type { RefObject } from '@mui/x-internals/types';
 import type { GridPrivateApiPremium } from "../../../models/gridApiPremium.js";
 import type { DataGridPremiumProcessedProps } from "../../../models/dataGridPremiumProps.js";
-export declare const useGridRowsOverridableMethods: (apiRef: RefObject<GridPrivateApiPremium>, props: Pick<DataGridPremiumProcessedProps, "processRowUpdate" | "onProcessRowUpdateError">) => {
-  setRowIndex: (rowId: GridRowId, targetIndex: number) => void;
+export declare const useGridRowsOverridableMethods: (apiRef: RefObject<GridPrivateApiPremium>, props: Pick<DataGridPremiumProcessedProps, "processRowUpdate" | "onProcessRowUpdateError" | "treeData">) => {
+  setRowIndex: (rowId: import("@mui/x-data-grid").GridRowId, targetIndex: number) => void;
+  setRowPosition: (sourceRowId: import("@mui/x-data-grid").GridRowId, targetRowId: import("@mui/x-data-grid").GridRowId, position: import("@mui/x-data-grid/internals").RowReorderDropPosition) => void | Promise<void>;
 };