@mui/x-data-grid 5.4.0 → 5.6.0

package/legacy/components/virtualization/GridVirtualScrollerContent.js

@@ -0,0 +1,47 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["className", "style"];
+import * as React from 'react';
+import clsx from 'clsx';
+import { styled } from '@mui/material/styles';
+import { unstable_composeClasses as composeClasses } from '@mui/material';
+import { useGridRootProps } from '../../hooks/utils/useGridRootProps';
+import { getDataGridUtilityClass } from '../../constants/gridClasses';
+import { jsx as _jsx } from "react/jsx-runtime";
+
+var useUtilityClasses = function useUtilityClasses(ownerState) {
+  var classes = ownerState.classes,
+      overflowedContent = ownerState.overflowedContent;
+  var slots = {
+    root: ['virtualScrollerContent', overflowedContent && 'virtualScrollerContent--overflowed']
+  };
+  return composeClasses(slots, getDataGridUtilityClass, classes);
+};
+
+var VirtualScrollerContentRoot = styled('div', {
+  name: 'MuiDataGrid',
+  slot: 'VirtualScrollerContent',
+  overridesResolver: function overridesResolver(props, styles) {
+    return styles.virtualScrollerContent;
+  }
+})({
+  position: 'relative'
+});
+var GridVirtualScrollerContent = /*#__PURE__*/React.forwardRef(function GridVirtualScrollerContent(props, ref) {
+  var className = props.className,
+      style = props.style,
+      other = _objectWithoutProperties(props, _excluded);
+
+  var rootProps = useGridRootProps();
+  var ownerState = {
+    classes: rootProps.classes,
+    overflowedContent: !rootProps.autoHeight && (style == null ? void 0 : style.minHeight) === 'auto'
+  };
+  var classes = useUtilityClasses(ownerState);
+  return /*#__PURE__*/_jsx(VirtualScrollerContentRoot, _extends({
+    ref: ref,
+    className: clsx(classes.root, className),
+    style: style
+  }, other));
+});
+export { GridVirtualScrollerContent };

package/legacy/components/virtualization/GridVirtualScrollerRenderZone.js

@@ -0,0 +1,43 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["className"];
+import * as React from 'react';
+import clsx from 'clsx';
+import { styled } from '@mui/material/styles';
+import { unstable_composeClasses as composeClasses } from '@mui/material';
+import { useGridRootProps } from '../../hooks/utils/useGridRootProps';
+import { getDataGridUtilityClass } from '../../constants/gridClasses';
+import { jsx as _jsx } from "react/jsx-runtime";
+
+var useUtilityClasses = function useUtilityClasses(ownerState) {
+  var classes = ownerState.classes;
+  var slots = {
+    root: ['virtualScrollerRenderZone']
+  };
+  return composeClasses(slots, getDataGridUtilityClass, classes);
+};
+
+var VirtualScrollerRenderZoneRoot = styled('div', {
+  name: 'MuiDataGrid',
+  slot: 'VirtualScrollerRenderZone',
+  overridesResolver: function overridesResolver(props, styles) {
+    return styles.virtualScrollerRenderZone;
+  }
+})({
+  position: 'absolute'
+});
+var GridVirtualScrollerRenderZone = /*#__PURE__*/React.forwardRef(function GridVirtualScrollerRenderZone(props, ref) {
+  var className = props.className,
+      other = _objectWithoutProperties(props, _excluded);
+
+  var rootProps = useGridRootProps();
+  var ownerState = {
+    classes: rootProps.classes
+  };
+  var classes = useUtilityClasses(ownerState);
+  return /*#__PURE__*/_jsx(VirtualScrollerRenderZoneRoot, _extends({
+    ref: ref,
+    className: clsx(classes.root, className)
+  }, other));
+});
+export { GridVirtualScrollerRenderZone };

package/legacy/constants/defaultGridSlotsComponents.js

@@ -0,0 +1,66 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import MUICheckbox from '@mui/material/Checkbox';
+import MUITextField from '@mui/material/TextField';
+import MUIFormControl from '@mui/material/FormControl';
+import MUISelect from '@mui/material/Select';
+import MUISwitch from '@mui/material/Switch';
+import MUIButton from '@mui/material/Button';
+import MUITooltip from '@mui/material/Tooltip';
+import MUIPopper from '@mui/material/Popper';
+import { GridArrowDownwardIcon, GridArrowUpwardIcon, GridCell, GridCheckIcon, GridCloseIcon, GridColumnIcon, GridColumnMenu, GridColumnsPanel, GridFilterAltIcon, GridFilterListIcon, GridFilterPanel, GridFooter, GridHeader, GridLoadingOverlay, GridNoRowsOverlay, GridPagination, GridPanel, GridPreferencesPanel, GridRow, GridSaveAltIcon, GridSeparatorIcon, GridTableRowsIcon, GridTripleDotsVerticalIcon, GridViewHeadlineIcon, GridViewStreamIcon, GridMoreVertIcon, GridExpandMoreIcon, GridKeyboardArrowRight, GridAddIcon, GridRemoveIcon } from '../components';
+import { GridColumnUnsortedIcon } from '../components/columnHeaders/GridColumnUnsortedIcon';
+import { ErrorOverlay } from '../components/ErrorOverlay';
+import { GridNoResultsOverlay } from '../components/GridNoResultsOverlay';
+var DEFAULT_GRID_ICON_SLOTS_COMPONENTS = {
+  BooleanCellTrueIcon: GridCheckIcon,
+  BooleanCellFalseIcon: GridCloseIcon,
+  ColumnMenuIcon: GridTripleDotsVerticalIcon,
+  OpenFilterButtonIcon: GridFilterListIcon,
+  FilterPanelDeleteIcon: GridCloseIcon,
+  ColumnFilteredIcon: GridFilterAltIcon,
+  ColumnSelectorIcon: GridColumnIcon,
+  ColumnUnsortedIcon: GridColumnUnsortedIcon,
+  ColumnSortedAscendingIcon: GridArrowUpwardIcon,
+  ColumnSortedDescendingIcon: GridArrowDownwardIcon,
+  ColumnResizeIcon: GridSeparatorIcon,
+  DensityCompactIcon: GridViewHeadlineIcon,
+  DensityStandardIcon: GridTableRowsIcon,
+  DensityComfortableIcon: GridViewStreamIcon,
+  ExportIcon: GridSaveAltIcon,
+  MoreActionsIcon: GridMoreVertIcon,
+  TreeDataCollapseIcon: GridExpandMoreIcon,
+  TreeDataExpandIcon: GridKeyboardArrowRight,
+  GroupingCriteriaCollapseIcon: GridExpandMoreIcon,
+  GroupingCriteriaExpandIcon: GridKeyboardArrowRight,
+  DetailPanelExpandIcon: GridAddIcon,
+  DetailPanelCollapseIcon: GridRemoveIcon
+};
+/**
+ * TODO: Differentiate community and pro value and interface
+ */
+
+export var DATA_GRID_DEFAULT_SLOTS_COMPONENTS = _extends({}, DEFAULT_GRID_ICON_SLOTS_COMPONENTS, {
+  BaseCheckbox: MUICheckbox,
+  BaseTextField: MUITextField,
+  BaseFormControl: MUIFormControl,
+  BaseSelect: MUISelect,
+  BaseSwitch: MUISwitch,
+  BaseButton: MUIButton,
+  BaseTooltip: MUITooltip,
+  BasePopper: MUIPopper,
+  Cell: GridCell,
+  ColumnMenu: GridColumnMenu,
+  ErrorOverlay: ErrorOverlay,
+  Footer: GridFooter,
+  Header: GridHeader,
+  Toolbar: null,
+  PreferencesPanel: GridPreferencesPanel,
+  LoadingOverlay: GridLoadingOverlay,
+  NoResultsOverlay: GridNoResultsOverlay,
+  NoRowsOverlay: GridNoRowsOverlay,
+  Pagination: GridPagination,
+  FilterPanel: GridFilterPanel,
+  ColumnsPanel: GridColumnsPanel,
+  Panel: GridPanel,
+  Row: GridRow
+});

package/legacy/constants/envConstants.js

@@ -0,0 +1,27 @@
+import { localStorageAvailable } from '../utils/utils'; // A guide to feature toggling.
+//
+// The feature toggle is:
+// - independent from the NODE_ENV
+// - isn't pruning code in production, as the objective is to eventually ship the code.
+// - doesn't allow to cherry-pick which feature to enable
+//
+// By default, the experimental features are only enabled in:
+// - the local environment
+// - the pull request previews
+//
+// Reviewers can force the value with the local storage and the GRID_EXPERIMENTAL_ENABLED key:
+// - 'true' => force it to be enabled
+// - 'false' => force it to be disabled
+//
+// Developers (users) are discouraged to enable the experimental feature by setting the GRID_EXPERIMENTAL_ENABLED env.
+// Instead, prefer exposing experimental APIs, for instance, a prop or a new `unstable_` module.
+
+var experimentalEnabled = false;
+
+if (typeof process !== 'undefined' && process.env.GRID_EXPERIMENTAL_ENABLED !== undefined && localStorageAvailable() && window.localStorage.getItem('GRID_EXPERIMENTAL_ENABLED')) {
+  experimentalEnabled = window.localStorage.getItem('GRID_EXPERIMENTAL_ENABLED') === 'true';
+} else if (typeof process !== 'undefined') {
+  experimentalEnabled = process.env.GRID_EXPERIMENTAL_ENABLED === 'true';
+}
+
+export var GRID_EXPERIMENTAL_ENABLED = experimentalEnabled;

package/legacy/constants/gridClasses.js

@@ -0,0 +1,5 @@
+import { generateUtilityClasses, generateUtilityClass } from '@mui/material';
+export function getDataGridUtilityClass(slot) {
+  return generateUtilityClass('MuiDataGrid', slot);
+}
+export var gridClasses = generateUtilityClasses('MuiDataGrid', ['actionsCell', 'autoHeight', 'booleanCell', 'cell--editable', 'cell--editing', 'cell--textCenter', 'cell--textLeft', 'cell--textRight', 'cell--withRenderer', 'cell', 'cellContent', 'cellCheckbox', 'checkboxInput', 'columnHeader--alignCenter', 'columnHeader--alignLeft', 'columnHeader--alignRight', 'columnHeader--dragging', 'columnHeader--moving', 'columnHeader--numeric', 'columnHeader--sortable', 'columnHeader--sorted', 'columnHeader', 'columnHeaderCheckbox', 'columnHeaderDraggableContainer', 'columnHeaderDropZone', 'columnHeaderTitle', 'columnHeaderTitleContainer', 'columnHeaderTitleContainerContent', 'columnHeaders', 'columnHeadersInner', 'columnHeadersInner--scrollable', 'columnSeparator--resizable', 'columnSeparator--resizing', 'columnSeparator--sideLeft', 'columnSeparator--sideRight', 'columnSeparator', 'columnsPanel', 'columnsPanelRow', 'detailPanel', 'detailPanels', 'detailPanelToggleCell', 'detailPanelToggleCell--expanded', 'panel', 'panelHeader', 'panelWrapper', 'panelContent', 'panelFooter', 'paper', 'editBooleanCell', 'editInputCell', 'filterForm', 'filterFormDeleteIcon', 'filterFormLinkOperatorInput', 'filterFormColumnInput', 'filterFormOperatorInput', 'filterFormValueInput', 'filterIcon', 'footerContainer', 'iconButtonContainer', 'iconSeparator', 'main', 'menu', 'menuIcon', 'menuIconButton', 'menuOpen', 'menuList', 'overlay', 'root', 'row--editable', 'row--editing', 'row', 'row--lastVisible', 'rowCount', 'scrollArea--left', 'scrollArea--right', 'scrollArea', 'selectedRowCount', 'sortIcon', 'toolbarContainer', 'toolbarFilterList', 'virtualScroller', 'virtualScrollerContent', 'virtualScrollerContent--overflowed', 'virtualScrollerRenderZone', 'pinnedColumns', 'pinnedColumns--left', 'pinnedColumns--right', 'pinnedColumnHeaders', 'pinnedColumnHeaders--left', 'pinnedColumnHeaders--right', 'withBorder', 'treeDataGroupingCell', 'treeDataGroupingCellToggle', 'groupingCriteriaCell', 'groupingCriteriaCellToggle']);

package/legacy/constants/index.js

@@ -0,0 +1,4 @@
+export * from './envConstants';
+export * from './localeTextConstants';
+export * from './defaultGridSlotsComponents';
+export * from './gridClasses';

package/legacy/constants/localeTextConstants.js

@@ -0,0 +1,119 @@
+export var GRID_DEFAULT_LOCALE_TEXT = {
+  // Root
+  noRowsLabel: 'No rows',
+  noResultsOverlayLabel: 'No results found.',
+  errorOverlayDefaultLabel: 'An error occurred.',
+  // Density selector toolbar button text
+  toolbarDensity: 'Density',
+  toolbarDensityLabel: 'Density',
+  toolbarDensityCompact: 'Compact',
+  toolbarDensityStandard: 'Standard',
+  toolbarDensityComfortable: 'Comfortable',
+  // Columns selector toolbar button text
+  toolbarColumns: 'Columns',
+  toolbarColumnsLabel: 'Select columns',
+  // Filters toolbar button text
+  toolbarFilters: 'Filters',
+  toolbarFiltersLabel: 'Show filters',
+  toolbarFiltersTooltipHide: 'Hide filters',
+  toolbarFiltersTooltipShow: 'Show filters',
+  toolbarFiltersTooltipActive: function toolbarFiltersTooltipActive(count) {
+    return count !== 1 ? "".concat(count, " active filters") : "".concat(count, " active filter");
+  },
+  // Export selector toolbar button text
+  toolbarExport: 'Export',
+  toolbarExportLabel: 'Export',
+  toolbarExportCSV: 'Download as CSV',
+  toolbarExportPrint: 'Print',
+  // Columns panel text
+  columnsPanelTextFieldLabel: 'Find column',
+  columnsPanelTextFieldPlaceholder: 'Column title',
+  columnsPanelDragIconLabel: 'Reorder column',
+  columnsPanelShowAllButton: 'Show all',
+  columnsPanelHideAllButton: 'Hide all',
+  // Filter panel text
+  filterPanelAddFilter: 'Add filter',
+  filterPanelDeleteIconLabel: 'Delete',
+  filterPanelLinkOperator: 'Logic operator',
+  filterPanelOperators: 'Operator',
+  // TODO v6: rename to filterPanelOperator
+  filterPanelOperatorAnd: 'And',
+  filterPanelOperatorOr: 'Or',
+  filterPanelColumns: 'Columns',
+  filterPanelInputLabel: 'Value',
+  filterPanelInputPlaceholder: 'Filter value',
+  // Filter operators text
+  filterOperatorContains: 'contains',
+  filterOperatorEquals: 'equals',
+  filterOperatorStartsWith: 'starts with',
+  filterOperatorEndsWith: 'ends with',
+  filterOperatorIs: 'is',
+  filterOperatorNot: 'is not',
+  filterOperatorAfter: 'is after',
+  filterOperatorOnOrAfter: 'is on or after',
+  filterOperatorBefore: 'is before',
+  filterOperatorOnOrBefore: 'is on or before',
+  filterOperatorIsEmpty: 'is empty',
+  filterOperatorIsNotEmpty: 'is not empty',
+  filterOperatorIsAnyOf: 'is any of',
+  // Filter values text
+  filterValueAny: 'any',
+  filterValueTrue: 'true',
+  filterValueFalse: 'false',
+  // Column menu text
+  columnMenuLabel: 'Menu',
+  columnMenuShowColumns: 'Show columns',
+  columnMenuFilter: 'Filter',
+  columnMenuHideColumn: 'Hide',
+  columnMenuUnsort: 'Unsort',
+  columnMenuSortAsc: 'Sort by ASC',
+  columnMenuSortDesc: 'Sort by DESC',
+  // Column header text
+  columnHeaderFiltersTooltipActive: function columnHeaderFiltersTooltipActive(count) {
+    return count !== 1 ? "".concat(count, " active filters") : "".concat(count, " active filter");
+  },
+  columnHeaderFiltersLabel: 'Show filters',
+  columnHeaderSortIconLabel: 'Sort',
+  // Rows selected footer text
+  footerRowSelected: function footerRowSelected(count) {
+    return count !== 1 ? "".concat(count.toLocaleString(), " rows selected") : "".concat(count.toLocaleString(), " row selected");
+  },
+  // Total row amount footer text
+  footerTotalRows: 'Total Rows:',
+  // Total visible row amount footer text
+  footerTotalVisibleRows: function footerTotalVisibleRows(visibleCount, totalCount) {
+    return "".concat(visibleCount.toLocaleString(), " of ").concat(totalCount.toLocaleString());
+  },
+  // Checkbox selection text
+  checkboxSelectionHeaderName: 'Checkbox selection',
+  checkboxSelectionSelectAllRows: 'Select all rows',
+  checkboxSelectionUnselectAllRows: 'Unselect all rows',
+  checkboxSelectionSelectRow: 'Select row',
+  checkboxSelectionUnselectRow: 'Unselect row',
+  // Boolean cell text
+  booleanCellTrueLabel: 'yes',
+  booleanCellFalseLabel: 'no',
+  // Actions cell more text
+  actionsCellMore: 'more',
+  // Column pinning text
+  pinToLeft: 'Pin to left',
+  pinToRight: 'Pin to right',
+  unpin: 'Unpin',
+  // Tree Data
+  treeDataGroupingHeaderName: 'Group',
+  treeDataExpand: 'see children',
+  treeDataCollapse: 'hide children',
+  // Grouping columns
+  groupingColumnHeaderName: 'Group',
+  groupColumn: function groupColumn(name) {
+    return "Group by ".concat(name);
+  },
+  unGroupColumn: function unGroupColumn(name) {
+    return "Stop grouping by ".concat(name);
+  },
+  // Master/detail
+  expandDetailPanel: 'Expand',
+  collapseDetailPanel: 'Collapse',
+  // Used core components translation keys
+  MuiTablePagination: {}
+};

package/legacy/context/GridContextProvider.js

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { GridApiContext } from '../components/GridApiContext';
+import { GridRootPropsContext } from './GridRootPropsContext';
+import { jsx as _jsx } from "react/jsx-runtime";
+export var GridContextProvider = function GridContextProvider(_ref) {
+  var apiRef = _ref.apiRef,
+      props = _ref.props,
+      children = _ref.children;
+  return /*#__PURE__*/_jsx(GridRootPropsContext.Provider, {
+    value: props,
+    children: /*#__PURE__*/_jsx(GridApiContext.Provider, {
+      value: apiRef,
+      children: children
+    })
+  });
+};

package/legacy/context/GridRootPropsContext.js

@@ -0,0 +1,8 @@
+import * as React from 'react';
+var GridRootPropsContext = /*#__PURE__*/React.createContext(undefined);
+
+if (process.env.NODE_ENV !== 'production') {
+  GridRootPropsContext.displayName = 'GridRootPropsContext';
+}
+
+export { GridRootPropsContext };

package/legacy/context/index.js

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

package/legacy/hooks/core/index.js

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

package/legacy/hooks/core/preProcessing/gridPreProcessingApi.js

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

package/legacy/hooks/core/preProcessing/index.js

@@ -0,0 +1,3 @@
+export * from './gridPreProcessingApi';
+export * from './useGridPreProcessing';
+export * from './useGridRegisterPreProcessor';

package/legacy/hooks/core/preProcessing/useGridPreProcessing.js

@@ -0,0 +1,58 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _toPropertyKey from "@babel/runtime/helpers/esm/toPropertyKey";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { useGridApiMethod } from '../../utils/useGridApiMethod';
+import { GridEvents } from '../../../models/events';
+export var useGridPreProcessing = function useGridPreProcessing(apiRef) {
+  var preProcessorsRef = React.useRef({});
+  var registerPreProcessor = React.useCallback(function (group, id, callback) {
+    if (!preProcessorsRef.current[group]) {
+      preProcessorsRef.current[group] = {};
+    }
+
+    var preProcessors = preProcessorsRef.current[group];
+    var oldCallback = preProcessors[id];
+
+    if (!oldCallback || oldCallback !== callback) {
+      preProcessorsRef.current[group] = _extends({}, preProcessors, _defineProperty({}, id, callback));
+      apiRef.current.publishEvent(GridEvents.preProcessorRegister, group);
+    }
+
+    return function () {
+      var _ref = preProcessorsRef.current[group],
+          removedPreProcessor = _ref[id],
+          otherProcessors = _objectWithoutProperties(_ref, [id].map(_toPropertyKey));
+
+      preProcessorsRef.current[group] = otherProcessors;
+      apiRef.current.publishEvent(GridEvents.preProcessorUnregister, group);
+    };
+  }, [apiRef]);
+  var applyPreProcessors = React.useCallback(function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    var _ref2 = args,
+        _ref3 = _slicedToArray(_ref2, 3),
+        group = _ref3[0],
+        value = _ref3[1],
+        params = _ref3[2];
+
+    if (!preProcessorsRef.current[group]) {
+      return value;
+    }
+
+    var preProcessors = Object.values(preProcessorsRef.current[group]);
+    return preProcessors.reduce(function (acc, preProcessor) {
+      return preProcessor(acc, params);
+    }, value);
+  }, []);
+  var preProcessingApi = {
+    unstable_registerPreProcessor: registerPreProcessor,
+    unstable_applyPreProcessors: applyPreProcessors
+  };
+  useGridApiMethod(apiRef, preProcessingApi, 'GridPreProcessing');
+};

package/legacy/hooks/core/preProcessing/useGridRegisterPreProcessor.js

@@ -0,0 +1,27 @@
+import * as React from 'react';
+import { useFirstRender } from '../../utils/useFirstRender';
+export var useGridRegisterPreProcessor = function useGridRegisterPreProcessor(apiRef, group, callback) {
+  var cleanup = React.useRef();
+  var id = React.useRef("mui-".concat(Math.round(Math.random() * 1e9)));
+  var registerPreProcessor = React.useCallback(function () {
+    cleanup.current = apiRef.current.unstable_registerPreProcessor(group, id.current, callback);
+  }, [apiRef, callback, group]);
+  useFirstRender(function () {
+    registerPreProcessor();
+  });
+  var isFirstRender = React.useRef(true);
+  React.useEffect(function () {
+    if (isFirstRender.current) {
+      isFirstRender.current = false;
+    } else {
+      registerPreProcessor();
+    }
+
+    return function () {
+      if (cleanup.current) {
+        cleanup.current();
+        cleanup.current = null;
+      }
+    };
+  }, [registerPreProcessor]);
+};

package/legacy/hooks/core/rowGroupsPreProcessing/gridRowGroupsPreProcessingApi.js

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

package/legacy/hooks/core/rowGroupsPreProcessing/index.js

@@ -0,0 +1,2 @@
+export * from './useGridRowGroupsPreProcessing';
+export * from './gridRowGroupsPreProcessingApi';

package/legacy/hooks/core/rowGroupsPreProcessing/useGridRowGroupsPreProcessing.js

@@ -0,0 +1,71 @@
+import * as React from 'react';
+import { GridEvents } from '../../../models/events';
+import { useGridApiMethod } from '../../utils/useGridApiMethod';
+
+var getFlatRowTree = function getFlatRowTree(_ref) {
+  var ids = _ref.ids,
+      idRowsLookup = _ref.idRowsLookup,
+      previousTree = _ref.previousTree;
+  var tree = {};
+
+  for (var i = 0; i < ids.length; i += 1) {
+    var rowId = ids[i];
+
+    if (previousTree && previousTree[rowId]) {
+      tree[rowId] = previousTree[rowId];
+    } else {
+      tree[rowId] = {
+        id: rowId,
+        depth: 0,
+        parent: null,
+        groupingKey: '',
+        groupingField: null
+      };
+    }
+  }
+
+  return {
+    groupingName: 'none',
+    tree: tree,
+    treeDepth: 1,
+    idRowsLookup: idRowsLookup,
+    ids: ids
+  };
+};
+
+export var useGridRowGroupsPreProcessing = function useGridRowGroupsPreProcessing(apiRef) {
+  var rowGroupsPreProcessingRef = React.useRef(new Map());
+  var registerRowGroupsBuilder = React.useCallback(function (processingName, rowGroupingPreProcessing) {
+    var _rowGroupsPreProcessi;
+
+    var rowGroupingPreProcessingBefore = (_rowGroupsPreProcessi = rowGroupsPreProcessingRef.current.get(processingName)) != null ? _rowGroupsPreProcessi : null;
+
+    if (rowGroupingPreProcessingBefore !== rowGroupingPreProcessing) {
+      rowGroupsPreProcessingRef.current.set(processingName, rowGroupingPreProcessing);
+      apiRef.current.publishEvent(GridEvents.rowGroupsPreProcessingChange);
+    }
+  }, [apiRef]);
+  var groupRows = React.useCallback(function () {
+    var response = null;
+    var preProcessingList = Array.from(rowGroupsPreProcessingRef.current.values());
+
+    while (!response && preProcessingList.length) {
+      var preProcessing = preProcessingList.shift();
+
+      if (preProcessing) {
+        response = preProcessing.apply(void 0, arguments);
+      }
+    }
+
+    if (!response) {
+      return getFlatRowTree.apply(void 0, arguments);
+    }
+
+    return response;
+  }, []);
+  var rowGroupsPreProcessingApi = {
+    unstable_registerRowGroupsBuilder: registerRowGroupsBuilder,
+    unstable_groupRows: groupRows
+  };
+  useGridApiMethod(apiRef, rowGroupsPreProcessingApi, 'GridRowGroupsPreProcessing');
+};

package/legacy/hooks/core/useGridApiInitialization.js

@@ -0,0 +1,69 @@
+import * as React from 'react';
+import { GridEvents } from '../../models/events';
+import { useGridApiMethod } from '../utils/useGridApiMethod';
+import { GridSignature } from '../utils/useGridApiEventHandler';
+import { EventManager } from '../../utils/EventManager';
+
+var isSyntheticEvent = function isSyntheticEvent(event) {
+  return event.isPropagationStopped !== undefined;
+};
+
+var globalId = 0;
+export function useGridApiInitialization(inputApiRef, props) {
+  var apiRef = React.useRef();
+
+  if (!apiRef.current) {
+    apiRef.current = {
+      unstable_eventManager: new EventManager(),
+      state: {},
+      instanceId: globalId
+    };
+    globalId += 1;
+  }
+
+  React.useImperativeHandle(inputApiRef, function () {
+    return apiRef.current;
+  }, [apiRef]);
+  var publishEvent = React.useCallback(function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    var name = args[0],
+        params = args[1],
+        _args$ = args[2],
+        event = _args$ === void 0 ? {} : _args$;
+    event.defaultMuiPrevented = false;
+
+    if (isSyntheticEvent(event) && event.isPropagationStopped()) {
+      return;
+    }
+
+    var details = props.signature === GridSignature.DataGridPro ? {
+      api: apiRef.current
+    } : {};
+    apiRef.current.unstable_eventManager.emit(name, params, event, details);
+  }, [apiRef, props.signature]);
+  var subscribeEvent = React.useCallback(function (event, handler, options) {
+    apiRef.current.unstable_eventManager.on(event, handler, options);
+    var api = apiRef.current;
+    return function () {
+      api.unstable_eventManager.removeListener(event, handler);
+    };
+  }, [apiRef]);
+  var showError = React.useCallback(function (args) {
+    apiRef.current.publishEvent(GridEvents.componentError, args);
+  }, [apiRef]);
+  useGridApiMethod(apiRef, {
+    subscribeEvent: subscribeEvent,
+    publishEvent: publishEvent,
+    showError: showError
+  }, 'GridCoreApi');
+  React.useEffect(function () {
+    var api = apiRef.current;
+    return function () {
+      api.publishEvent(GridEvents.unmount);
+    };
+  }, [apiRef]);
+  return apiRef;
+}

package/legacy/hooks/core/useGridErrorHandler.js

@@ -0,0 +1,18 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { GridEvents } from '../../models/events';
+import { useGridApiEventHandler } from '../utils/useGridApiEventHandler';
+export function useGridErrorHandler(apiRef, props) {
+  var handleError = React.useCallback(function (args) {
+    // We are handling error here, to set up the handler as early as possible and be able to catch error thrown at init time.
+    apiRef.current.setState(function (state) {
+      return _extends({}, state, {
+        error: args
+      });
+    });
+  }, [apiRef]);
+  React.useEffect(function () {
+    handleError(props.error);
+  }, [handleError, props.error]);
+  useGridApiEventHandler(apiRef, GridEvents.componentError, handleError);
+}

package/legacy/hooks/core/useGridInitialization.js

@@ -0,0 +1,21 @@
+import { useGridLoggerFactory } from './useGridLoggerFactory';
+import { useGridApiInitialization } from './useGridApiInitialization';
+import { useGridErrorHandler } from './useGridErrorHandler';
+import { useGridLocaleText } from './useGridLocaleText';
+import { useGridPreProcessing } from './preProcessing';
+import { useGridRowGroupsPreProcessing } from './rowGroupsPreProcessing';
+import { useGridStateInitialization } from './useGridStateInitialization';
+/**
+ * Initialize the technical pieces of the DataGrid (logger, state, ...) that any DataGrid implementation needs
+ */
+
+export var useGridInitialization = function useGridInitialization(inputApiRef, props) {
+  var apiRef = useGridApiInitialization(inputApiRef, props);
+  useGridLoggerFactory(apiRef, props);
+  useGridErrorHandler(apiRef, props);
+  useGridStateInitialization(apiRef, props);
+  useGridPreProcessing(apiRef);
+  useGridRowGroupsPreProcessing(apiRef);
+  useGridLocaleText(apiRef, props);
+  return apiRef;
+};

package/legacy/hooks/core/useGridLocaleText.js

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { useGridApiMethod } from '../utils/useGridApiMethod';
+export var useGridLocaleText = function useGridLocaleText(apiRef, props) {
+  var getLocaleText = React.useCallback(function (key) {
+    if (props.localeText[key] == null) {
+      throw new Error("Missing translation for key ".concat(key, "."));
+    }
+
+    return props.localeText[key];
+  }, [props.localeText]);
+  var localeTextApi = {
+    getLocaleText: getLocaleText
+  };
+  useGridApiMethod(apiRef, localeTextApi, 'LocaleTextApi');
+};