@mui/x-data-grid-premium 5.11.0

package/legacy/DataGridPremium/index.js

@@ -0,0 +1,2 @@
+export * from './DataGridPremium';
+export { DATA_GRID_PREMIUM_PROPS_DEFAULT_VALUES } from './useDataGridPremiumProps';

package/legacy/DataGridPremium/useDataGridPremiumComponent.js

@@ -0,0 +1,78 @@
+import { useGridInitialization, useGridInitializeState, useGridClipboard, useGridColumnMenu, useGridColumns, columnsStateInitializer, useGridDensity, useGridCsvExport, useGridPrintExport, useGridFilter, filterStateInitializer, useGridFocus, useGridKeyboardNavigation, useGridPagination, paginationStateInitializer, useGridPreferencesPanel, useGridEditing_new, useGridEditing_old, editingStateInitializer_old, editingStateInitializer_new, useGridRows, useGridRowsPreProcessors, rowsStateInitializer, useGridRowsMeta, useGridParamsApi, useGridSelection, useGridSorting, sortingStateInitializer, useGridScroll, useGridEvents, useGridDimensions, useGridStatePersistence, useGridSelectionPreProcessors, columnMenuStateInitializer, densityStateInitializer, focusStateInitializer, preferencePanelStateInitializer, rowsMetaStateInitializer, selectionStateInitializer, useGridColumnReorder, columnReorderStateInitializer, useGridColumnResize, columnResizeStateInitializer, useGridTreeData, useGridTreeDataPreProcessors, useGridColumnPinning, columnPinningStateInitializer, useGridColumnPinningPreProcessors, useGridDetailPanel, detailPanelStateInitializer, useGridDetailPanelCache, useGridDetailPanelPreProcessors, useGridInfiniteLoader, useGridColumnSpanning, useGridRowReorder, useGridRowReorderPreProcessors } from '@mui/x-data-grid-pro/internals';
+// Premium-only features
+import { useGridRowGrouping, rowGroupingStateInitializer } from '../hooks/features/rowGrouping/useGridRowGrouping';
+import { useGridRowGroupingPreProcessors } from '../hooks/features/rowGrouping/useGridRowGroupingPreProcessors';
+import { useGridExcelExport } from '../hooks/features/export/useGridExcelExport';
+export var useDataGridPremiumComponent = function useDataGridPremiumComponent(inputApiRef, props) {
+  var _props$experimentalFe, _props$experimentalFe2;
+
+  var apiRef = useGridInitialization(inputApiRef, props);
+  /**
+   * Register all pre-processors called during state initialization here.
+   */
+
+  useGridSelectionPreProcessors(apiRef, props);
+  useGridRowReorderPreProcessors(apiRef, props);
+  useGridRowGroupingPreProcessors(apiRef, props);
+  useGridTreeDataPreProcessors(apiRef, props);
+  useGridDetailPanelPreProcessors(apiRef, props); // The column pinning `hydrateColumns` pre-processor must be after every other `hydrateColumns` pre-processors
+  // Because it changes the order of the columns.
+
+  useGridColumnPinningPreProcessors(apiRef, props);
+  useGridRowsPreProcessors(apiRef);
+  /**
+   * Register all state initializers here.
+   */
+
+  useGridInitializeState(rowGroupingStateInitializer, apiRef, props);
+  useGridInitializeState(selectionStateInitializer, apiRef, props);
+  useGridInitializeState(detailPanelStateInitializer, apiRef, props);
+  useGridInitializeState(columnPinningStateInitializer, apiRef, props);
+  useGridInitializeState(columnsStateInitializer, apiRef, props);
+  useGridInitializeState(rowsStateInitializer, apiRef, props);
+  useGridInitializeState((_props$experimentalFe = props.experimentalFeatures) != null && _props$experimentalFe.newEditingApi ? editingStateInitializer_new : editingStateInitializer_old, apiRef, props);
+  useGridInitializeState(focusStateInitializer, apiRef, props);
+  useGridInitializeState(sortingStateInitializer, apiRef, props);
+  useGridInitializeState(preferencePanelStateInitializer, apiRef, props);
+  useGridInitializeState(filterStateInitializer, apiRef, props);
+  useGridInitializeState(densityStateInitializer, apiRef, props);
+  useGridInitializeState(columnReorderStateInitializer, apiRef, props);
+  useGridInitializeState(columnResizeStateInitializer, apiRef, props);
+  useGridInitializeState(paginationStateInitializer, apiRef, props);
+  useGridInitializeState(rowsMetaStateInitializer, apiRef, props);
+  useGridInitializeState(columnMenuStateInitializer, apiRef, props);
+  useGridRowGrouping(apiRef, props);
+  useGridTreeData(apiRef);
+  useGridKeyboardNavigation(apiRef, props);
+  useGridSelection(apiRef, props);
+  useGridDetailPanel(apiRef, props);
+  useGridColumnPinning(apiRef, props);
+  useGridColumns(apiRef, props);
+  useGridRows(apiRef, props);
+  useGridParamsApi(apiRef);
+  useGridColumnSpanning(apiRef);
+  useGridDetailPanelCache(apiRef, props);
+  var useGridEditing = (_props$experimentalFe2 = props.experimentalFeatures) != null && _props$experimentalFe2.newEditingApi ? useGridEditing_new : useGridEditing_old;
+  useGridEditing(apiRef, props);
+  useGridFocus(apiRef, props);
+  useGridPreferencesPanel(apiRef);
+  useGridFilter(apiRef, props);
+  useGridSorting(apiRef, props);
+  useGridDensity(apiRef, props);
+  useGridColumnReorder(apiRef, props);
+  useGridColumnResize(apiRef, props);
+  useGridPagination(apiRef, props);
+  useGridRowsMeta(apiRef, props);
+  useGridRowReorder(apiRef, props);
+  useGridScroll(apiRef, props);
+  useGridInfiniteLoader(apiRef, props);
+  useGridColumnMenu(apiRef);
+  useGridCsvExport(apiRef);
+  useGridPrintExport(apiRef, props);
+  useGridExcelExport(apiRef);
+  useGridClipboard(apiRef);
+  useGridDimensions(apiRef, props);
+  useGridEvents(apiRef, props);
+  useGridStatePersistence(apiRef);
+  return apiRef;
+};

package/legacy/DataGridPremium/useDataGridPremiumProps.js

@@ -0,0 +1,46 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { useThemeProps } from '@mui/material/styles';
+import { DATA_GRID_PRO_PROPS_DEFAULT_VALUES, DATA_GRID_DEFAULT_SLOTS_COMPONENTS, GRID_DEFAULT_LOCALE_TEXT } from '@mui/x-data-grid-pro';
+
+/**
+ * The default values of `DataGridPremiumPropsWithDefaultValue` to inject in the props of DataGridPremium.
+ */
+export var DATA_GRID_PREMIUM_PROPS_DEFAULT_VALUES = _extends({}, DATA_GRID_PRO_PROPS_DEFAULT_VALUES, {
+  disableRowGrouping: false,
+  rowGroupingColumnMode: 'single'
+});
+export var useDataGridPremiumProps = function useDataGridPremiumProps(inProps) {
+  var themedProps = useThemeProps({
+    props: inProps,
+    name: 'MuiDataGrid'
+  });
+  var localeText = React.useMemo(function () {
+    return _extends({}, GRID_DEFAULT_LOCALE_TEXT, themedProps.localeText);
+  }, [themedProps.localeText]);
+  var components = React.useMemo(function () {
+    var overrides = themedProps.components;
+
+    if (!overrides) {
+      return _extends({}, DATA_GRID_DEFAULT_SLOTS_COMPONENTS);
+    }
+
+    var mergedComponents = {};
+    Object.entries(DATA_GRID_DEFAULT_SLOTS_COMPONENTS).forEach(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+          key = _ref2[0],
+          defaultComponent = _ref2[1];
+
+      mergedComponents[key] = overrides[key] === undefined ? defaultComponent : overrides[key];
+    });
+    return mergedComponents;
+  }, [themedProps.components]);
+  return React.useMemo(function () {
+    return _extends({}, DATA_GRID_PREMIUM_PROPS_DEFAULT_VALUES, themedProps, {
+      localeText: localeText,
+      components: components,
+      signature: 'DataGridPremium'
+    });
+  }, [themedProps, localeText, components]);
+};

package/legacy/components/GridExcelExportMenuItem.js

@@ -0,0 +1,30 @@
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import MenuItem from '@mui/material/MenuItem';
+import { useGridApiContext } from '../hooks/utils/useGridApiContext';
+import { jsx as _jsx } from "react/jsx-runtime";
+
+var GridExcelExportMenuItem = function GridExcelExportMenuItem(props) {
+  var apiRef = useGridApiContext();
+  var hideMenu = props.hideMenu,
+      options = props.options;
+  return /*#__PURE__*/_jsx(MenuItem, {
+    onClick: function onClick() {
+      apiRef.current.exportDataAsExcel(options);
+      hideMenu == null ? void 0 : hideMenu();
+    },
+    children: apiRef.current.getLocaleText('toolbarExportExcel')
+  });
+};
+
+process.env.NODE_ENV !== "production" ? GridExcelExportMenuItem.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  hideMenu: PropTypes.func,
+  options: PropTypes.shape({
+    disableToolbarButton: PropTypes.bool
+  })
+} : void 0;
+export { GridExcelExportMenuItem };

package/legacy/components/GridGroupingColumnLeafCell.js

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import Box from '@mui/material/Box';
+import { useGridRootProps } from '../hooks/utils/useGridRootProps';
+import { jsx as _jsx } from "react/jsx-runtime";
+
+var GridGroupingColumnLeafCell = function GridGroupingColumnLeafCell(props) {
+  var _props$formattedValue;
+
+  var rowNode = props.rowNode;
+  var rootProps = useGridRootProps();
+  var marginLeft = rootProps.rowGroupingColumnMode === 'multiple' ? 1 : rowNode.depth * 2;
+  return /*#__PURE__*/_jsx(Box, {
+    sx: {
+      ml: marginLeft
+    },
+    children: (_props$formattedValue = props.formattedValue) != null ? _props$formattedValue : props.value
+  });
+};
+
+export { GridGroupingColumnLeafCell };

package/legacy/components/GridGroupingCriteriaCell.js

@@ -0,0 +1,74 @@
+import * as React from 'react';
+import { unstable_composeClasses as composeClasses } from '@mui/material';
+import IconButton from '@mui/material/IconButton';
+import Box from '@mui/material/Box';
+import { useGridSelector, gridFilteredDescendantCountLookupSelector, getDataGridUtilityClass } from '@mui/x-data-grid-pro';
+import { useGridApiContext } from '../hooks/utils/useGridApiContext';
+import { useGridRootProps } from '../hooks/utils/useGridRootProps';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+
+var useUtilityClasses = function useUtilityClasses(ownerState) {
+  var classes = ownerState.classes;
+  var slots = {
+    root: ['groupingCriteriaCell'],
+    toggle: ['groupingCriteriaCellToggle']
+  };
+  return composeClasses(slots, getDataGridUtilityClass, classes);
+};
+
+export var GridGroupingCriteriaCell = function GridGroupingCriteriaCell(props) {
+  var _filteredDescendantCo;
+
+  var id = props.id,
+      field = props.field,
+      rowNode = props.rowNode,
+      hideDescendantCount = props.hideDescendantCount,
+      formattedValue = props.formattedValue;
+  var rootProps = useGridRootProps();
+  var apiRef = useGridApiContext();
+  var ownerState = {
+    classes: rootProps.classes
+  };
+  var classes = useUtilityClasses(ownerState);
+  var filteredDescendantCountLookup = useGridSelector(apiRef, gridFilteredDescendantCountLookupSelector);
+  var filteredDescendantCount = (_filteredDescendantCo = filteredDescendantCountLookup[rowNode.id]) != null ? _filteredDescendantCo : 0;
+  var Icon = rowNode.childrenExpanded ? rootProps.components.GroupingCriteriaCollapseIcon : rootProps.components.GroupingCriteriaExpandIcon;
+
+  var handleKeyDown = function handleKeyDown(event) {
+    if (event.key === ' ') {
+      event.stopPropagation();
+    }
+
+    apiRef.current.publishEvent('cellKeyDown', props, event);
+  };
+
+  var handleClick = function handleClick(event) {
+    apiRef.current.setRowChildrenExpansion(id, !rowNode.childrenExpanded);
+    apiRef.current.setCellFocus(id, field);
+    event.stopPropagation();
+  };
+
+  var marginLeft = rootProps.rowGroupingColumnMode === 'multiple' ? 0 : rowNode.depth * 2;
+  return /*#__PURE__*/_jsxs(Box, {
+    className: classes.root,
+    sx: {
+      ml: marginLeft
+    },
+    children: [/*#__PURE__*/_jsx("div", {
+      className: classes.toggle,
+      children: filteredDescendantCount > 0 && /*#__PURE__*/_jsx(IconButton, {
+        size: "small",
+        onClick: handleClick,
+        onKeyDown: handleKeyDown,
+        tabIndex: -1,
+        "aria-label": rowNode.childrenExpanded ? apiRef.current.getLocaleText('treeDataCollapse') : apiRef.current.getLocaleText('treeDataExpand'),
+        children: /*#__PURE__*/_jsx(Icon, {
+          fontSize: "inherit"
+        })
+      })
+    }), /*#__PURE__*/_jsxs("span", {
+      children: [formattedValue === undefined ? rowNode.groupingKey : formattedValue, !hideDescendantCount && filteredDescendantCount > 0 ? " (".concat(filteredDescendantCount, ")") : '']
+    })]
+  });
+};

package/legacy/components/GridRowGroupableColumnMenuItems.js

@@ -0,0 +1,61 @@
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import MenuItem from '@mui/material/MenuItem';
+import { gridColumnLookupSelector, useGridSelector } from '@mui/x-data-grid-pro';
+import { useGridApiContext } from '../hooks/utils/useGridApiContext';
+import { gridRowGroupingSanitizedModelSelector } from '../hooks/features/rowGrouping/gridRowGroupingSelector';
+import { jsx as _jsx } from "react/jsx-runtime";
+
+var GridRowGroupableColumnMenuItems = function GridRowGroupableColumnMenuItems(props) {
+  var _columnsLookup$column;
+
+  var column = props.column,
+      onClick = props.onClick;
+  var apiRef = useGridApiContext();
+  var rowGroupingModel = useGridSelector(apiRef, gridRowGroupingSanitizedModelSelector);
+  var columnsLookup = useGridSelector(apiRef, gridColumnLookupSelector);
+
+  if (!(column != null && column.groupable)) {
+    return null;
+  }
+
+  var ungroupColumn = function ungroupColumn(event) {
+    apiRef.current.removeRowGroupingCriteria(column.field);
+
+    if (onClick) {
+      onClick(event);
+    }
+  };
+
+  var groupColumn = function groupColumn(event) {
+    apiRef.current.addRowGroupingCriteria(column.field);
+
+    if (onClick) {
+      onClick(event);
+    }
+  };
+
+  var name = (_columnsLookup$column = columnsLookup[column.field].headerName) != null ? _columnsLookup$column : column.field;
+
+  if (rowGroupingModel.includes(column.field)) {
+    return /*#__PURE__*/_jsx(MenuItem, {
+      onClick: ungroupColumn,
+      children: apiRef.current.getLocaleText('unGroupColumn')(name)
+    });
+  }
+
+  return /*#__PURE__*/_jsx(MenuItem, {
+    onClick: groupColumn,
+    children: apiRef.current.getLocaleText('groupColumn')(name)
+  });
+};
+
+process.env.NODE_ENV !== "production" ? GridRowGroupableColumnMenuItems.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  column: PropTypes.object,
+  onClick: PropTypes.func
+} : void 0;
+export { GridRowGroupableColumnMenuItems };

package/legacy/components/GridRowGroupingColumnMenuItems.js

@@ -0,0 +1,56 @@
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import MenuItem from '@mui/material/MenuItem';
+import { useGridSelector, gridColumnLookupSelector } from '@mui/x-data-grid-pro';
+import { useGridApiContext } from '../hooks/utils/useGridApiContext';
+import { gridRowGroupingSanitizedModelSelector } from '../hooks/features/rowGrouping/gridRowGroupingSelector';
+import { getRowGroupingCriteriaFromGroupingField, GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD, isGroupingColumn } from '../hooks/features/rowGrouping/gridRowGroupingUtils';
+import { jsx as _jsx } from "react/jsx-runtime";
+
+var GridRowGroupingColumnMenuItems = function GridRowGroupingColumnMenuItems(props) {
+  var column = props.column,
+      onClick = props.onClick;
+  var apiRef = useGridApiContext();
+  var rowGroupingModel = useGridSelector(apiRef, gridRowGroupingSanitizedModelSelector);
+  var columnsLookup = useGridSelector(apiRef, gridColumnLookupSelector);
+
+  var renderUnGroupingMenuItem = function renderUnGroupingMenuItem(field) {
+    var _columnsLookup$field$;
+
+    var ungroupColumn = function ungroupColumn(event) {
+      apiRef.current.removeRowGroupingCriteria(field);
+
+      if (onClick) {
+        onClick(event);
+      }
+    };
+
+    var name = (_columnsLookup$field$ = columnsLookup[field].headerName) != null ? _columnsLookup$field$ : field;
+    return /*#__PURE__*/_jsx(MenuItem, {
+      onClick: ungroupColumn,
+      children: apiRef.current.getLocaleText('unGroupColumn')(name)
+    }, field);
+  };
+
+  if (!column || !isGroupingColumn(column.field)) {
+    return null;
+  }
+
+  if (column.field === GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD) {
+    return /*#__PURE__*/_jsx(React.Fragment, {
+      children: rowGroupingModel.map(renderUnGroupingMenuItem)
+    });
+  }
+
+  return renderUnGroupingMenuItem(getRowGroupingCriteriaFromGroupingField(column.field));
+};
+
+process.env.NODE_ENV !== "production" ? GridRowGroupingColumnMenuItems.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  column: PropTypes.object,
+  onClick: PropTypes.func
+} : void 0;
+export { GridRowGroupingColumnMenuItems };

package/legacy/components/index.js

@@ -0,0 +1 @@
+export * from './GridExcelExportMenuItem';

package/legacy/hooks/features/export/gridExcelExportInterface.js

@@ -0,0 +1 @@
+export {};

package/legacy/hooks/features/export/index.js

@@ -0,0 +1 @@
+export * from './gridExcelExportInterface';

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

@@ -0,0 +1,260 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+
+var _defaultColumnsStyles;
+
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { GRID_DATE_COL_DEF, GRID_DATETIME_COL_DEF } from '@mui/x-data-grid-pro';
+import { buildWarning } from '@mui/x-data-grid/internals';
+
+var getExcelJs = function getExcelJs() {
+  return import('exceljs');
+};
+
+var warnInvalidFormattedValue = buildWarning(['MUI: 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.']);
+
+var getFormattedValueOptions = function getFormattedValueOptions(colDef, valueOptions, api) {
+  if (!colDef.valueOptions) {
+    return [];
+  }
+
+  var valueOptionsFormatted = valueOptions;
+
+  if (colDef.valueFormatter) {
+    valueOptionsFormatted = valueOptionsFormatted.map(function (option) {
+      if (_typeof(option) === 'object') {
+        return option;
+      }
+
+      var params = {
+        field: colDef.field,
+        api: api,
+        value: option
+      };
+      return String(colDef.valueFormatter(params));
+    });
+  }
+
+  return valueOptionsFormatted.map(function (option) {
+    return _typeof(option) === 'object' ? option.label : option;
+  });
+};
+
+var serializeRow = function serializeRow(id, columns, api, defaultValueOptionsFormulae) {
+  var row = {};
+  var dataValidation = {};
+  var firstCellParams = api.getCellParams(id, columns[0].field);
+  var outlineLevel = firstCellParams.rowNode.depth;
+  columns.forEach(function (column) {
+    var cellParams = api.getCellParams(id, column.field);
+
+    switch (cellParams.colDef.type) {
+      case 'singleSelect':
+        {
+          var _formattedValue$label;
+
+          if (typeof cellParams.colDef.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
+            var valueOptions = cellParams.colDef.valueOptions({
+              id: id,
+              row: row,
+              field: cellParams.field
+            });
+            var formattedValueOptions = getFormattedValueOptions(cellParams.colDef, valueOptions, api);
+            dataValidation[column.field] = {
+              type: 'list',
+              allowBlank: true,
+              formulae: ["\"".concat(formattedValueOptions.map(function (x) {
+                return x.toString().replaceAll(',', 'CHAR(44)');
+              }).join(','), "\"")]
+            };
+          } else {
+            // If value option is defined for the column, refer to another sheet
+            dataValidation[column.field] = {
+              type: 'list',
+              allowBlank: true,
+              formulae: [defaultValueOptionsFormulae[column.field]]
+            };
+          }
+
+          var formattedValue = api.getCellParams(id, column.field).formattedValue;
+
+          if (process.env.NODE_ENV !== 'production') {
+            if (String(cellParams.formattedValue) === '[object Object]') {
+              warnInvalidFormattedValue();
+            }
+          }
+
+          row[column.field] = (_formattedValue$label = formattedValue == null ? void 0 : formattedValue.label) != null ? _formattedValue$label : formattedValue;
+          break;
+        }
+
+      case 'boolean':
+      case 'number':
+        row[column.field] = api.getCellParams(id, column.field).value;
+        break;
+
+      case 'date':
+      case 'dateTime':
+        {
+          // 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/fr/docs/Web/JavaScript/Reference/Global_Objects/Date/UTC#exemples
+          var date = api.getCellParams(id, column.field).value; // value may be `undefined` in auto-generated grouping rows
+
+          if (!date) {
+            break;
+          }
+
+          var utcDate = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds()));
+          row[column.field] = utcDate;
+          break;
+        }
+
+      case 'actions':
+        break;
+
+      default:
+        row[column.field] = api.getCellParams(id, column.field).formattedValue;
+
+        if (process.env.NODE_ENV !== 'production') {
+          if (String(cellParams.formattedValue) === '[object Object]') {
+            warnInvalidFormattedValue();
+          }
+        }
+
+        break;
+    }
+  });
+  return {
+    row: row,
+    dataValidation: dataValidation,
+    outlineLevel: outlineLevel
+  };
+};
+
+var defaultColumnsStyles = (_defaultColumnsStyles = {}, _defineProperty(_defaultColumnsStyles, GRID_DATE_COL_DEF.type, {
+  numFmt: 'dd.mm.yyyy'
+}), _defineProperty(_defaultColumnsStyles, GRID_DATETIME_COL_DEF.type, {
+  numFmt: 'dd.mm.yyyy hh:mm'
+}), _defaultColumnsStyles);
+
+var serializeColumn = function serializeColumn(column, columnsStyles) {
+  var field = column.field,
+      type = column.type;
+  return {
+    key: field,
+    // Excel width must stay between 0 and 255 (https://support.microsoft.com/en-us/office/change-the-column-width-and-row-height-72f5e3cc-994d-43e8-ae58-9774a0905f46)
+    // From the example of column width behavior (https://docs.microsoft.com/en-US/office/troubleshoot/excel/determine-column-widths#example-of-column-width-behavior)
+    // a value of 10 corresponds to 75px. This is an approximation, because column width depends on the the font-size
+    width: Math.min(255, column.width ? column.width / 7.5 : 8.43),
+    style: _extends({}, type && (defaultColumnsStyles == null ? void 0 : defaultColumnsStyles[type]), columnsStyles == null ? void 0 : columnsStyles[field])
+  };
+};
+
+export function buildExcel(_x, _x2) {
+  return _buildExcel.apply(this, arguments);
+}
+
+function _buildExcel() {
+  _buildExcel = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(options, api) {
+    var columns, rowIds, includeHeaders, valueOptionsSheetName, exceljsPreProcess, exceljsPostProcess, _options$columnsStyle, columnsStyles, excelJS, workbook, worksheet, columnsWithArrayValueOptions, defaultValueOptionsFormulae, valueOptionsWorksheet;
+
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            columns = options.columns, rowIds = options.rowIds, includeHeaders = options.includeHeaders, valueOptionsSheetName = options.valueOptionsSheetName, exceljsPreProcess = options.exceljsPreProcess, exceljsPostProcess = options.exceljsPostProcess, _options$columnsStyle = options.columnsStyles, columnsStyles = _options$columnsStyle === void 0 ? {} : _options$columnsStyle;
+            _context.next = 3;
+            return getExcelJs();
+
+          case 3:
+            excelJS = _context.sent;
+            workbook = new excelJS.Workbook();
+            worksheet = workbook.addWorksheet('Sheet1');
+            worksheet.columns = columns.map(function (column) {
+              return serializeColumn(column, columnsStyles);
+            });
+
+            if (!exceljsPreProcess) {
+              _context.next = 10;
+              break;
+            }
+
+            _context.next = 10;
+            return exceljsPreProcess({
+              workbook: workbook,
+              worksheet: worksheet
+            });
+
+          case 10:
+            if (includeHeaders) {
+              worksheet.addRow(columns.map(function (column) {
+                return column.headerName || column.field;
+              }));
+            }
+
+            columnsWithArrayValueOptions = columns.filter(function (column) {
+              return column.type === 'singleSelect' && column.valueOptions && typeof column.valueOptions !== 'function';
+            });
+            defaultValueOptionsFormulae = {};
+
+            if (columnsWithArrayValueOptions.length) {
+              valueOptionsWorksheet = workbook.addWorksheet(valueOptionsSheetName);
+              valueOptionsWorksheet.columns = columnsWithArrayValueOptions.map(function (_ref) {
+                var field = _ref.field;
+                return {
+                  key: field
+                };
+              });
+              columnsWithArrayValueOptions.forEach(function (column) {
+                var formattedValueOptions = getFormattedValueOptions(column, column.valueOptions, api);
+                valueOptionsWorksheet.getColumn(column.field).values = [column.headerName || column.field].concat(_toConsumableArray(formattedValueOptions));
+                var columnLetter = valueOptionsWorksheet.getColumn(column.field).letter;
+                defaultValueOptionsFormulae[column.field] = "".concat(valueOptionsSheetName, "!$").concat(columnLetter, "$2:$").concat(columnLetter, "$").concat(1 + formattedValueOptions.length);
+              });
+            }
+
+            rowIds.forEach(function (id) {
+              var _serializeRow = serializeRow(id, columns, api, defaultValueOptionsFormulae),
+                  row = _serializeRow.row,
+                  dataValidation = _serializeRow.dataValidation,
+                  outlineLevel = _serializeRow.outlineLevel;
+
+              var newRow = worksheet.addRow(row);
+              Object.keys(dataValidation).forEach(function (field) {
+                newRow.getCell(field).dataValidation = _extends({}, dataValidation[field]);
+              });
+
+              if (outlineLevel) {
+                newRow.outlineLevel = outlineLevel;
+              }
+            });
+
+            if (!exceljsPostProcess) {
+              _context.next = 18;
+              break;
+            }
+
+            _context.next = 18;
+            return exceljsPostProcess({
+              workbook: workbook,
+              worksheet: worksheet
+            });
+
+          case 18:
+            return _context.abrupt("return", workbook);
+
+          case 19:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _buildExcel.apply(this, arguments);
+}