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

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

@@ -1,343 +0,0 @@
-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/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/hooks/features/rowReorder/reorderExecutor.js

@@ -1,31 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.rowGroupingReorderExecutor = void 0;
-var _warning = require("@mui/x-internals/warning");
-var _operations = require("./operations");
-/**
- * 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;
-      }
-    }
-    (0, _warning.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');
-  }
-}
-const rowGroupingReorderExecutor = exports.rowGroupingReorderExecutor = new RowReorderExecutor([new _operations.SameParentSwapOperation(), new _operations.CrossParentLeafOperation(), new _operations.CrossParentGroupOperation()]);

package/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/hooks/features/rowReorder/reorderValidator.js

@@ -1,122 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.rowGroupingReorderValidator = void 0;
-var _utils = require("./utils");
-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 => _utils.conditions.isAdjacentPosition(ctx),
-  isInvalid: () => true,
-  message: 'Source and target are adjacent'
-}, {
-  name: 'group-to-leaf',
-  applies: _utils.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 => _utils.conditions.isGroupToGroup(ctx) && _utils.conditions.isDropAbove(ctx) && _utils.conditions.prevIsLeaf(ctx),
-  isInvalid: _utils.conditions.prevBelongsToSource,
-  message: 'Previous leaf belongs to source group or its descendants'
-}, {
-  name: 'group-to-group-above-invalid-depth',
-  applies: ctx => _utils.conditions.isGroupToGroup(ctx) && _utils.conditions.isDropAbove(ctx) && !_utils.conditions.sameDepth(ctx) && !(ctx.targetNode.depth < ctx.sourceNode.depth && (_utils.conditions.prevIsLeaf(ctx) || _utils.conditions.prevIsGroup(ctx) && _utils.conditions.prevDepthEqualsSource(ctx))),
-  isInvalid: () => true,
-  message: 'Invalid depth configuration for group above group'
-}, {
-  name: 'group-to-group-above-different-parent-depth',
-  applies: ctx => _utils.conditions.isGroupToGroup(ctx) && _utils.conditions.isDropAbove(ctx) && _utils.conditions.prevIsGroup(ctx) && _utils.conditions.prevDepthEqualsSource(ctx) && _utils.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 => _utils.conditions.isGroupToGroup(ctx) && _utils.conditions.isDropBelow(ctx),
-  isInvalid: ctx => {
-    // Valid case 1: Same depth and target not expanded
-    if (_utils.conditions.sameDepth(ctx) && _utils.conditions.targetGroupCollapsed(ctx)) {
-      return false;
-    }
-    // Valid case 2: Target is parent level, expanded, with compatible first child
-    if (_utils.conditions.targetDepthIsSourceMinusOne(ctx) && _utils.conditions.targetGroupExpanded(ctx) && _utils.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 => _utils.conditions.isLeafToLeaf(ctx) && !_utils.conditions.sameDepth(ctx),
-  isInvalid: () => true,
-  message: 'Leaves at different depths cannot be reordered'
-}, {
-  name: 'leaf-to-leaf-invalid-below',
-  applies: ctx => _utils.conditions.isLeafToLeaf(ctx) && _utils.conditions.sameDepth(ctx) && !_utils.conditions.sameParent(ctx) && _utils.conditions.isDropBelow(ctx),
-  isInvalid: ctx => !(_utils.conditions.nextIsGroup(ctx) && ctx.sourceNode.depth > ctx.nextNode.depth) && !_utils.conditions.nextIsLeaf(ctx),
-  message: 'Invalid leaf below leaf configuration'
-},
-// ===== Leaf to Group Rules =====
-{
-  name: 'leaf-to-group-above-no-prev-leaf',
-  applies: ctx => _utils.conditions.isLeafToGroup(ctx) && _utils.conditions.isDropAbove(ctx),
-  isInvalid: ctx => !_utils.conditions.hasPrevNode(ctx) || !_utils.conditions.prevIsLeaf(ctx),
-  message: 'No valid previous leaf for leaf above group'
-}, {
-  name: 'leaf-to-group-above-depth-mismatch',
-  applies: ctx => _utils.conditions.isLeafToGroup(ctx) && _utils.conditions.isDropAbove(ctx) && _utils.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 => _utils.conditions.isLeafToGroup(ctx) && _utils.conditions.isDropBelow(ctx),
-  isInvalid: _utils.conditions.targetGroupCollapsed,
-  message: 'Cannot drop below collapsed group'
-}, {
-  name: 'leaf-to-group-below-invalid-depth',
-  applies: ctx => _utils.conditions.isLeafToGroup(ctx) && _utils.conditions.isDropBelow(ctx) && _utils.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 (_utils.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;
-  }
-}
-const rowGroupingReorderValidator = exports.rowGroupingReorderValidator = new RowReorderValidator(validationRules);

package/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/hooks/features/rowReorder/types.js

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