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

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

@@ -0,0 +1,96 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { GRID_ROOT_GROUP_ID, gridRowsLookupSelector, gridRowTreeSelector } from '@mui/x-data-grid';
+import { warnOnce } from '@mui/x-internals/warning';
+import { BatchRowUpdater, collectAllDescendants, updateDescendantDepths } from "../rowReorder/utils.js";
+export const buildTreeDataPath = (node, tree) => {
+  const path = [];
+  let current = node;
+  while (current && current.id !== GRID_ROOT_GROUP_ID) {
+    if ((current.type === 'leaf' || current.type === 'group') && current.groupingKey !== null) {
+      path.unshift(String(current.groupingKey));
+    }
+    current = tree[current.parent];
+  }
+  return path;
+};
+export function displaySetTreeDataPathWarning(operationName) {
+  warnOnce(`MUI X: ${operationName} requires \`setTreeDataPath()\` prop to update row data paths. ` + 'Please provide a `setTreeDataPath()` function to enable this feature.', 'warning');
+}
+export function removeNodeFromSourceParent(updatedTree, sourceNode) {
+  const sourceParent = updatedTree[sourceNode.parent];
+  const sourceChildren = sourceParent.children.filter(id => id !== sourceNode.id);
+  if (sourceChildren.length === 0) {
+    updatedTree[sourceNode.parent] = _extends({}, sourceParent, {
+      type: 'leaf',
+      children: undefined
+    });
+  } else {
+    updatedTree[sourceNode.parent] = _extends({}, sourceParent, {
+      children: sourceChildren
+    });
+  }
+}
+export async function updateLeafPath(sourceNode, targetPath, ctx) {
+  const {
+    apiRef,
+    setTreeDataPath,
+    processRowUpdate,
+    onProcessRowUpdateError
+  } = ctx;
+  const dataRowIdToModelLookup = gridRowsLookupSelector(apiRef);
+  const leafKey = sourceNode.type === 'leaf' ? sourceNode.groupingKey : null;
+  const newPath = leafKey !== null ? [...targetPath, String(leafKey)] : targetPath;
+  const originalRow = dataRowIdToModelLookup[sourceNode.id];
+  const updatedRow = setTreeDataPath(newPath, originalRow);
+  const updater = new BatchRowUpdater(apiRef, processRowUpdate, onProcessRowUpdateError);
+  updater.queueUpdate(sourceNode.id, originalRow, updatedRow);
+  const {
+    successful,
+    updates
+  } = await updater.executeAll();
+  if (successful.length === 0) {
+    return null;
+  }
+  return updates[0];
+}
+export async function updateGroupHierarchyPaths(sourceNode, sourceBasePath, targetPath, ctx) {
+  const {
+    apiRef,
+    setTreeDataPath,
+    processRowUpdate,
+    onProcessRowUpdateError
+  } = ctx;
+  const rowTree = gridRowTreeSelector(apiRef);
+  const dataRowIdToModelLookup = gridRowsLookupSelector(apiRef);
+  const nodesToUpdate = collectAllDescendants(sourceNode, rowTree);
+  nodesToUpdate.unshift(sourceNode); // Include the group itself
+
+  const sourceDepth = sourceBasePath.length;
+  const updater = new BatchRowUpdater(apiRef, processRowUpdate, onProcessRowUpdateError);
+  for (const node of nodesToUpdate) {
+    const originalRow = dataRowIdToModelLookup[node.id];
+    const currentPath = buildTreeDataPath(node, rowTree);
+    const relativePath = currentPath.slice(sourceDepth);
+    const newPath = [...targetPath, ...relativePath];
+    const updatedRow = setTreeDataPath(newPath, originalRow);
+    updater.queueUpdate(node.id, originalRow, updatedRow);
+  }
+  const {
+    successful,
+    updates
+  } = await updater.executeAll();
+  if (successful.length === 0) {
+    return [];
+  }
+  return updates;
+}
+export function updateNodeParentAndDepth(updatedTree, node, newParentId, newDepth) {
+  updatedTree[node.id] = _extends({}, node, {
+    parent: newParentId,
+    depth: newDepth
+  });
+  if (node.type === 'group') {
+    const depthDiff = newDepth - node.depth;
+    updateDescendantDepths(node, updatedTree, depthDiff);
+  }
+}

package/esm/index.js

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

package/esm/internals/index.d.ts

@@ -12,6 +12,7 @@ export { useGridDetailPanel, detailPanelStateInitializer } from "../hooks/featur
 export { useGridDetailPanelPreProcessors } from "../hooks/features/detailPanel/useGridDetailPanelPreProcessors.js";
 export { useGridInfiniteLoader } from "../hooks/features/infiniteLoader/useGridInfiniteLoader.js";
 export { useGridRowReorder, rowReorderStateInitializer } from "../hooks/features/rowReorder/useGridRowReorder.js";
+export { useGridRowsOverridableMethods as useGridRowsOverridableMethodsPro } from "../hooks/features/rows/useGridRowsOverridableMethods.js";
 export { useGridRowReorderPreProcessors } from "../hooks/features/rowReorder/useGridRowReorderPreProcessors.js";
 export type { GridRowReorderPrivateApi } from "../models/gridRowReorderApi.js";
 export { useGridTreeData } from "../hooks/features/treeData/useGridTreeData.js";
@@ -38,4 +39,11 @@ export declare enum RowGroupingStrategy {
   Default = "grouping-columns",
   DataSource = "grouping-columns-data-source",
 }
+export { RowReorderValidator } from "../hooks/features/rowReorder/reorderValidator.js";
+export type { ValidationRule } from "../hooks/features/rowReorder/reorderValidator.js";
+export { RowReorderExecutor, BaseReorderOperation } from "../hooks/features/rowReorder/reorderExecutor.js";
+export { SameParentSwapOperation } from "../hooks/features/treeData/treeDataReorderExecutor.js";
+export type { ReorderExecutionContext, ReorderOperation, ReorderOperationType } from "../hooks/features/rowReorder/types.js";
+export { commonReorderConditions } from "../hooks/features/rowReorder/commonReorderConditions.js";
+export * as rowReorderUtils from "../hooks/features/rowReorder/utils.js";
 export * from "./propValidation.js";

package/esm/internals/index.js

@@ -16,6 +16,7 @@ export { useGridDetailPanel, detailPanelStateInitializer } from "../hooks/featur
 export { useGridDetailPanelPreProcessors } from "../hooks/features/detailPanel/useGridDetailPanelPreProcessors.js";
 export { useGridInfiniteLoader } from "../hooks/features/infiniteLoader/useGridInfiniteLoader.js";
 export { useGridRowReorder, rowReorderStateInitializer } from "../hooks/features/rowReorder/useGridRowReorder.js";
+export { useGridRowsOverridableMethods as useGridRowsOverridableMethodsPro } from "../hooks/features/rows/useGridRowsOverridableMethods.js";
 export { useGridRowReorderPreProcessors } from "../hooks/features/rowReorder/useGridRowReorderPreProcessors.js";
 export { useGridTreeData } from "../hooks/features/treeData/useGridTreeData.js";
 export { useGridTreeDataPreProcessors } from "../hooks/features/treeData/useGridTreeDataPreProcessors.js";
@@ -39,4 +40,9 @@ export let RowGroupingStrategy = /*#__PURE__*/function (RowGroupingStrategy) {
   RowGroupingStrategy["DataSource"] = "grouping-columns-data-source";
   return RowGroupingStrategy;
 }({});
+export { RowReorderValidator } from "../hooks/features/rowReorder/reorderValidator.js";
+export { RowReorderExecutor, BaseReorderOperation } from "../hooks/features/rowReorder/reorderExecutor.js";
+export { SameParentSwapOperation } from "../hooks/features/treeData/treeDataReorderExecutor.js";
+export { commonReorderConditions } from "../hooks/features/rowReorder/commonReorderConditions.js";
+export * as rowReorderUtils from "../hooks/features/rowReorder/utils.js";
 export * from "./propValidation.js";

package/esm/models/dataGridProProps.d.ts

@@ -3,12 +3,14 @@ import { RefObject } from '@mui/x-internals/types';
 import { GridEventListener, GridCallbackDetails, GridRowParams, GridRowId, GridValidRowModel, GridGroupNode, GridFeatureMode, GridListViewColDef, GridGetRowsError, GridUpdateRowError } from '@mui/x-data-grid';
 import type { GridExperimentalFeatures, DataGridPropsWithoutDefaultValue, DataGridPropsWithDefaultValues, DataGridPropsWithComplexDefaultValueAfterProcessing, DataGridPropsWithComplexDefaultValueBeforeProcessing, GridPinnedColumnFields, DataGridProSharedPropsWithDefaultValue, DataGridProSharedPropsWithoutDefaultValue } from '@mui/x-data-grid/internals';
 import type { GridPinnedRowsProp } from "../hooks/features/rowPinning/index.js";
-import { GridApiPro } from "./gridApiPro.js";
+import type { GridApiPro } from "./gridApiPro.js";
 import { GridGroupingColDefOverride, GridGroupingColDefOverrideParams } from "./gridGroupingColDefOverride.js";
-import { GridInitialStatePro } from "./gridStatePro.js";
-import { GridProSlotsComponent } from "./gridProSlotsComponent.js";
+import type { GridInitialStatePro } from "./gridStatePro.js";
+import type { GridProSlotsComponent } from "./gridProSlotsComponent.js";
 import type { GridProSlotProps } from "./gridProSlotProps.js";
-import { GridDataSourcePro as GridDataSource, GridGetRowsParamsPro as GridGetRowsParams } from "../hooks/features/dataSource/models.js";
+import type { GridDataSourcePro as GridDataSource, GridGetRowsParamsPro as GridGetRowsParams } from "../hooks/features/dataSource/models.js";
+import type { ReorderValidationContext } from "../hooks/features/rowReorder/models.js";
+import type { IsRowReorderableParams } from "../hooks/features/rowReorder/index.js";
 export interface GridExperimentalProFeatures extends GridExperimentalFeatures {}
 interface DataGridProPropsWithComplexDefaultValueBeforeProcessing extends Omit<DataGridPropsWithComplexDefaultValueBeforeProcessing, 'components'> {
   /**
@@ -127,6 +129,15 @@ interface DataGridProRegularProps<R extends GridValidRowModel> {
    * @returns {string[]} The path to the row.
    */
   getTreeDataPath?: (row: R) => readonly string[];
+  /**
+   * Updates the tree path in a row model.
+   * Used when reordering rows across different parents in tree data.
+   * @template R
+   * @param {string[]} path The new path for the row.
+   * @param {R} row The row model to update.
+   * @returns {R} The updated row model with the new path.
+   */
+  setTreeDataPath?: (path: string[], row: R) => R;
 }
 export interface DataGridProPropsWithoutDefaultValue<R extends GridValidRowModel = any> extends Omit<DataGridPropsWithoutDefaultValue<R>, 'initialState' | 'componentsProps' | 'slotProps' | 'dataSource' | 'onDataSourceError'>, DataGridProRegularProps<R>, DataGridProSharedPropsWithoutDefaultValue {
   /**
@@ -218,5 +229,22 @@ export interface DataGridProPropsWithoutDefaultValue<R extends GridValidRowModel
    * @param {GridGetRowsError | GridUpdateRowError} error The data source error object.
    */
   onDataSourceError?: (error: GridGetRowsError<GridGetRowsParams> | GridUpdateRowError) => void;
+  /**
+   * Indicates whether a row is reorderable.
+   * @param {object} params With all properties from the row.
+   * @param {R} params.row The row model of the row that the current cell belongs to.
+   * @param {GridTreeNode} params.rowNode The node of the row that the current cell belongs to.
+   * @returns {boolean} A boolean indicating if the row is reorderable.
+   */
+  isRowReorderable?: (params: IsRowReorderableParams) => boolean;
+  /**
+   * Indicates if a row reorder attempt is valid.
+   * Can be used to disable certain row reorder operations based on the context.
+   * The internal validation is still applied, preventing unsupported use-cases.
+   * Use `isValidRowReorder()` to add additional validation rules to the default ones.
+   * @param {ReorderValidationContext} context The context object containing all information about the reorder operation.
+   * @returns {boolean} A boolean indicating if the reorder operation should go through.
+   */
+  isValidRowReorder?: (context: ReorderValidationContext) => boolean;
 }
 export {};

package/esm/models/gridRowOrderChangeParams.d.ts

@@ -1,18 +1,42 @@
-import { GridRowModel } from '@mui/x-data-grid';
+import { GridRowModel, GridRowId } from '@mui/x-data-grid';
 /**
  * Object passed as parameter of the row order change event.
+ * @demos
+ *   - [Flat row reordering](/x/react-data-grid/row-ordering/#implementing-row-reordering)
+ *   - [Tree data reordering](/x/react-data-grid/tree-data/#drag-and-drop-tree-data-reordering)
+ *   - [Row grouping reordering](/x/react-data-grid/row-grouping/#drag-and-drop-group-reordering)
  */
 export interface GridRowOrderChangeParams {
   /**
-   * The row data.
+   * The row data of the primary row being moved.
+   * For group moves, this represents the group row itself.
+   * Descendants move should be handled as data updates. e.g. using `processRowUpdate()`
    */
   row: GridRowModel;
   /**
-   * The target row index.
+   * The old index of the row.
+   * - For flat data: Position in the flat array.
+   * - For nested data: Position within oldParent's children array (0-based).
+   */
+  oldIndex: number;
+  /**
+   * The target index of the row.
+   * - For flat data: New position in the flat array.
+   * - For nested data: Position within newParent's children array (0-based).
    */
   targetIndex: number;
   /**
-   * The old row index.
+   * The parent row ID before the move.
+   * - For flat data: `null`
+   * - For nested row at root level: `null`.
+   * - For nested row at levels below root: Parent row's ID.
    */
-  oldIndex: number;
+  oldParent: GridRowId | null;
+  /**
+   * The parent row ID after the move.
+   * - For flat data: `null`.
+   * - For nested row at root level: `null`.
+   * - For nested row at levels below root: Parent row's ID.
+   */
+  newParent: GridRowId | null;
 }

package/hooks/features/dataSource/useGridDataSourceBasePro.js

@@ -141,7 +141,7 @@ const useGridDataSourceBasePro = (apiRef, props, options = {}) => {
           params: fetchParams,
           cause: childrenFetchError
         }));
-      } else if (process.env.NODE_ENV !== 'production') {
+      } else {
         (0, _warning.warnOnce)(['MUI X: A call to `dataSource.getRows()` threw an error which was not handled because `onDataSourceError()` is missing.', 'To handle the error pass a callback to the `onDataSourceError` prop, for example `<DataGrid onDataSourceError={(error) => ...} />`.', 'For more detail, see https://mui.com/x/react-data-grid/server-side-data/#error-handling.'], 'error');
       }
     } finally {

package/hooks/features/rowReorder/commonReorderConditions.d.ts

@@ -0,0 +1,30 @@
+import type { ReorderValidationContext as Ctx } from "./models.js";
+/**
+ * Reusable validation conditions for row reordering validation
+ */
+export declare const commonReorderConditions: {
+  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;
+};

package/hooks/features/rowReorder/commonReorderConditions.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.commonReorderConditions = void 0;
+var _xDataGrid = require("@mui/x-data-grid");
+/**
+ * Reusable validation conditions for row reordering validation
+ */
+const commonReorderConditions = exports.commonReorderConditions = {
+  // 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 = (0, _xDataGrid.gridRowTreeSelector)(ctx.apiRef)[currentId];
+      if (!node) {
+        break;
+      }
+      currentId = node.parent;
+    }
+    return false;
+  },
+  // Position checks
+  isAdjacentPosition: ctx => {
+    const expandedSortedRowIndexLookup = (0, _xDataGrid.gridExpandedSortedRowIndexLookupSelector)(ctx.apiRef);
+    const sourceRowIndex = expandedSortedRowIndexLookup[ctx.sourceNode.id];
+    const targetRowIndex = expandedSortedRowIndexLookup[ctx.targetNode.id];
+    const dropPosition = ctx.dropPosition;
+    return dropPosition === 'above' && targetRowIndex === sourceRowIndex + 1 || dropPosition === 'below' && targetRowIndex === sourceRowIndex - 1;
+  },
+  // First child check
+  targetFirstChildIsGroupWithSourceDepth: ctx => {
+    if (ctx.targetNode.type !== 'group') {
+      return false;
+    }
+    const rowTree = (0, _xDataGrid.gridRowTreeSelector)(ctx.apiRef);
+    const targetGroup = ctx.targetNode;
+    const firstChild = targetGroup.children?.[0] ? rowTree[targetGroup.children[0]] : null;
+    return firstChild?.type === 'group' && firstChild.depth === ctx.sourceNode.depth;
+  },
+  targetFirstChildDepthEqualsSource: ctx => {
+    if (ctx.targetNode.type !== 'group') {
+      return false;
+    }
+    const rowTree = (0, _xDataGrid.gridRowTreeSelector)(ctx.apiRef);
+    const targetGroup = ctx.targetNode;
+    const firstChild = targetGroup.children?.[0] ? rowTree[targetGroup.children[0]] : null;
+    return firstChild ? firstChild.depth === ctx.sourceNode.depth : false;
+  }
+};

package/hooks/features/rowReorder/index.d.ts

@@ -1 +1,2 @@
-export * from "./gridRowReorderColDef.js";
+export * from "./gridRowReorderColDef.js";
+export type { ReorderValidationContext, IsRowReorderableParams } from "./models.js";

package/hooks/features/rowReorder/models.d.ts

@@ -0,0 +1,17 @@
+import { GridTreeNode, GridValidRowModel } from '@mui/x-data-grid';
+import type { RefObject } from '@mui/x-internals/types';
+import type { RowReorderDropPosition, RowReorderDragDirection } from '@mui/x-data-grid/internals';
+import type { GridPrivateApiPro } from "../../../models/gridApiPro.js";
+export type IsRowReorderableParams<R extends GridValidRowModel = any> = {
+  row: R;
+  rowNode: GridTreeNode;
+};
+export type ReorderValidationContext = {
+  apiRef: RefObject<GridPrivateApiPro>;
+  sourceNode: GridTreeNode;
+  targetNode: GridTreeNode;
+  prevNode: GridTreeNode | null;
+  nextNode: GridTreeNode | null;
+  dropPosition: RowReorderDropPosition;
+  dragDirection: RowReorderDragDirection;
+};

package/hooks/features/rowReorder/models.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

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

@@ -0,0 +1,27 @@
+import type { ReorderExecutionContext, ReorderOperation } from "./types.js";
+/**
+ * Base class for all reorder operations.
+ * Provides abstract methods for operation detection and execution.
+ */
+export declare abstract class BaseReorderOperation {
+  abstract readonly operationType: string;
+  /**
+   * Detects if this operation can handle the given context.
+   */
+  abstract detectOperation(ctx: ReorderExecutionContext): ReorderOperation | null;
+  /**
+   * Executes the detected operation.
+   */
+  abstract executeOperation(operation: ReorderOperation, ctx: ReorderExecutionContext): Promise<void> | void;
+}
+/**
+ * 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.
+ */
+export declare class RowReorderExecutor {
+  private operations;
+  constructor(operations: BaseReorderOperation[]);
+  execute(ctx: ReorderExecutionContext): Promise<void>;
+}

package/hooks/features/rowReorder/reorderExecutor.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RowReorderExecutor = exports.BaseReorderOperation = void 0;
+var _warning = require("@mui/x-internals/warning");
+/**
+ * Base class for all reorder operations.
+ * Provides abstract methods for operation detection and execution.
+ */
+class BaseReorderOperation {}
+
+/**
+ * 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.
+ */
+exports.BaseReorderOperation = BaseReorderOperation;
+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;
+      }
+    }
+    (0, _warning.warnOnce)(['MUI X: The parameters provided to the API method resulted in a no-op.', 'Consider looking at the documentation at https://mui.com/x/react-data-grid/row-ordering/'], 'warning');
+  }
+}
+exports.RowReorderExecutor = RowReorderExecutor;

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

@@ -0,0 +1,12 @@
+import { ReorderValidationContext } from "./models.js";
+export interface ValidationRule {
+  name: string;
+  applies: (ctx: ReorderValidationContext) => boolean;
+  isInvalid: (ctx: ReorderValidationContext) => boolean;
+  message?: string;
+}
+export declare class RowReorderValidator {
+  private rules;
+  constructor(rules: ValidationRule[]);
+  validate(context: ReorderValidationContext): boolean;
+}

package/hooks/features/rowReorder/reorderValidator.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RowReorderValidator = void 0;
+class RowReorderValidator {
+  constructor(rules) {
+    this.rules = rules;
+  }
+  validate(context) {
+    // Check all validation rules
+    for (const rule of this.rules) {
+      if (rule.applies(context) && rule.isInvalid(context)) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
+exports.RowReorderValidator = RowReorderValidator;

package/hooks/features/rowReorder/types.d.ts

@@ -0,0 +1,25 @@
+import type { GridRowId, GridTreeNode, GridRowTreeConfig } from '@mui/x-data-grid';
+import type { RefObject } from '@mui/x-internals/types';
+import type { RowReorderDropPosition } from '@mui/x-data-grid/internals';
+import type { GridPrivateApiPro } from "../../../models/gridApiPro.js";
+import type { DataGridProProcessedProps } from "../../../models/dataGridProProps.js";
+export type ReorderOperationType = 'same-parent-swap' | 'cross-parent-leaf' | 'cross-parent-group' | 'drop-on-leaf' | 'drop-on-group';
+export interface ReorderExecutionContext<ApiRef extends GridPrivateApiPro = GridPrivateApiPro> {
+  sourceRowId: GridRowId;
+  dropPosition: RowReorderDropPosition;
+  placeholderIndex: number;
+  sortedFilteredRowIds: GridRowId[];
+  sortedFilteredRowIndexLookup: Record<GridRowId, number>;
+  rowTree: GridRowTreeConfig;
+  apiRef: RefObject<ApiRef>;
+  processRowUpdate?: DataGridProProcessedProps['processRowUpdate'];
+  onProcessRowUpdateError?: DataGridProProcessedProps['onProcessRowUpdateError'];
+  setTreeDataPath?: DataGridProProcessedProps['setTreeDataPath'];
+}
+export interface ReorderOperation {
+  sourceNode: GridTreeNode;
+  targetNode: GridTreeNode;
+  actualTargetIndex: number;
+  isLastChild: boolean;
+  operationType: ReorderOperationType;
+}

package/hooks/features/rowReorder/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/hooks/features/rowReorder/useGridRowReorder.d.ts

@@ -7,4 +7,4 @@ export declare const rowReorderStateInitializer: GridStateInitializer;
  * Hook for row reordering (Pro package)
  * @requires useGridRows (method)
  */
-export declare const useGridRowReorder: (apiRef: RefObject<GridPrivateApiPro>, props: Pick<DataGridProProcessedProps, "rowReordering" | "onRowOrderChange" | "classes" | "treeData" | "dataSource">) => void;
+export declare const useGridRowReorder: (apiRef: RefObject<GridPrivateApiPro>, props: Pick<DataGridProProcessedProps, "rowReordering" | "onRowOrderChange" | "classes" | "treeData" | "dataSource" | "isValidRowReorder">) => void;