@mui/x-data-grid-premium 8.0.0-alpha.11 → 8.0.0-alpha.13

package/esm/hooks/features/rowGrouping/createGroupingColDef.d.ts

@@ -0,0 +1,57 @@
+import { RefObject } from '@mui/x-internals/types';
+import { GridColDef, GridGroupingColDefOverride } from '@mui/x-data-grid-pro';
+import { GridColumnRawLookup } from '@mui/x-data-grid-pro/internals';
+import { GridApiPremium } from "../../../models/gridApiPremium.js";
+import { RowGroupingStrategy } from "./gridRowGroupingUtils.js";
+interface CreateGroupingColDefMonoCriteriaParams {
+  columnsLookup: GridColumnRawLookup;
+  /**
+   * The field from which we are grouping the rows.
+   */
+  groupingCriteria: string;
+  /**
+   * The col def from which we are grouping the rows.
+   */
+  groupedByColDef: GridColDef;
+  /**
+   * The col def properties the user wants to override.
+   * This value comes `prop.groupingColDef`.
+   */
+  colDefOverride: GridGroupingColDefOverride | null | undefined;
+  strategy?: RowGroupingStrategy;
+}
+/**
+ * Creates the `GridColDef` for a grouping column that only takes care of a single grouping criteria
+ */
+export declare const createGroupingColDefForOneGroupingCriteria: ({
+  columnsLookup,
+  groupedByColDef,
+  groupingCriteria,
+  colDefOverride,
+  strategy
+}: CreateGroupingColDefMonoCriteriaParams) => GridColDef;
+interface CreateGroupingColDefSeveralCriteriaParams {
+  apiRef: RefObject<GridApiPremium>;
+  columnsLookup: GridColumnRawLookup;
+  /**
+   * The fields from which we are grouping the rows.
+   */
+  rowGroupingModel: string[];
+  /**
+   * The col def properties the user wants to override.
+   * This value comes `prop.groupingColDef`.
+   */
+  colDefOverride: GridGroupingColDefOverride | null | undefined;
+  strategy?: RowGroupingStrategy;
+}
+/**
+ * Creates the `GridColDef` for a grouping column that takes care of all the grouping criteria
+ */
+export declare const createGroupingColDefForAllGroupingCriteria: ({
+  apiRef,
+  columnsLookup,
+  rowGroupingModel,
+  colDefOverride,
+  strategy
+}: CreateGroupingColDefSeveralCriteriaParams) => GridColDef;
+export {};

package/esm/hooks/features/rowGrouping/createGroupingColDef.js

@@ -3,7 +3,7 @@ import _extends from "@babel/runtime/helpers/esm/extends";
 const _excluded = ["leafField", "mainGroupingCriteria", "hideDescendantCount"],
   _excluded2 = ["leafField", "mainGroupingCriteria", "hideDescendantCount"];
 import * as React from 'react';
-import { GRID_STRING_COL_DEF } from '@mui/x-data-grid-pro';
+import { GRID_STRING_COL_DEF, gridRowIdSelector, gridRowNodeSelector } from '@mui/x-data-grid-pro';
 import { isSingleSelectColDef } from '@mui/x-data-grid-pro/internals';
 import { GridGroupingColumnFooterCell } from "../../../components/GridGroupingColumnFooterCell.js";
 import { GridGroupingCriteriaCell } from "../../../components/GridGroupingCriteriaCell.js";
@@ -140,8 +140,8 @@ export const createGroupingColDefForOneGroupingCriteria = ({
       return '';
     },
     valueGetter: (value, row, column, apiRef) => {
-      const rowId = apiRef.current.getRowId(row);
-      const rowNode = apiRef.current.getRowNode(rowId);
+      const rowId = gridRowIdSelector(apiRef, row);
+      const rowNode = gridRowNodeSelector(apiRef, rowId);
       if (!rowNode || rowNode.type === 'footer' || rowNode.type === 'pinnedRow') {
         return undefined;
       }
@@ -232,8 +232,8 @@ export const createGroupingColDefForAllGroupingCriteria = ({
       }));
     },
     valueGetter: (value, row) => {
-      const rowId = apiRef.current.getRowId(row);
-      const rowNode = apiRef.current.getRowNode(rowId);
+      const rowId = gridRowIdSelector(apiRef, row);
+      const rowNode = gridRowNodeSelector(apiRef, rowId);
       if (!rowNode || rowNode.type === 'footer' || rowNode.type === 'pinnedRow') {
         return undefined;
       }

package/esm/hooks/features/rowGrouping/gridRowGroupingInterfaces.d.ts

@@ -0,0 +1,44 @@
+import { GridColDef, GridValidRowModel } from '@mui/x-data-grid';
+export type GridRowGroupingModel = string[];
+export interface GridRowGroupingState {
+  model: GridRowGroupingModel;
+}
+export interface GridRowGroupingInitialState {
+  model?: GridRowGroupingModel;
+}
+export interface GridRowGroupingInternalCache {
+  /**
+   * Tracks the model on the last pre-processing
+   * Allows to check if we need to re-build the grouping columns when the grid upserts a column.
+   */
+  rulesOnLastRowTreeCreation: GridGroupingRules;
+}
+export interface GridRowGroupingApi {
+  /**
+   * Sets the columns to use as grouping criteria.
+   * @param {GridRowGroupingModel} model The columns to use as grouping criteria.
+   */
+  setRowGroupingModel: (model: GridRowGroupingModel) => void;
+  /**
+   * Adds the field to the row grouping model.
+   * @param {string} groupingCriteriaField The field from which we want to group the rows.
+   * @param {number | undefined} groupingIndex The grouping index at which we want to insert the new grouping criteria. By default, it will be inserted at the end of the model.
+   */
+  addRowGroupingCriteria: (groupingCriteriaField: string, groupingIndex?: number) => void;
+  /**
+   * Remove the field from the row grouping model.
+   * @param {string} groupingCriteriaField The field from which we want to stop grouping the rows.
+   */
+  removeRowGroupingCriteria: (groupingCriteriaField: string) => void;
+  /**
+   * Sets the grouping index of a grouping criteria.
+   * @param {string} groupingCriteriaField The field of the grouping criteria from which we want to change the grouping index.
+   * @param {number} groupingIndex The new grouping index of this grouping criteria.
+   */
+  setRowGroupingCriteriaIndex: (groupingCriteriaField: string, groupingIndex: number) => void;
+}
+export interface GridGroupingRule<R extends GridValidRowModel = GridValidRowModel, V = any> {
+  field: string;
+  groupingValueGetter?: GridColDef<R, V>['groupingValueGetter'];
+}
+export type GridGroupingRules<R extends GridValidRowModel = GridValidRowModel> = GridGroupingRule<R>[];

package/esm/hooks/features/rowGrouping/gridRowGroupingSelector.d.ts

@@ -0,0 +1,3 @@
+import { GridStatePremium } from "../../../models/gridStatePremium.js";
+export declare const gridRowGroupingModelSelector: import("@mui/x-data-grid").OutputSelector<GridStatePremium, import("./gridRowGroupingInterfaces").GridRowGroupingState, import("./gridRowGroupingInterfaces").GridRowGroupingModel>;
+export declare const gridRowGroupingSanitizedModelSelector: import("@mui/x-data-grid").OutputSelector<GridStatePremium, import("@mui/x-data-grid").GridColumnLookup, string[]>;

package/esm/hooks/features/rowGrouping/gridRowGroupingSelector.js

@@ -1,5 +1,5 @@
 import { gridColumnLookupSelector } from '@mui/x-data-grid-pro';
-import { createSelector, createSelectorMemoized } from '@mui/x-data-grid/internals';
-const gridRowGroupingStateSelector = state => state.rowGrouping;
+import { createSelector, createRootSelector, createSelectorMemoized } from '@mui/x-data-grid-pro/internals';
+const gridRowGroupingStateSelector = createRootSelector(state => state.rowGrouping);
 export const gridRowGroupingModelSelector = createSelector(gridRowGroupingStateSelector, rowGrouping => rowGrouping.model);
 export const gridRowGroupingSanitizedModelSelector = createSelectorMemoized(gridRowGroupingModelSelector, gridColumnLookupSelector, (model, columnsLookup) => model.filter(field => !!columnsLookup[field]));

package/esm/hooks/features/rowGrouping/gridRowGroupingUtils.d.ts

@@ -0,0 +1,54 @@
+import { RefObject } from '@mui/x-internals/types';
+import { GridRowTreeConfig, GridFilterState, GridFilterModel, GridRowModel, GridColDef, GridKeyValue, GridDataSource } from '@mui/x-data-grid-pro';
+import { GridAggregatedFilterItemApplier, GridColumnRawLookup, GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD, getRowGroupingCriteriaFromGroupingField, isGroupingColumn } from '@mui/x-data-grid-pro/internals';
+import { DataGridPremiumProcessedProps } from "../../../models/dataGridPremiumProps.js";
+import { GridGroupingRule, GridGroupingRules, GridRowGroupingModel } from "./gridRowGroupingInterfaces.js";
+import { GridStatePremium } from "../../../models/gridStatePremium.js";
+import { GridPrivateApiPremium } from "../../../models/gridApiPremium.js";
+export { GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD, getRowGroupingCriteriaFromGroupingField, isGroupingColumn };
+export declare enum RowGroupingStrategy {
+  Default = "grouping-columns",
+  DataSource = "grouping-columns-data-source",
+}
+export declare const getRowGroupingFieldFromGroupingCriteria: (groupingCriteria: string | null) => string;
+interface FilterRowTreeFromTreeDataParams {
+  rowTree: GridRowTreeConfig;
+  isRowMatchingFilters: GridAggregatedFilterItemApplier | null;
+  filterModel: GridFilterModel;
+  apiRef: RefObject<GridPrivateApiPremium>;
+}
+/**
+ * A leaf is visible if it passed the filter
+ * A group is visible if all the following criteria are met:
+ * - One of its children is passing the filter
+ * - It is passing the filter
+ */
+export declare const filterRowTreeFromGroupingColumns: (params: FilterRowTreeFromTreeDataParams) => Omit<GridFilterState, "filterModel">;
+export declare const getColDefOverrides: (groupingColDefProp: DataGridPremiumProcessedProps["groupingColDef"], fields: string[], strategy?: RowGroupingStrategy) => import("@mui/x-data-grid-pro").GridGroupingColDefOverride<any> | null | undefined;
+export declare const mergeStateWithRowGroupingModel: (rowGroupingModel: GridRowGroupingModel) => (state: GridStatePremium) => GridStatePremium;
+export declare const setStrategyAvailability: (privateApiRef: RefObject<GridPrivateApiPremium>, disableRowGrouping: boolean, dataSource?: GridDataSource) => void;
+export declare const getCellGroupingCriteria: ({
+  row,
+  colDef,
+  groupingRule,
+  apiRef
+}: {
+  row: GridRowModel;
+  colDef: GridColDef;
+  groupingRule: GridGroupingRule;
+  apiRef: RefObject<GridPrivateApiPremium>;
+}) => {
+  key: GridKeyValue | null | undefined;
+  field: string;
+};
+export declare const getGroupingRules: ({
+  sanitizedRowGroupingModel,
+  columnsLookup
+}: {
+  sanitizedRowGroupingModel: GridRowGroupingModel;
+  columnsLookup: GridColumnRawLookup;
+}) => GridGroupingRules;
+/**
+ * Compares two sets of grouping rules to determine if they are equal or not.
+ */
+export declare const areGroupingRulesEqual: (newValue: GridGroupingRules, previousValue: GridGroupingRules) => boolean;

package/esm/hooks/features/rowGrouping/gridRowGroupingUtils.js

@@ -1,5 +1,5 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
-import { passFilterLogic, GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD, getRowGroupingCriteriaFromGroupingField, isGroupingColumn, GridStrategyGroup } from '@mui/x-data-grid-pro/internals';
+import { passFilterLogic, GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD, getRowGroupingCriteriaFromGroupingField, isGroupingColumn, GridStrategyGroup, getRowValue } from '@mui/x-data-grid-pro/internals';
 import { gridRowGroupingSanitizedModelSelector } from "./gridRowGroupingSelector.js";
 export { GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD, getRowGroupingCriteriaFromGroupingField, isGroupingColumn };
 export let RowGroupingStrategy = /*#__PURE__*/function (RowGroupingStrategy) {
@@ -138,7 +138,7 @@ export const getCellGroupingCriteria = ({
   if (groupingRule.groupingValueGetter) {
     key = groupingRule.groupingValueGetter(row[groupingRule.field], row, colDef, apiRef);
   } else {
-    key = row[groupingRule.field];
+    key = getRowValue(row, colDef, apiRef);
   }
   return {
     key,

package/esm/hooks/features/rowGrouping/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./gridRowGroupingSelector.js";
+export * from "./gridRowGroupingInterfaces.js";
+export { GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD, getRowGroupingFieldFromGroupingCriteria, isGroupingColumn } from "./gridRowGroupingUtils.js";

package/esm/hooks/features/rowGrouping/useGridDataSourceRowGroupingPreProcessors.d.ts

@@ -0,0 +1,4 @@
+import { RefObject } from '@mui/x-internals/types';
+import { DataGridPremiumProcessedProps } from "../../../models/dataGridPremiumProps.js";
+import { GridPrivateApiPremium } from "../../../models/gridApiPremium.js";
+export declare const useGridDataSourceRowGroupingPreProcessors: (apiRef: RefObject<GridPrivateApiPremium>, props: Pick<DataGridPremiumProcessedProps, "disableRowGrouping" | "groupingColDef" | "rowGroupingColumnMode" | "defaultGroupingExpansionDepth" | "isGroupExpandedByDefault" | "dataSource">) => void;

package/esm/hooks/features/rowGrouping/useGridDataSourceRowGroupingPreProcessors.js

@@ -5,11 +5,11 @@ import { getGroupingRules, RowGroupingStrategy } from "./gridRowGroupingUtils.js
 import { gridRowGroupingSanitizedModelSelector } from "./gridRowGroupingSelector.js";
 export const useGridDataSourceRowGroupingPreProcessors = (apiRef, props) => {
   const createRowTreeForRowGrouping = React.useCallback(params => {
-    const getGroupKey = props.unstable_dataSource?.getGroupKey;
+    const getGroupKey = props.dataSource?.getGroupKey;
     if (!getGroupKey) {
       throw new Error('MUI X: No `getGroupKey` method provided with the dataSource.');
     }
-    const getChildrenCount = props.unstable_dataSource?.getChildrenCount;
+    const getChildrenCount = props.dataSource?.getChildrenCount;
     if (!getChildrenCount) {
       throw new Error('MUI X: No `getChildrenCount` method provided with the dataSource.');
     }
@@ -57,7 +57,7 @@ export const useGridDataSourceRowGroupingPreProcessors = (apiRef, props) => {
       isGroupExpandedByDefault: props.isGroupExpandedByDefault,
       groupingName: RowGroupingStrategy.DataSource
     });
-  }, [apiRef, props.unstable_dataSource, props.defaultGroupingExpansionDepth, props.isGroupExpandedByDefault]);
+  }, [apiRef, props.dataSource, props.defaultGroupingExpansionDepth, props.isGroupExpandedByDefault]);
   const filterRows = React.useCallback(() => {
     const rowTree = gridRowTreeSelector(apiRef);
     return skipFiltering(rowTree);

package/esm/hooks/features/rowGrouping/useGridRowGrouping.d.ts

@@ -0,0 +1,11 @@
+import { RefObject } from '@mui/x-internals/types';
+import { GridStateInitializer } from '@mui/x-data-grid-pro/internals';
+import { GridPrivateApiPremium } from "../../../models/gridApiPremium.js";
+import { DataGridPremiumProcessedProps } from "../../../models/dataGridPremiumProps.js";
+export declare const rowGroupingStateInitializer: GridStateInitializer<Pick<DataGridPremiumProcessedProps, 'rowGroupingModel' | 'initialState'>>;
+/**
+ * @requires useGridColumns (state, method) - can be after, async only
+ * @requires useGridRows (state, method) - can be after, async only
+ * @requires useGridParamsApi (method) - can be after, async only
+ */
+export declare const useGridRowGrouping: (apiRef: RefObject<GridPrivateApiPremium>, props: Pick<DataGridPremiumProcessedProps, "initialState" | "rowGroupingModel" | "onRowGroupingModelChange" | "defaultGroupingExpansionDepth" | "isGroupExpandedByDefault" | "groupingColDef" | "rowGroupingColumnMode" | "disableRowGrouping" | "slotProps" | "slots" | "dataSource">) => void;

package/esm/hooks/features/rowGrouping/useGridRowGrouping.js

@@ -37,7 +37,6 @@ export const useGridRowGrouping = (apiRef, props) => {
     if (currentModel !== model) {
       apiRef.current.setState(mergeStateWithRowGroupingModel(model));
       setStrategyAvailability(apiRef, props.disableRowGrouping);
-      apiRef.current.forceUpdate();
     }
   }, [apiRef, props.disableRowGrouping]);
   const addRowGroupingCriteria = React.useCallback((field, groupingIndex) => {
@@ -141,13 +140,13 @@ export const useGridRowGrouping = (apiRef, props) => {
       if (!isOnGroupingCell) {
         return;
       }
-      if (props.unstable_dataSource && !params.rowNode.childrenExpanded) {
-        apiRef.current.unstable_dataSource.fetchRows(params.id);
+      if (props.dataSource && !params.rowNode.childrenExpanded) {
+        apiRef.current.dataSource.fetchRows(params.id);
         return;
       }
       apiRef.current.setRowChildrenExpansion(params.id, !params.rowNode.childrenExpanded);
     }
-  }, [apiRef, props.rowGroupingColumnMode, props.unstable_dataSource]);
+  }, [apiRef, props.rowGroupingColumnMode, props.dataSource]);
   const checkGroupingColumnsModelDiff = React.useCallback(() => {
     const sanitizedRowGroupingModel = gridRowGroupingSanitizedModelSelector(apiRef);
     const rulesOnLastRowTreeCreation = apiRef.current.caches.rowGrouping.rulesOnLastRowTreeCreation || [];
@@ -170,7 +169,7 @@ export const useGridRowGrouping = (apiRef, props) => {
   useGridApiEventHandler(apiRef, 'cellKeyDown', handleCellKeyDown);
   useGridApiEventHandler(apiRef, 'columnsChange', checkGroupingColumnsModelDiff);
   useGridApiEventHandler(apiRef, 'rowGroupingModelChange', checkGroupingColumnsModelDiff);
-  useGridApiEventHandler(apiRef, 'rowGroupingModelChange', () => apiRef.current.unstable_dataSource.fetchRows());
+  useGridApiEventHandler(apiRef, 'rowGroupingModelChange', () => apiRef.current.dataSource.fetchRows());
 
   /*
    * EFFECTS

package/esm/hooks/features/rowGrouping/useGridRowGroupingPreProcessors.d.ts

@@ -0,0 +1,4 @@
+import { RefObject } from '@mui/x-internals/types';
+import { DataGridPremiumProcessedProps } from "../../../models/dataGridPremiumProps.js";
+import { GridPrivateApiPremium } from "../../../models/gridApiPremium.js";
+export declare const useGridRowGroupingPreProcessors: (apiRef: RefObject<GridPrivateApiPremium>, props: Pick<DataGridPremiumProcessedProps, "disableRowGrouping" | "groupingColDef" | "rowGroupingColumnMode" | "defaultGroupingExpansionDepth" | "isGroupExpandedByDefault" | "dataSource">) => void;

package/esm/hooks/features/rowGrouping/useGridRowGroupingPreProcessors.js

@@ -9,7 +9,7 @@ export const useGridRowGroupingPreProcessors = (apiRef, props) => {
     if (props.disableRowGrouping) {
       return [];
     }
-    const strategy = props.unstable_dataSource ? RowGroupingStrategy.DataSource : RowGroupingStrategy.Default;
+    const strategy = props.dataSource ? RowGroupingStrategy.DataSource : RowGroupingStrategy.Default;
     const groupingColDefProp = props.groupingColDef;
 
     // We can't use `gridGroupingRowsSanitizedModelSelector` here because the new columns are not in the state yet
@@ -43,7 +43,7 @@ export const useGridRowGroupingPreProcessors = (apiRef, props) => {
           return [];
         }
     }
-  }, [apiRef, props.groupingColDef, props.rowGroupingColumnMode, props.disableRowGrouping, props.unstable_dataSource]);
+  }, [apiRef, props.groupingColDef, props.rowGroupingColumnMode, props.disableRowGrouping, props.dataSource]);
   const updateGroupingColumn = React.useCallback(columnsState => {
     const groupingColDefs = getGroupingColDefs(columnsState);
     let newColumnFields = [];
@@ -148,14 +148,14 @@ export const useGridRowGroupingPreProcessors = (apiRef, props) => {
   useGridRegisterStrategyProcessor(apiRef, RowGroupingStrategy.Default, 'sorting', sortRows);
   useGridRegisterStrategyProcessor(apiRef, RowGroupingStrategy.Default, 'visibleRowsLookupCreation', getVisibleRowsLookup);
   useFirstRender(() => {
-    setStrategyAvailability(apiRef, props.disableRowGrouping, props.unstable_dataSource);
+    setStrategyAvailability(apiRef, props.disableRowGrouping, props.dataSource);
   });
   const isFirstRender = React.useRef(true);
   React.useEffect(() => {
     if (!isFirstRender.current) {
-      setStrategyAvailability(apiRef, props.disableRowGrouping, props.unstable_dataSource);
+      setStrategyAvailability(apiRef, props.disableRowGrouping, props.dataSource);
     } else {
       isFirstRender.current = false;
     }
-  }, [apiRef, props.disableRowGrouping, props.unstable_dataSource]);
+  }, [apiRef, props.disableRowGrouping, props.dataSource]);
 };

package/esm/hooks/features/rows/index.d.ts

@@ -0,0 +1 @@
+export * from "./useGridRowAriaAttributes.js";

package/esm/hooks/features/rows/useGridRowAriaAttributes.d.ts

@@ -0,0 +1 @@
+export declare const useGridRowAriaAttributes: () => (rowNode: import("@mui/x-data-grid").GridTreeNode, index: number) => React.HTMLAttributes<HTMLElement>;

package/esm/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./features/index.js";
+export * from "./utils/index.js";

package/esm/hooks/utils/index.d.ts

@@ -0,0 +1 @@
+export * from "./useKeepGroupedColumnsHidden.js";

package/esm/hooks/utils/useGridApiContext.d.ts

@@ -0,0 +1,4 @@
+import { RefObject } from '@mui/x-internals/types';
+import { GridApiCommon } from '@mui/x-data-grid';
+import { GridApiPremium } from "../../models/gridApiPremium.js";
+export declare const useGridApiContext: <Api extends GridApiCommon = GridApiPremium>() => RefObject<Api>;

package/esm/hooks/utils/useGridApiRef.d.ts

@@ -0,0 +1,4 @@
+import { RefObject } from '@mui/x-internals/types';
+import { GridApiCommon } from '@mui/x-data-grid';
+import { GridApiPremium } from "../../models/gridApiPremium.js";
+export declare const useGridApiRef: <Api extends GridApiCommon = GridApiPremium>() => RefObject<Api | null>;

package/esm/hooks/utils/useGridAriaAttributes.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export declare const useGridAriaAttributes: () => React.HTMLAttributes<HTMLElement>;

package/esm/hooks/utils/useGridPrivateApiContext.d.ts

@@ -0,0 +1,2 @@
+import { GridPrivateApiPremium } from "../../models/gridApiPremium.js";
+export declare const useGridPrivateApiContext: () => import("react").RefObject<GridPrivateApiPremium>;

package/esm/hooks/utils/useGridRootProps.d.ts

@@ -0,0 +1,2 @@
+import { DataGridPremiumProcessedProps } from "../../models/dataGridPremiumProps.js";
+export declare const useGridRootProps: () => DataGridPremiumProcessedProps;

package/esm/hooks/utils/useKeepGroupedColumnsHidden.d.ts

@@ -0,0 +1,12 @@
+import { RefObject } from '@mui/x-internals/types';
+import { GridApi } from '@mui/x-data-grid-pro';
+import { GridInitialStatePremium } from "../../models/gridStatePremium.js";
+import { DataGridPremiumProps } from "../../models/dataGridPremiumProps.js";
+/**
+ * Automatically hide columns when added to the row grouping model and stop hiding them when they are removed.
+ * Handles both the `props.initialState.rowGrouping.model` and `props.rowGroupingModel`
+ * Does not work when used with the `hide` property of `GridColDef`
+ */
+export declare const useKeepGroupedColumnsHidden: (props: {
+  apiRef: RefObject<GridApi | null>;
+} & Pick<DataGridPremiumProps, "initialState" | "rowGroupingModel">) => GridInitialStatePremium;

package/esm/index.d.ts

@@ -0,0 +1,23 @@
+import "./typeOverloads/index.js";
+export * from '@mui/x-data-grid/components';
+export * from '@mui/x-data-grid-pro/components';
+export * from '@mui/x-data-grid/constants';
+export * from '@mui/x-data-grid/hooks';
+export * from '@mui/x-data-grid-pro/hooks';
+export * from '@mui/x-data-grid/models';
+export * from '@mui/x-data-grid-pro/models';
+export * from '@mui/x-data-grid/context';
+export * from '@mui/x-data-grid/colDef';
+export * from '@mui/x-data-grid/utils';
+export * from '@mui/x-data-grid-pro/utils';
+export * from "./DataGridPremium/index.js";
+export * from "./hooks/index.js";
+export * from "./models/index.js";
+export * from "./components/index.js";
+export { GridColumnHeaders } from '@mui/x-data-grid-pro';
+export type { GridColumnHeadersProps } from '@mui/x-data-grid-pro';
+export type { DataGridPremiumProps, GridExperimentalPremiumFeatures } from './models/dataGridPremiumProps';
+export { useGridApiContext, useGridApiRef, useGridRootProps } from "./typeOverloads/reexports.js";
+export type { GridApi, GridInitialState, GridState } from './typeOverloads/reexports';
+export { GridColumnMenu, GRID_COLUMN_MENU_SLOTS, GRID_COLUMN_MENU_SLOT_PROPS } from "./components/reexports.js";
+export type { GridGetRowsParamsPremium as GridGetRowsParams, GridGetRowsResponsePremium as GridGetRowsResponse, GridDataSourcePremium as GridDataSource, GridDataSourceApiPremium as GridDataSourceApi, GridDataSourceApiBasePremium as GridDataSourceApiBase, GridDataSourcePremiumPrivateApi as GridDataSourcePrivateApi } from './hooks/features/dataSource/models';

package/esm/index.js

@@ -1,10 +1,11 @@
-import "./typeOverloads/index.js";
-import { LicenseInfo as LicenseInfoExport } from '@mui/x-license';
 /**
- * @deprecated Use `@mui/x-license` package instead:
- * @example import { LicenseInfo } from '@mui/x-license';
+ * @mui/x-data-grid-premium v8.0.0-alpha.13
+ *
+ * @license MUI X Commercial
+ * This source code is licensed under the commercial license found in the
+ * LICENSE file in the root directory of this source tree.
  */
-export class LicenseInfo extends LicenseInfoExport {}
+import "./typeOverloads/index.js";
 export * from '@mui/x-data-grid/components';
 export * from '@mui/x-data-grid-pro/components';
 export * from '@mui/x-data-grid/constants';

package/esm/locales.d.ts

@@ -0,0 +1 @@
+export * from '@mui/x-data-grid/locales';

package/esm/material/icons.d.ts

@@ -0,0 +1,15 @@
+export declare const GridWorkspacesIcon: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").SvgIconTypeMap<{}, "svg">> & {
+  muiName: string;
+};
+export declare const GridGroupWorkIcon: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").SvgIconTypeMap<{}, "svg">> & {
+  muiName: string;
+};
+export declare const GridFunctionsIcon: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").SvgIconTypeMap<{}, "svg">> & {
+  muiName: string;
+};
+export declare const GridSendPromptIcon: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").SvgIconTypeMap<{}, "svg">> & {
+  muiName: string;
+};
+export declare const GridRecordPromptIcon: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").SvgIconTypeMap<{}, "svg">> & {
+  muiName: string;
+};

package/esm/material/index.d.ts

@@ -0,0 +1,8 @@
+declare const materialSlots: {
+  columnMenuUngroupIcon: React.JSXElementConstructor<any>;
+  columnMenuGroupIcon: React.JSXElementConstructor<any>;
+  columnMenuAggregationIcon: React.JSXElementConstructor<any>;
+  toolbarPromptSendIcon: React.JSXElementConstructor<any>;
+  toolbarPromptRecordIcon: React.JSXElementConstructor<any>;
+};
+export default materialSlots;

package/esm/models/dataGridPremiumProps.d.ts

@@ -0,0 +1,162 @@
+import { RefObject } from '@mui/x-internals/types';
+import { GridCallbackDetails, GridValidRowModel, GridGroupNode, GridEventListener, GridGetRowsError, GridUpdateRowError } from '@mui/x-data-grid-pro';
+import { GridExperimentalProFeatures, DataGridProPropsWithDefaultValue, DataGridProPropsWithoutDefaultValue, DataGridPropsWithComplexDefaultValueAfterProcessing, DataGridPropsWithComplexDefaultValueBeforeProcessing, DataGridPremiumSharedPropsWithDefaultValue } from '@mui/x-data-grid-pro/internals';
+import type { GridRowGroupingModel } from '../hooks/features/rowGrouping';
+import type { GridAggregationModel, GridAggregationFunction, GridAggregationFunctionDataSource, GridAggregationPosition } from '../hooks/features/aggregation';
+import { GridPremiumSlotsComponent } from "./gridPremiumSlotsComponent.js";
+import { GridInitialStatePremium } from "./gridStatePremium.js";
+import { GridApiPremium } from "./gridApiPremium.js";
+import { GridCellSelectionModel } from "../hooks/features/cellSelection/index.js";
+import { GridDataSourcePremium as GridDataSource, GridGetRowsParamsPremium as GridGetRowsParams } from "../hooks/features/dataSource/models.js";
+export interface GridExperimentalPremiumFeatures extends GridExperimentalProFeatures {}
+export interface DataGridPremiumPropsWithComplexDefaultValueBeforeProcessing extends Pick<DataGridPropsWithComplexDefaultValueBeforeProcessing, 'localeText'> {
+  /**
+   * Overridable components.
+   */
+  slots?: Partial<GridPremiumSlotsComponent>;
+}
+/**
+ * The props users can give to the `DataGridPremiumProps` component.
+ */
+export interface DataGridPremiumProps<R extends GridValidRowModel = any> extends Omit<Partial<DataGridPremiumPropsWithDefaultValue<R>> & DataGridPremiumPropsWithComplexDefaultValueBeforeProcessing & DataGridPremiumPropsWithoutDefaultValue<R>, DataGridPremiumForcedPropsKey> {}
+export interface DataGridPremiumPropsWithComplexDefaultValueAfterProcessing extends Pick<DataGridPropsWithComplexDefaultValueAfterProcessing, 'localeText'> {
+  slots: GridPremiumSlotsComponent;
+}
+/**
+ * The props of the Data Grid Premium component after the pre-processing phase.
+ */
+export interface DataGridPremiumProcessedProps extends DataGridPremiumPropsWithDefaultValue, DataGridPremiumPropsWithComplexDefaultValueAfterProcessing, DataGridPremiumPropsWithoutDefaultValue {}
+export type DataGridPremiumForcedPropsKey = 'signature';
+/**
+ * The Data Grid Premium options with a default value overridable through props.
+ * None of the entry of this interface should be optional, they all have default values and `DataGridProps` already applies a `Partial<DataGridSimpleOptions>` for the public interface.
+ * The controlled model do not have a default value at the prop processing level, so they must be defined in `DataGridOtherProps`.
+ */
+export interface DataGridPremiumPropsWithDefaultValue<R extends GridValidRowModel = any> extends DataGridProPropsWithDefaultValue<R>, DataGridPremiumSharedPropsWithDefaultValue {
+  /**
+   * If `true`, aggregation is disabled.
+   * @default false
+   */
+  disableAggregation: boolean;
+  /**
+   * If `true`, the row grouping is disabled.
+   * @default false
+   */
+  disableRowGrouping: boolean;
+  /**
+   * If `single`, all the columns that are grouped are represented in the same grid column.
+   * If `multiple`, each column that is grouped is represented in its own grid column.
+   * @default 'single'
+   */
+  rowGroupingColumnMode: 'single' | 'multiple';
+  /**
+   * Aggregation functions available on the grid.
+   * @default GRID_AGGREGATION_FUNCTIONS when `dataSource` is not provided, `{}` when `dataSource` is provided
+   */
+  aggregationFunctions: Record<string, GridAggregationFunction> | Record<string, GridAggregationFunctionDataSource>;
+  /**
+   * Rows used to generate the aggregated value.
+   * If `filtered`, the aggregated values are generated using only the rows currently passing the filtering process.
+   * If `all`, the aggregated values are generated using all the rows.
+   * @default "filtered"
+   */
+  aggregationRowsScope: 'filtered' | 'all';
+  /**
+   * Determines the position of an aggregated value.
+   * @param {GridGroupNode} groupNode The current group.
+   * @returns {GridAggregationPosition | null} Position of the aggregated value (if `null`, the group isn't aggregated).
+   * @default (groupNode) => groupNode == null ? 'footer' : 'inline'
+   */
+  getAggregationPosition: (groupNode: GridGroupNode) => GridAggregationPosition | null;
+  /**
+   * If `true`, the clipboard paste is disabled.
+   * @default false
+   */
+  disableClipboardPaste: boolean;
+  /**
+   * The function is used to split the pasted text into rows and cells.
+   * @param {string} text The text pasted from the clipboard.
+   * @returns {string[][] | null} A 2D array of strings. The first dimension is the rows, the second dimension is the columns.
+   * @default (pastedText) => { const text = pastedText.replace(/\r?\n$/, ''); return text.split(/\r\n|\n|\r/).map((row) => row.split('\t')); }
+   */
+  splitClipboardPastedText: (text: string) => string[][] | null;
+}
+export interface DataGridPremiumPropsWithoutDefaultValue<R extends GridValidRowModel = any> extends Omit<DataGridProPropsWithoutDefaultValue<R>, 'initialState' | 'apiRef' | 'dataSource' | 'onDataSourceError'> {
+  /**
+   * The ref object that allows grid manipulation. Can be instantiated with `useGridApiRef()`.
+   */
+  apiRef?: RefObject<GridApiPremium | null>;
+  /**
+   * The initial state of the DataGridPremium.
+   * The data in it is set in the state on initialization but isn't controlled.
+   * If one of the data in `initialState` is also being controlled, then the control state wins.
+   */
+  initialState?: GridInitialStatePremium;
+  /**
+   * Set the row grouping model of the grid.
+   */
+  rowGroupingModel?: GridRowGroupingModel;
+  /**
+   * Callback fired when the row grouping model changes.
+   * @param {GridRowGroupingModel} model Columns used as grouping criteria.
+   * @param {GridCallbackDetails} details Additional details for this callback.
+   */
+  onRowGroupingModelChange?: (model: GridRowGroupingModel, details: GridCallbackDetails) => void;
+  /**
+   * Set the aggregation model of the grid.
+   */
+  aggregationModel?: GridAggregationModel;
+  /**
+   * Callback fired when the row grouping model changes.
+   * @param {GridAggregationModel} model The aggregated columns.
+   * @param {GridCallbackDetails} details Additional details for this callback.
+   */
+  onAggregationModelChange?: (model: GridAggregationModel, details: GridCallbackDetails) => void;
+  /**
+   * Set the cell selection model of the grid.
+   */
+  cellSelectionModel?: GridCellSelectionModel;
+  /**
+   * Callback fired when the selection state of one or multiple cells changes.
+   * @param {GridCellSelectionModel} cellSelectionModel Object in the shape of [[GridCellSelectionModel]] containing the selected cells.
+   * @param {GridCallbackDetails} details Additional details for this callback.
+   */
+  onCellSelectionModelChange?: (cellSelectionModel: GridCellSelectionModel, details: GridCallbackDetails) => void;
+  /**
+   * Callback fired when the state of the Excel export changes.
+   * @param {string} inProgress Indicates if the task is in progress.
+   */
+  onExcelExportStateChange?: (inProgress: 'pending' | 'finished') => void;
+  /**
+   * Callback fired before the clipboard paste operation starts.
+   * Use it to confirm or cancel the paste operation.
+   * @param {object} params Params passed to the callback.
+   * @param {string[][]} params.data The raw pasted data split by rows and cells.
+   * @returns {Promise<any>} A promise that resolves to confirm the paste operation, and rejects to cancel it.
+   */
+  onBeforeClipboardPasteStart?: (params: {
+    data: string[][];
+  }) => Promise<any>;
+  /**
+   * Callback fired when the clipboard paste operation starts.
+   */
+  onClipboardPasteStart?: GridEventListener<'clipboardPasteStart'>;
+  /**
+   * Callback fired when the clipboard paste operation ends.
+   */
+  onClipboardPasteEnd?: GridEventListener<'clipboardPasteEnd'>;
+  /**
+   * Unstable features, breaking changes might be introduced.
+   * For each feature, if the flag is not explicitly set to `true`, then the feature is fully disabled, and neither property nor method calls will have any effect.
+   */
+  experimentalFeatures?: Partial<GridExperimentalPremiumFeatures>;
+  /**
+   * Data source object.
+   */
+  dataSource?: GridDataSource;
+  /**
+   * Callback fired when a data source request fails.
+   * @param {GridGetRowsError | GridUpdateRowError} error The data source error object.
+   */
+  onDataSourceError?: (error: GridGetRowsError<GridGetRowsParams> | GridUpdateRowError) => void;
+}