@mui/x-data-grid-premium 8.24.0 → 8.26.0

package/esm/hooks/features/history/useGridHistory.js

@@ -0,0 +1,294 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { isObjectEmpty } from '@mui/x-internals/isObjectEmpty';
+import debounce from '@mui/utils/debounce';
+import { useGridEvent, useGridApiMethod, isUndoShortcut, isRedoShortcut, runIf, useGridNativeEventListener } from '@mui/x-data-grid-pro/internals';
+import { gridHistoryCurrentPositionSelector, gridHistoryStackSelector, gridHistoryCanUndoSelector, gridHistoryCanRedoSelector } from "./gridHistorySelectors.js";
+import { createDefaultHistoryHandlers } from "./defaultHistoryHandlers.js";
+export const historyStateInitializer = state => {
+  return _extends({}, state, {
+    history: {
+      stack: [],
+      currentPosition: -1,
+      enabled: false
+    }
+  });
+};
+export const useGridHistory = (apiRef, props) => {
+  const {
+    historyStackSize,
+    onUndo,
+    onRedo,
+    historyValidationEvents
+  } = props;
+
+  // Use default history events if none provided
+  const historyEventHandlers = React.useMemo(() => {
+    if (props.historyEventHandlers && !isObjectEmpty(props.historyEventHandlers)) {
+      return props.historyEventHandlers;
+    }
+    return createDefaultHistoryHandlers(apiRef, {
+      dataSource: props.dataSource,
+      columns: props.columns,
+      isCellEditable: props.isCellEditable
+    });
+  }, [apiRef, props.columns, props.isCellEditable, props.dataSource, props.historyEventHandlers]);
+  const isEnabled = React.useMemo(() => historyStackSize > 0 && !isObjectEmpty(historyEventHandlers), [historyStackSize, historyEventHandlers]);
+  const isValidationNeeded = React.useMemo(() => isEnabled && historyValidationEvents.length > 0 && Object.values(historyEventHandlers).some(handler => handler.validate), [isEnabled, historyEventHandlers, historyValidationEvents]);
+
+  // Internal ref to track undo/redo operation state
+  // - 'idle': everything is done
+  // - 'in-progress': during async undo/redo handler execution (skip validation and prevent the state change by other events)
+  // - 'waiting-replay': after undo/redo handler is done, the validation event is triggered again (as undo/redo is changing the state).
+  //   In this hook we want to skip the replayed event.
+  const operationStateRef = React.useRef('idle');
+
+  // History event unsubscribers
+  const eventUnsubscribersRef = React.useRef([]);
+  // Validation event unsubscribers
+  const validationEventUnsubscribersRef = React.useRef([]);
+  const updateHistoryState = React.useCallback(newState => {
+    apiRef.current.setState(state => _extends({}, state, {
+      history: _extends({}, state.history, newState)
+    }));
+  }, [apiRef]);
+  const addToStack = React.useCallback(item => {
+    const currentPosition = gridHistoryCurrentPositionSelector(apiRef);
+    let newStack = [...gridHistoryStackSelector(apiRef)];
+
+    // If we're not at the end of the stack, truncate forward history
+    if (currentPosition < newStack.length - 1) {
+      newStack = newStack.slice(0, currentPosition + 1);
+    }
+
+    // Add the new item
+    newStack.push(item);
+
+    // If stack exceeds size, remove oldest items
+    if (newStack.length > historyStackSize) {
+      newStack = newStack.slice(newStack.length - historyStackSize);
+    }
+    updateHistoryState({
+      stack: newStack,
+      currentPosition: newStack.length - 1
+    });
+  }, [apiRef, updateHistoryState, historyStackSize]);
+  const clear = React.useCallback(() => {
+    updateHistoryState({
+      stack: [],
+      currentPosition: -1
+    });
+  }, [updateHistoryState]);
+  const clearUndoItems = React.useCallback(() => {
+    const stack = gridHistoryStackSelector(apiRef);
+    const currentPosition = gridHistoryCurrentPositionSelector(apiRef);
+
+    // If we're at the end of the stack (no redo items), clear everything
+    if (currentPosition >= stack.length - 1) {
+      clear();
+    } else {
+      updateHistoryState({
+        stack: stack.slice(currentPosition + 1),
+        currentPosition: -1
+      });
+    }
+  }, [apiRef, clear, updateHistoryState]);
+  const clearRedoItems = React.useCallback(() => {
+    const stack = gridHistoryStackSelector(apiRef);
+    const currentPosition = gridHistoryCurrentPositionSelector(apiRef);
+    updateHistoryState({
+      stack: stack.slice(0, currentPosition + 1)
+    });
+  }, [apiRef, updateHistoryState]);
+  const canUndo = React.useCallback(() => gridHistoryCanUndoSelector(apiRef), [apiRef]);
+  const canRedo = React.useCallback(() => gridHistoryCanRedoSelector(apiRef), [apiRef]);
+  const validateStackItems = React.useCallback(() => {
+    /**
+     * When:
+     * - idle: continue with the validation
+     * - in-progress: skip the validation and don't change the state
+     * - waiting-replay: skip the validation this time and reset the state to idle
+     */
+    if (operationStateRef.current !== 'idle') {
+      if (operationStateRef.current === 'waiting-replay') {
+        operationStateRef.current = 'idle';
+      }
+      return;
+    }
+    const stack = gridHistoryStackSelector(apiRef);
+    const currentPosition = gridHistoryCurrentPositionSelector(apiRef);
+    if (historyStackSize === 0) {
+      if (stack.length > 0) {
+        clear();
+      }
+      return;
+    }
+    if (stack.length === 0) {
+      return;
+    }
+    const newStack = [...stack];
+
+    // Redo check
+    if (currentPosition + 1 < newStack.length) {
+      const item = newStack[currentPosition + 1];
+      const handler = historyEventHandlers[item.eventName];
+      if (!handler) {
+        clearRedoItems();
+      } else {
+        const isValid = handler.validate ? handler.validate(item.data, 'redo') : true;
+        if (!isValid) {
+          clearRedoItems();
+        }
+      }
+    }
+
+    // Undo check
+    if (currentPosition >= 0) {
+      const item = newStack[currentPosition];
+      const handler = historyEventHandlers[item.eventName];
+      if (!handler) {
+        clearUndoItems();
+      } else {
+        const isValid = handler.validate ? handler.validate(item.data, 'undo') : true;
+        if (!isValid) {
+          clearUndoItems();
+        }
+      }
+    }
+  }, [apiRef, historyEventHandlers, historyStackSize, clear, clearUndoItems, clearRedoItems]);
+  const debouncedValidateStackItems = React.useMemo(() => debounce(validateStackItems, 0), [validateStackItems]);
+  const apply = React.useCallback(async (item, operation) => {
+    const currentPosition = gridHistoryCurrentPositionSelector(apiRef);
+    const clearMethod = operation === 'undo' ? clearUndoItems : clearRedoItems;
+    const {
+      eventName,
+      data
+    } = item;
+    const handler = historyEventHandlers[eventName];
+    if (!handler) {
+      // If the handler is not found, it means tha we are updating the handlers map, so we can igore this request
+      return false;
+    }
+    const isValid = handler.validate ? handler.validate(data, operation) : true;
+
+    // The data is validated every time state change event happens.
+    // We can get into a situation where the operation is not valid at this point only with the direct state updates.
+    if (!isValid) {
+      // Clear history and return false
+      clearMethod();
+      return false;
+    }
+
+    // Execute the operation
+    operationStateRef.current = 'in-progress';
+    await handler[operation](data);
+    operationStateRef.current = 'waiting-replay';
+    updateHistoryState({
+      currentPosition: operation === 'undo' ? currentPosition - 1 : currentPosition + 1
+    });
+    apiRef.current.publishEvent(operation, {
+      eventName,
+      data
+    });
+    // If there are no validations in the current setup, skip calling it and change the operation state to idle
+    if (isValidationNeeded) {
+      validateStackItems();
+    } else {
+      operationStateRef.current = 'idle';
+    }
+    return true;
+  }, [apiRef, isValidationNeeded, historyEventHandlers, clearUndoItems, clearRedoItems, updateHistoryState, validateStackItems]);
+  const undo = React.useCallback(async () => {
+    if (!canUndo()) {
+      return false;
+    }
+    const stack = gridHistoryStackSelector(apiRef);
+    const currentPosition = gridHistoryCurrentPositionSelector(apiRef);
+    return apply(stack[currentPosition], 'undo');
+  }, [apiRef, apply, canUndo]);
+  const redo = React.useCallback(async () => {
+    if (!canRedo()) {
+      return false;
+    }
+    const stack = gridHistoryStackSelector(apiRef);
+    const currentPosition = gridHistoryCurrentPositionSelector(apiRef);
+    return apply(stack[currentPosition + 1], 'redo');
+  }, [apiRef, apply, canRedo]);
+  const historyApi = {
+    undo,
+    redo,
+    clear,
+    canUndo,
+    canRedo
+  };
+  useGridApiMethod(apiRef, {
+    history: historyApi
+  }, 'public');
+  const handleKeyDown = React.useCallback(async event => {
+    if (!isUndoShortcut(event) && !isRedoShortcut(event)) {
+      return;
+    }
+    const action = isUndoShortcut(event) ? apiRef.current.history.undo : apiRef.current.history.redo;
+    event.preventDefault();
+    event.stopPropagation();
+    await action();
+  }, [apiRef]);
+  useGridNativeEventListener(apiRef, () => apiRef.current.rootElementRef.current, 'keydown', runIf(isEnabled, handleKeyDown));
+  useGridEvent(apiRef, 'undo', onUndo);
+  useGridEvent(apiRef, 'redo', onRedo);
+  React.useEffect(() => {
+    updateHistoryState({
+      enabled: isEnabled
+    });
+  }, [isEnabled, updateHistoryState]);
+  React.useEffect(() => {
+    if (!isValidationNeeded) {
+      return () => {};
+    }
+    historyValidationEvents.forEach(eventName => {
+      validationEventUnsubscribersRef.current.push(apiRef.current.subscribeEvent(eventName, debouncedValidateStackItems));
+    });
+    return () => {
+      validationEventUnsubscribersRef.current.forEach(unsubscribe => unsubscribe());
+      validationEventUnsubscribersRef.current = [];
+    };
+  }, [apiRef, isValidationNeeded, historyValidationEvents, debouncedValidateStackItems]);
+  React.useEffect(() => {
+    if (historyStackSize === 0) {
+      return () => {};
+    }
+    const events = Object.keys(historyEventHandlers);
+    // Subscribe to all events in the map
+    events.forEach(eventName => {
+      const handler = historyEventHandlers[eventName];
+      const unsubscribe = apiRef.current.subscribeEvent(eventName, (...params) => {
+        // Don't store if the event was triggered by undo/redo
+        if (operationStateRef.current !== 'idle') {
+          return;
+        }
+        const data = handler.store(...params);
+        if (data !== null) {
+          addToStack({
+            eventName,
+            data
+          });
+        }
+      });
+      eventUnsubscribersRef.current.push(unsubscribe);
+    });
+    return () => {
+      eventUnsubscribersRef.current.forEach(unsubscribe => unsubscribe());
+      eventUnsubscribersRef.current = [];
+    };
+  }, [apiRef, historyEventHandlers, historyStackSize, addToStack]);
+
+  // If the stack size is changed and it is smaller than the current stack size, clear the stack
+  React.useEffect(() => {
+    const currentStackSize = gridHistoryStackSelector(apiRef).length;
+    if (currentStackSize > historyStackSize) {
+      clear();
+    }
+  }, [apiRef, historyStackSize, clear]);
+};

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

@@ -4,4 +4,5 @@ export * from "./export/index.js";
 export * from "./cellSelection/index.js";
 export * from "./aiAssistant/index.js";
 export * from "./sidebar/index.js";
-export * from "./pivoting/index.js";
+export * from "./pivoting/index.js";
+export * from "./history/index.js";

package/esm/hooks/features/index.js

@@ -5,4 +5,5 @@ export * from "./export/index.js";
 export * from "./cellSelection/index.js";
 export * from "./aiAssistant/index.js";
 export * from "./sidebar/index.js";
-export * from "./pivoting/index.js";
+export * from "./pivoting/index.js";
+export * from "./history/index.js";

package/esm/hooks/utils/useGridChartIntegration.js

@@ -1,3 +1,5 @@
+'use client';
+
 import * as React from 'react';
 import { GridChartsIntegrationContext } from "../../components/chartsIntegration/GridChartsIntegrationContext.js";
 export const useGridChartsIntegrationContext = (ignoreError = false) => {

package/esm/index.js

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

package/esm/models/dataGridPremiumProps.d.ts

@@ -1,5 +1,5 @@
 import { RefObject } from '@mui/x-internals/types';
-import { GridCallbackDetails, GridValidRowModel, GridGroupNode, GridEventListener, GridGetRowsError, GridUpdateRowError, type GridColDef, GridLocaleTextApi } from '@mui/x-data-grid-pro';
+import { GridCallbackDetails, GridValidRowModel, GridGroupNode, GridEventListener, GridGetRowsError, GridUpdateRowError, type GridColDef, GridLocaleTextApi, type GridEvents } from '@mui/x-data-grid-pro';
 import { GridExperimentalProFeatures, DataGridProPropsWithDefaultValue, DataGridProPropsWithoutDefaultValue, DataGridPropsWithComplexDefaultValueAfterProcessing, DataGridPropsWithComplexDefaultValueBeforeProcessing, DataGridPremiumSharedPropsWithDefaultValue } from '@mui/x-data-grid-pro/internals';
 import type { GridRowGroupingModel } from "../hooks/features/rowGrouping/index.js";
 import type { GridAggregationModel, GridAggregationFunction, GridAggregationFunctionDataSource, GridAggregationPosition } from "../hooks/features/aggregation/index.js";
@@ -11,6 +11,7 @@ import { GridCellSelectionModel } from "../hooks/features/cellSelection/index.js
 import type { GridPivotingColDefOverrides, PivotingColDefCallback, GridPivotModel } from "../hooks/features/pivoting/gridPivotingInterfaces.js";
 import { GridDataSourcePremium as GridDataSource, GridGetRowsParamsPremium as GridGetRowsParams } from "../hooks/features/dataSource/models.js";
 import { Conversation, PromptResponse, PromptSuggestion } from "../hooks/features/aiAssistant/gridAiAssistantInterfaces.js";
+import type { GridHistoryEventHandler } from "../hooks/features/history/gridHistoryInterfaces.js";
 export interface GridExperimentalPremiumFeatures extends GridExperimentalProFeatures {
   charts?: boolean;
 }
@@ -101,6 +102,22 @@ export interface DataGridPremiumPropsWithDefaultValue<R extends GridValidRowMode
    * @default false
    */
   chartsIntegration: boolean;
+  /**
+   * The maximum size of the history stack.
+   * Set to 0 to disable the undo/redo feature.
+   * @default 30
+   */
+  historyStackSize: number;
+  /**
+   * Map of grid events to their undo/redo handlers.
+   * @default Handlers for `rowEditStop`, `cellEditStop` and `clipboardPasteEnd` events
+   */
+  historyEventHandlers: Record<GridEvents, GridHistoryEventHandler<any>>;
+  /**
+   * List of grid events after which the history stack items should be re-validated.
+   * @default ['columnsChange', 'rowsSet', 'sortedRowsSet', 'filteredRowsSet', 'paginationModelChange']
+   */
+  historyValidationEvents: GridEvents[];
 }
 export interface DataGridPremiumPropsWithoutDefaultValue<R extends GridValidRowModel = any> extends Omit<DataGridProPropsWithoutDefaultValue<R>, 'initialState' | 'apiRef' | 'dataSource' | 'onDataSourceError'> {
   /**
@@ -292,4 +309,12 @@ export interface DataGridPremiumPropsWithoutDefaultValue<R extends GridValidRowM
    * @param {string} activeChartId The new active chart id.
    */
   onActiveChartIdChange?: (activeChartId: string) => void;
+  /**
+   * Callback fired when an undo operation is executed.
+   */
+  onUndo?: GridEventListener<'undo'>;
+  /**
+   * Callback fired when a redo operation is executed.
+   */
+  onRedo?: GridEventListener<'redo'>;
 }

package/esm/models/gridApiPremium.d.ts

@@ -11,9 +11,10 @@ import type { GridPivotingApi, GridPivotingPrivateApi } from "../hooks/features/
 import { GridAiAssistantApi } from "../hooks/features/aiAssistant/gridAiAssistantInterfaces.js";
 import { GridSidebarApi } from "../hooks/features/sidebar/gridSidebarInterfaces.js";
 import { GridChartsIntegrationApi, GridChartsIntegrationPrivateApi } from "../hooks/features/chartsIntegration/gridChartsIntegrationInterfaces.js";
+import type { GridHistoryApi } from "../hooks/features/history/gridHistoryInterfaces.js";
 /**
  * The api of Data Grid Premium.
  * TODO: Do not redefine manually the pro features
  */
-export interface GridApiPremium extends GridApiCommon<GridStatePremium, GridInitialStatePremium>, GridRowProApi, GridColumnPinningApi, GridDetailPanelApi, GridRowGroupingApi, GridExcelExportApi, GridAggregationApi, GridRowPinningApi, GridDataSourceApiPremium, GridCellSelectionApi, GridPivotingApi, GridAiAssistantApi, GridSidebarApi, GridChartsIntegrationApi, GridRowMultiSelectionApi, GridColumnReorderApi {}
+export interface GridApiPremium extends GridApiCommon<GridStatePremium, GridInitialStatePremium>, GridRowProApi, GridColumnPinningApi, GridDetailPanelApi, GridRowGroupingApi, GridExcelExportApi, GridAggregationApi, GridRowPinningApi, GridDataSourceApiPremium, GridCellSelectionApi, GridPivotingApi, GridAiAssistantApi, GridSidebarApi, GridChartsIntegrationApi, GridHistoryApi, GridRowMultiSelectionApi, GridColumnReorderApi {}
 export interface GridPrivateApiPremium extends GridApiPremium, GridPrivateOnlyApiCommon<GridApiPremium, GridPrivateApiPremium, DataGridPremiumProcessedProps>, GridDataSourcePremiumPrivateApi, GridAggregationPrivateApi, GridDetailPanelPrivateApi, GridRowReorderPrivateApi, GridPivotingPrivateApi, GridChartsIntegrationPrivateApi {}

package/esm/models/gridStatePremium.d.ts

@@ -4,6 +4,7 @@ import type { GridPivotingInitialState, GridPivotingState } from "../hooks/featu
 import type { GridAiAssistantInitialState, GridAiAssistantState } from "../hooks/features/aiAssistant/gridAiAssistantInterfaces.js";
 import type { GridSidebarInitialState, GridSidebarState } from "../hooks/features/sidebar/gridSidebarState.js";
 import type { GridChartsIntegrationState, GridChartsIntegrationInitialState } from "../hooks/features/chartsIntegration/gridChartsIntegrationInterfaces.js";
+import type { GridHistoryState } from "../hooks/features/history/gridHistoryInterfaces.js";
 /**
  * The state of Data Grid Premium.
  */
@@ -15,6 +16,7 @@ export interface GridStatePremium extends GridStatePro {
   aiAssistant: GridAiAssistantState;
   sidebar: GridSidebarState;
   chartsIntegration: GridChartsIntegrationState;
+  history: GridHistoryState;
 }
 /**
  * The initial state of Data Grid Premium.

package/esm/typeOverloads/modules.d.ts

@@ -1,4 +1,4 @@
-import type { GridExportDisplayOptions, GridValidRowModel } from '@mui/x-data-grid-pro';
+import { GridEventLookup, GridExportDisplayOptions, GridRowId, GridValidRowModel } from '@mui/x-data-grid-pro';
 import type { GridAggregationCellMeta } from '@mui/x-data-grid-pro/internals';
 import type { GridPipeProcessingLookupPro, GridControlledStateEventLookupPro, GridApiCachesPro, GridEventLookupPro } from '@mui/x-data-grid-pro/typeOverloads';
 import type { GridGroupingValueGetter, GridGroupingValueSetter, GridPastedValueParser } from "../models/index.js";
@@ -79,7 +79,12 @@ interface GridEventLookupPremium extends GridEventLookupPro {
   /**
    * Fired when the clipboard paste operation ends.
    */
-  clipboardPasteEnd: {};
+  clipboardPasteEnd: {
+    params: {
+      oldRows: Map<GridRowId, GridValidRowModel>;
+      newRows: Map<GridRowId, GridValidRowModel>;
+    };
+  };
   /**
    * Fired when the sidebar is opened.
    */
@@ -105,6 +110,24 @@ interface GridEventLookupPremium extends GridEventLookupPro {
       synced: boolean;
     };
   };
+  /**
+   * Fired when an undo operation is executed.
+   */
+  undo: {
+    params: {
+      eventName: keyof GridEventLookup;
+      data: any;
+    };
+  };
+  /**
+   * Fired when a redo operation is executed.
+   */
+  redo: {
+    params: {
+      eventName: keyof GridEventLookup;
+      data: any;
+    };
+  };
 }
 export interface GridColDefPremium<R extends GridValidRowModel = any, V = any, F = V> {
   /**

package/esm/typeOverloads/modules.js

@@ -1 +1,5 @@
-export {};
+import { GridEventLookup } from '@mui/x-data-grid-pro';
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars

package/hooks/features/aggregation/useGridAggregationPreProcessors.js

@@ -1,4 +1,5 @@
 "use strict";
+'use client';
 
 var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;

package/hooks/features/clipboard/useGridClipboardImport.js

@@ -61,7 +61,7 @@ async function getTextFromClipboard(rootEl) {
 
 // Keeps track of updated rows during clipboard paste
 class CellValueUpdater {
-  rowsToUpdate = {};
+  rowsToUpdate = new Map();
   constructor(options) {
     this.options = options;
     this.updateRow = batchRowUpdates(options.apiRef.current.updateRows, 50);
@@ -82,7 +82,7 @@ class CellValueUpdater {
     if (!colDef || !colDef.editable) {
       return;
     }
-    const row = this.rowsToUpdate[rowId] || (0, _extends2.default)({}, apiRef.current.getRow(rowId));
+    const row = this.rowsToUpdate.get(rowId) || (0, _extends2.default)({}, apiRef.current.getRow(rowId));
     if (!row) {
       return;
     }
@@ -112,7 +112,7 @@ class CellValueUpdater {
       // We cannot update row id, so this cell value update should be ignored
       return;
     }
-    this.rowsToUpdate[rowId] = rowCopy;
+    this.rowsToUpdate.set(rowId, rowCopy);
   }
   applyUpdates() {
     const {
@@ -121,13 +121,20 @@ class CellValueUpdater {
       onProcessRowUpdateError
     } = this.options;
     const rowsToUpdate = this.rowsToUpdate;
-    const rowIdsToUpdate = Object.keys(rowsToUpdate);
+    const rowIdsToUpdate = Array.from(rowsToUpdate.keys());
     if (rowIdsToUpdate.length === 0) {
-      apiRef.current.publishEvent('clipboardPasteEnd');
+      apiRef.current.publishEvent('clipboardPasteEnd', {
+        oldRows: new Map(),
+        newRows: new Map()
+      });
       return;
     }
+    const oldRows = new Map();
+    const newRows = new Map();
     const handleRowUpdate = async rowId => {
-      const newRow = rowsToUpdate[rowId];
+      const oldRow = apiRef.current.getRow(rowId);
+      const newRow = rowsToUpdate.get(rowId);
+      oldRows.set(rowId, oldRow);
       if (typeof processRowUpdate === 'function') {
         const handleError = errorThrown => {
           if (onProcessRowUpdateError) {
@@ -137,15 +144,16 @@ class CellValueUpdater {
           }
         };
         try {
-          const oldRow = apiRef.current.getRow(rowId);
           const finalRowUpdate = await processRowUpdate(newRow, oldRow, {
             rowId
           });
+          newRows.set(rowId, finalRowUpdate);
           this.updateRow(finalRowUpdate);
         } catch (error) {
           handleError(error);
         }
       } else {
+        newRows.set(rowId, newRow);
         this.updateRow(newRow);
       }
     };
@@ -157,8 +165,11 @@ class CellValueUpdater {
       });
     });
     Promise.all(promises).then(() => {
-      this.rowsToUpdate = {};
-      apiRef.current.publishEvent('clipboardPasteEnd');
+      apiRef.current.publishEvent('clipboardPasteEnd', {
+        oldRows,
+        newRows
+      });
+      this.rowsToUpdate.clear();
     });
   }
 }

package/hooks/features/history/constants.d.ts

@@ -0,0 +1,2 @@
+import type { GridEvents } from '@mui/x-data-grid-pro';
+export declare const DEFAULT_HISTORY_VALIDATION_EVENTS: GridEvents[];

package/hooks/features/history/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEFAULT_HISTORY_VALIDATION_EVENTS = void 0;
+const DEFAULT_HISTORY_VALIDATION_EVENTS = exports.DEFAULT_HISTORY_VALIDATION_EVENTS = ['columnsChange', 'rowsSet', 'sortedRowsSet', 'filteredRowsSet', 'paginationModelChange'];

package/hooks/features/history/defaultHistoryHandlers.d.ts

@@ -0,0 +1,20 @@
+import { RefObject } from '@mui/x-internals/types';
+import type { GridApiPremium } from "../../../models/gridApiPremium.js";
+import type { DataGridPremiumProcessedProps } from "../../../models/dataGridPremiumProps.js";
+import type { GridHistoryEventHandler, GridCellEditHistoryData, GridRowEditHistoryData, GridClipboardPasteHistoryData } from "./gridHistoryInterfaces.js";
+/**
+ * Create the default handler for cellEditStop events.
+ */
+export declare const createCellEditHistoryHandler: (apiRef: RefObject<GridApiPremium>) => GridHistoryEventHandler<GridCellEditHistoryData>;
+/**
+ * Create the default handler for rowEditStop events.
+ */
+export declare const createRowEditHistoryHandler: (apiRef: RefObject<GridApiPremium>) => GridHistoryEventHandler<GridRowEditHistoryData>;
+/**
+ * Create the default handler for clipboardPasteEnd events.
+ */
+export declare const createClipboardPasteHistoryHandler: (apiRef: RefObject<GridApiPremium>) => GridHistoryEventHandler<GridClipboardPasteHistoryData>;
+/**
+ * Create the default history events map.
+ */
+export declare const createDefaultHistoryHandlers: (apiRef: RefObject<GridApiPremium>, props: Pick<DataGridPremiumProcessedProps, "columns" | "isCellEditable" | "dataSource">) => Record<keyof import("@mui/x-data-grid").GridEventLookup, GridHistoryEventHandler<GridCellEditHistoryData> | GridHistoryEventHandler<GridRowEditHistoryData> | GridHistoryEventHandler<GridClipboardPasteHistoryData>>;