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

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;

package/hooks/features/rowReorder/rowGroupingReorderValidator.js

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.rowGroupingReorderValidator = void 0;
+var _internals = require("@mui/x-data-grid-pro/internals");
+const validationRules = [
+// ===== Basic invalid cases =====
+{
+  name: 'same-position',
+  applies: ctx => ctx.sourceNode.id === ctx.targetNode.id,
+  isInvalid: () => true,
+  message: 'Source and target are the same'
+}, {
+  name: 'adjacent-position',
+  applies: ctx => _internals.commonReorderConditions.isAdjacentPosition(ctx),
+  isInvalid: () => true,
+  message: 'Source and target are adjacent'
+}, {
+  name: 'group-to-leaf',
+  applies: _internals.commonReorderConditions.isGroupToLeaf,
+  isInvalid: () => true,
+  message: 'Cannot drop group on leaf'
+},
+// ===== Group to Group Rules =====
+{
+  name: 'group-to-group-above-leaf-belongs-to-source',
+  applies: ctx => _internals.commonReorderConditions.isGroupToGroup(ctx) && _internals.commonReorderConditions.isDropAbove(ctx) && _internals.commonReorderConditions.prevIsLeaf(ctx),
+  isInvalid: _internals.commonReorderConditions.prevBelongsToSource,
+  message: 'Previous leaf belongs to source group or its descendants'
+}, {
+  name: 'group-to-group-above-invalid-depth',
+  applies: ctx => _internals.commonReorderConditions.isGroupToGroup(ctx) && _internals.commonReorderConditions.isDropAbove(ctx) && !_internals.commonReorderConditions.sameDepth(ctx) && !(ctx.targetNode.depth < ctx.sourceNode.depth && (_internals.commonReorderConditions.prevIsLeaf(ctx) || _internals.commonReorderConditions.prevIsGroup(ctx) && _internals.commonReorderConditions.prevDepthEqualsSource(ctx))),
+  isInvalid: () => true,
+  message: 'Invalid depth configuration for group above group'
+}, {
+  name: 'group-to-group-above-different-parent-depth',
+  applies: ctx => _internals.commonReorderConditions.isGroupToGroup(ctx) && _internals.commonReorderConditions.isDropAbove(ctx) && _internals.commonReorderConditions.prevIsGroup(ctx) && _internals.commonReorderConditions.prevDepthEqualsSource(ctx) && _internals.commonReorderConditions.targetGroupExpanded(ctx),
+  isInvalid: ctx => ctx.prevNode.depth !== ctx.sourceNode.depth,
+  message: 'Cannot reorder groups with different depths'
+}, {
+  name: 'group-to-group-below-invalid-config',
+  applies: ctx => _internals.commonReorderConditions.isGroupToGroup(ctx) && _internals.commonReorderConditions.isDropBelow(ctx),
+  isInvalid: ctx => {
+    // Valid case 1: Same depth and target not expanded
+    if (_internals.commonReorderConditions.sameDepth(ctx) && _internals.commonReorderConditions.targetGroupCollapsed(ctx)) {
+      return false;
+    }
+    // Valid case 2: Target is parent level, expanded, with compatible first child
+    if (_internals.commonReorderConditions.targetDepthIsSourceMinusOne(ctx) && _internals.commonReorderConditions.targetGroupExpanded(ctx) && _internals.commonReorderConditions.targetFirstChildIsGroupWithSourceDepth(ctx)) {
+      return false;
+    }
+    return true;
+  },
+  message: 'Invalid group below group configuration'
+},
+// ===== Leaf to Leaf Rules =====
+{
+  name: 'leaf-to-leaf-different-depth',
+  applies: ctx => _internals.commonReorderConditions.isLeafToLeaf(ctx) && !_internals.commonReorderConditions.sameDepth(ctx),
+  isInvalid: () => true,
+  message: 'Leaves at different depths cannot be reordered'
+}, {
+  name: 'leaf-to-leaf-invalid-below',
+  applies: ctx => _internals.commonReorderConditions.isLeafToLeaf(ctx) && _internals.commonReorderConditions.sameDepth(ctx) && !_internals.commonReorderConditions.sameParent(ctx) && _internals.commonReorderConditions.isDropBelow(ctx),
+  isInvalid: ctx => !(_internals.commonReorderConditions.nextIsGroup(ctx) && ctx.sourceNode.depth > ctx.nextNode.depth) && !_internals.commonReorderConditions.nextIsLeaf(ctx),
+  message: 'Invalid leaf below leaf configuration'
+},
+// ===== Leaf to Group Rules =====
+{
+  name: 'leaf-to-group-above-no-prev-leaf',
+  applies: ctx => _internals.commonReorderConditions.isLeafToGroup(ctx) && _internals.commonReorderConditions.isDropAbove(ctx),
+  isInvalid: ctx => !_internals.commonReorderConditions.hasPrevNode(ctx) || !_internals.commonReorderConditions.prevIsLeaf(ctx),
+  message: 'No valid previous leaf for leaf above group'
+}, {
+  name: 'leaf-to-group-above-depth-mismatch',
+  applies: ctx => _internals.commonReorderConditions.isLeafToGroup(ctx) && _internals.commonReorderConditions.isDropAbove(ctx) && _internals.commonReorderConditions.prevIsLeaf(ctx) && !(ctx.sourceNode.depth > ctx.targetNode.depth && ctx.targetNode.depth === 0),
+  isInvalid: ctx => ctx.prevNode.depth !== ctx.sourceNode.depth,
+  message: 'Previous node depth mismatch for leaf above group'
+}, {
+  name: 'leaf-to-group-below-collapsed',
+  applies: ctx => _internals.commonReorderConditions.isLeafToGroup(ctx) && _internals.commonReorderConditions.isDropBelow(ctx),
+  isInvalid: _internals.commonReorderConditions.targetGroupCollapsed,
+  message: 'Cannot drop below collapsed group'
+}, {
+  name: 'leaf-to-group-below-invalid-depth',
+  applies: ctx => _internals.commonReorderConditions.isLeafToGroup(ctx) && _internals.commonReorderConditions.isDropBelow(ctx) && _internals.commonReorderConditions.targetGroupExpanded(ctx),
+  isInvalid: ctx => {
+    // Valid case 1: Target is parent level
+    if (ctx.sourceNode.depth > ctx.targetNode.depth && ctx.targetNode.depth === ctx.sourceNode.depth - 1) {
+      return false;
+    }
+    // Valid case 2: First child has same depth as source
+    if (_internals.commonReorderConditions.targetFirstChildDepthEqualsSource(ctx)) {
+      return false;
+    }
+    return true;
+  },
+  message: 'Invalid depth configuration for leaf below group'
+}];
+const rowGroupingReorderValidator = exports.rowGroupingReorderValidator = new _internals.RowReorderValidator(validationRules);

package/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>;
 };