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

package/esm/hooks/features/treeData/treeDataReorderExecutor.js

@@ -0,0 +1,534 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { gridRowNodeSelector, gridRowTreeSelector } from '@mui/x-data-grid';
+import { BaseReorderOperation, RowReorderExecutor } from "../rowReorder/reorderExecutor.js";
+import { calculateTargetIndex, isDescendantOf } from "../rowReorder/utils.js";
+import { displaySetTreeDataPathWarning, removeNodeFromSourceParent, updateLeafPath, updateGroupHierarchyPaths, updateNodeParentAndDepth, buildTreeDataPath } from "./utils.js";
+
+/**
+ * Handles reordering of items within the same parent group.
+ */
+export class SameParentSwapOperation extends BaseReorderOperation {
+  operationType = 'same-parent-swap';
+  detectOperation(ctx) {
+    if (ctx.dropPosition === 'inside') {
+      return null;
+    }
+    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;
+      }
+    }
+
+    // Check if below last node in the same group as source node
+    const isBelowPosition = ctx.dropPosition === 'below';
+    if (isBelowPosition && sourceNode.parent !== adjustedTargetNode.parent) {
+      const unAdjustedTargetIndex = placeholderIndex - 1;
+      const unAdjustedTargetNode = gridRowNodeSelector(apiRef, sortedFilteredRowIds[unAdjustedTargetIndex]);
+      if (unAdjustedTargetNode && unAdjustedTargetNode.parent === sourceNode.parent) {
+        adjustedTargetNode = unAdjustedTargetNode;
+        isLastChild = true;
+      }
+    }
+    if (sourceNode.parent !== adjustedTargetNode.parent) {
+      return null;
+    }
+    const actualTargetIndex = calculateTargetIndex(sourceNode, adjustedTargetNode, isLastChild, rowTree);
+    targetNode = adjustedTargetNode;
+    return {
+      sourceNode,
+      targetNode,
+      actualTargetIndex,
+      isLastChild,
+      operationType: this.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 parents.
+ */
+class CrossParentLeafOperation extends BaseReorderOperation {
+  operationType = 'cross-parent-leaf';
+  detectOperation(ctx) {
+    // Fail for "inside" position - let DropOnLeafOperation handle it
+    if (ctx.dropPosition === 'inside') {
+      return null;
+    }
+    const {
+      sourceRowId,
+      placeholderIndex,
+      sortedFilteredRowIds,
+      rowTree,
+      apiRef,
+      setTreeDataPath
+    } = ctx;
+    const sourceNode = gridRowNodeSelector(apiRef, sourceRowId);
+    if (!sourceNode || sourceNode.type !== 'leaf') {
+      return null;
+    }
+    if (!setTreeDataPath) {
+      displaySetTreeDataPathWarning('Cross-parent reordering');
+    }
+    let targetIndex = placeholderIndex;
+    if (targetIndex === sortedFilteredRowIds.length && sortedFilteredRowIds.length > 0) {
+      targetIndex = sortedFilteredRowIds.length - 1;
+    }
+    if (targetIndex < 0) {
+      return null;
+    }
+    const targetNode = gridRowNodeSelector(apiRef, sortedFilteredRowIds[targetIndex]);
+    if (!targetNode) {
+      return null;
+    }
+    if (sourceNode.parent === targetNode.parent) {
+      return null;
+    }
+    const actualTargetIndex = calculateTargetIndex(sourceNode, targetNode, placeholderIndex >= sortedFilteredRowIds.length, rowTree);
+    return {
+      sourceNode,
+      targetNode,
+      actualTargetIndex,
+      isLastChild: placeholderIndex >= sortedFilteredRowIds.length,
+      operationType: this.operationType
+    };
+  }
+  async executeOperation(operation, ctx) {
+    const {
+      sourceNode,
+      targetNode,
+      actualTargetIndex
+    } = operation;
+    const {
+      apiRef
+    } = ctx;
+    const rowTree = gridRowTreeSelector(apiRef);
+    const targetParentNode = rowTree[targetNode.parent];
+    const targetPath = buildTreeDataPath(targetParentNode, rowTree);
+    const updatedRow = await updateLeafPath(sourceNode, targetPath, ctx);
+    if (!updatedRow) {
+      return;
+    }
+
+    // Update tree structure
+    apiRef.current.setState(state => {
+      const updatedTree = _extends({}, state.rows.tree);
+      removeNodeFromSourceParent(updatedTree, sourceNode);
+      const targetParent = updatedTree[targetNode.parent];
+      const targetChildren = [...targetParent.children];
+      targetChildren.splice(actualTargetIndex, 0, sourceNode.id);
+      updatedTree[targetNode.parent] = _extends({}, targetParent, {
+        children: targetChildren
+      });
+      const parentNode = updatedTree[targetNode.parent];
+      updateNodeParentAndDepth(updatedTree, sourceNode, targetNode.parent, parentNode.depth + 1);
+      return _extends({}, state, {
+        rows: _extends({}, state.rows, {
+          tree: updatedTree
+        })
+      });
+    });
+    apiRef.current.updateRows([updatedRow]);
+    apiRef.current.publishEvent('rowsSet');
+  }
+}
+
+/**
+ * Handles dropping any node (leaf or group) "inside" a leaf node.
+ * This converts the target leaf into a parent group and makes the dragged node its child.
+ */
+class DropOnLeafOperation extends BaseReorderOperation {
+  operationType = 'drop-on-leaf';
+  detectOperation(ctx) {
+    const {
+      sourceRowId,
+      dropPosition,
+      placeholderIndex,
+      sortedFilteredRowIds,
+      apiRef,
+      setTreeDataPath
+    } = ctx;
+    if (dropPosition !== 'inside') {
+      return null;
+    }
+    const sourceNode = gridRowNodeSelector(apiRef, sourceRowId);
+    if (!sourceNode || sourceNode.type === 'footer') {
+      return null;
+    }
+    if (!setTreeDataPath) {
+      displaySetTreeDataPathWarning('Drop on leaf reordering');
+    }
+
+    // Find target node
+    let targetIndex = placeholderIndex;
+    if (targetIndex === sortedFilteredRowIds.length && sortedFilteredRowIds.length > 0) {
+      targetIndex = sortedFilteredRowIds.length - 1;
+    }
+    if (targetIndex < 0) {
+      return null;
+    }
+    const targetNode = gridRowNodeSelector(apiRef, sortedFilteredRowIds[targetIndex]);
+    if (!targetNode || targetNode.type !== 'leaf') {
+      return null;
+    }
+
+    // Target leaf will become a parent, so the actual target index is 0 (first child)
+    const actualTargetIndex = 0;
+    return {
+      sourceNode,
+      targetNode,
+      actualTargetIndex,
+      isLastChild: false,
+      operationType: this.operationType
+    };
+  }
+  async executeOperation(operation, ctx) {
+    const {
+      sourceNode,
+      targetNode
+    } = operation;
+    const {
+      apiRef
+    } = ctx;
+    const rowTree = gridRowTreeSelector(apiRef);
+
+    // Build target path for the new structure
+    const targetPath = buildTreeDataPath(targetNode, rowTree);
+    let rowsToUpdate = [];
+
+    // Handle source node path updates
+    if (sourceNode.type === 'leaf') {
+      // Simple leaf move
+      const updatedRow = await updateLeafPath(sourceNode, targetPath, ctx);
+      if (!updatedRow) {
+        return;
+      }
+      rowsToUpdate.push(updatedRow);
+    } else {
+      // Group move - update entire hierarchy
+      const sourceParentNode = rowTree[sourceNode.parent];
+      const sourceBasePath = buildTreeDataPath(sourceParentNode, rowTree);
+      rowsToUpdate = await updateGroupHierarchyPaths(sourceNode, sourceBasePath, targetPath, ctx);
+      if (rowsToUpdate.length === 0) {
+        return;
+      }
+    }
+    apiRef.current.setState(state => {
+      const updatedTree = _extends({}, state.rows.tree);
+      removeNodeFromSourceParent(updatedTree, sourceNode);
+      updatedTree[targetNode.id] = _extends({}, targetNode, {
+        type: 'group',
+        children: [sourceNode.id],
+        childrenFromPath: {},
+        groupingField: null,
+        isAutoGenerated: false,
+        childrenExpanded: true
+      });
+      updateNodeParentAndDepth(updatedTree, sourceNode, targetNode.id, targetNode.depth + 1);
+      return _extends({}, state, {
+        rows: _extends({}, state.rows, {
+          tree: updatedTree
+        })
+      });
+    });
+
+    // Update rows in the grid
+    apiRef.current.updateRows(rowsToUpdate);
+    apiRef.current.publishEvent('rowsSet');
+  }
+}
+
+/**
+ * Handles dropping any node (leaf or group) "inside" a group node.
+ * This makes the dragged node the first child of the target group.
+ */
+class DropOnGroupOperation extends BaseReorderOperation {
+  operationType = 'drop-on-group';
+  detectOperation(ctx) {
+    const {
+      sourceRowId,
+      dropPosition,
+      placeholderIndex,
+      sortedFilteredRowIds,
+      apiRef,
+      setTreeDataPath,
+      rowTree
+    } = ctx;
+
+    // Only applies to "inside" drop position
+    if (dropPosition !== 'inside') {
+      return null;
+    }
+    const sourceNode = gridRowNodeSelector(apiRef, sourceRowId);
+    if (!sourceNode || sourceNode.type === 'footer') {
+      return null;
+    }
+    if (!setTreeDataPath) {
+      displaySetTreeDataPathWarning('Drop on group reordering');
+    }
+    let targetIndex = placeholderIndex;
+    if (targetIndex === sortedFilteredRowIds.length && sortedFilteredRowIds.length > 0) {
+      targetIndex = sortedFilteredRowIds.length - 1;
+    }
+    if (targetIndex < 0) {
+      return null;
+    }
+    const targetNode = gridRowNodeSelector(apiRef, sortedFilteredRowIds[targetIndex]);
+    if (!targetNode || targetNode.type !== 'group') {
+      return null;
+    }
+    if (isDescendantOf(targetNode, sourceNode, rowTree)) {
+      return null;
+    }
+    const actualTargetIndex = 0;
+    return {
+      sourceNode,
+      targetNode,
+      actualTargetIndex,
+      isLastChild: false,
+      operationType: this.operationType
+    };
+  }
+  async executeOperation(operation, ctx) {
+    const {
+      sourceNode,
+      targetNode
+    } = operation;
+    const {
+      apiRef
+    } = ctx;
+    const rowTree = gridRowTreeSelector(apiRef);
+
+    // Build target path for the new structure
+    const targetPath = buildTreeDataPath(targetNode, rowTree);
+    let rowsToUpdate = [];
+
+    // Handle source node path updates
+    if (sourceNode.type === 'leaf') {
+      // Simple leaf move
+      const updatedRow = await updateLeafPath(sourceNode, targetPath, ctx);
+      if (!updatedRow) {
+        return;
+      }
+      rowsToUpdate.push(updatedRow);
+    } else {
+      // Group move - update entire hierarchy
+      const sourceParentNode = rowTree[sourceNode.parent];
+      const sourceBasePath = buildTreeDataPath(sourceParentNode, rowTree);
+      rowsToUpdate = await updateGroupHierarchyPaths(sourceNode, sourceBasePath, targetPath, ctx);
+      if (rowsToUpdate.length === 0) {
+        return;
+      }
+    }
+
+    // Update tree structure
+    apiRef.current.setState(state => {
+      const updatedTree = _extends({}, state.rows.tree);
+
+      // Remove source from its current parent
+      removeNodeFromSourceParent(updatedTree, sourceNode);
+
+      // Add source as first child of target group
+      const targetGroup = updatedTree[targetNode.id];
+      const targetChildren = [sourceNode.id, ...targetGroup.children];
+      updatedTree[targetNode.id] = _extends({}, targetGroup, {
+        children: targetChildren
+      });
+      updateNodeParentAndDepth(updatedTree, sourceNode, targetNode.id, targetNode.depth + 1);
+      return _extends({}, state, {
+        rows: _extends({}, state.rows, {
+          tree: updatedTree
+        })
+      });
+    });
+
+    // Update rows in the grid
+    apiRef.current.updateRows(rowsToUpdate);
+    apiRef.current.publishEvent('rowsSet');
+  }
+}
+
+/**
+ * Handles moving group nodes (and all their descendants) between different parents.
+ */
+class CrossParentGroupOperation extends BaseReorderOperation {
+  operationType = 'cross-parent-group';
+  detectOperation(ctx) {
+    if (ctx.dropPosition === 'inside') {
+      return null;
+    }
+    const {
+      sourceRowId,
+      placeholderIndex,
+      sortedFilteredRowIds,
+      rowTree,
+      apiRef,
+      setTreeDataPath
+    } = ctx;
+    const sourceNode = gridRowNodeSelector(apiRef, sourceRowId);
+    if (!sourceNode || sourceNode.type !== 'group') {
+      return null;
+    }
+    if (!setTreeDataPath) {
+      displaySetTreeDataPathWarning('Cross-parent reordering');
+    }
+
+    // Find target node
+    let targetIndex = placeholderIndex;
+    if (targetIndex === sortedFilteredRowIds.length && sortedFilteredRowIds.length > 0) {
+      targetIndex = sortedFilteredRowIds.length - 1;
+    }
+    if (targetIndex < 0) {
+      return null;
+    }
+    const targetNode = gridRowNodeSelector(apiRef, sortedFilteredRowIds[targetIndex]);
+    if (!targetNode) {
+      return null;
+    }
+    if (sourceNode.parent === targetNode.parent) {
+      return null;
+    }
+    if (isDescendantOf(targetNode, sourceNode, rowTree)) {
+      return null;
+    }
+    const actualTargetIndex = calculateTargetIndex(sourceNode, targetNode, placeholderIndex >= sortedFilteredRowIds.length, rowTree);
+    return {
+      sourceNode,
+      targetNode,
+      actualTargetIndex,
+      isLastChild: placeholderIndex >= sortedFilteredRowIds.length,
+      operationType: this.operationType
+    };
+  }
+  async executeOperation(operation, ctx) {
+    const {
+      sourceNode,
+      targetNode,
+      actualTargetIndex
+    } = operation;
+    const {
+      apiRef
+    } = ctx;
+    const rowTree = gridRowTreeSelector(apiRef);
+
+    // Calculate new base path for the moved group
+    const targetParentNode = rowTree[targetNode.parent];
+    const newBasePath = buildTreeDataPath(targetParentNode, rowTree);
+
+    // Calculate the original base path depth
+    const sourceParentNode = rowTree[sourceNode.parent];
+    const sourceBasePath = buildTreeDataPath(sourceParentNode, rowTree);
+
+    // Update group hierarchy paths
+    const updates = await updateGroupHierarchyPaths(sourceNode, sourceBasePath, newBasePath, ctx);
+    if (updates.length > 0) {
+      // Update tree structure (partial moves are allowed)
+      apiRef.current.setState(state => {
+        const updatedTree = _extends({}, state.rows.tree);
+
+        // Remove from source parent
+        removeNodeFromSourceParent(updatedTree, sourceNode);
+
+        // Add to target parent
+        const targetParent = updatedTree[targetNode.parent];
+        const targetChildren = [...targetParent.children];
+        targetChildren.splice(actualTargetIndex, 0, sourceNode.id);
+        updatedTree[targetNode.parent] = _extends({}, targetParent, {
+          children: targetChildren
+        });
+        const newParentNode = updatedTree[targetNode.parent];
+        const newGroupDepth = newParentNode.depth + 1;
+        updateNodeParentAndDepth(updatedTree, sourceNode, targetNode.parent, newGroupDepth);
+        return _extends({}, state, {
+          rows: _extends({}, state.rows, {
+            tree: updatedTree
+          })
+        });
+      });
+      apiRef.current.updateRows(updates);
+      apiRef.current.publishEvent('rowsSet');
+    }
+  }
+}
+export const treeDataReorderExecutor = new RowReorderExecutor([new SameParentSwapOperation(), new CrossParentLeafOperation(), new DropOnLeafOperation(), new DropOnGroupOperation(), new CrossParentGroupOperation()]);

package/esm/hooks/features/treeData/treeDataReorderValidator.d.ts

@@ -0,0 +1,2 @@
+import { RowReorderValidator } from "../rowReorder/reorderValidator.js";
+export declare const treeDataReorderValidator: RowReorderValidator;

package/esm/hooks/features/treeData/treeDataReorderValidator.js

@@ -0,0 +1,35 @@
+import { gridRowTreeSelector } from '@mui/x-data-grid';
+import { RowReorderValidator } from "../rowReorder/reorderValidator.js";
+import { commonReorderConditions as conditions } from "../rowReorder/commonReorderConditions.js";
+const validationRules = [{
+  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 => conditions.isAdjacentPosition(ctx),
+  isInvalid: () => true,
+  message: 'Source and target are adjacent'
+}, {
+  name: 'to-descendent',
+  applies: ctx => conditions.isGroupToLeaf(ctx) || conditions.isGroupToGroup(ctx),
+  isInvalid: ctx => {
+    let currentNode = ctx.targetNode;
+    const rowTree = gridRowTreeSelector(ctx.apiRef);
+    while (currentNode.parent) {
+      currentNode = rowTree[currentNode.parent];
+      if (currentNode.id === ctx.sourceNode.id) {
+        return true;
+      }
+    }
+    return false;
+  },
+  message: 'Cannot drop group on one of its descendents'
+}, {
+  name: 'group-to-group-above-leaf-belongs-to-source',
+  applies: ctx => conditions.isGroupToGroup(ctx) && conditions.isDropAbove(ctx) && conditions.prevIsLeaf(ctx),
+  isInvalid: conditions.prevBelongsToSource,
+  message: 'Previous leaf belongs to source group or its descendants'
+}];
+export const treeDataReorderValidator = new RowReorderValidator(validationRules);

package/esm/hooks/features/treeData/useGridTreeData.d.ts

@@ -1,4 +1,4 @@
 import { RefObject } from '@mui/x-internals/types';
-import { GridApiPro } from "../../../models/gridApiPro.js";
-import { DataGridProProcessedProps } from "../../../models/dataGridProProps.js";
-export declare const useGridTreeData: (apiRef: RefObject<GridApiPro>, props: Pick<DataGridProProcessedProps, "dataSource">) => void;
+import type { GridPrivateApiPro } from "../../../models/gridApiPro.js";
+import type { DataGridProProcessedProps } from "../../../models/dataGridProProps.js";
+export declare const useGridTreeData: (apiRef: RefObject<GridPrivateApiPro>, props: Pick<DataGridProProcessedProps, "treeData" | "dataSource" | "isValidRowReorder">) => void;

package/esm/hooks/features/treeData/useGridTreeData.js

@@ -1,10 +1,9 @@
 import * as React from 'react';
-import { useGridEvent } from '@mui/x-data-grid';
+import { useGridEvent, gridRowMaximumTreeDepthSelector, gridExpandedSortedRowIdsSelector, gridRowTreeSelector, gridExpandedSortedRowIndexLookupSelector } from '@mui/x-data-grid';
+import { useGridRegisterPipeProcessor } from '@mui/x-data-grid/internals';
 import { GRID_TREE_DATA_GROUPING_FIELD } from "./gridTreeDataGroupColDef.js";
+import { treeDataReorderValidator } from "./treeDataReorderValidator.js";
 export const useGridTreeData = (apiRef, props) => {
-  /**
-   * EVENTS
-   */
   const handleCellKeyDown = React.useCallback((params, event) => {
     const cellParams = apiRef.current.getCellParams(params.id, params.field);
     if (cellParams.colDef.field === GRID_TREE_DATA_GROUPING_FIELD && (event.key === ' ' || event.key === 'Enter') && !event.shiftKey) {
@@ -18,5 +17,51 @@ export const useGridTreeData = (apiRef, props) => {
       apiRef.current.setRowChildrenExpansion(params.id, !params.rowNode.childrenExpanded);
     }
   }, [apiRef, props.dataSource]);
+  const isValidRowReorderProp = props.isValidRowReorder;
+  const isRowReorderValid = React.useCallback((initialValue, {
+    sourceRowId,
+    targetRowId,
+    dropPosition,
+    dragDirection
+  }) => {
+    if (gridRowMaximumTreeDepthSelector(apiRef) === 1 || !props.treeData) {
+      return initialValue;
+    }
+    const expandedSortedRowIndexLookup = gridExpandedSortedRowIndexLookupSelector(apiRef);
+    const expandedSortedRowIds = gridExpandedSortedRowIdsSelector(apiRef);
+    const rowTree = gridRowTreeSelector(apiRef);
+    const targetRowIndex = expandedSortedRowIndexLookup[targetRowId];
+    const sourceNode = rowTree[sourceRowId];
+    const targetNode = rowTree[targetRowId];
+    const prevNode = targetRowIndex > 0 ? rowTree[expandedSortedRowIds[targetRowIndex - 1]] : null;
+    const nextNode = targetRowIndex < expandedSortedRowIds.length - 1 ? rowTree[expandedSortedRowIds[targetRowIndex + 1]] : null;
+
+    // Basic validity checks
+    if (!sourceNode || !targetNode) {
+      return false;
+    }
+
+    // Create context object
+    const context = {
+      apiRef,
+      sourceNode,
+      targetNode,
+      prevNode,
+      nextNode,
+      dropPosition,
+      dragDirection
+    };
+
+    // First apply internal validation
+    let isValid = treeDataReorderValidator.validate(context);
+
+    // If internal validation passes AND user provided additional validation
+    if (isValid && isValidRowReorderProp) {
+      // Apply additional user restrictions
+      isValid = isValidRowReorderProp(context);
+    }
+    return isValid;
+  }, [apiRef, props.treeData, isValidRowReorderProp]);
+  useGridRegisterPipeProcessor(apiRef, 'isRowReorderValid', isRowReorderValid);
   useGridEvent(apiRef, 'cellKeyDown', handleCellKeyDown);
 };

package/esm/hooks/features/treeData/utils.d.ts

@@ -0,0 +1,8 @@
+import { type GridRowId, type GridTreeNode, type GridGroupNode, type GridValidRowModel, type GridRowTreeConfig } from '@mui/x-data-grid';
+import type { ReorderExecutionContext } from "../rowReorder/types.js";
+export declare const buildTreeDataPath: (node: GridTreeNode, tree: GridRowTreeConfig) => string[];
+export declare function displaySetTreeDataPathWarning(operationName: string): void;
+export declare function removeNodeFromSourceParent(updatedTree: Record<string, GridTreeNode>, sourceNode: GridTreeNode): void;
+export declare function updateLeafPath(sourceNode: GridTreeNode, targetPath: string[], ctx: ReorderExecutionContext): Promise<GridValidRowModel | null>;
+export declare function updateGroupHierarchyPaths(sourceNode: GridGroupNode, sourceBasePath: string[], targetPath: string[], ctx: ReorderExecutionContext): Promise<GridValidRowModel[]>;
+export declare function updateNodeParentAndDepth(updatedTree: Record<string, GridTreeNode>, node: GridTreeNode, newParentId: GridRowId, newDepth: number): void;