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

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

package/hooks/features/rows/useGridRowsOverridableMethods.js

@@ -8,28 +8,44 @@ exports.useGridRowsOverridableMethods = void 0;
 var React = _interopRequireWildcard(require("react"));
 var _xDataGridPro = require("@mui/x-data-grid-pro");
 var _internals = require("@mui/x-data-grid-pro/internals");
-var _reorderExecutor = require("../rowReorder/reorderExecutor");
+var _rowGroupingReorderExecutor = require("../rowReorder/rowGroupingReorderExecutor");
 const useGridRowsOverridableMethods = (apiRef, props) => {
   const {
     processRowUpdate,
     onProcessRowUpdateError
   } = props;
   const {
-    setRowIndex: setRowIndexPlain
-  } = (0, _internals.useGridRowsOverridableMethods)(apiRef);
+    setRowIndex: setRowIndexPlain,
+    setRowPosition: setRowPositionPlain
+  } = (0, _internals.useGridRowsOverridableMethodsCommunity)(apiRef);
+  const {
+    setRowIndex: setRowIndexTreeData,
+    setRowPosition: setRowPositionTreeData
+  } = (0, _internals.useGridRowsOverridableMethodsPro)(apiRef, props);
   const flatTree = (0, _internals.useGridSelector)(apiRef, _xDataGridPro.gridRowMaximumTreeDepthSelector) === 1;
-  const setRowIndex = React.useCallback(async (sourceRowId, targetOriginalIndex) => {
+  const setRowPosition = React.useCallback(async (sourceRowId, targetRowId, position) => {
     const sortedFilteredRowIds = (0, _xDataGridPro.gridExpandedSortedRowIdsSelector)(apiRef);
-    const sortedFilteredRowIndexLookup = (0, _internals.gridExpandedSortedRowIndexLookupSelector)(apiRef);
+    const sortedFilteredRowIndexLookup = (0, _xDataGridPro.gridExpandedSortedRowIndexLookupSelector)(apiRef);
     const rowTree = (0, _xDataGridPro.gridRowTreeSelector)(apiRef);
     const sourceNode = (0, _xDataGridPro.gridRowNodeSelector)(apiRef, sourceRowId);
+    const targetNode = (0, _xDataGridPro.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
      * =================================
@@ -47,6 +63,31 @@ const useGridRowsOverridableMethods = (apiRef, props) => {
 
     const executionContext = {
       sourceRowId,
+      dropPosition: position,
+      placeholderIndex: targetIndex,
+      sortedFilteredRowIds,
+      sortedFilteredRowIndexLookup,
+      rowTree,
+      apiRef,
+      processRowUpdate,
+      onProcessRowUpdateError
+    };
+    return _rowGroupingReorderExecutor.rowGroupingReorderExecutor.execute(executionContext);
+  }, [apiRef, processRowUpdate, onProcessRowUpdateError]);
+  const setRowIndex = React.useCallback(async (sourceRowId, targetOriginalIndex) => {
+    const sortedFilteredRowIds = (0, _xDataGridPro.gridExpandedSortedRowIdsSelector)(apiRef);
+    const sortedFilteredRowIndexLookup = (0, _xDataGridPro.gridExpandedSortedRowIndexLookupSelector)(apiRef);
+    const rowTree = (0, _xDataGridPro.gridRowTreeSelector)(apiRef);
+    const sourceNode = (0, _xDataGridPro.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,
@@ -55,10 +96,23 @@ const useGridRowsOverridableMethods = (apiRef, props) => {
       processRowUpdate,
       onProcessRowUpdateError
     };
-    await _reorderExecutor.rowGroupingReorderExecutor.execute(executionContext);
+    return _rowGroupingReorderExecutor.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
   };
 };
 exports.useGridRowsOverridableMethods = useGridRowsOverridableMethods;

package/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/x-data-grid-premium",
-  "version": "8.19.0",
+  "version": "8.21.0",
   "author": "MUI Team",
   "description": "The Premium plan edition of the MUI X Data Grid Components.",
   "license": "SEE LICENSE IN LICENSE",
@@ -38,10 +38,10 @@
     "@mui/x-internal-exceljs-fork": "4.4.3",
     "clsx": "^2.1.1",
     "prop-types": "^15.8.1",
-    "@mui/x-data-grid-pro": "8.19.0",
-    "@mui/x-data-grid": "8.19.0",
-    "@mui/x-internals": "8.19.0",
-    "@mui/x-license": "8.19.0"
+    "@mui/x-data-grid-pro": "8.21.0",
+    "@mui/x-data-grid": "8.21.0",
+    "@mui/x-internals": "8.21.0",
+    "@mui/x-license": "8.21.0"
   },
   "peerDependencies": {
     "@emotion/react": "^11.9.0",

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

@@ -1,15 +0,0 @@
-import { BaseReorderOperation } from "./operations.js";
-import type { ReorderExecutionContext } from "./types.js";
-/**
- * Executor class for handling row reorder operations in grouped data grids.
- *
- * This class coordinates the execution of different reorder operation types,
- * trying each operation in order until one succeeds or all fail.
- */
-declare class RowReorderExecutor {
-  private operations;
-  constructor(operations: BaseReorderOperation[]);
-  execute(ctx: ReorderExecutionContext): Promise<void>;
-}
-export declare const rowGroupingReorderExecutor: RowReorderExecutor;
-export {};

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

@@ -1,25 +0,0 @@
-import { warnOnce } from '@mui/x-internals/warning';
-import { SameParentSwapOperation, CrossParentLeafOperation, CrossParentGroupOperation } from "./operations.js";
-/**
- * Executor class for handling row reorder operations in grouped data grids.
- *
- * This class coordinates the execution of different reorder operation types,
- * trying each operation in order until one succeeds or all fail.
- */
-class RowReorderExecutor {
-  constructor(operations) {
-    this.operations = operations;
-  }
-  async execute(ctx) {
-    for (const operation of this.operations) {
-      const detectedOperation = operation.detectOperation(ctx);
-      if (detectedOperation) {
-        // eslint-disable-next-line no-await-in-loop
-        await operation.executeOperation(detectedOperation, ctx);
-        return;
-      }
-    }
-    warnOnce(['MUI X: The parameters provided to the `setRowIndex()` resulted in a no-op.', 'Consider looking at the documentation at https://mui.com/x/react-data-grid/row-grouping/'], 'warning');
-  }
-}
-export const rowGroupingReorderExecutor = new RowReorderExecutor([new SameParentSwapOperation(), new CrossParentLeafOperation(), new CrossParentGroupOperation()]);

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

@@ -1,16 +0,0 @@
-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/types.d.ts

@@ -1,42 +0,0 @@
-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

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

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

@@ -1,127 +0,0 @@
-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[];
-  }>;
-}