@mui/x-data-grid-premium 6.3.1 → 6.4.0

package/modern/DataGridPremium/useDataGridPremiumComponent.js

@@ -6,6 +6,7 @@ import { useGridRowGrouping, rowGroupingStateInitializer } from '../hooks/featur
 import { useGridRowGroupingPreProcessors } from '../hooks/features/rowGrouping/useGridRowGroupingPreProcessors';
 import { useGridExcelExport } from '../hooks/features/export/useGridExcelExport';
 import { cellSelectionStateInitializer, useGridCellSelection } from '../hooks/features/cellSelection/useGridCellSelection';
+import { useGridClipboardImport } from '../hooks/features/clipboard/useGridClipboardImport';
 export const useDataGridPremiumComponent = (inputApiRef, props) => {
   const privateApiRef = useGridInitialization(inputApiRef, props);
 
@@ -63,6 +64,7 @@ export const useDataGridPremiumComponent = (inputApiRef, props) => {
   useGridDetailPanel(privateApiRef, props);
   useGridColumnSpanning(privateApiRef);
   useGridColumnGrouping(privateApiRef, props);
+  useGridClipboardImport(privateApiRef, props);
   useGridEditing(privateApiRef, props);
   useGridFocus(privateApiRef, props);
   useGridPreferencesPanel(privateApiRef, props);
@@ -78,10 +80,10 @@ export const useDataGridPremiumComponent = (inputApiRef, props) => {
   useGridInfiniteLoader(privateApiRef, props);
   useGridLazyLoader(privateApiRef, props);
   useGridColumnMenu(privateApiRef);
-  useGridCsvExport(privateApiRef);
+  useGridCsvExport(privateApiRef, props);
   useGridPrintExport(privateApiRef, props);
   useGridExcelExport(privateApiRef, props);
-  useGridClipboard(privateApiRef);
+  useGridClipboard(privateApiRef, props);
   useGridDimensions(privateApiRef, props);
   useGridEvents(privateApiRef, props);
   useGridStatePersistence(privateApiRef);

package/modern/DataGridPremium/useDataGridPremiumProps.js

@@ -18,7 +18,9 @@ export const DATA_GRID_PREMIUM_PROPS_DEFAULT_VALUES = _extends({}, DATA_GRID_PRO
   rowGroupingColumnMode: 'single',
   aggregationFunctions: GRID_AGGREGATION_FUNCTIONS,
   aggregationRowsScope: 'filtered',
-  getAggregationPosition: groupNode => groupNode.depth === -1 ? 'footer' : 'inline'
+  getAggregationPosition: groupNode => groupNode.depth === -1 ? 'footer' : 'inline',
+  disableClipboardPaste: false,
+  unstable_splitClipboardPastedText: text => text.split(/\r\n|\n|\r/).map(row => row.split('\t'))
 });
 const defaultSlots = uncapitalizeObjectKeys(DATA_GRID_PREMIUM_DEFAULT_SLOTS_COMPONENTS);
 export const useDataGridPremiumProps = inProps => {

package/modern/hooks/features/cellSelection/useGridCellSelection.js

@@ -1,7 +1,7 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import { useEventCallback } from '@mui/material/utils';
-import { isNavigationKey, useGridRegisterPipeProcessor, useGridVisibleRows } from '@mui/x-data-grid-pro/internals';
+import { isNavigationKey, serializeCellValue, useGridRegisterPipeProcessor, useGridVisibleRows } from '@mui/x-data-grid-pro/internals';
 import { useGridApiEventHandler, useGridApiMethod, GRID_ACTIONS_COLUMN_TYPE, GRID_CHECKBOX_SELECTION_COL_DEF, GRID_DETAIL_PANEL_TOGGLE_FIELD, gridRowsDataRowIdToIdLookupSelector, gridClasses, gridFocusCellSelector } from '@mui/x-data-grid-pro';
 import { gridCellSelectionStateSelector } from './gridCellSelectionSelector';
 export const cellSelectionStateInitializer = (state, props) => _extends({}, state, {
@@ -14,6 +14,9 @@ export const useGridCellSelection = (apiRef, props) => {
   const visibleRows = useGridVisibleRows(apiRef, props);
   const cellWithVirtualFocus = React.useRef();
   const lastMouseDownCell = React.useRef();
+  const ignoreValueFormatterProp = props.unstable_ignoreValueFormatterDuringExport;
+  const ignoreValueFormatter = (typeof ignoreValueFormatterProp === 'object' ? ignoreValueFormatterProp?.clipboardExport : ignoreValueFormatterProp) || false;
+  const clipboardCopyCellDelimiter = props.clipboardCopyCellDelimiter;
   apiRef.current.registerControlState({
     stateId: 'cellSelection',
     propModel: props.unstable_cellSelectionModel,
@@ -312,7 +315,32 @@ export const useGridCellSelection = (apiRef, props) => {
     }
     return initialValue;
   }, [apiRef, props.unstable_cellSelection, hasClickedValidCellForRangeSelection]);
+  const handleClipboardCopy = React.useCallback(value => {
+    if (apiRef.current.unstable_getSelectedCellsAsArray().length <= 1) {
+      return value;
+    }
+    const cellSelectionModel = apiRef.current.unstable_getCellSelectionModel();
+    const copyData = Object.keys(cellSelectionModel).reduce((acc, rowId) => {
+      const fieldsMap = cellSelectionModel[rowId];
+      const rowString = Object.keys(fieldsMap).reduce((acc2, field) => {
+        let cellData;
+        if (fieldsMap[field]) {
+          const cellParams = apiRef.current.getCellParams(rowId, field);
+          cellData = serializeCellValue(cellParams, {
+            delimiterCharacter: clipboardCopyCellDelimiter,
+            ignoreValueFormatter
+          });
+        } else {
+          cellData = '';
+        }
+        return acc2 === '' ? cellData : [acc2, cellData].join(clipboardCopyCellDelimiter);
+      }, '');
+      return acc === '' ? rowString : [acc, rowString].join('\r\n');
+    }, '');
+    return copyData;
+  }, [apiRef, ignoreValueFormatter, clipboardCopyCellDelimiter]);
   useGridRegisterPipeProcessor(apiRef, 'isCellSelected', checkIfCellIsSelected);
   useGridRegisterPipeProcessor(apiRef, 'cellClassName', addClassesToCells);
   useGridRegisterPipeProcessor(apiRef, 'canUpdateFocus', canUpdateFocus);
+  useGridRegisterPipeProcessor(apiRef, 'clipboardCopy', handleClipboardCopy);
 };

package/modern/hooks/features/clipboard/useGridClipboardImport.js

@@ -0,0 +1,313 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { GRID_CHECKBOX_SELECTION_FIELD, gridFocusCellSelector, gridVisibleColumnFieldsSelector, useGridApiOptionHandler, useGridApiEventHandler, gridPaginatedVisibleSortedGridRowIdsSelector } from '@mui/x-data-grid';
+import { buildWarning, getRowIdFromRowModel, getActiveElement, useGridRegisterPipeProcessor } from '@mui/x-data-grid/internals';
+import { GRID_DETAIL_PANEL_TOGGLE_FIELD, GRID_REORDER_COL_DEF } from '@mui/x-data-grid-pro';
+import { unstable_debounce as debounce } from '@mui/utils';
+const missingOnProcessRowUpdateErrorWarning = buildWarning(['MUI: 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, e.g. `<DataGrid onProcessRowUpdateError={(error) => ...} />`.', 'For more detail, see http://mui.com/components/data-grid/editing/#persistence.'], 'error');
+const columnFieldsToExcludeFromPaste = [GRID_CHECKBOX_SELECTION_FIELD, GRID_REORDER_COL_DEF.field, GRID_DETAIL_PANEL_TOGGLE_FIELD];
+
+// Batches rows that are updated during clipboard paste to reduce `updateRows` calls
+function batchRowUpdates(func, wait) {
+  let rows = [];
+  const debounced = debounce(() => {
+    func(rows);
+    rows = [];
+  }, wait);
+  return row => {
+    rows.push(row);
+    debounced();
+  };
+}
+async function getTextFromClipboard(rootEl) {
+  return new Promise(resolve => {
+    const focusedCell = getActiveElement(document);
+    const el = document.createElement('input');
+    el.style.width = '0px';
+    el.style.height = '0px';
+    el.style.border = 'none';
+    el.style.margin = '0';
+    el.style.padding = '0';
+    el.style.outline = 'none';
+    el.style.position = 'absolute';
+    el.style.top = '0';
+    el.style.left = '0';
+    const handlePasteEvent = event => {
+      el.removeEventListener('paste', handlePasteEvent);
+      const text = event.clipboardData?.getData('text/plain');
+      if (focusedCell instanceof HTMLElement) {
+        focusedCell.focus({
+          preventScroll: true
+        });
+      }
+      el.remove();
+      resolve(text || '');
+    };
+    el.addEventListener('paste', handlePasteEvent);
+    rootEl.appendChild(el);
+    el.focus({
+      preventScroll: true
+    });
+  });
+}
+
+// Keeps track of updated rows during clipboard paste
+class CellValueUpdater {
+  constructor(options) {
+    this.rowsToUpdate = {};
+    this.updateRow = void 0;
+    this.options = void 0;
+    this.options = options;
+    this.updateRow = batchRowUpdates(options.apiRef.current.updateRows, 50);
+  }
+  updateCell({
+    rowId,
+    field,
+    pastedCellValue
+  }) {
+    if (pastedCellValue === undefined) {
+      return;
+    }
+    const {
+      apiRef,
+      getRowId
+    } = this.options;
+    const colDef = apiRef.current.getColumn(field);
+    if (!colDef || !colDef.editable) {
+      return;
+    }
+    const row = this.rowsToUpdate[rowId] || _extends({}, apiRef.current.getRow(rowId));
+    if (!row) {
+      return;
+    }
+    const cellParams = apiRef.current.getCellParams(rowId, field);
+    let parsedValue = pastedCellValue;
+    if (colDef.pastedValueParser) {
+      parsedValue = colDef.pastedValueParser(pastedCellValue, cellParams);
+    } else if (colDef.valueParser) {
+      parsedValue = colDef.valueParser(parsedValue, cellParams);
+    }
+    if (parsedValue === undefined) {
+      return;
+    }
+    let rowCopy = _extends({}, row);
+    if (typeof colDef.valueSetter === 'function') {
+      rowCopy = colDef.valueSetter({
+        value: parsedValue,
+        row: rowCopy
+      });
+    } else {
+      rowCopy[field] = parsedValue;
+    }
+    const newRowId = getRowIdFromRowModel(rowCopy, getRowId);
+    if (String(newRowId) !== String(rowId)) {
+      // We cannot update row id, so this cell value update should be ignored
+      return;
+    }
+    this.rowsToUpdate[rowId] = rowCopy;
+  }
+  applyUpdates() {
+    const {
+      apiRef,
+      processRowUpdate,
+      onProcessRowUpdateError
+    } = this.options;
+    const rowsToUpdate = this.rowsToUpdate;
+    const rowIdsToUpdate = Object.keys(rowsToUpdate);
+    if (rowIdsToUpdate.length === 0) {
+      apiRef.current.publishEvent('clipboardPasteEnd');
+      return;
+    }
+    const handleRowUpdate = async rowId => {
+      const newRow = rowsToUpdate[rowId];
+      if (typeof processRowUpdate === 'function') {
+        const handleError = errorThrown => {
+          if (onProcessRowUpdateError) {
+            onProcessRowUpdateError(errorThrown);
+          } else {
+            missingOnProcessRowUpdateErrorWarning();
+          }
+        };
+        try {
+          const oldRow = apiRef.current.getRow(rowId);
+          const finalRowUpdate = await processRowUpdate(newRow, oldRow);
+          this.updateRow(finalRowUpdate);
+        } catch (error) {
+          handleError(error);
+        }
+      } else {
+        this.updateRow(newRow);
+      }
+    };
+    const promises = rowIdsToUpdate.map(rowId => {
+      // Wrap in promise that always resolves to avoid Promise.all from stopping on first error.
+      // This is to avoid using `Promise.allSettled` that has worse browser support.
+      return new Promise(resolve => {
+        handleRowUpdate(rowId).then(resolve).catch(resolve);
+      });
+    });
+    Promise.all(promises).then(() => {
+      this.rowsToUpdate = {};
+      apiRef.current.publishEvent('clipboardPasteEnd');
+    });
+  }
+}
+function defaultPasteResolver({
+  pastedData,
+  apiRef,
+  updateCell
+}) {
+  const isSingleValuePasted = pastedData.length === 1 && pastedData[0].length === 1;
+  const cellSelectionModel = apiRef.current.unstable_getCellSelectionModel();
+  if (cellSelectionModel && apiRef.current.unstable_getSelectedCellsAsArray().length > 1) {
+    Object.keys(cellSelectionModel).forEach((rowId, rowIndex) => {
+      const rowDataArr = pastedData[isSingleValuePasted ? 0 : rowIndex];
+      const hasRowData = isSingleValuePasted ? true : rowDataArr !== undefined;
+      if (!hasRowData) {
+        return;
+      }
+      Object.keys(cellSelectionModel[rowId]).forEach((field, colIndex) => {
+        const cellValue = isSingleValuePasted ? rowDataArr[0] : rowDataArr[colIndex];
+        updateCell({
+          rowId,
+          field,
+          pastedCellValue: cellValue
+        });
+      });
+    });
+    return;
+  }
+  const visibleColumnFields = gridVisibleColumnFieldsSelector(apiRef).filter(field => {
+    if (columnFieldsToExcludeFromPaste.includes(field)) {
+      return false;
+    }
+    return true;
+  });
+  const selectedRows = apiRef.current.getSelectedRows();
+  if (selectedRows.size > 0 && !isSingleValuePasted) {
+    // Multiple values are pasted starting from the first and top-most cell
+    const pastedRowsDataCount = pastedData.length;
+
+    // There's no guarantee that the selected rows are in the same order as the pasted rows
+    selectedRows.forEach((row, rowId) => {
+      let rowData;
+      if (pastedRowsDataCount === 1) {
+        // If only one row is pasted - paste it to all selected rows
+        rowData = pastedData[0];
+      } else {
+        rowData = pastedData.shift();
+      }
+      if (rowData === undefined) {
+        return;
+      }
+      rowData.forEach((newCellValue, cellIndex) => {
+        updateCell({
+          rowId,
+          field: visibleColumnFields[cellIndex],
+          pastedCellValue: newCellValue
+        });
+      });
+    });
+    return;
+  }
+  const selectedCell = gridFocusCellSelector(apiRef);
+  if (!selectedCell) {
+    return;
+  }
+  if (columnFieldsToExcludeFromPaste.includes(selectedCell.field)) {
+    return;
+  }
+  const selectedRowId = selectedCell.id;
+  const selectedRowIndex = apiRef.current.getRowIndexRelativeToVisibleRows(selectedRowId);
+  const visibleRowIds = gridPaginatedVisibleSortedGridRowIdsSelector(apiRef);
+  const selectedFieldIndex = visibleColumnFields.indexOf(selectedCell.field);
+  pastedData.forEach((rowData, index) => {
+    const rowId = visibleRowIds[selectedRowIndex + index];
+    if (typeof rowId === 'undefined') {
+      return;
+    }
+    for (let i = selectedFieldIndex; i < visibleColumnFields.length; i += 1) {
+      const field = visibleColumnFields[i];
+      const stringValue = rowData[i - selectedFieldIndex];
+      updateCell({
+        rowId,
+        field,
+        pastedCellValue: stringValue
+      });
+    }
+  });
+}
+function isPasteShortcut(event) {
+  const isModifierKeyPressed = event.ctrlKey || event.metaKey || event.altKey;
+  if (event.code === 'KeyV' && isModifierKeyPressed) {
+    return true;
+  }
+  return false;
+}
+export const useGridClipboardImport = (apiRef, props) => {
+  const processRowUpdate = props.processRowUpdate;
+  const onProcessRowUpdateError = props.onProcessRowUpdateError;
+  const getRowId = props.getRowId;
+  const enableClipboardPaste = (!props.disableClipboardPaste && props.experimentalFeatures?.clipboardPaste) ?? false;
+  const rootEl = apiRef.current.rootElementRef?.current;
+  const splitClipboardPastedText = props.unstable_splitClipboardPastedText;
+  const handlePaste = React.useCallback(async (params, event) => {
+    if (!enableClipboardPaste) {
+      return;
+    }
+    if (!isPasteShortcut(event)) {
+      return;
+    }
+    const focusedCell = gridFocusCellSelector(apiRef);
+    if (focusedCell !== null) {
+      const cellMode = apiRef.current.getCellMode(focusedCell.id, focusedCell.field);
+      if (cellMode === 'edit') {
+        // Do not paste data when the cell is in edit mode
+        return;
+      }
+    }
+    if (!rootEl) {
+      return;
+    }
+    const text = await getTextFromClipboard(rootEl);
+    if (!text) {
+      return;
+    }
+    const pastedData = splitClipboardPastedText(text);
+    if (!pastedData) {
+      return;
+    }
+    const cellUpdater = new CellValueUpdater({
+      apiRef,
+      processRowUpdate,
+      onProcessRowUpdateError,
+      getRowId
+    });
+    apiRef.current.publishEvent('clipboardPasteStart', {
+      data: pastedData
+    });
+    defaultPasteResolver({
+      pastedData,
+      apiRef: {
+        current: apiRef.current.getPublicApi()
+      },
+      updateCell: (...args) => {
+        cellUpdater.updateCell(...args);
+      }
+    });
+    cellUpdater.applyUpdates();
+  }, [apiRef, processRowUpdate, onProcessRowUpdateError, getRowId, enableClipboardPaste, rootEl, splitClipboardPastedText]);
+  const checkIfCanStartEditing = React.useCallback((initialValue, {
+    event
+  }) => {
+    if (isPasteShortcut(event) && enableClipboardPaste) {
+      // Do not enter cell edit mode on paste
+      return false;
+    }
+    return initialValue;
+  }, [enableClipboardPaste]);
+  useGridApiEventHandler(apiRef, 'cellKeyDown', handlePaste);
+  useGridApiOptionHandler(apiRef, 'clipboardPasteStart', props.onClipboardPasteStart);
+  useGridApiOptionHandler(apiRef, 'clipboardPasteEnd', props.onClipboardPasteEnd);
+  useGridRegisterPipeProcessor(apiRef, 'canStartEditing', checkIfCanStartEditing);
+};

package/modern/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-data-grid-premium v6.3.1
+ * @mui/x-data-grid-premium v6.4.0
  *
  * @license MUI X Commercial
  * This source code is licensed under the commercial license found in the

package/modern/utils/releaseInfo.js

@@ -1,6 +1,6 @@
 import { ponyfillGlobal } from '@mui/utils';
 export const getReleaseInfo = () => {
-  const releaseInfo = "MTY4MzIzNzYwMDAwMA==";
+  const releaseInfo = "MTY4Mzg0MjQwMDAwMA==";
   if (process.env.NODE_ENV !== 'production') {
     // A simple hack to set the value in the test environment (has no build step).
     // eslint-disable-next-line no-useless-concat

package/node/DataGridPremium/DataGridPremium.js

@@ -115,6 +115,11 @@ process.env.NODE_ENV !== "production" ? DataGridPremiumRaw.propTypes = {
    * Override or extend the styles applied to the component.
    */
   classes: _propTypes.default.object,
+  /**
+   * The character used to separate cell values when copying to the clipboard.
+   * @default '\t'
+   */
+  clipboardCopyCellDelimiter: _propTypes.default.string,
   /**
    * Number of extra columns to be rendered before/after the visible slice.
    * @default 3
@@ -180,6 +185,11 @@ process.env.NODE_ENV !== "production" ? DataGridPremiumRaw.propTypes = {
    * @default false
    */
   disableChildrenSorting: _propTypes.default.bool,
+  /**
+   * If `true`, the clipboard paste is disabled.
+   * @default false
+   */
+  disableClipboardPaste: _propTypes.default.bool,
   /**
    * If `true`, column filters are disabled.
    * @default false
@@ -255,6 +265,7 @@ process.env.NODE_ENV !== "production" ? DataGridPremiumRaw.propTypes = {
    * For each feature, if the flag is not explicitly set to `true`, then the feature is fully disabled, and neither property nor method calls will have any effect.
    */
   experimentalFeatures: _propTypes.default.shape({
+    clipboardPaste: _propTypes.default.bool,
     columnGrouping: _propTypes.default.bool,
     lazyLoading: _propTypes.default.bool,
     warnIfFocusStateIsNotSynced: _propTypes.default.bool
@@ -490,6 +501,19 @@ process.env.NODE_ENV !== "production" ? DataGridPremiumRaw.propTypes = {
    * @param {GridCallbackDetails} details Additional details for this callback.
    */
   onCellModesModelChange: _propTypes.default.func,
+  /**
+   * Callback called when the data is copied to the clipboard.
+   * @param {string} data The data copied to the clipboard.
+   */
+  onClipboardCopy: _propTypes.default.func,
+  /**
+   * Callback fired when the clipboard paste operation ends.
+   */
+  onClipboardPasteEnd: _propTypes.default.func,
+  /**
+   * Callback fired when the clipboard paste operation starts.
+   */
+  onClipboardPasteStart: _propTypes.default.func,
   /**
    * Callback fired when a click event comes from a column header element.
    * @param {GridColumnHeaderParams} params With all properties from [[GridColumnHeaderParams]].
@@ -894,10 +918,26 @@ process.env.NODE_ENV !== "production" ? DataGridPremiumRaw.propTypes = {
    * Set the cell selection model of the grid.
    */
   unstable_cellSelectionModel: _propTypes.default.object,
+  /**
+   * If `true`, the grid will not use `valueFormatter` when exporting to CSV or copying to clipboard.
+   * If an object is provided, you can choose to ignore the `valueFormatter` for CSV export or clipboard export.
+   * @default: false
+   */
+  unstable_ignoreValueFormatterDuringExport: _propTypes.default.oneOfType([_propTypes.default.shape({
+    clipboardExport: _propTypes.default.bool,
+    csvExport: _propTypes.default.bool
+  }), _propTypes.default.bool]),
   /**
    * Callback fired when the selection state of one or multiple cells changes.
    * @param {GridCellSelectionModel} cellSelectionModel Object in the shape of [[GridCellSelectionModel]] containing the selected cells.
    * @param {GridCallbackDetails} details Additional details for this callback.
    */
-  unstable_onCellSelectionModelChange: _propTypes.default.func
+  unstable_onCellSelectionModelChange: _propTypes.default.func,
+  /**
+   * The function is used to split the pasted text into rows and cells.
+   * @param {string} text The text pasted from the clipboard.
+   * @returns {string[][] | null} A 2D array of strings. The first dimension is the rows, the second dimension is the columns.
+   * @default `(text) => text.split(/\r\n|\n|\r/).map((row) => row.split('\t'))`
+   */
+  unstable_splitClipboardPastedText: _propTypes.default.func
 } : void 0;

package/node/DataGridPremium/useDataGridPremiumComponent.js

@@ -11,6 +11,7 @@ var _useGridRowGrouping = require("../hooks/features/rowGrouping/useGridRowGroup
 var _useGridRowGroupingPreProcessors = require("../hooks/features/rowGrouping/useGridRowGroupingPreProcessors");
 var _useGridExcelExport = require("../hooks/features/export/useGridExcelExport");
 var _useGridCellSelection = require("../hooks/features/cellSelection/useGridCellSelection");
+var _useGridClipboardImport = require("../hooks/features/clipboard/useGridClipboardImport");
 // Premium-only features
 
 const useDataGridPremiumComponent = (inputApiRef, props) => {
@@ -70,6 +71,7 @@ const useDataGridPremiumComponent = (inputApiRef, props) => {
   (0, _internals.useGridDetailPanel)(privateApiRef, props);
   (0, _internals.useGridColumnSpanning)(privateApiRef);
   (0, _internals.useGridColumnGrouping)(privateApiRef, props);
+  (0, _useGridClipboardImport.useGridClipboardImport)(privateApiRef, props);
   (0, _internals.useGridEditing)(privateApiRef, props);
   (0, _internals.useGridFocus)(privateApiRef, props);
   (0, _internals.useGridPreferencesPanel)(privateApiRef, props);
@@ -85,10 +87,10 @@ const useDataGridPremiumComponent = (inputApiRef, props) => {
   (0, _internals.useGridInfiniteLoader)(privateApiRef, props);
   (0, _internals.useGridLazyLoader)(privateApiRef, props);
   (0, _internals.useGridColumnMenu)(privateApiRef);
-  (0, _internals.useGridCsvExport)(privateApiRef);
+  (0, _internals.useGridCsvExport)(privateApiRef, props);
   (0, _internals.useGridPrintExport)(privateApiRef, props);
   (0, _useGridExcelExport.useGridExcelExport)(privateApiRef, props);
-  (0, _internals.useGridClipboard)(privateApiRef);
+  (0, _internals.useGridClipboard)(privateApiRef, props);
   (0, _internals.useGridDimensions)(privateApiRef, props);
   (0, _internals.useGridEvents)(privateApiRef, props);
   (0, _internals.useGridStatePersistence)(privateApiRef);

package/node/DataGridPremium/useDataGridPremiumProps.js

@@ -26,7 +26,9 @@ const DATA_GRID_PREMIUM_PROPS_DEFAULT_VALUES = (0, _extends2.default)({}, _xData
   rowGroupingColumnMode: 'single',
   aggregationFunctions: _aggregation.GRID_AGGREGATION_FUNCTIONS,
   aggregationRowsScope: 'filtered',
-  getAggregationPosition: groupNode => groupNode.depth === -1 ? 'footer' : 'inline'
+  getAggregationPosition: groupNode => groupNode.depth === -1 ? 'footer' : 'inline',
+  disableClipboardPaste: false,
+  unstable_splitClipboardPastedText: text => text.split(/\r\n|\n|\r/).map(row => row.split('\t'))
 });
 exports.DATA_GRID_PREMIUM_PROPS_DEFAULT_VALUES = DATA_GRID_PREMIUM_PROPS_DEFAULT_VALUES;
 const defaultSlots = (0, _internals.uncapitalizeObjectKeys)(_dataGridPremiumDefaultSlotsComponents.DATA_GRID_PREMIUM_DEFAULT_SLOTS_COMPONENTS);

package/node/hooks/features/cellSelection/useGridCellSelection.js

@@ -24,6 +24,9 @@ const useGridCellSelection = (apiRef, props) => {
   const visibleRows = (0, _internals.useGridVisibleRows)(apiRef, props);
   const cellWithVirtualFocus = React.useRef();
   const lastMouseDownCell = React.useRef();
+  const ignoreValueFormatterProp = props.unstable_ignoreValueFormatterDuringExport;
+  const ignoreValueFormatter = (typeof ignoreValueFormatterProp === 'object' ? ignoreValueFormatterProp?.clipboardExport : ignoreValueFormatterProp) || false;
+  const clipboardCopyCellDelimiter = props.clipboardCopyCellDelimiter;
   apiRef.current.registerControlState({
     stateId: 'cellSelection',
     propModel: props.unstable_cellSelectionModel,
@@ -322,8 +325,33 @@ const useGridCellSelection = (apiRef, props) => {
     }
     return initialValue;
   }, [apiRef, props.unstable_cellSelection, hasClickedValidCellForRangeSelection]);
+  const handleClipboardCopy = React.useCallback(value => {
+    if (apiRef.current.unstable_getSelectedCellsAsArray().length <= 1) {
+      return value;
+    }
+    const cellSelectionModel = apiRef.current.unstable_getCellSelectionModel();
+    const copyData = Object.keys(cellSelectionModel).reduce((acc, rowId) => {
+      const fieldsMap = cellSelectionModel[rowId];
+      const rowString = Object.keys(fieldsMap).reduce((acc2, field) => {
+        let cellData;
+        if (fieldsMap[field]) {
+          const cellParams = apiRef.current.getCellParams(rowId, field);
+          cellData = (0, _internals.serializeCellValue)(cellParams, {
+            delimiterCharacter: clipboardCopyCellDelimiter,
+            ignoreValueFormatter
+          });
+        } else {
+          cellData = '';
+        }
+        return acc2 === '' ? cellData : [acc2, cellData].join(clipboardCopyCellDelimiter);
+      }, '');
+      return acc === '' ? rowString : [acc, rowString].join('\r\n');
+    }, '');
+    return copyData;
+  }, [apiRef, ignoreValueFormatter, clipboardCopyCellDelimiter]);
   (0, _internals.useGridRegisterPipeProcessor)(apiRef, 'isCellSelected', checkIfCellIsSelected);
   (0, _internals.useGridRegisterPipeProcessor)(apiRef, 'cellClassName', addClassesToCells);
   (0, _internals.useGridRegisterPipeProcessor)(apiRef, 'canUpdateFocus', canUpdateFocus);
+  (0, _internals.useGridRegisterPipeProcessor)(apiRef, 'clipboardCopy', handleClipboardCopy);
 };
 exports.useGridCellSelection = useGridCellSelection;