@mui/x-data-grid-premium 7.26.0 → 7.27.0

package/esm/hooks/features/export/useGridExcelExport.js

@@ -5,7 +5,7 @@ import { useGridApiMethod, useGridLogger, useGridApiOptionHandler } from '@mui/x
 import { useGridRegisterPipeProcessor, exportAs, getColumnsToExport, defaultGetRowsToExport } from '@mui/x-data-grid/internals';
 import { buildExcel, getDataForValueOptionsSheet, serializeColumns, serializeRowUnsafe } from "./serializer/excelSerializer.js";
 import { GridExcelExportMenuItem } from "../../../components/index.js";
-
+import { jsx as _jsx } from "react/jsx-runtime";
 /**
  * @requires useGridColumns (state)
  * @requires useGridFilter (state)
@@ -13,7 +13,6 @@ import { GridExcelExportMenuItem } from "../../../components/index.js";
  * @requires useGridSelection (state)
  * @requires useGridParamsApi (method)
  */
-import { jsx as _jsx } from "react/jsx-runtime";
 export const useGridExcelExport = (apiRef, props) => {
   const logger = useGridLogger(apiRef, 'useGridExcelExport');
   const getDataAsExcel = React.useCallback((options = {}) => {
@@ -89,15 +88,22 @@ export const useGridExcelExport = (apiRef, props) => {
     const valueOptionsData = await getDataForValueOptionsSheet(exportedColumns, valueOptionsSheetName, apiRef.current);
     const serializedColumns = serializeColumns(exportedColumns, options.columnsStyles || {});
     apiRef.current.resetColSpan();
-    const serializedRows = exportedRowIds.map(id => serializeRowUnsafe(id, exportedColumns, apiRef, valueOptionsData, {
-      escapeFormulas: options.escapeFormulas ?? true
-    }));
+    const serializedRows = [];
+    for (let i = 0; i < exportedRowIds.length; i += 1) {
+      const id = exportedRowIds[i];
+      const serializedRow = serializeRowUnsafe(id, exportedColumns, apiRef, valueOptionsData, {
+        escapeFormulas: options.escapeFormulas ?? true
+      });
+      serializedRows.push(serializedRow);
+    }
     apiRef.current.resetColSpan();
     const columnGroupPaths = exportedColumns.reduce((acc, column) => {
       acc[column.field] = apiRef.current.getColumnGroupPath(column.field);
       return acc;
     }, {});
     const message = {
+      // workers share the pub-sub channel namespace. Use this property to filter out messages.
+      namespace: 'mui-x-data-grid-export',
       serializedColumns,
       serializedRows,
       valueOptionsData,

package/esm/setupExcelExportWebWorker.js

@@ -0,0 +1 @@
+export { setupExcelExportWebWorker } from "./hooks/features/export/serializer/setupExcelExportWebWorker.js";

package/esm/utils/releaseInfo.js

@@ -1,6 +1,6 @@
 import { ponyfillGlobal } from '@mui/utils';
 export const getReleaseInfo = () => {
-  const releaseInfo = "MTczODg4MjgwMDAwMA==";
+  const releaseInfo = "MTczOTc0NjgwMDAwMA==";
   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/hooks/features/clipboard/useGridClipboardImport.js

@@ -263,7 +263,6 @@ const useGridClipboardImport = (apiRef, props) => {
   const onProcessRowUpdateError = props.onProcessRowUpdateError;
   const getRowId = props.getRowId;
   const enableClipboardPaste = !props.disableClipboardPaste;
-  const rootEl = apiRef.current.rootElementRef?.current;
   const logger = (0, _internals.useGridLogger)(apiRef, 'useGridClipboardImport');
   const splitClipboardPastedText = props.splitClipboardPastedText;
   const {
@@ -286,6 +285,7 @@ const useGridClipboardImport = (apiRef, props) => {
         return;
       }
     }
+    const rootEl = apiRef.current.rootElementRef?.current;
     if (!rootEl) {
       return;
     }
@@ -326,7 +326,7 @@ const useGridClipboardImport = (apiRef, props) => {
       paginationMode
     });
     cellUpdater.applyUpdates();
-  }, [apiRef, processRowUpdate, onProcessRowUpdateError, getRowId, enableClipboardPaste, rootEl, splitClipboardPastedText, pagination, paginationMode, onBeforeClipboardPasteStart, logger]);
+  }, [apiRef, processRowUpdate, onProcessRowUpdateError, getRowId, enableClipboardPaste, splitClipboardPastedText, pagination, paginationMode, onBeforeClipboardPasteStart, logger]);
   const checkIfCanStartEditing = React.useCallback((initialValue, {
     event
   }) => {

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

@@ -1,2 +1,2 @@
 export * from './gridExcelExportInterface';
-export { setupExcelExportWebWorker } from './serializer/excelSerializer';
+export { setupExcelExportWebWorker } from './serializer/setupExcelExportWebWorker';

package/hooks/features/export/index.js

@@ -9,7 +9,7 @@ var _exportNames = {
 Object.defineProperty(exports, "setupExcelExportWebWorker", {
   enumerable: true,
   get: function () {
-    return _excelSerializer.setupExcelExportWebWorker;
+    return _setupExcelExportWebWorker.setupExcelExportWebWorker;
   }
 });
 var _gridExcelExportInterface = require("./gridExcelExportInterface");
@@ -24,4 +24,4 @@ Object.keys(_gridExcelExportInterface).forEach(function (key) {
     }
   });
 });
-var _excelSerializer = require("./serializer/excelSerializer");
+var _setupExcelExportWebWorker = require("./serializer/setupExcelExportWebWorker");

package/hooks/features/export/serializer/excelSerializer.d.ts

@@ -1,18 +1,11 @@
 import type * as Excel from 'exceljs';
 import { RefObject } from '@mui/x-internals/types';
 import { GridRowId, GridColDef } from '@mui/x-data-grid-pro';
-import { GridStateColDef, GridColumnGroupLookup } from '@mui/x-data-grid/internals';
+import { GridStateColDef } from '@mui/x-data-grid/internals';
 import { ColumnsStylesInterface, GridExcelExportOptions } from '../gridExcelExportInterface';
 import { GridPrivateApiPremium } from '../../../../models/gridApiPremium';
-interface SerializedRow {
-    row: Record<string, undefined | number | boolean | string | Date>;
-    dataValidation: Record<string, Excel.DataValidation>;
-    outlineLevel: number;
-    mergedCells: {
-        leftIndex: number;
-        rightIndex: number;
-    }[];
-}
+import { SerializedColumns, SerializedRow, ValueOptionsData } from './utils';
+export type { ExcelExportInitEvent } from './utils';
 /**
  * FIXME: This function mutates the colspan info, but colspan info assumes that the columns
  * passed to it are always consistent. In this case, the exported columns may differ from the
@@ -37,17 +30,7 @@ export declare const serializeColumn: (column: GridColDef, columnsStyles: Column
         fill?: Excel.Fill | undefined;
     };
 };
-type SerializedColumns = Array<{
-    key: string;
-    width: number;
-    style: Partial<Excel.Style>;
-    headerText: string;
-}>;
 export declare function serializeColumns(columns: GridStateColDef[], styles: ColumnsStylesInterface): SerializedColumns;
-type ValueOptionsData = Record<string, {
-    values: (string | number)[];
-    address: string;
-}>;
 export declare function getDataForValueOptionsSheet(columns: GridStateColDef[], valueOptionsSheetName: string, api: GridPrivateApiPremium): Promise<ValueOptionsData>;
 interface BuildExcelOptions extends Pick<GridExcelExportOptions, 'exceljsPreProcess' | 'exceljsPostProcess'>, Pick<Required<GridExcelExportOptions>, 'valueOptionsSheetName' | 'includeHeaders' | 'includeColumnGroupsHeaders' | 'escapeFormulas'> {
     columns: GridStateColDef[];
@@ -55,14 +38,3 @@ interface BuildExcelOptions extends Pick<GridExcelExportOptions, 'exceljsPreProc
     columnsStyles?: ColumnsStylesInterface;
 }
 export declare function buildExcel(options: BuildExcelOptions, apiRef: RefObject<GridPrivateApiPremium>): Promise<Excel.Workbook>;
-export interface ExcelExportInitEvent {
-    serializedColumns: SerializedColumns;
-    serializedRows: SerializedRow[];
-    valueOptionsSheetName: string;
-    columnGroupPaths: Record<string, string[]>;
-    columnGroupDetails: GridColumnGroupLookup;
-    valueOptionsData: ValueOptionsData;
-    options: Omit<GridExcelExportOptions, 'exceljsPreProcess' | 'exceljsPostProcess' | 'columnsStyles' | 'valueOptionsSheetName'>;
-}
-export declare function setupExcelExportWebWorker(workerOptions?: Pick<GridExcelExportOptions, 'exceljsPostProcess' | 'exceljsPreProcess'>): void;
-export {};

package/hooks/features/export/serializer/excelSerializer.js

@@ -9,33 +9,36 @@ exports.getDataForValueOptionsSheet = getDataForValueOptionsSheet;
 exports.serializeColumn = void 0;
 exports.serializeColumns = serializeColumns;
 exports.serializeRowUnsafe = void 0;
-exports.setupExcelExportWebWorker = setupExcelExportWebWorker;
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
-var _interopRequireWildcard2 = _interopRequireDefault(require("@babel/runtime/helpers/interopRequireWildcard"));
 var _xDataGridPro = require("@mui/x-data-grid-pro");
 var _internals = require("@mui/x-data-grid/internals");
 var _warning = require("@mui/x-internals/warning");
-const getExcelJs = async () => {
-  const excelJsModule = await Promise.resolve().then(() => (0, _interopRequireWildcard2.default)(require('exceljs')));
-  return excelJsModule.default ?? excelJsModule;
-};
-const getFormattedValueOptions = (colDef, row, valueOptions, api) => {
+var _utils = require("./utils");
+const getFormattedValueOptions = (colDef, row, valueOptions, api, callback) => {
   if (!colDef.valueOptions) {
-    return [];
+    return;
   }
-  let valueOptionsFormatted = valueOptions;
-  if (colDef.valueFormatter) {
-    valueOptionsFormatted = valueOptionsFormatted.map(option => {
+  const valueFormatter = colDef.valueFormatter;
+  for (let i = 0; i < valueOptions.length; i += 1) {
+    const option = valueOptions[i];
+    let value;
+    if (valueFormatter) {
       if (typeof option === 'object') {
-        return option;
+        value = option.label;
+      } else {
+        value = String(colDef.valueFormatter(option, row, colDef, {
+          current: api
+        }));
       }
-      return String(colDef.valueFormatter(option, row, colDef, {
-        current: api
-      }));
-    });
+    } else {
+      value = typeof option === 'object' ? option.label : option;
+    }
+    callback(value, i);
   }
-  return valueOptionsFormatted.map(option => typeof option === 'object' ? option.label : option);
 };
+const commaRegex = /,/g;
+const commaReplacement = 'CHAR(44)';
+
 /**
  * FIXME: This function mutates the colspan info, but colspan info assumes that the columns
  * passed to it are always consistent. In this case, the exported columns may differ from the
@@ -43,11 +46,15 @@ const getFormattedValueOptions = (colDef, row, valueOptions, api) => {
  * The caller of this function MUST call `resetColSpan()` before and after usage.
  */
 const serializeRowUnsafe = (id, columns, apiRef, defaultValueOptionsFormulae, options) => {
-  const row = {};
+  const serializedRow = {};
   const dataValidation = {};
   const mergedCells = [];
-  const firstCellParams = apiRef.current.getCellParams(id, columns[0].field);
-  const outlineLevel = firstCellParams.rowNode.depth;
+  const row = apiRef.current.getRow(id);
+  const rowNode = apiRef.current.getRowNode(id);
+  if (!row || !rowNode) {
+    throw new Error(`No row with id #${id} found`);
+  }
+  const outlineLevel = rowNode.depth;
   const hasColSpan = (0, _internals.gridHasColSpanSelector)(apiRef);
   if (hasColSpan) {
     // `colSpan` is only calculated for rendered rows, so we need to calculate it during export for every row
@@ -69,25 +76,32 @@ const serializeRowUnsafe = (id, columns, apiRef, defaultValueOptionsFormulae, op
         rightIndex: colIndex + colSpanInfo.cellProps.colSpan
       });
     }
-    const cellParams = apiRef.current.getCellParams(id, column.field);
     let cellValue;
-    switch (cellParams.colDef.type) {
+    switch (column.type) {
       case 'singleSelect':
         {
-          const castColumn = cellParams.colDef;
+          const castColumn = column;
           if (typeof castColumn.valueOptions === 'function') {
             // If value option depends on the row, set specific options to the cell
             // This dataValidation is buggy with LibreOffice and does not allow to have coma
             const valueOptions = castColumn.valueOptions({
               id,
               row,
-              field: cellParams.field
+              field: column.field
+            });
+            let formulae = '"';
+            getFormattedValueOptions(castColumn, row, valueOptions, apiRef.current, (value, index) => {
+              const formatted = value.toString().replace(commaRegex, commaReplacement);
+              formulae += formatted;
+              if (index < valueOptions.length - 1) {
+                formulae += ',';
+              }
             });
-            const formattedValueOptions = getFormattedValueOptions(castColumn, row, valueOptions, apiRef.current);
+            formulae += '"';
             dataValidation[castColumn.field] = {
               type: 'list',
               allowBlank: true,
-              formulae: [`"${formattedValueOptions.map(x => x.toString().replaceAll(',', 'CHAR(44)')).join(',')}"`]
+              formulae: [formulae]
             };
           } else {
             const address = defaultValueOptionsFormulae[column.field].address;
@@ -99,22 +113,22 @@ const serializeRowUnsafe = (id, columns, apiRef, defaultValueOptionsFormulae, op
               formulae: [address]
             };
           }
-          const formattedValue = apiRef.current.getCellParams(id, castColumn.field).formattedValue;
+          const formattedValue = apiRef.current.getRowFormattedValue(row, castColumn);
           if (process.env.NODE_ENV !== 'production') {
-            if (String(cellParams.formattedValue) === '[object Object]') {
+            if (String(formattedValue) === '[object Object]') {
               (0, _warning.warnOnce)(['MUI X: When the value of a field is an object or a `renderCell` is provided, the Excel export might not display the value correctly.', 'You can provide a `valueFormatter` with a string representation to be used.']);
             }
           }
           if ((0, _internals.isObject)(formattedValue)) {
-            row[castColumn.field] = formattedValue?.label;
+            serializedRow[castColumn.field] = formattedValue?.label;
           } else {
-            row[castColumn.field] = formattedValue;
+            serializedRow[castColumn.field] = formattedValue;
           }
           break;
         }
       case 'boolean':
       case 'number':
-        cellValue = apiRef.current.getCellParams(id, column.field).value;
+        cellValue = apiRef.current.getRowValue(row, column);
         break;
       case 'date':
       case 'dateTime':
@@ -122,21 +136,21 @@ const serializeRowUnsafe = (id, columns, apiRef, defaultValueOptionsFormulae, op
           // Excel does not do any timezone conversion, so we create a date using UTC instead of local timezone
           // Solution from: https://github.com/exceljs/exceljs/issues/486#issuecomment-432557582
           // About Date.UTC(): https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/UTC#exemples
-          const value = apiRef.current.getCellParams(id, column.field).value;
+          const value = apiRef.current.getRowValue(row, column);
           // value may be `undefined` in auto-generated grouping rows
           if (!value) {
             break;
           }
           const utcDate = new Date(Date.UTC(value.getFullYear(), value.getMonth(), value.getDate(), value.getHours(), value.getMinutes(), value.getSeconds()));
-          row[column.field] = utcDate;
+          serializedRow[column.field] = utcDate;
           break;
         }
       case 'actions':
         break;
       default:
-        cellValue = apiRef.current.getCellParams(id, column.field).formattedValue;
+        cellValue = apiRef.current.getRowFormattedValue(row, column);
         if (process.env.NODE_ENV !== 'production') {
-          if (String(cellParams.formattedValue) === '[object Object]') {
+          if (String(cellValue) === '[object Object]') {
             (0, _warning.warnOnce)(['MUI X: When the value of a field is an object or a `renderCell` is provided, the Excel export might not display the value correctly.', 'You can provide a `valueFormatter` with a string representation to be used.']);
           }
         }
@@ -149,11 +163,11 @@ const serializeRowUnsafe = (id, columns, apiRef, defaultValueOptionsFormulae, op
       }
     }
     if (typeof cellValue !== 'undefined') {
-      row[column.field] = cellValue;
+      serializedRow[column.field] = cellValue;
     }
   });
   return {
-    row,
+    row: serializedRow,
     dataValidation,
     outlineLevel,
     mergedCells
@@ -184,120 +198,39 @@ const serializeColumn = (column, columnsStyles) => {
   };
 };
 exports.serializeColumn = serializeColumn;
-const addColumnGroupingHeaders = (worksheet, columns, columnGroupPaths, columnGroupDetails) => {
-  const maxDepth = Math.max(...columns.map(({
-    key
-  }) => columnGroupPaths[key]?.length ?? 0));
-  if (maxDepth === 0) {
-    return;
-  }
-  for (let rowIndex = 0; rowIndex < maxDepth; rowIndex += 1) {
-    const row = columns.map(({
-      key
-    }) => {
-      const groupingPath = columnGroupPaths[key];
-      if (groupingPath.length <= rowIndex) {
-        return {
-          groupId: null,
-          parents: groupingPath
-        };
-      }
-      return (0, _extends2.default)({}, columnGroupDetails[groupingPath[rowIndex]], {
-        parents: groupingPath.slice(0, rowIndex)
-      });
-    });
-    const newRow = worksheet.addRow(row.map(group => group.groupId === null ? null : group?.headerName ?? group.groupId));
-
-    // use `rowCount`, since worksheet can have additional rows added in `exceljsPreProcess`
-    const lastRowIndex = newRow.worksheet.rowCount;
-    let leftIndex = 0;
-    let rightIndex = 1;
-    while (rightIndex < columns.length) {
-      const {
-        groupId: leftGroupId,
-        parents: leftParents
-      } = row[leftIndex];
-      const {
-        groupId: rightGroupId,
-        parents: rightParents
-      } = row[rightIndex];
-      const areInSameGroup = leftGroupId === rightGroupId && leftParents.length === rightParents.length && leftParents.every((leftParent, index) => rightParents[index] === leftParent);
-      if (areInSameGroup) {
-        rightIndex += 1;
-      } else {
-        if (rightIndex - leftIndex > 1) {
-          worksheet.mergeCells(lastRowIndex, leftIndex + 1, lastRowIndex, rightIndex);
-        }
-        leftIndex = rightIndex;
-        rightIndex += 1;
-      }
-    }
-    if (rightIndex - leftIndex > 1) {
-      worksheet.mergeCells(lastRowIndex, leftIndex + 1, lastRowIndex, rightIndex);
-    }
-  }
-};
 function serializeColumns(columns, styles) {
   return columns.map(column => serializeColumn(column, styles));
 }
 async function getDataForValueOptionsSheet(columns, valueOptionsSheetName, api) {
-  const candidateColumns = columns.filter(column => (0, _internals.isSingleSelectColDef)(column) && Array.isArray(column.valueOptions));
-
   // Creates a temp worksheet to obtain the column letters
-  const excelJS = await getExcelJs();
+  const excelJS = await (0, _utils.getExcelJs)();
   const workbook = new excelJS.Workbook();
   const worksheet = workbook.addWorksheet('Sheet1');
-  worksheet.columns = candidateColumns.map(column => ({
-    key: column.field
-  }));
-  return candidateColumns.reduce((acc, column) => {
-    const singleSelectColumn = column;
-    const formattedValueOptions = getFormattedValueOptions(singleSelectColumn, {}, singleSelectColumn.valueOptions, api);
+  const record = {};
+  const worksheetColumns = [];
+  for (let i = 0; i < columns.length; i += 1) {
+    const column = columns[i];
+    const isCandidateColumn = (0, _internals.isSingleSelectColDef)(column) && Array.isArray(column.valueOptions);
+    if (!isCandidateColumn) {
+      continue;
+    }
+    worksheetColumns.push({
+      key: column.field
+    });
+    worksheet.columns = worksheetColumns;
     const header = column.headerName ?? column.field;
-    const values = [header, ...formattedValueOptions];
+    const values = [header];
+    getFormattedValueOptions(column, {}, column.valueOptions, api, value => {
+      values.push(value);
+    });
     const letter = worksheet.getColumn(column.field).letter;
     const address = `${valueOptionsSheetName}!$${letter}$2:$${letter}$${values.length}`;
-    acc[column.field] = {
+    record[column.field] = {
       values,
       address
     };
-    return acc;
-  }, {});
-}
-function addSerializedRowToWorksheet(serializedRow, worksheet) {
-  const {
-    row,
-    dataValidation,
-    outlineLevel,
-    mergedCells
-  } = serializedRow;
-  const newRow = worksheet.addRow(row);
-  Object.keys(dataValidation).forEach(field => {
-    newRow.getCell(field).dataValidation = (0, _extends2.default)({}, dataValidation[field]);
-  });
-  if (outlineLevel) {
-    newRow.outlineLevel = outlineLevel;
   }
-
-  // use `rowCount`, since worksheet can have additional rows added in `exceljsPreProcess`
-  const lastRowIndex = newRow.worksheet.rowCount;
-  mergedCells.forEach(mergedCell => {
-    worksheet.mergeCells(lastRowIndex, mergedCell.leftIndex, lastRowIndex, mergedCell.rightIndex);
-  });
-}
-async function createValueOptionsSheetIfNeeded(valueOptionsData, sheetName, workbook) {
-  if (Object.keys(valueOptionsData).length === 0) {
-    return;
-  }
-  const valueOptionsWorksheet = workbook.addWorksheet(sheetName);
-  valueOptionsWorksheet.columns = Object.keys(valueOptionsData).map(key => ({
-    key
-  }));
-  Object.entries(valueOptionsData).forEach(([field, {
-    values
-  }]) => {
-    valueOptionsWorksheet.getColumn(field).values = values;
-  });
+  return record;
 }
 async function buildExcel(options, apiRef) {
   const {
@@ -310,7 +243,7 @@ async function buildExcel(options, apiRef) {
     exceljsPostProcess,
     columnsStyles = {}
   } = options;
-  const excelJS = await getExcelJs();
+  const excelJS = await (0, _utils.getExcelJs)();
   const workbook = new excelJS.Workbook();
   const worksheet = workbook.addWorksheet('Sheet1');
   const serializedColumns = serializeColumns(columns, columnsStyles);
@@ -326,17 +259,17 @@ async function buildExcel(options, apiRef) {
       acc[column.field] = apiRef.current.getColumnGroupPath(column.field);
       return acc;
     }, {});
-    addColumnGroupingHeaders(worksheet, serializedColumns, columnGroupPaths, apiRef.current.getAllGroupDetails());
+    (0, _utils.addColumnGroupingHeaders)(worksheet, serializedColumns, columnGroupPaths, apiRef.current.getAllGroupDetails());
   }
   if (includeHeaders) {
     worksheet.addRow(columns.map(column => column.headerName ?? column.field));
   }
   const valueOptionsData = await getDataForValueOptionsSheet(columns, valueOptionsSheetName, apiRef.current);
-  createValueOptionsSheetIfNeeded(valueOptionsData, valueOptionsSheetName, workbook);
+  (0, _utils.createValueOptionsSheetIfNeeded)(valueOptionsData, valueOptionsSheetName, workbook);
   apiRef.current.resetColSpan();
   rowIds.forEach(id => {
     const serializedRow = serializeRowUnsafe(id, columns, apiRef, valueOptionsData, options);
-    addSerializedRowToWorksheet(serializedRow, worksheet);
+    (0, _utils.addSerializedRowToWorksheet)(serializedRow, worksheet);
   });
   apiRef.current.resetColSpan();
   if (exceljsPostProcess) {
@@ -346,50 +279,4 @@ async function buildExcel(options, apiRef) {
     });
   }
   return workbook;
-}
-function setupExcelExportWebWorker(workerOptions = {}) {
-  // eslint-disable-next-line no-restricted-globals
-  addEventListener('message', async event => {
-    const {
-      serializedColumns,
-      serializedRows,
-      options,
-      valueOptionsSheetName,
-      valueOptionsData,
-      columnGroupDetails,
-      columnGroupPaths
-    } = event.data;
-    const {
-      exceljsPostProcess,
-      exceljsPreProcess
-    } = workerOptions;
-    const excelJS = await getExcelJs();
-    const workbook = new excelJS.Workbook();
-    const worksheet = workbook.addWorksheet('Sheet1');
-    worksheet.columns = serializedColumns;
-    if (exceljsPreProcess) {
-      await exceljsPreProcess({
-        workbook,
-        worksheet
-      });
-    }
-    if (options.includeColumnGroupsHeaders) {
-      addColumnGroupingHeaders(worksheet, serializedColumns, columnGroupPaths, columnGroupDetails);
-    }
-    const includeHeaders = options.includeHeaders ?? true;
-    if (includeHeaders) {
-      worksheet.addRow(serializedColumns.map(column => column.headerText));
-    }
-    createValueOptionsSheetIfNeeded(valueOptionsData, valueOptionsSheetName, workbook);
-    serializedRows.forEach(serializedRow => {
-      addSerializedRowToWorksheet(serializedRow, worksheet);
-    });
-    if (exceljsPostProcess) {
-      await exceljsPostProcess({
-        workbook,
-        worksheet
-      });
-    }
-    postMessage(await workbook.xlsx.writeBuffer());
-  });
 }

package/hooks/features/export/serializer/setupExcelExportWebWorker.d.ts

@@ -0,0 +1,2 @@
+import type { GridExcelExportOptions } from '../gridExcelExportInterface';
+export declare function setupExcelExportWebWorker(workerOptions?: Pick<GridExcelExportOptions, 'exceljsPostProcess' | 'exceljsPreProcess'>): void;

package/hooks/features/export/serializer/setupExcelExportWebWorker.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setupExcelExportWebWorker = setupExcelExportWebWorker;
+var _utils = require("./utils");
+function setupExcelExportWebWorker(workerOptions = {}) {
+  // eslint-disable-next-line no-restricted-globals
+  addEventListener('message', async event => {
+    const {
+      namespace,
+      serializedColumns,
+      serializedRows,
+      options,
+      valueOptionsSheetName,
+      valueOptionsData,
+      columnGroupDetails,
+      columnGroupPaths
+    } = event.data;
+
+    // workers share the pub-sub channel namespace. Use this property to filter out messages.
+    if (namespace !== 'mui-x-data-grid-export') {
+      return;
+    }
+    const {
+      exceljsPostProcess,
+      exceljsPreProcess
+    } = workerOptions;
+    const excelJS = await (0, _utils.getExcelJs)();
+    const workbook = new excelJS.Workbook();
+    const worksheet = workbook.addWorksheet('Sheet1');
+    worksheet.columns = serializedColumns;
+    if (exceljsPreProcess) {
+      await exceljsPreProcess({
+        workbook,
+        worksheet
+      });
+    }
+    if (options.includeColumnGroupsHeaders) {
+      (0, _utils.addColumnGroupingHeaders)(worksheet, serializedColumns, columnGroupPaths, columnGroupDetails);
+    }
+    const includeHeaders = options.includeHeaders ?? true;
+    if (includeHeaders) {
+      worksheet.addRow(serializedColumns.map(column => column.headerText));
+    }
+    (0, _utils.createValueOptionsSheetIfNeeded)(valueOptionsData, valueOptionsSheetName, workbook);
+    serializedRows.forEach(serializedRow => {
+      (0, _utils.addSerializedRowToWorksheet)(serializedRow, worksheet);
+    });
+    if (exceljsPostProcess) {
+      await exceljsPostProcess({
+        workbook,
+        worksheet
+      });
+    }
+    postMessage(await workbook.xlsx.writeBuffer());
+  });
+}

package/hooks/features/export/serializer/utils.d.ts

@@ -0,0 +1,36 @@
+import type * as Excel from 'exceljs';
+import type { GridColumnGroupLookup } from '@mui/x-data-grid/internals';
+import type { GridExcelExportOptions } from '../gridExcelExportInterface';
+export declare const getExcelJs: () => Promise<typeof Excel>;
+export interface SerializedRow {
+    row: Record<string, undefined | number | boolean | string | Date>;
+    dataValidation: Record<string, Excel.DataValidation>;
+    outlineLevel: number;
+    mergedCells: {
+        leftIndex: number;
+        rightIndex: number;
+    }[];
+}
+export declare const addColumnGroupingHeaders: (worksheet: Excel.Worksheet, columns: SerializedColumns, columnGroupPaths: Record<string, string[]>, columnGroupDetails: GridColumnGroupLookup) => void;
+export type SerializedColumns = Array<{
+    key: string;
+    width: number;
+    style: Partial<Excel.Style>;
+    headerText: string;
+}>;
+export type ValueOptionsData = Record<string, {
+    values: (string | number)[];
+    address: string;
+}>;
+export declare function addSerializedRowToWorksheet(serializedRow: SerializedRow, worksheet: Excel.Worksheet): void;
+export declare function createValueOptionsSheetIfNeeded(valueOptionsData: ValueOptionsData, sheetName: string, workbook: Excel.Workbook): Promise<void>;
+export interface ExcelExportInitEvent {
+    namespace?: string;
+    serializedColumns: SerializedColumns;
+    serializedRows: SerializedRow[];
+    valueOptionsSheetName: string;
+    columnGroupPaths: Record<string, string[]>;
+    columnGroupDetails: GridColumnGroupLookup;
+    valueOptionsData: ValueOptionsData;
+    options: Omit<GridExcelExportOptions, 'exceljsPreProcess' | 'exceljsPostProcess' | 'columnsStyles' | 'valueOptionsSheetName'>;
+}