@mui/x-data-grid-premium 8.10.2 → 8.11.1

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

@@ -0,0 +1,16 @@
+import { ReorderValidationContext } from "./types.js";
+interface ValidationRule {
+  name: string;
+  applies: (ctx: ReorderValidationContext) => boolean;
+  isInvalid: (ctx: ReorderValidationContext) => boolean;
+  message?: string;
+}
+declare class RowReorderValidator {
+  private rules;
+  constructor(rules?: ValidationRule[]);
+  addRule(rule: ValidationRule): void;
+  removeRule(ruleName: string): void;
+  validate(context: ReorderValidationContext): boolean;
+}
+export declare const rowGroupingReorderValidator: RowReorderValidator;
+export {};

package/esm/hooks/features/rowReorder/reorderValidator.js

@@ -0,0 +1,116 @@
+import { conditions } from "./utils.js";
+const validationRules = [
+// ===== Basic invalid cases =====
+{
+  name: 'same-position',
+  applies: ctx => ctx.sourceRowIndex === ctx.targetRowIndex,
+  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: 'group-to-leaf',
+  applies: conditions.isGroupToLeaf,
+  isInvalid: () => true,
+  message: 'Cannot drop group on leaf'
+},
+// ===== Group to Group Rules =====
+{
+  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'
+}, {
+  name: 'group-to-group-above-invalid-depth',
+  applies: ctx => conditions.isGroupToGroup(ctx) && conditions.isDropAbove(ctx) && !conditions.sameDepth(ctx) && !(ctx.targetNode.depth < ctx.sourceNode.depth && (conditions.prevIsLeaf(ctx) || conditions.prevIsGroup(ctx) && conditions.prevDepthEqualsSource(ctx))),
+  isInvalid: () => true,
+  message: 'Invalid depth configuration for group above group'
+}, {
+  name: 'group-to-group-above-different-parent-depth',
+  applies: ctx => conditions.isGroupToGroup(ctx) && conditions.isDropAbove(ctx) && conditions.prevIsGroup(ctx) && conditions.prevDepthEqualsSource(ctx) && conditions.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 => conditions.isGroupToGroup(ctx) && conditions.isDropBelow(ctx),
+  isInvalid: ctx => {
+    // Valid case 1: Same depth and target not expanded
+    if (conditions.sameDepth(ctx) && conditions.targetGroupCollapsed(ctx)) {
+      return false;
+    }
+    // Valid case 2: Target is parent level, expanded, with compatible first child
+    if (conditions.targetDepthIsSourceMinusOne(ctx) && conditions.targetGroupExpanded(ctx) && conditions.targetFirstChildIsGroupWithSourceDepth(ctx)) {
+      return false;
+    }
+    return true;
+  },
+  message: 'Invalid group below group configuration'
+},
+// ===== Leaf to Leaf Rules =====
+{
+  name: 'leaf-to-leaf-different-depth',
+  applies: ctx => conditions.isLeafToLeaf(ctx) && !conditions.sameDepth(ctx),
+  isInvalid: () => true,
+  message: 'Leaves at different depths cannot be reordered'
+}, {
+  name: 'leaf-to-leaf-invalid-below',
+  applies: ctx => conditions.isLeafToLeaf(ctx) && conditions.sameDepth(ctx) && !conditions.sameParent(ctx) && conditions.isDropBelow(ctx),
+  isInvalid: ctx => !(conditions.nextIsGroup(ctx) && ctx.sourceNode.depth > ctx.nextNode.depth) && !conditions.nextIsLeaf(ctx),
+  message: 'Invalid leaf below leaf configuration'
+},
+// ===== Leaf to Group Rules =====
+{
+  name: 'leaf-to-group-above-no-prev-leaf',
+  applies: ctx => conditions.isLeafToGroup(ctx) && conditions.isDropAbove(ctx),
+  isInvalid: ctx => !conditions.hasPrevNode(ctx) || !conditions.prevIsLeaf(ctx),
+  message: 'No valid previous leaf for leaf above group'
+}, {
+  name: 'leaf-to-group-above-depth-mismatch',
+  applies: ctx => conditions.isLeafToGroup(ctx) && conditions.isDropAbove(ctx) && conditions.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 => conditions.isLeafToGroup(ctx) && conditions.isDropBelow(ctx),
+  isInvalid: conditions.targetGroupCollapsed,
+  message: 'Cannot drop below collapsed group'
+}, {
+  name: 'leaf-to-group-below-invalid-depth',
+  applies: ctx => conditions.isLeafToGroup(ctx) && conditions.isDropBelow(ctx) && conditions.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 (conditions.targetFirstChildDepthEqualsSource(ctx)) {
+      return false;
+    }
+    return true;
+  },
+  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/rowReorder/types.d.ts

@@ -0,0 +1,42 @@
+import { GridRowId, GridTreeNode } from '@mui/x-data-grid-pro';
+import type { GridRowTreeConfig } from '@mui/x-data-grid-pro';
+import { RefObject } from '@mui/x-internals/types';
+import { GridPrivateApiPremium } from "../../../models/gridApiPremium.js";
+import { DataGridPremiumProcessedProps } from "../../../models/dataGridPremiumProps.js";
+export type DropPosition = 'above' | 'below';
+export type DragDirection = 'up' | 'down';
+export interface ReorderValidationContext {
+  sourceNode: GridTreeNode;
+  targetNode: GridTreeNode;
+  prevNode: GridTreeNode | null;
+  nextNode: GridTreeNode | null;
+  rowTree: Record<GridRowId, GridTreeNode>;
+  dropPosition: DropPosition;
+  dragDirection: DragDirection;
+  targetRowIndex: number;
+  sourceRowIndex: number;
+  expandedSortedRowIndexLookup: Record<GridRowId, number>;
+}
+export interface ReorderExecutionContext {
+  sourceRowId: GridRowId;
+  placeholderIndex: number;
+  sortedFilteredRowIds: GridRowId[];
+  sortedFilteredRowIndexLookup: Record<GridRowId, number>;
+  rowTree: GridRowTreeConfig;
+  apiRef: RefObject<GridPrivateApiPremium>;
+  processRowUpdate?: DataGridPremiumProcessedProps['processRowUpdate'];
+  onProcessRowUpdateError?: DataGridPremiumProcessedProps['onProcessRowUpdateError'];
+}
+export interface ReorderOperation {
+  sourceNode: GridTreeNode;
+  targetNode: GridTreeNode;
+  actualTargetIndex: number;
+  isLastChild: boolean;
+  operationType: ReorderOperationType;
+}
+export interface ReorderScenario {
+  name: string;
+  detectOperation: (ctx: ReorderExecutionContext) => ReorderOperation | null;
+  execute: (operation: ReorderOperation, ctx: ReorderExecutionContext) => Promise<void> | void;
+}
+export type ReorderOperationType = 'same-parent-swap' | 'cross-parent-leaf' | 'cross-parent-group';

package/esm/hooks/features/rowReorder/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,127 @@
+import type { RefObject } from '@mui/x-internals/types';
+import { type GridRowId, type GridTreeNode, type GridGroupNode, type GridRowTreeConfig, type GridKeyValue, type GridValidRowModel } from '@mui/x-data-grid-pro';
+import type { RowTreeBuilderGroupingCriterion } from '@mui/x-data-grid-pro/internals';
+import type { ReorderValidationContext as Ctx, ReorderOperationType } from "./types.js";
+import type { GridPrivateApiPremium } from "../../../models/gridApiPremium.js";
+import { DataGridPremiumProcessedProps } from "../../../models/dataGridPremiumProps.js";
+/**
+ * Reusable validation conditions for row reordering validation
+ */
+export declare const conditions: {
+  isGroupToGroup: (ctx: Ctx) => boolean;
+  isLeafToLeaf: (ctx: Ctx) => boolean;
+  isLeafToGroup: (ctx: Ctx) => boolean;
+  isGroupToLeaf: (ctx: Ctx) => boolean;
+  isDropAbove: (ctx: Ctx) => boolean;
+  isDropBelow: (ctx: Ctx) => boolean;
+  sameDepth: (ctx: Ctx) => boolean;
+  sourceDepthGreater: (ctx: Ctx) => boolean;
+  targetDepthIsSourceMinusOne: (ctx: Ctx) => boolean;
+  sameParent: (ctx: Ctx) => boolean;
+  targetGroupExpanded: (ctx: Ctx) => boolean;
+  targetGroupCollapsed: (ctx: Ctx) => boolean;
+  hasPrevNode: (ctx: Ctx) => boolean;
+  hasNextNode: (ctx: Ctx) => boolean;
+  prevIsLeaf: (ctx: Ctx) => boolean;
+  prevIsGroup: (ctx: Ctx) => boolean;
+  nextIsLeaf: (ctx: Ctx) => boolean;
+  nextIsGroup: (ctx: Ctx) => boolean;
+  prevDepthEquals: (ctx: Ctx, depth: number) => boolean;
+  prevDepthEqualsSource: (ctx: Ctx) => boolean;
+  prevBelongsToSource: (ctx: Ctx) => boolean;
+  isAdjacentPosition: (ctx: Ctx) => boolean;
+  targetFirstChildIsGroupWithSourceDepth: (ctx: Ctx) => boolean;
+  targetFirstChildDepthEqualsSource: (ctx: Ctx) => boolean;
+};
+export declare function determineOperationType(sourceNode: GridTreeNode, targetNode: GridTreeNode): ReorderOperationType;
+export declare function calculateTargetIndex(sourceNode: GridTreeNode, targetNode: GridTreeNode, isLastChild: boolean, rowTree: Record<GridRowId, GridTreeNode>): number;
+export declare const getNodePathInTree: ({
+  id,
+  tree
+}: {
+  id: GridRowId;
+  tree: GridRowTreeConfig;
+}) => RowTreeBuilderGroupingCriterion[];
+export declare const collectAllLeafDescendants: (groupNode: GridGroupNode, tree: GridRowTreeConfig) => GridRowId[];
+/**
+ * Adjusts the target node based on specific reorder scenarios and constraints.
+ *
+ * This function applies scenario-specific logic to find the actual target node
+ * for operations, handling cases like:
+ * - Moving to collapsed groups
+ * - Depth-based adjustments
+ * - End-of-list positioning
+ *
+ * @param sourceNode The node being moved
+ * @param targetNode The initial target node
+ * @param targetIndex The index of the target node in the visible rows
+ * @param placeholderIndex The index where the placeholder appears
+ * @param sortedFilteredRowIds Array of visible row IDs in display order
+ * @param apiRef Reference to the grid API
+ * @returns Object containing the adjusted target node and last child flag
+ */
+export declare function adjustTargetNode(sourceNode: GridTreeNode, targetNode: GridTreeNode, targetIndex: number, placeholderIndex: number, sortedFilteredRowIds: GridRowId[], apiRef: RefObject<GridPrivateApiPremium>): {
+  adjustedTargetNode: GridTreeNode;
+  isLastChild: boolean;
+};
+/**
+ * Finds an existing group node with the same groupingKey and groupingField under a parent.
+ *
+ * @param parentNode - The parent group node to search in
+ * @param groupingKey - The grouping key to match
+ * @param groupingField - The grouping field to match
+ * @param tree - The row tree configuration
+ * @returns The existing group node if found, null otherwise
+ */
+export declare function findExistingGroupWithSameKey(parentNode: GridGroupNode, groupingKey: GridKeyValue, groupingField: string, tree: GridRowTreeConfig): GridGroupNode | null;
+/**
+ * Removes empty ancestor groups from the tree after a row move operation.
+ * Walks up the tree from the given group, removing any empty groups encountered.
+ *
+ * @param groupId - The ID of the group to start checking from
+ * @param tree - The row tree configuration
+ * @param removedGroups - Set to track which groups have been removed
+ * @returns The number of root-level groups that were removed
+ */
+export declare function removeEmptyAncestors(groupId: GridRowId, tree: GridRowTreeConfig, removedGroups: Set<GridRowId>): number;
+export declare function handleProcessRowUpdateError(error: any, onProcessRowUpdateError?: DataGridPremiumProcessedProps['onProcessRowUpdateError']): void;
+/**
+ * Handles batch row updates with partial failure tracking.
+ *
+ * This class is designed for operations that need to update multiple rows
+ * atomically (like moving entire groups), while gracefully handling cases
+ * where some updates succeed and others fail.
+ *
+ * @example
+ * ```tsx
+ * const updater = new BatchRowUpdater(processRowUpdate, onError);
+ *
+ * // Queue multiple updates
+ * updater.queueUpdate('row1', originalRow1, newRow1);
+ * updater.queueUpdate('row2', originalRow2, newRow2);
+ *
+ * // Execute all updates
+ * const { successful, failed, updates } = await updater.executeAll();
+ *
+ * // Handle results
+ * if (successful.length > 0) {
+ *   apiRef.current.updateRows(updates);
+ * }
+ * ```
+ */
+export declare class BatchRowUpdater {
+  private processRowUpdate;
+  private onProcessRowUpdateError;
+  private rowsToUpdate;
+  private originalRows;
+  private successfulRowIds;
+  private failedRowIds;
+  private pendingRowUpdates;
+  constructor(processRowUpdate: DataGridPremiumProcessedProps['processRowUpdate'] | undefined, onProcessRowUpdateError: DataGridPremiumProcessedProps['onProcessRowUpdateError'] | undefined);
+  queueUpdate(rowId: GridRowId, originalRow: GridValidRowModel, updatedRow: GridValidRowModel): void;
+  executeAll(): Promise<{
+    successful: GridRowId[];
+    failed: GridRowId[];
+    updates: GridValidRowModel[];
+  }>;
+}

package/esm/hooks/features/rowReorder/utils.js

@@ -0,0 +1,343 @@
+import { GRID_ROOT_GROUP_ID, gridRowNodeSelector } from '@mui/x-data-grid-pro';
+import { warnOnce } from '@mui/x-internals/warning';
+// TODO: Share these conditions with the executor by making the contexts similar
+/**
+ * Reusable validation conditions for row reordering validation
+ */
+export const conditions = {
+  // Node type checks
+  isGroupToGroup: ctx => ctx.sourceNode.type === 'group' && ctx.targetNode.type === 'group',
+  isLeafToLeaf: ctx => ctx.sourceNode.type === 'leaf' && ctx.targetNode.type === 'leaf',
+  isLeafToGroup: ctx => ctx.sourceNode.type === 'leaf' && ctx.targetNode.type === 'group',
+  isGroupToLeaf: ctx => ctx.sourceNode.type === 'group' && ctx.targetNode.type === 'leaf',
+  // Drop position checks
+  isDropAbove: ctx => ctx.dropPosition === 'above',
+  isDropBelow: ctx => ctx.dropPosition === 'below',
+  // Depth checks
+  sameDepth: ctx => ctx.sourceNode.depth === ctx.targetNode.depth,
+  sourceDepthGreater: ctx => ctx.sourceNode.depth > ctx.targetNode.depth,
+  targetDepthIsSourceMinusOne: ctx => ctx.targetNode.depth === ctx.sourceNode.depth - 1,
+  // Parent checks
+  sameParent: ctx => ctx.sourceNode.parent === ctx.targetNode.parent,
+  // Node state checks
+  targetGroupExpanded: ctx => (ctx.targetNode.type === 'group' && ctx.targetNode.childrenExpanded) ?? false,
+  targetGroupCollapsed: ctx => ctx.targetNode.type === 'group' && !ctx.targetNode.childrenExpanded,
+  // Previous/Next node checks
+  hasPrevNode: ctx => ctx.prevNode !== null,
+  hasNextNode: ctx => ctx.nextNode !== null,
+  prevIsLeaf: ctx => ctx.prevNode?.type === 'leaf',
+  prevIsGroup: ctx => ctx.prevNode?.type === 'group',
+  nextIsLeaf: ctx => ctx.nextNode?.type === 'leaf',
+  nextIsGroup: ctx => ctx.nextNode?.type === 'group',
+  prevDepthEquals: (ctx, depth) => ctx.prevNode?.depth === depth,
+  prevDepthEqualsSource: ctx => ctx.prevNode?.depth === ctx.sourceNode.depth,
+  // Complex checks
+  prevBelongsToSource: ctx => {
+    if (!ctx.prevNode) {
+      return false;
+    }
+    // Check if prevNode.parent OR any of its ancestors === sourceNode.id
+    let currentId = ctx.prevNode.parent;
+    while (currentId) {
+      if (currentId === ctx.sourceNode.id) {
+        return true;
+      }
+      const node = ctx.rowTree[currentId];
+      if (!node) {
+        break;
+      }
+      currentId = node.parent;
+    }
+    return false;
+  },
+  // Position checks
+  isAdjacentPosition: ctx => {
+    const {
+      sourceRowIndex,
+      targetRowIndex,
+      dropPosition
+    } = ctx;
+    return dropPosition === 'above' && targetRowIndex === sourceRowIndex + 1 || dropPosition === 'below' && targetRowIndex === sourceRowIndex - 1;
+  },
+  // First child check
+  targetFirstChildIsGroupWithSourceDepth: ctx => {
+    if (ctx.targetNode.type !== 'group') {
+      return false;
+    }
+    const targetGroup = ctx.targetNode;
+    const firstChild = targetGroup.children?.[0] ? ctx.rowTree[targetGroup.children[0]] : null;
+    return firstChild?.type === 'group' && firstChild.depth === ctx.sourceNode.depth;
+  },
+  targetFirstChildDepthEqualsSource: ctx => {
+    if (ctx.targetNode.type !== 'group') {
+      return false;
+    }
+    const targetGroup = ctx.targetNode;
+    const firstChild = targetGroup.children?.[0] ? ctx.rowTree[targetGroup.children[0]] : null;
+    return firstChild ? firstChild.depth === ctx.sourceNode.depth : false;
+  }
+};
+export function determineOperationType(sourceNode, targetNode) {
+  if (sourceNode.parent === targetNode.parent) {
+    return 'same-parent-swap';
+  }
+  if (sourceNode.type === 'leaf') {
+    return 'cross-parent-leaf';
+  }
+  return 'cross-parent-group';
+}
+export function calculateTargetIndex(sourceNode, targetNode, isLastChild, rowTree) {
+  if (sourceNode.parent === targetNode.parent && !isLastChild) {
+    // Same parent: find target's position in parent's children
+    const parent = rowTree[sourceNode.parent];
+    return parent.children.findIndex(id => id === targetNode.id);
+  }
+  if (isLastChild) {
+    // Append at the end
+    const targetParent = rowTree[targetNode.parent];
+    return targetParent.children.length;
+  }
+
+  // Find position in target parent
+  const targetParent = rowTree[targetNode.parent];
+  const targetIndex = targetParent.children.findIndex(id => id === targetNode.id);
+  return targetIndex >= 0 ? targetIndex : 0;
+}
+
+// Get the path from a node to the root in the tree
+export const getNodePathInTree = ({
+  id,
+  tree
+}) => {
+  const path = [];
+  let node = tree[id];
+  while (node.id !== GRID_ROOT_GROUP_ID) {
+    path.push({
+      field: node.type === 'leaf' ? null : node.groupingField,
+      key: node.groupingKey
+    });
+    node = tree[node.parent];
+  }
+  path.reverse();
+  return path;
+};
+
+// Recursively collect all leaf node IDs from a group
+export const collectAllLeafDescendants = (groupNode, tree) => {
+  const leafIds = [];
+  const collectFromNode = nodeId => {
+    const node = tree[nodeId];
+    if (node.type === 'leaf') {
+      leafIds.push(nodeId);
+    } else if (node.type === 'group') {
+      node.children.forEach(collectFromNode);
+    }
+  };
+  groupNode.children.forEach(collectFromNode);
+  return leafIds;
+};
+
+/**
+ * Adjusts the target node based on specific reorder scenarios and constraints.
+ *
+ * This function applies scenario-specific logic to find the actual target node
+ * for operations, handling cases like:
+ * - Moving to collapsed groups
+ * - Depth-based adjustments
+ * - End-of-list positioning
+ *
+ * @param sourceNode The node being moved
+ * @param targetNode The initial target node
+ * @param targetIndex The index of the target node in the visible rows
+ * @param placeholderIndex The index where the placeholder appears
+ * @param sortedFilteredRowIds Array of visible row IDs in display order
+ * @param apiRef Reference to the grid API
+ * @returns Object containing the adjusted target node and last child flag
+ */
+export function adjustTargetNode(sourceNode, targetNode, targetIndex, placeholderIndex, sortedFilteredRowIds, apiRef) {
+  let adjustedTargetNode = targetNode;
+  let isLastChild = false;
+
+  // Handle end-of-list case
+  if (placeholderIndex >= sortedFilteredRowIds.length && sortedFilteredRowIds.length > 0) {
+    isLastChild = true;
+  }
+
+  // Case A and B adjustment: Move to last child of parent where target should be the node above
+  if (targetNode.type === 'group' && sourceNode.parent !== targetNode.parent && sourceNode.depth > targetNode.depth) {
+    // Find the first node with the same depth as source before target and quit early if a
+    // node with depth < source.depth is found
+    let i = targetIndex - 1;
+    while (i >= 0) {
+      const node = apiRef.current.getRowNode(sortedFilteredRowIds[i]);
+      if (node && node.depth < sourceNode.depth) {
+        break;
+      }
+      if (node && node.depth === sourceNode.depth) {
+        adjustedTargetNode = node;
+        break;
+      }
+      i -= 1;
+    }
+  }
+
+  // Case D adjustment: Leaf to group where we need previous leaf
+  if (sourceNode.type === 'leaf' && targetNode.type === 'group' && targetNode.depth < sourceNode.depth) {
+    isLastChild = true;
+    const prevIndex = placeholderIndex - 1;
+    if (prevIndex >= 0) {
+      const prevRowId = sortedFilteredRowIds[prevIndex];
+      const leafTargetNode = gridRowNodeSelector(apiRef, prevRowId);
+      if (leafTargetNode && leafTargetNode.type === 'leaf') {
+        adjustedTargetNode = leafTargetNode;
+      }
+    }
+  }
+  return {
+    adjustedTargetNode,
+    isLastChild
+  };
+}
+
+/**
+ * Finds an existing group node with the same groupingKey and groupingField under a parent.
+ *
+ * @param parentNode - The parent group node to search in
+ * @param groupingKey - The grouping key to match
+ * @param groupingField - The grouping field to match
+ * @param tree - The row tree configuration
+ * @returns The existing group node if found, null otherwise
+ */
+export function findExistingGroupWithSameKey(parentNode, groupingKey, groupingField, tree) {
+  for (const childId of parentNode.children) {
+    const childNode = tree[childId];
+    if (childNode && childNode.type === 'group' && childNode.groupingKey === groupingKey && childNode.groupingField === groupingField) {
+      return childNode;
+    }
+  }
+  return null;
+}
+
+/**
+ * Removes empty ancestor groups from the tree after a row move operation.
+ * Walks up the tree from the given group, removing any empty groups encountered.
+ *
+ * @param groupId - The ID of the group to start checking from
+ * @param tree - The row tree configuration
+ * @param removedGroups - Set to track which groups have been removed
+ * @returns The number of root-level groups that were removed
+ */
+export function removeEmptyAncestors(groupId, tree, removedGroups) {
+  let rootLevelRemovals = 0;
+  let currentGroupId = groupId;
+  while (currentGroupId && currentGroupId !== GRID_ROOT_GROUP_ID) {
+    const group = tree[currentGroupId];
+    if (!group) {
+      break;
+    }
+    const remainingChildren = group.children.filter(childId => !removedGroups.has(childId));
+    if (remainingChildren.length > 0) {
+      break;
+    }
+    if (group.depth === 0) {
+      rootLevelRemovals += 1;
+    }
+    removedGroups.add(currentGroupId);
+    currentGroupId = group.parent;
+  }
+  return rootLevelRemovals;
+}
+export function handleProcessRowUpdateError(error, onProcessRowUpdateError) {
+  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');
+  }
+}
+
+/**
+ * Handles batch row updates with partial failure tracking.
+ *
+ * This class is designed for operations that need to update multiple rows
+ * atomically (like moving entire groups), while gracefully handling cases
+ * where some updates succeed and others fail.
+ *
+ * @example
+ * ```tsx
+ * const updater = new BatchRowUpdater(processRowUpdate, onError);
+ *
+ * // Queue multiple updates
+ * updater.queueUpdate('row1', originalRow1, newRow1);
+ * updater.queueUpdate('row2', originalRow2, newRow2);
+ *
+ * // Execute all updates
+ * const { successful, failed, updates } = await updater.executeAll();
+ *
+ * // Handle results
+ * if (successful.length > 0) {
+ *   apiRef.current.updateRows(updates);
+ * }
+ * ```
+ */
+export class BatchRowUpdater {
+  rowsToUpdate = (() => new Map())();
+  originalRows = (() => new Map())();
+  successfulRowIds = (() => new Set())();
+  failedRowIds = (() => new Set())();
+  pendingRowUpdates = [];
+  constructor(processRowUpdate, onProcessRowUpdateError) {
+    this.processRowUpdate = processRowUpdate;
+    this.onProcessRowUpdateError = onProcessRowUpdateError;
+  }
+  queueUpdate(rowId, originalRow, updatedRow) {
+    this.originalRows.set(rowId, originalRow);
+    this.rowsToUpdate.set(rowId, updatedRow);
+  }
+  async executeAll() {
+    const rowIds = Array.from(this.rowsToUpdate.keys());
+    if (rowIds.length === 0) {
+      return {
+        successful: [],
+        failed: [],
+        updates: []
+      };
+    }
+
+    // Handle each row update, tracking success/failure
+    const handleRowUpdate = async rowId => {
+      const newRow = this.rowsToUpdate.get(rowId);
+      const oldRow = this.originalRows.get(rowId);
+      try {
+        if (typeof this.processRowUpdate === 'function') {
+          const params = {
+            rowId,
+            previousRow: oldRow,
+            updatedRow: newRow
+          };
+          const finalRow = await this.processRowUpdate(newRow, oldRow, params);
+          this.pendingRowUpdates.push(finalRow || newRow);
+          this.successfulRowIds.add(rowId);
+        } else {
+          this.pendingRowUpdates.push(newRow);
+          this.successfulRowIds.add(rowId);
+        }
+      } catch (error) {
+        this.failedRowIds.add(rowId);
+        handleProcessRowUpdateError(error, this.onProcessRowUpdateError);
+      }
+    };
+
+    // Use Promise.all with wrapped promises to avoid Promise.allSettled (browser support)
+    const promises = rowIds.map(rowId => {
+      return new Promise(resolve => {
+        handleRowUpdate(rowId).then(resolve).catch(resolve);
+      });
+    });
+    await Promise.all(promises);
+    return {
+      successful: Array.from(this.successfulRowIds),
+      failed: Array.from(this.failedRowIds),
+      updates: this.pendingRowUpdates
+    };
+  }
+}

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

@@ -0,0 +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: (sourceRowId: GridRowId, targetOriginalIndex: number) => Promise<void>;
+};