@mui/x-data-grid 7.0.0-alpha.7 → 7.0.0-alpha.8

package/legacy/hooks/features/columnGrouping/useGridColumnGrouping.js

@@ -20,17 +20,19 @@ var createGroupLookup = function createGroupLookup(columnGroupingModel) {
       children = node.children,
       other = _objectWithoutProperties(node, _excluded);
     if (!groupId) {
-      throw new Error('MUI: An element of the columnGroupingModel does not have either `field` or `groupId`.');
+      throw new Error('MUI X: An element of the columnGroupingModel does not have either `field` or `groupId`.');
     }
-    if (!children) {
-      console.warn("MUI: group groupId=".concat(groupId, " has no children."));
+    if (process.env.NODE_ENV !== 'production') {
+      if (!children) {
+        console.warn("MUI X: group groupId=".concat(groupId, " has no children."));
+      }
     }
     var groupParam = _extends({}, other, {
       groupId: groupId
     });
     var subTreeLookup = createGroupLookup(children);
     if (subTreeLookup[groupId] !== undefined || groupLookup[groupId] !== undefined) {
-      throw new Error("MUI: The groupId ".concat(groupId, " is used multiple times in the columnGroupingModel."));
+      throw new Error("MUI X: The groupId ".concat(groupId, " is used multiple times in the columnGroupingModel."));
     }
     groupLookup = _extends({}, groupLookup, subTreeLookup, _defineProperty({}, groupId, groupParam));
   });

package/legacy/hooks/features/editing/useGridCellEditing.js

@@ -18,7 +18,7 @@ import { buildWarning } from '../../../utils/warning';
 import { gridRowsDataRowIdToIdLookupSelector } from '../rows/gridRowsSelector';
 import { deepClone } from '../../../utils/utils';
 import { GridCellEditStartReasons, GridCellEditStopReasons } from '../../../models/params/gridEditCellParams';
-var 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/#server-side-persistence.'], 'error');
+var missingOnProcessRowUpdateErrorWarning = buildWarning(['MUI X: 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 https://mui.com/x/react-data-grid/editing/#server-side-persistence.'], 'error');
 export var useGridCellEditing = function useGridCellEditing(apiRef, props) {
   var _React$useState = React.useState({}),
     _React$useState2 = _slicedToArray(_React$useState, 2),
@@ -40,12 +40,12 @@ export var useGridCellEditing = function useGridCellEditing(apiRef, props) {
   var throwIfNotEditable = React.useCallback(function (id, field) {
     var params = apiRef.current.getCellParams(id, field);
     if (!apiRef.current.isCellEditable(params)) {
-      throw new Error("MUI: The cell with id=".concat(id, " and field=").concat(field, " is not editable."));
+      throw new Error("MUI X: The cell with id=".concat(id, " and field=").concat(field, " is not editable."));
     }
   }, [apiRef]);
   var throwIfNotInMode = React.useCallback(function (id, field, mode) {
     if (apiRef.current.getCellMode(id, field) !== mode) {
-      throw new Error("MUI: The cell with id=".concat(id, " and field=").concat(field, " is not in ").concat(mode, " mode."));
+      throw new Error("MUI X: The cell with id=".concat(id, " and field=").concat(field, " is not in ").concat(mode, " mode."));
     }
   }, [apiRef]);
   var handleCellDoubleClick = React.useCallback(function (params, event) {
@@ -299,7 +299,7 @@ export var useGridCellEditing = function useGridCellEditing(apiRef, props) {
                 });
                 if (onProcessRowUpdateError) {
                   onProcessRowUpdateError(errorThrown);
-                } else {
+                } else if (process.env.NODE_ENV !== 'production') {
                   missingOnProcessRowUpdateErrorWarning();
                 }
               };

package/legacy/hooks/features/editing/useGridRowEditing.js

@@ -18,7 +18,7 @@ import { gridRowsDataRowIdToIdLookupSelector } from '../rows/gridRowsSelector';
 import { deepClone } from '../../../utils/utils';
 import { GridRowEditStopReasons, GridRowEditStartReasons } from '../../../models/params/gridRowParams';
 import { GRID_ACTIONS_COLUMN_TYPE } from '../../../colDef';
-var 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/#server-side-persistence.'], 'error');
+var missingOnProcessRowUpdateErrorWarning = buildWarning(['MUI X: 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 https://mui.com/x/react-data-grid/editing/#server-side-persistence.'], 'error');
 export var useGridRowEditing = function useGridRowEditing(apiRef, props) {
   var _React$useState = React.useState({}),
     _React$useState2 = _slicedToArray(_React$useState, 2),
@@ -42,12 +42,12 @@ export var useGridRowEditing = function useGridRowEditing(apiRef, props) {
   var throwIfNotEditable = React.useCallback(function (id, field) {
     var params = apiRef.current.getCellParams(id, field);
     if (!apiRef.current.isCellEditable(params)) {
-      throw new Error("MUI: The cell with id=".concat(id, " and field=").concat(field, " is not editable."));
+      throw new Error("MUI X: The cell with id=".concat(id, " and field=").concat(field, " is not editable."));
     }
   }, [apiRef]);
   var throwIfNotInMode = React.useCallback(function (id, mode) {
     if (apiRef.current.getRowMode(id) !== mode) {
-      throw new Error("MUI: The row with id=".concat(id, " is not in ").concat(mode, " mode."));
+      throw new Error("MUI X: The row with id=".concat(id, " is not in ").concat(mode, " mode."));
     }
   }, [apiRef]);
   var handleCellDoubleClick = React.useCallback(function (params, event) {
@@ -378,7 +378,7 @@ export var useGridRowEditing = function useGridRowEditing(apiRef, props) {
         });
         if (onProcessRowUpdateError) {
           onProcessRowUpdateError(errorThrown);
-        } else {
+        } else if (process.env.NODE_ENV !== 'production') {
           missingOnProcessRowUpdateErrorWarning();
         }
       };

package/legacy/hooks/features/export/serializers/csvSerializer.js

@@ -36,7 +36,7 @@ export var serializeCellValue = function serializeCellValue(cellParams, options)
   }
   return sanitizeCellValue(value, delimiterCharacter);
 };
-var objectFormattedValueWarning = buildWarning(['MUI: When the value of a field is an object or a `renderCell` is provided, the CSV export might not display the value correctly.', 'You can provide a `valueFormatter` with a string representation to be used.']);
+var objectFormattedValueWarning = buildWarning(['MUI X: When the value of a field is an object or a `renderCell` is provided, the CSV export might not display the value correctly.', 'You can provide a `valueFormatter` with a string representation to be used.']);
 var CSVRow = /*#__PURE__*/function () {
   function CSVRow(options) {
     _classCallCheck(this, CSVRow);

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

@@ -234,7 +234,7 @@ export var useGridPrintExport = function useGridPrintExport(apiRef, props) {
               _context.next = 3;
               break;
             }
-            throw new Error('MUI: No grid root element available.');
+            throw new Error('MUI X: No grid root element available.');
           case 3:
             previousGridState.current = apiRef.current.exportState();
             // It appends that the visibility model is not exported, especially if columnVisibility is not controlled

package/legacy/hooks/features/filter/gridFilterUtils.js

@@ -36,9 +36,9 @@ export var cleanFilterItem = function cleanFilterItem(item, apiRef) {
   }
   return cleanItem;
 };
-var filterModelDisableMultiColumnsFilteringWarning = buildWarning(['MUI: The `filterModel` can only contain a single item when the `disableMultipleColumnsFiltering` prop is set to `true`.', 'If you are using the community version of the `DataGrid`, this prop is always `true`.'], 'error');
-var filterModelMissingItemIdWarning = buildWarning('MUI: The `id` field is required on `filterModel.items` when you use multiple filters.', 'error');
-var filterModelMissingItemOperatorWarning = buildWarning('MUI: The `operator` field is required on `filterModel.items`, one or more of your filtering item has no `operator` provided.', 'error');
+var filterModelDisableMultiColumnsFilteringWarning = buildWarning(['MUI X: The `filterModel` can only contain a single item when the `disableMultipleColumnsFiltering` prop is set to `true`.', 'If you are using the community version of the `DataGrid`, this prop is always `true`.'], 'error');
+var filterModelMissingItemIdWarning = buildWarning('MUI X: The `id` field is required on `filterModel.items` when you use multiple filters.', 'error');
+var filterModelMissingItemOperatorWarning = buildWarning('MUI X: The `operator` field is required on `filterModel.items`, one or more of your filtering item has no `operator` provided.', 'error');
 export var sanitizeFilterModel = function sanitizeFilterModel(model, disableMultipleColumnsFiltering, apiRef) {
   var hasSeveralItems = model.items.length > 1;
   var items;
@@ -114,13 +114,13 @@ var getFilterCallbackFromItem = function getFilterCallbackFromItem(filterItem, a
   });
   var filterOperators = column.filterOperators;
   if (!(filterOperators != null && filterOperators.length)) {
-    throw new Error("MUI: No filter operators found for column '".concat(column.field, "'."));
+    throw new Error("MUI X: No filter operators found for column '".concat(column.field, "'."));
   }
   var filterOperator = filterOperators.find(function (operator) {
     return operator.value === newFilterItem.operator;
   });
   if (!filterOperator) {
-    throw new Error("MUI: No filter operator found for column '".concat(column.field, "' and operator value '").concat(newFilterItem.operator, "'."));
+    throw new Error("MUI X: No filter operator found for column '".concat(column.field, "' and operator value '").concat(newFilterItem.operator, "'."));
   }
   var publicApiRef = getPublicApiRef(apiRef);
   var applyFilterOnRow = filterOperator.getApplyFilterFn(newFilterItem, column);

package/legacy/hooks/features/pagination/gridPaginationUtils.js

@@ -10,7 +10,7 @@ export var getPageCount = function getPageCount(rowCount, pageSize) {
   }
   return 0;
 };
-export var noRowCountInServerMode = buildWarning(["MUI: the 'rowCount' prop is undefined while using paginationMode='server'", 'For more detail, see http://mui.com/components/data-grid/pagination/#basic-implementation'], 'error');
+export var noRowCountInServerMode = buildWarning(["MUI X: the 'rowCount' prop is undefined while using paginationMode='server'", 'For more detail, see http://mui.com/components/data-grid/pagination/#basic-implementation'], 'error');
 export var getDefaultGridPaginationModel = function getDefaultGridPaginationModel(autoPageSize) {
   return {
     page: 0,
@@ -26,6 +26,6 @@ export var getValidPage = function getValidPage(page) {
 };
 export var throwIfPageSizeExceedsTheLimit = function throwIfPageSizeExceedsTheLimit(pageSize, signatureProp) {
   if (signatureProp === GridSignature.DataGrid && pageSize > MAX_PAGE_SIZE) {
-    throw new Error(['MUI: `pageSize` cannot exceed 100 in the MIT version of the DataGrid.', 'You need to upgrade to DataGridPro or DataGridPremium component to unlock this feature.'].join('\n'));
+    throw new Error(['MUI X: `pageSize` cannot exceed 100 in the MIT version of the DataGrid.', 'You need to upgrade to DataGridPro or DataGridPremium component to unlock this feature.'].join('\n'));
   }
 };

package/legacy/hooks/features/rowSelection/useGridRowSelection.js

@@ -101,7 +101,7 @@ export var useGridRowSelection = function useGridRowSelection(apiRef, props) {
    */
   var setRowSelectionModel = React.useCallback(function (model) {
     if (props.signature === GridSignature.DataGrid && !canHaveMultipleSelection && Array.isArray(model) && model.length > 1) {
-      throw new Error(['MUI: `rowSelectionModel` can only contain 1 item in DataGrid.', 'You need to upgrade to DataGridPro or DataGridPremium component to unlock multiple selection.'].join('\n'));
+      throw new Error(['MUI X: `rowSelectionModel` can only contain 1 item in DataGrid.', 'You need to upgrade to DataGridPro or DataGridPremium component to unlock multiple selection.'].join('\n'));
     }
     var currentModel = gridRowSelectionStateSelector(apiRef.current.state);
     if (currentModel !== model) {

package/legacy/hooks/features/rows/gridRowsUtils.js

@@ -28,7 +28,7 @@ export var buildRootGroup = function buildRootGroup() {
 export function checkGridRowIdIsValid(id, row) {
   var detailErrorMessage = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'A row was provided without id in the rows prop:';
   if (id == null) {
-    throw new Error(['MUI: The data grid component requires all rows to have a unique `id` property.', 'Alternatively, you can use the `getRowId` prop to specify a custom id for each row.', detailErrorMessage, JSON.stringify(row)].join('\n'));
+    throw new Error(['MUI X: The data grid component requires all rows to have a unique `id` property.', 'Alternatively, you can use the `getRowId` prop to specify a custom id for each row.', detailErrorMessage, JSON.stringify(row)].join('\n'));
   }
 }
 export var getRowIdFromRowModel = function getRowIdFromRowModel(rowModel, getRowId, detailErrorMessage) {
@@ -148,7 +148,7 @@ export var updateCacheWithNewRows = function updateCacheWithNewRows(_ref4) {
     getRowId = _ref4.getRowId,
     updates = _ref4.updates;
   if (previousCache.updates.type === 'full') {
-    throw new Error('MUI: Unable to prepare a partial update if a full update is not applied yet');
+    throw new Error('MUI X: Unable to prepare a partial update if a full update is not applied yet.');
   }
 
   // Remove duplicate updates.

package/legacy/hooks/features/rows/useGridParamsApi.js

@@ -1,11 +1,11 @@
 import _createClass from "@babel/runtime/helpers/esm/createClass";
 import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _inherits from "@babel/runtime/helpers/esm/inherits";
 import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
 import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
 import _wrapNativeSuper from "@babel/runtime/helpers/esm/wrapNativeSuper";
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
 import * as React from 'react';
 import { getGridCellElement, getGridColumnHeaderElement, getGridRowElement } from '../../../utils/domUtils';
 import { GRID_ID_AUTOGENERATED } from './gridRowsUtils';
@@ -13,10 +13,9 @@ import { useGridApiMethod } from '../../utils/useGridApiMethod';
 import { gridFocusCellSelector, gridTabIndexCellSelector } from '../focus/gridFocusStateSelector';
 export var MissingRowIdError = /*#__PURE__*/function (_Error) {
   _inherits(MissingRowIdError, _Error);
-  var _super = _createSuper(MissingRowIdError);
   function MissingRowIdError() {
     _classCallCheck(this, MissingRowIdError);
-    return _super.apply(this, arguments);
+    return _callSuper(this, MissingRowIdError, arguments);
   }
   return _createClass(MissingRowIdError);
 }( /*#__PURE__*/_wrapNativeSuper(Error));

package/legacy/hooks/features/rows/useGridRows.js

@@ -124,7 +124,7 @@ export var useGridRows = function useGridRows(apiRef, props) {
   }, [logger, props.getRowId, props.loading, props.rowCount, throttledRowsChange, apiRef]);
   var updateRows = React.useCallback(function (updates) {
     if (props.signature === GridSignature.DataGrid && updates.length > 1) {
-      throw new Error(["MUI: You can't update several rows at once in `apiRef.current.updateRows` on the DataGrid.", 'You need to upgrade to DataGridPro or DataGridPremium component to unlock this feature.'].join('\n'));
+      throw new Error(["MUI X: You can't update several rows at once in `apiRef.current.updateRows` on the DataGrid.", 'You need to upgrade to DataGridPro or DataGridPremium component to unlock this feature.'].join('\n'));
     }
     var nonPinnedRowsUpdates = [];
     updates.forEach(function (update) {
@@ -171,10 +171,10 @@ export var useGridRows = function useGridRows(apiRef, props) {
   var setRowChildrenExpansion = React.useCallback(function (id, isExpanded) {
     var currentNode = apiRef.current.getRowNode(id);
     if (!currentNode) {
-      throw new Error("MUI: No row with id #".concat(id, " found"));
+      throw new Error("MUI X: No row with id #".concat(id, " found."));
     }
     if (currentNode.type !== 'group') {
-      throw new Error('MUI: Only group nodes can be expanded or collapsed');
+      throw new Error('MUI X: Only group nodes can be expanded or collapsed.');
     }
     var newNode = _extends({}, currentNode, {
       childrenExpanded: isExpanded
@@ -231,13 +231,13 @@ export var useGridRows = function useGridRows(apiRef, props) {
   var setRowIndex = React.useCallback(function (rowId, targetIndex) {
     var node = apiRef.current.getRowNode(rowId);
     if (!node) {
-      throw new Error("MUI: No row with id #".concat(rowId, " found"));
+      throw new Error("MUI X: No row with id #".concat(rowId, " found."));
     }
     if (node.parent !== GRID_ROOT_GROUP_ID) {
-      throw new Error("MUI: The row reordering do not support reordering of grouped rows yet");
+      throw new Error("MUI X: The row reordering do not support reordering of grouped rows yet.");
     }
     if (node.type !== 'leaf') {
-      throw new Error("MUI: The row reordering do not support reordering of footer or grouping rows");
+      throw new Error("MUI X: The row reordering do not support reordering of footer or grouping rows.");
     }
     apiRef.current.setState(function (state) {
       var group = gridRowTreeSelector(state, apiRef.current.instanceId)[GRID_ROOT_GROUP_ID];
@@ -263,7 +263,7 @@ export var useGridRows = function useGridRows(apiRef, props) {
   }, [apiRef, logger]);
   var replaceRows = React.useCallback(function (firstRowToRender, newRows) {
     if (props.signature === GridSignature.DataGrid && newRows.length > 1) {
-      throw new Error(["MUI: You can't replace rows using `apiRef.current.unstable_replaceRows` on the DataGrid.", 'You need to upgrade to DataGridPro or DataGridPremium component to unlock this feature.'].join('\n'));
+      throw new Error(["MUI X: You can't replace rows using `apiRef.current.unstable_replaceRows` on the DataGrid.", 'You need to upgrade to DataGridPro or DataGridPremium component to unlock this feature.'].join('\n'));
     }
     if (newRows.length === 0) {
       return;

package/legacy/hooks/features/rows/useGridRowsMeta.js

@@ -30,8 +30,8 @@ var getValidRowHeight = function getValidRowHeight(rowHeightProp, defaultRowHeig
   }
   return defaultRowHeight;
 };
-var rowHeightWarning = ["MUI: The `rowHeight` prop should be a number greater than 0.", "The default value will be used instead."].join('\n');
-var getRowHeightWarning = ["MUI: The `getRowHeight` prop should return a number greater than 0 or 'auto'.", "The default value will be used instead."].join('\n');
+var rowHeightWarning = ["MUI X: The `rowHeight` prop should be a number greater than 0.", "The default value will be used instead."].join('\n');
+var getRowHeightWarning = ["MUI X: The `getRowHeight` prop should return a number greater than 0 or 'auto'.", "The default value will be used instead."].join('\n');
 
 /**
  * @requires useGridPageSize (method)

package/legacy/hooks/features/sorting/gridSortingUtils.js

@@ -1,9 +1,11 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import { buildWarning } from '../../../utils/warning';
-var sortModelDisableMultiColumnsSortingWarning = buildWarning(['MUI: The `sortModel` can only contain a single item when the `disableMultipleColumnsSorting` prop is set to `true`.', 'If you are using the community version of the `DataGrid`, this prop is always `true`.'], 'error');
+var sortModelDisableMultiColumnsSortingWarning = buildWarning(['MUI X: The `sortModel` can only contain a single item when the `disableMultipleColumnsSorting` prop is set to `true`.', 'If you are using the community version of the `DataGrid`, this prop is always `true`.'], 'error');
 export var sanitizeSortModel = function sanitizeSortModel(model, disableMultipleColumnsSorting) {
   if (disableMultipleColumnsSorting && model.length > 1) {
-    sortModelDisableMultiColumnsSortingWarning();
+    if (process.env.NODE_ENV !== 'production') {
+      sortModelDisableMultiColumnsSortingWarning();
+    }
     return [model[0]];
   }
   return model;

package/legacy/hooks/utils/useGridApiContext.js

@@ -3,7 +3,7 @@ import { GridApiContext } from '../../components/GridApiContext';
 export function useGridApiContext() {
   var apiRef = React.useContext(GridApiContext);
   if (apiRef === undefined) {
-    throw new Error(['MUI: Could not find the data grid context.', 'It looks like you rendered your component outside of a DataGrid, DataGridPro or DataGridPremium parent component.', 'This can also happen if you are bundling multiple versions of the data grid.'].join('\n'));
+    throw new Error(['MUI X: Could not find the data grid context.', 'It looks like you rendered your component outside of a DataGrid, DataGridPro or DataGridPremium parent component.', 'This can also happen if you are bundling multiple versions of the data grid.'].join('\n'));
   }
   return apiRef;
 }

package/legacy/hooks/utils/useGridPrivateApiContext.js

@@ -6,7 +6,7 @@ if (process.env.NODE_ENV !== 'production') {
 export function useGridPrivateApiContext() {
   var privateApiRef = React.useContext(GridPrivateApiContext);
   if (privateApiRef === undefined) {
-    throw new Error(['MUI: Could not find the data grid private context.', 'It looks like you rendered your component outside of a DataGrid, DataGridPro or DataGridPremium parent component.', 'This can also happen if you are bundling multiple versions of the data grid.'].join('\n'));
+    throw new Error(['MUI X: Could not find the data grid private context.', 'It looks like you rendered your component outside of a DataGrid, DataGridPro or DataGridPremium parent component.', 'This can also happen if you are bundling multiple versions of the data grid.'].join('\n'));
   }
   return privateApiRef;
 }

package/legacy/hooks/utils/useGridRootProps.js

@@ -3,7 +3,7 @@ import { GridRootPropsContext } from '../../context/GridRootPropsContext';
 export var useGridRootProps = function useGridRootProps() {
   var contextValue = React.useContext(GridRootPropsContext);
   if (!contextValue) {
-    throw new Error('MUI: useGridRootProps should only be used inside the DataGrid, DataGridPro or DataGridPremium component.');
+    throw new Error('MUI X: useGridRootProps should only be used inside the DataGrid, DataGridPro or DataGridPremium component.');
   }
   return contextValue;
 };

package/legacy/hooks/utils/useGridSelector.js

@@ -4,7 +4,7 @@ import { useLazyRef } from './useLazyRef';
 import { useOnMount } from './useOnMount';
 import { buildWarning } from '../../utils/warning';
 import { fastObjectShallowCompare } from '../../utils/fastObjectShallowCompare';
-var stateNotInitializedWarning = buildWarning(['MUI: `useGridSelector` has been called before the initialization of the state.', 'This hook can only be used inside the context of the grid.']);
+var stateNotInitializedWarning = buildWarning(['MUI X: `useGridSelector` has been called before the initialization of the state.', 'This hook can only be used inside the context of the grid.']);
 function isOutputSelector(selector) {
   return selector.acceptsApiRef;
 }

package/legacy/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-data-grid v7.0.0-alpha.7
+ * @mui/x-data-grid v7.0.0-alpha.8
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the
@@ -12,7 +12,6 @@ export * from './DataGrid';
 export * from './components';
 export * from './constants';
 export * from './hooks';
-export * from './locales';
 export * from './models';
 export * from './context';
 export * from './colDef';

package/legacy/internals/utils/index.js

@@ -1,2 +1,3 @@
 export * from './computeSlots';
-export * from './useProps';
+export * from './useProps';
+export * from './propValidation';

package/legacy/internals/utils/propValidation.js

@@ -0,0 +1,21 @@
+export var propValidatorsDataGrid = [function (props) {
+  return props.autoPageSize && props.autoHeight && ['MUI X: `<DataGrid autoPageSize={true} autoHeight={true} />` are not valid props.', 'You can not use both the `autoPageSize` and `autoHeight` props at the same time because `autoHeight` scales the height of the Data Grid according to the `pageSize`.', '', 'Please remove one of these two props.'].join('\n') || undefined;
+}];
+var warnedOnceMap = new Set();
+var warnOnce = function warnOnce(message) {
+  if (!warnedOnceMap.has(message)) {
+    console.error(message);
+    warnedOnceMap.add(message);
+  }
+};
+export var validateProps = function validateProps(props, validators) {
+  if (process.env.NODE_ENV === 'production') {
+    return;
+  }
+  validators.forEach(function (validator) {
+    var warning = validator(props);
+    if (warning) {
+      warnOnce(warning);
+    }
+  });
+};

package/legacy/utils/createSelector.js

@@ -3,7 +3,7 @@ import { buildWarning } from './warning';
 var cacheContainer = {
   cache: new WeakMap()
 };
-var missingInstanceIdWarning = buildWarning(['MUI: A selector was called without passing the instance ID, which may impact the performance of the grid.', 'To fix, call it with `apiRef`, e.g. `mySelector(apiRef)`, or pass the instance ID explicitly, e.g. `mySelector(state, apiRef.current.instanceId)`.']);
+var missingInstanceIdWarning = buildWarning(['MUI X: A selector was called without passing the instance ID, which may impact the performance of the grid.', 'To fix, call it with `apiRef`, e.g. `mySelector(apiRef)`, or pass the instance ID explicitly, e.g. `mySelector(state, apiRef.current.instanceId)`.']);
 function checkIsAPIRef(value) {
   return 'current' in value && 'instanceId' in value.current;
 }

package/legacy/utils/exportAs.js

@@ -36,5 +36,5 @@ export function exportAs(blob) {
     });
     return;
   }
-  throw new Error('MUI: exportAs not supported');
+  throw new Error('MUI X: exportAs not supported.');
 }

package/models/props/DataGridProps.d.ts

@@ -668,7 +668,7 @@ export interface DataGridPropsWithoutDefaultValue<R extends GridValidRowModel =
      */
     'aria-labelledby'?: string;
     /**
-     * Set of columns of type [[GridColDef[]]].
+     * Set of columns of type [[GridColDef]][].
      */
     columns: readonly GridColDef<R>[];
     /**

package/modern/DataGrid/DataGrid.js

@@ -1,17 +1,21 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import PropTypes from 'prop-types';
-import { chainPropTypes } from '@mui/utils';
 import { GridBody, GridFooterPlaceholder, GridHeader, GridRoot } from '../components';
 import { GridContextProvider } from '../context/GridContextProvider';
 import { useDataGridComponent } from './useDataGridComponent';
 import { useDataGridProps } from './useDataGridProps';
 import { DataGridVirtualScroller } from '../components/DataGridVirtualScroller';
+import { propValidatorsDataGrid, validateProps } from '../internals/utils/propValidation';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
+const propValidators = [...propValidatorsDataGrid,
+// Only validate in MIT version
+props => props.columns && props.columns.some(column => column.resizable) && [`MUI X: \`column.resizable = true\` is not a valid prop.`, 'Column resizing is not available in the MIT version.', '', 'You need to upgrade to DataGridPro or DataGridPremium component to unlock this feature.'].join('\n') || undefined];
 const DataGridRaw = /*#__PURE__*/React.forwardRef(function DataGrid(inProps, ref) {
   const props = useDataGridProps(inProps);
   const privateApiRef = useDataGridComponent(props.apiRef, props);
+  validateProps(props, propValidators);
   return /*#__PURE__*/_jsx(GridContextProvider, {
     privateApiRef: privateApiRef,
     props: props,
@@ -63,12 +67,7 @@ DataGridRaw.propTypes = {
    * If `true`, the pageSize is calculated according to the container size and the max number of rows to avoid rendering a vertical scroll bar.
    * @default false
    */
-  autoPageSize: chainPropTypes(PropTypes.bool, props => {
-    if (props.autoHeight && props.autoPageSize) {
-      return new Error(['MUI: `<DataGrid autoPageSize={true} autoHeight={true} />` are not valid props.', 'You can not use both the `autoPageSize` and `autoHeight` props at the same time because `autoHeight` scales the height of the Data Grid according to the `pageSize`.', '', 'Please remove one of these two props.'].join('\n'));
-    }
-    return null;
-  }),
+  autoPageSize: PropTypes.bool,
   /**
    * Controls the modes of the cells.
    */
@@ -99,15 +98,9 @@ DataGridRaw.propTypes = {
    */
   columnHeaderHeight: PropTypes.number,
   /**
-   * Set of columns of type [[GridColDef[]]].
+   * Set of columns of type [[GridColDef]][].
    */
-  columns: chainPropTypes(PropTypes.array.isRequired, props => {
-    // @ts-ignore because otherwise `build:api` doesn't work
-    if (props.columns && props.columns.some(column => column.resizable)) {
-      return new Error([`MUI: \`column.resizable = true\` is not a valid prop.`, 'Column resizing is not available in the MIT version.', '', 'You need to upgrade to DataGridPro or DataGridPremium component to unlock this feature.'].join('\n'));
-    }
-    return null;
-  }),
+  columns: PropTypes.arrayOf(PropTypes.object).isRequired,
   /**
    * Number of rows from the `columnBuffer` that can be visible before a new slice is rendered.
    * @default 3
@@ -552,12 +545,7 @@ DataGridRaw.propTypes = {
     label: PropTypes.string.isRequired,
     value: PropTypes.number.isRequired
   })]).isRequired),
-  pagination: props => {
-    if (props.pagination === false) {
-      return new Error(['MUI: `<DataGrid pagination={false} />` is not a valid prop.', 'Infinite scrolling is not available in the MIT version.', '', 'You need to upgrade to DataGridPro or DataGridPremium component to disable the pagination.'].join('\n'));
-    }
-    return null;
-  },
+  pagination: PropTypes.oneOf([true]),
   /**
    * Pagination can be processed on the server or client-side.
    * Set it to 'client' if you would like to handle the pagination on the client-side.

package/modern/colDef/gridDateColDef.js

@@ -10,7 +10,7 @@ function throwIfNotDateObject({
   field
 }) {
   if (!(value instanceof Date)) {
-    throw new Error([`MUI: \`${columnType}\` column type only accepts \`Date\` objects as values.`, 'Use `valueGetter` to transform the value into a `Date` object.', `Row ID: ${rowId}, field: "${field}".`].join('\n'));
+    throw new Error([`MUI X: \`${columnType}\` column type only accepts \`Date\` objects as values.`, 'Use `valueGetter` to transform the value into a `Date` object.', `Row ID: ${rowId}, field: "${field}".`].join('\n'));
   }
 }
 export function gridDateFormatter({

package/modern/components/GridPagination.js

@@ -56,7 +56,7 @@ export const GridPagination = /*#__PURE__*/React.forwardRef(function GridPaginat
     const warnedOnceMissingInPageSizeOptions = React.useRef(false);
     const pageSize = rootProps.paginationModel?.pageSize ?? paginationModel.pageSize;
     if (!warnedOnceMissingInPageSizeOptions.current && !rootProps.autoPageSize && !isPageSizeIncludedInPageSizeOptions(pageSize)) {
-      console.warn([`MUI: The page size \`${paginationModel.pageSize}\` is not preset in the \`pageSizeOptions\``, `Add it to show the pagination select.`].join('\n'));
+      console.warn([`MUI X: The page size \`${paginationModel.pageSize}\` is not preset in the \`pageSizeOptions\`.`, `Add it to show the pagination select.`].join('\n'));
       warnedOnceMissingInPageSizeOptions.current = true;
     }
   }

package/modern/components/cell/GridActionsCell.js

@@ -35,7 +35,7 @@ function GridActionsCell(props) {
   const buttonId = useId();
   const rootProps = useGridRootProps();
   if (!hasActions(colDef)) {
-    throw new Error('MUI: Missing the `getActions` property in the `GridColDef`.');
+    throw new Error('MUI X: Missing the `getActions` property in the `GridColDef`.');
   }
   const options = colDef.getActions(apiRef.current.getRowParams(id));
   const iconButtons = options.filter(option => !option.props.showInMenu);

package/modern/components/cell/GridCell.js

@@ -274,7 +274,7 @@ const GridCell = /*#__PURE__*/React.forwardRef((props, ref) => {
         return;
       }
       if (!warnedOnce) {
-        console.warn([`MUI: The cell with id=${rowId} and field=${field} received focus.`, `According to the state, the focus should be at id=${focusedCell?.id}, field=${focusedCell?.field}.`, "Not syncing the state may cause unwanted behaviors since the `cellFocusIn` event won't be fired.", 'Call `fireEvent.mouseUp` before the `fireEvent.click` to sync the focus with the state.'].join('\n'));
+        console.warn([`MUI X: The cell with id=${rowId} and field=${field} received focus.`, `According to the state, the focus should be at id=${focusedCell?.id}, field=${focusedCell?.field}.`, "Not syncing the state may cause unwanted behaviors since the `cellFocusIn` event won't be fired.", 'Call `fireEvent.mouseUp` before the `fireEvent.click` to sync the focus with the state.'].join('\n'));
         warnedOnce = true;
       }
     };
@@ -544,7 +544,7 @@ const GridCellV7 = /*#__PURE__*/React.forwardRef((props, ref) => {
         return;
       }
       if (!warnedOnce) {
-        console.warn([`MUI: The cell with id=${rowId} and field=${field} received focus.`, `According to the state, the focus should be at id=${focusedCell?.id}, field=${focusedCell?.field}.`, "Not syncing the state may cause unwanted behaviors since the `cellFocusIn` event won't be fired.", 'Call `fireEvent.mouseUp` before the `fireEvent.click` to sync the focus with the state.'].join('\n'));
+        console.warn([`MUI X: The cell with id=${rowId} and field=${field} received focus.`, `According to the state, the focus should be at id=${focusedCell?.id}, field=${focusedCell?.field}.`, "Not syncing the state may cause unwanted behaviors since the `cellFocusIn` event won't be fired.", 'Call `fireEvent.mouseUp` before the `fireEvent.click` to sync the focus with the state.'].join('\n'));
         warnedOnce = true;
       }
     };

package/modern/components/panel/filterPanel/GridFilterForm.js

@@ -91,7 +91,7 @@ const getLogicOperatorLocaleKey = logicOperator => {
     case GridLogicOperator.Or:
       return 'filterPanelOperatorOr';
     default:
-      throw new Error('MUI: Invalid `logicOperator` property in the `GridFilterPanel`.');
+      throw new Error('MUI X: Invalid `logicOperator` property in the `GridFilterPanel`.');
   }
 };
 const getColumnLabel = col => col.headerName || col.field;

package/modern/components/toolbar/GridToolbarQuickFilter.js

@@ -123,12 +123,16 @@ process.env.NODE_ENV !== "production" ? GridToolbarQuickFilter.propTypes = {
    * Function responsible for formatting values of quick filter in a string when the model is modified
    * @param {any[]} values The new values passed to the quick filter model
    * @returns {string} The string to display in the text field
+   * @default (values: string[]) => values.join(' ')
    */
   quickFilterFormatter: PropTypes.func,
   /**
    * Function responsible for parsing text input in an array of independent values for quick filtering.
    * @param {string} input The value entered by the user
    * @returns {any[]} The array of value on which quick filter is applied
+   * @default (searchText: string) => searchText
+   *   .split(' ')
+   *   .filter((word) => word !== '')
    */
   quickFilterParser: PropTypes.func
 } : void 0;

package/modern/hooks/core/useGridLoggerFactory.js

@@ -13,13 +13,13 @@ const LOG_LEVELS = ['debug', 'info', 'warn', 'error'];
 function getAppender(name, logLevel, appender = console) {
   const minLogLevelIdx = LOG_LEVELS.indexOf(logLevel);
   if (minLogLevelIdx === -1) {
-    throw new Error(`MUI: Log level ${logLevel} not recognized.`);
+    throw new Error(`MUI X: Log level ${logLevel} not recognized.`);
   }
   const logger = LOG_LEVELS.reduce((loggerObj, method, idx) => {
     if (idx >= minLogLevelIdx) {
       loggerObj[method] = (...args) => {
         const [message, ...other] = args;
-        appender[method](`MUI: ${name} - ${message}`, ...other);
+        appender[method](`MUI X: ${name} - ${message}`, ...other);
       };
     } else {
       loggerObj[method] = noop;

package/modern/hooks/features/columnGrouping/gridColumnGroupsUtils.js

@@ -4,7 +4,7 @@ import { isDeepEqual } from '../../../utils/utils';
 const recurrentUnwrapGroupingColumnModel = (columnGroupNode, parents, unwrappedGroupingModelToComplete) => {
   if (isLeaf(columnGroupNode)) {
     if (unwrappedGroupingModelToComplete[columnGroupNode.field] !== undefined) {
-      throw new Error([`MUI: columnGroupingModel contains duplicated field`, `column field ${columnGroupNode.field} occurs two times in the grouping model:`, `- ${unwrappedGroupingModelToComplete[columnGroupNode.field].join(' > ')}`, `- ${parents.join(' > ')}`].join('\n'));
+      throw new Error([`MUI X: columnGroupingModel contains duplicated field`, `column field ${columnGroupNode.field} occurs two times in the grouping model:`, `- ${unwrappedGroupingModelToComplete[columnGroupNode.field].join(' > ')}`, `- ${parents.join(' > ')}`].join('\n'));
     }
     unwrappedGroupingModelToComplete[columnGroupNode.field] = parents;
     return;