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

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

package/esm/hooks/features/rows/useGridRowsOverridableMethods.js

@@ -1,28 +1,44 @@
 import * as React from 'react';
-import { gridRowTreeSelector, gridExpandedSortedRowIdsSelector, gridRowNodeSelector, gridRowMaximumTreeDepthSelector } from '@mui/x-data-grid-pro';
-import { gridExpandedSortedRowIndexLookupSelector, useGridRowsOverridableMethods as useGridRowsOverridableMethodsCommunity, useGridSelector } from '@mui/x-data-grid-pro/internals';
-import { rowGroupingReorderExecutor } from "../rowReorder/reorderExecutor.js";
+import { gridRowTreeSelector, gridExpandedSortedRowIdsSelector, gridRowNodeSelector, gridRowMaximumTreeDepthSelector, gridExpandedSortedRowIndexLookupSelector } from '@mui/x-data-grid-pro';
+import { useGridRowsOverridableMethodsCommunity, useGridRowsOverridableMethodsPro, useGridSelector } from '@mui/x-data-grid-pro/internals';
+import { rowGroupingReorderExecutor } from "../rowReorder/rowGroupingReorderExecutor.js";
 export const useGridRowsOverridableMethods = (apiRef, props) => {
   const {
     processRowUpdate,
     onProcessRowUpdateError
   } = props;
   const {
-    setRowIndex: setRowIndexPlain
+    setRowIndex: setRowIndexPlain,
+    setRowPosition: setRowPositionPlain
   } = useGridRowsOverridableMethodsCommunity(apiRef);
+  const {
+    setRowIndex: setRowIndexTreeData,
+    setRowPosition: setRowPositionTreeData
+  } = useGridRowsOverridableMethodsPro(apiRef, props);
   const flatTree = useGridSelector(apiRef, gridRowMaximumTreeDepthSelector) === 1;
-  const setRowIndex = React.useCallback(async (sourceRowId, targetOriginalIndex) => {
+  const setRowPosition = React.useCallback(async (sourceRowId, targetRowId, position) => {
     const sortedFilteredRowIds = gridExpandedSortedRowIdsSelector(apiRef);
     const sortedFilteredRowIndexLookup = gridExpandedSortedRowIndexLookupSelector(apiRef);
     const rowTree = gridRowTreeSelector(apiRef);
     const sourceNode = gridRowNodeSelector(apiRef, sourceRowId);
+    const targetNode = gridRowNodeSelector(apiRef, targetRowId);
     if (!sourceNode) {
       throw new Error(`MUI X: No row with id #${sourceRowId} found.`);
     }
+    if (!targetNode) {
+      throw new Error(`MUI X: No row with id #${targetRowId} found.`);
+    }
     if (sourceNode.type === 'footer') {
       throw new Error(`MUI X: The row reordering do not support reordering of footer rows.`);
     }
 
+    // Get the target index from the targetRowId using the lookup selector
+    const targetIndexUnadjusted = sortedFilteredRowIndexLookup[targetRowId];
+    if (targetIndexUnadjusted === undefined) {
+      throw new Error(`MUI X: Target row with id #${targetRowId} not found in current view.`);
+    }
+    const targetIndex = position === 'below' ? targetIndexUnadjusted + 1 : targetIndexUnadjusted;
+
     /**
      * Row Grouping Reordering Use Cases
      * =================================
@@ -40,6 +56,31 @@ export const useGridRowsOverridableMethods = (apiRef, props) => {
 
     const executionContext = {
       sourceRowId,
+      dropPosition: position,
+      placeholderIndex: targetIndex,
+      sortedFilteredRowIds,
+      sortedFilteredRowIndexLookup,
+      rowTree,
+      apiRef,
+      processRowUpdate,
+      onProcessRowUpdateError
+    };
+    return rowGroupingReorderExecutor.execute(executionContext);
+  }, [apiRef, processRowUpdate, onProcessRowUpdateError]);
+  const setRowIndex = React.useCallback(async (sourceRowId, targetOriginalIndex) => {
+    const sortedFilteredRowIds = gridExpandedSortedRowIdsSelector(apiRef);
+    const sortedFilteredRowIndexLookup = gridExpandedSortedRowIndexLookupSelector(apiRef);
+    const rowTree = gridRowTreeSelector(apiRef);
+    const sourceNode = gridRowNodeSelector(apiRef, sourceRowId);
+    if (!sourceNode) {
+      throw new Error(`MUI X: No row with id #${sourceRowId} found.`);
+    }
+    if (sourceNode.type === 'footer') {
+      throw new Error(`MUI X: The row reordering do not support reordering of footer rows.`);
+    }
+    const executionContext = {
+      sourceRowId,
+      dropPosition: 'below',
       placeholderIndex: targetOriginalIndex,
       sortedFilteredRowIds,
       sortedFilteredRowIndexLookup,
@@ -48,9 +89,22 @@ export const useGridRowsOverridableMethods = (apiRef, props) => {
       processRowUpdate,
       onProcessRowUpdateError
     };
-    await rowGroupingReorderExecutor.execute(executionContext);
+    return rowGroupingReorderExecutor.execute(executionContext);
   }, [apiRef, processRowUpdate, onProcessRowUpdateError]);
+  if (flatTree) {
+    return {
+      setRowIndex: setRowIndexPlain,
+      setRowPosition: setRowPositionPlain
+    };
+  }
+  if (props.treeData) {
+    return {
+      setRowIndex: setRowIndexTreeData,
+      setRowPosition: setRowPositionTreeData
+    };
+  }
   return {
-    setRowIndex: flatTree ? setRowIndexPlain : setRowIndex
+    setRowIndex,
+    setRowPosition
   };
 };

package/esm/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-data-grid-premium v8.19.0
+ * @mui/x-data-grid-premium v8.21.0
  *
  * @license SEE LICENSE IN LICENSE
  * This source code is licensed under the SEE LICENSE IN LICENSE license found in the

package/hooks/features/clipboard/useGridClipboardImport.js

@@ -86,6 +86,12 @@ class CellValueUpdater {
     if (!row) {
       return;
     }
+
+    // Check if the cell is editable using the API method, which respects the isCellEditable prop
+    const cellParams = apiRef.current.getCellParams(rowId, field);
+    if (!apiRef.current.isCellEditable(cellParams)) {
+      return;
+    }
     let parsedValue = pastedCellValue;
     if (colDef.pastedValueParser) {
       parsedValue = colDef.pastedValueParser(pastedCellValue, row, colDef, apiRef);